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

package/dist/v3/index.js

@@ -2,6 +2,7 @@
 
 var zod = require('zod');
 var api = require('@opentelemetry/api');
+var zodValidationError = require('zod-validation-error');
 var async_hooks = require('async_hooks');
 var socket_ioClient = require('socket.io-client');
 var crypto = require('crypto');
@@ -91,6 +92,7 @@ var TaskRunStringError = zod.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",
@@ -104,6 +106,7 @@ var TaskRunInternalError = zod.z.object({
   type: zod.z.literal("INTERNAL_ERROR"),
   code: zod.z.enum([
     "COULD_NOT_FIND_EXECUTOR",
+    "COULD_NOT_FIND_TASK",
     "CONFIGURED_INCORRECTLY",
     "TASK_ALREADY_RUNNING",
     "TASK_EXECUTION_FAILED",
@@ -448,15 +451,17 @@ var QueueOptions = zod.z.object({
 });
 var TaskMetadata = zod.z.object({
   id: zod.z.string(),
-  exportName: zod.z.string(),
   packageVersion: zod.z.string(),
   queue: QueueOptions.optional(),
   retry: RetryOptions.optional(),
-  machine: Machine.partial().optional()
+  machine: Machine.partial().optional(),
+  triggerSource: zod.z.string().optional()
 });
-var TaskMetadataWithFilePath = TaskMetadata.extend({
-  filePath: zod.z.string()
+var TaskFileMetadata = zod.z.object({
+  filePath: zod.z.string(),
+  exportName: zod.z.string()
 });
+var TaskMetadataWithFilePath = TaskMetadata.merge(TaskFileMetadata);
 var UncaughtExceptionMessage = zod.z.object({
   version: zod.z.literal("v1").default("v1"),
   error: zod.z.object({
@@ -608,7 +613,8 @@ var TaskResource = zod.z.object({
   exportName: zod.z.string(),
   queue: QueueOptions.optional(),
   retry: RetryOptions.optional(),
-  machine: Machine.partial().optional()
+  machine: Machine.partial().optional(),
+  triggerSource: zod.z.string().optional()
 });
 var BackgroundWorkerMetadata = zod.z.object({
   packageVersion: zod.z.string(),
@@ -664,7 +670,9 @@ var TriggerTaskRequestBody = zod.z.object({
     lockToVersion: zod.z.string().optional(),
     queue: QueueOptions.optional(),
     concurrencyKey: zod.z.string().optional(),
-    test: zod.z.boolean().optional()
+    idempotencyKey: zod.z.string().optional(),
+    test: zod.z.boolean().optional(),
+    payloadType: zod.z.string().optional()
   }).optional()
 });
 var TriggerTaskResponse = zod.z.object({
@@ -760,6 +768,87 @@ var ReplayRunResponse = zod.z.object({
 var CanceledRunResponse = zod.z.object({
   message: zod.z.string()
 });
+var ScheduledTaskPayload = zod.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: zod.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: zod.z.date(),
+  /** When the task was last run (it has been).
+  This can be undefined if it's never been run */
+  lastTimestamp: zod.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: zod.z.string().optional(),
+  /** The next 5 dates this task is scheduled to run */
+  upcoming: zod.z.array(zod.z.date())
+});
+var CreateScheduleOptions = zod.z.object({
+  /** The id of the task you want to attach to. */
+  task: zod.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: zod.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: zod.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: zod.z.string().optional()
+});
+var UpdateScheduleOptions = CreateScheduleOptions;
+var ScheduleObject = zod.z.object({
+  id: zod.z.string(),
+  task: zod.z.string(),
+  active: zod.z.boolean(),
+  deduplicationKey: zod.z.string().nullish(),
+  externalId: zod.z.string().nullish(),
+  generator: zod.z.object({
+    type: zod.z.literal("CRON"),
+    expression: zod.z.string(),
+    description: zod.z.string()
+  }),
+  nextRun: zod.z.coerce.date().nullish(),
+  environments: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    type: zod.z.string(),
+    userName: zod.z.string().nullish()
+  }))
+});
+var DeletedScheduleObject = zod.z.object({
+  id: zod.z.string()
+});
+var ListSchedulesResult = zod.z.object({
+  data: zod.z.array(ScheduleObject),
+  pagination: zod.z.object({
+    currentPage: zod.z.number(),
+    totalPages: zod.z.number(),
+    count: zod.z.number()
+  })
+});
+var ListScheduleOptions = zod.z.object({
+  page: zod.z.number().optional(),
+  perPage: zod.z.number().optional()
+});
 var PostStartCauses = zod.z.enum([
   "index",
   "create",
@@ -791,7 +880,8 @@ var Config = zod.z.object({
     zod.z.string(),
     RegexSchema
   ])).optional(),
-  logLevel: zod.z.string().optional()
+  logLevel: zod.z.string().optional(),
+  enableConsoleLogging: zod.z.boolean().optional()
 });
 var WaitReason = zod.z.enum([
   "WAIT_FOR_DURATION",
@@ -1447,101 +1537,384 @@ var SpanMessagingEvent = zod.z.object({
   destination: zod.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 zodValidationError.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) {
@@ -1693,7 +2066,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
@@ -1829,7 +2203,7 @@ __name(getEnvVar, "getEnvVar");
 // src/v3/apiClient/index.ts
 var zodFetchOptions = {
   retry: {
-    maxAttempts: 5,
+    maxAttempts: 3,
     minTimeoutInMs: 1e3,
     maxTimeoutInMs: 3e4,
     factor: 2,
@@ -1881,6 +2255,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) {
@@ -2794,11 +3219,6 @@ __name(unregisterGlobal, "unregisterGlobal");
 var _NoopRuntimeManager = class _NoopRuntimeManager {
   disable() {
   }
-  registerTasks() {
-  }
-  getTaskMetadata(id) {
-    return void 0;
-  }
   waitForDuration(ms) {
     return Promise.resolve();
   }
@@ -2858,12 +3278,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() {
@@ -3009,7 +3423,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) {
@@ -3046,6 +3460,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";
@@ -3096,6 +3518,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;
@@ -3219,19 +3713,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);
@@ -3309,18 +3794,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 = promises.setTimeout(ms, "duration");
@@ -3525,11 +4001,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
@@ -3538,12 +4015,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 {
@@ -3551,8 +4030,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, apiLogs.SeverityNumber.DEBUG, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Debug", ...args);
+  }
   log(...args) {
     __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Log", ...args);
   }
@@ -3569,6 +4052,13 @@ var _ConsoleInterceptor = class _ConsoleInterceptor {
 _handleLog = new WeakSet();
 handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, timestamp, severityText, ...args) {
   const body = util__default.default.format(...args);
+  if (this.sendToStdIO) {
+    if (severityNumber === apiLogs.SeverityNumber.ERROR) {
+      process.stderr.write(body);
+    } else {
+      process.stdout.write(body);
+    }
+  }
   const parsed = tryParseJSON(body);
   if (parsed.ok) {
     this.logger.emit({
@@ -3644,113 +4134,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);
@@ -4111,6 +4494,7 @@ async function stringifyIO(value) {
     };
   } catch {
     return {
+      data: value,
       dataType: "application/json"
     };
   }
@@ -4155,23 +4539,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) {
@@ -4200,19 +4581,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) {
@@ -4265,7 +4643,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;
@@ -4279,10 +4657,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") {
@@ -4328,14 +4712,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;
@@ -4607,7 +4991,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
@@ -4616,6 +5001,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);
@@ -4626,12 +5089,16 @@ function parseBatchTriggerTaskRequestBody(body) {
 }
 __name(parseBatchTriggerTaskRequestBody, "parseBatchTriggerTaskRequestBody");
 
+exports.APIConnectionError = APIConnectionError;
+exports.APIError = APIError;
 exports.ApiClient = ApiClient;
 exports.ApiClientManager = ApiClientManager;
+exports.AuthenticationError = AuthenticationError;
 exports.BackgroundWorkerClientMessages = BackgroundWorkerClientMessages;
 exports.BackgroundWorkerMetadata = BackgroundWorkerMetadata;
 exports.BackgroundWorkerProperties = BackgroundWorkerProperties;
 exports.BackgroundWorkerServerMessages = BackgroundWorkerServerMessages;
+exports.BadRequestError = BadRequestError;
 exports.BatchTaskRunExecutionResult = BatchTaskRunExecutionResult;
 exports.BatchTriggerTaskRequestBody = BatchTriggerTaskRequestBody;
 exports.BatchTriggerTaskResponse = BatchTriggerTaskResponse;
@@ -4639,13 +5106,16 @@ exports.CanceledRunResponse = CanceledRunResponse;
 exports.CancellationSpanEvent = CancellationSpanEvent;
 exports.ClientToSharedQueueMessages = ClientToSharedQueueMessages;
 exports.Config = Config;
+exports.ConflictError = ConflictError;
 exports.ConsoleInterceptor = ConsoleInterceptor;
 exports.CoordinatorToPlatformMessages = CoordinatorToPlatformMessages;
 exports.CoordinatorToProdWorkerMessages = CoordinatorToProdWorkerMessages;
 exports.CreateAuthorizationCodeResponseSchema = CreateAuthorizationCodeResponseSchema;
 exports.CreateBackgroundWorkerRequestBody = CreateBackgroundWorkerRequestBody;
 exports.CreateBackgroundWorkerResponse = CreateBackgroundWorkerResponse;
+exports.CreateScheduleOptions = CreateScheduleOptions;
 exports.CreateUploadPayloadUrlResponseBody = CreateUploadPayloadUrlResponseBody;
+exports.DeletedScheduleObject = DeletedScheduleObject;
 exports.DeploymentErrorData = DeploymentErrorData;
 exports.DevRuntimeManager = DevRuntimeManager;
 exports.DurableClock = PreciseWallClock;
@@ -4672,9 +5142,13 @@ exports.GetProjectsResponseBody = GetProjectsResponseBody;
 exports.ImageDetailsMetadata = ImageDetailsMetadata;
 exports.InitializeDeploymentRequestBody = InitializeDeploymentRequestBody;
 exports.InitializeDeploymentResponseBody = InitializeDeploymentResponseBody;
+exports.InternalServerError = InternalServerError;
+exports.ListScheduleOptions = ListScheduleOptions;
+exports.ListSchedulesResult = ListSchedulesResult;
 exports.Machine = Machine;
 exports.MachineCpu = MachineCpu;
 exports.MachineMemory = MachineMemory;
+exports.NotFoundError = NotFoundError;
 exports.OFFLOAD_IO_PACKET_LENGTH_LIMIT = OFFLOAD_IO_PACKET_LENGTH_LIMIT;
 exports.OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT;
 exports.OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT = OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT;
@@ -4687,6 +5161,7 @@ exports.OTEL_SPAN_EVENT_COUNT_LIMIT = OTEL_SPAN_EVENT_COUNT_LIMIT;
 exports.OtelTaskLogger = OtelTaskLogger;
 exports.OtherSpanEvent = OtherSpanEvent;
 exports.PRIMARY_VARIANT = PRIMARY_VARIANT;
+exports.PermissionDeniedError = PermissionDeniedError;
 exports.PlatformToCoordinatorMessages = PlatformToCoordinatorMessages;
 exports.PlatformToProviderMessages = PlatformToProviderMessages;
 exports.PostStartCauses = PostStartCauses;
@@ -4700,9 +5175,12 @@ exports.ProdWorkerToChildMessages = ProdWorkerToChildMessages;
 exports.ProdWorkerToCoordinatorMessages = ProdWorkerToCoordinatorMessages;
 exports.ProviderToPlatformMessages = ProviderToPlatformMessages;
 exports.QueueOptions = QueueOptions;
+exports.RateLimitError = RateLimitError;
 exports.RateLimitOptions = RateLimitOptions;
 exports.ReplayRunResponse = ReplayRunResponse;
 exports.RetryOptions = RetryOptions;
+exports.ScheduleObject = ScheduleObject;
+exports.ScheduledTaskPayload = ScheduledTaskPayload;
 exports.SemanticInternalAttributes = SemanticInternalAttributes;
 exports.SharedQueueToClientMessages = SharedQueueToClientMessages;
 exports.SimpleStructuredLogger = SimpleStructuredLogger;
@@ -4710,11 +5188,13 @@ exports.SlidingWindowRateLimit = SlidingWindowRateLimit;
 exports.SpanEvent = SpanEvent;
 exports.SpanEvents = SpanEvents;
 exports.SpanMessagingEvent = SpanMessagingEvent;
+exports.StandardTaskCatalog = StandardTaskCatalog;
 exports.StartDeploymentIndexingRequestBody = StartDeploymentIndexingRequestBody;
 exports.StartDeploymentIndexingResponseBody = StartDeploymentIndexingResponseBody;
 exports.TaskContextSpanProcessor = TaskContextSpanProcessor;
 exports.TaskEventStyle = TaskEventStyle;
 exports.TaskExecutor = TaskExecutor;
+exports.TaskFileMetadata = TaskFileMetadata;
 exports.TaskMetadata = TaskMetadata;
 exports.TaskMetadataFailedToParseData = TaskMetadataFailedToParseData;
 exports.TaskMetadataWithFilePath = TaskMetadataWithFilePath;
@@ -4745,6 +5225,8 @@ exports.TriggerTaskRequestBody = TriggerTaskRequestBody;
 exports.TriggerTaskResponse = TriggerTaskResponse;
 exports.TriggerTracer = TriggerTracer;
 exports.UncaughtExceptionMessage = UncaughtExceptionMessage;
+exports.UnprocessableEntityError = UnprocessableEntityError;
+exports.UpdateScheduleOptions = UpdateScheduleOptions;
 exports.WaitReason = WaitReason;
 exports.WhoAmIResponseSchema = WhoAmIResponseSchema;
 exports.ZodIpcConnection = ZodIpcConnection;
@@ -4801,6 +5283,7 @@ exports.runtime = runtime;
 exports.serverWebsocketMessages = serverWebsocketMessages;
 exports.stringPatternMatchers = stringPatternMatchers;
 exports.stringifyIO = stringifyIO;
+exports.taskCatalog = taskCatalog;
 exports.taskContextManager = taskContextManager;
 exports.unflattenAttributes = unflattenAttributes;
 exports.workerToChildMessages = workerToChildMessages;