@trigger.dev/core 3.0.0-beta.35 → 3.0.0-beta.36

package/dist/v3/index.mjs

@@ -29,7 +29,7 @@ var __privateMethod = (obj, member, method) => {
 };
 
 // package.json
-var version = "3.0.0-beta.35";
+var version = "3.0.0-beta.36";
 var dependencies = {
   "@google-cloud/precise-date": "^4.0.0",
   "@opentelemetry/api": "^1.8.0",
@@ -52,144 +52,6 @@ var dependencies = {
   "zod-error": "1.5.0",
   "zod-validation-error": "^1.5.0"
 };
-
-// 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");
 var CreateAuthorizationCodeResponseSchema = z.object({
   url: z.string().url(),
   authorizationCode: z.string()
@@ -508,7 +370,16 @@ var TaskFileMetadata = z.object({
   filePath: z.string(),
   exportName: z.string()
 });
-var TaskMetadataWithFilePath = TaskMetadata.merge(TaskFileMetadata);
+var TaskMetadataWithFilePath = z.object({
+  id: z.string(),
+  packageVersion: z.string(),
+  queue: QueueOptions.optional(),
+  retry: RetryOptions.optional(),
+  machine: Machine.partial().optional(),
+  triggerSource: z.string().optional(),
+  filePath: z.string(),
+  exportName: z.string()
+});
 var PostStartCauses = z.enum([
   "index",
   "create",
@@ -577,6 +448,152 @@ var ImageDetailsMetadata = z.object({
   contentHash: z.string(),
   imageTag: z.string()
 });
+function parseError(error) {
+  if (error instanceof Error) {
+    return {
+      type: "BUILT_IN_ERROR",
+      name: error.name,
+      message: error.message,
+      stackTrace: error.stack ?? ""
+    };
+  }
+  if (typeof error === "string") {
+    return {
+      type: "STRING_ERROR",
+      raw: error
+    };
+  }
+  try {
+    return {
+      type: "CUSTOM_ERROR",
+      raw: JSON.stringify(error)
+    };
+  } catch (e) {
+    return {
+      type: "CUSTOM_ERROR",
+      raw: String(error)
+    };
+  }
+}
+__name(parseError, "parseError");
+function createErrorTaskError(error) {
+  switch (error.type) {
+    case "BUILT_IN_ERROR": {
+      const e = new Error(error.message);
+      e.name = error.name;
+      e.stack = error.stackTrace;
+      return e;
+    }
+    case "STRING_ERROR": {
+      return error.raw;
+    }
+    case "CUSTOM_ERROR": {
+      return JSON.parse(error.raw);
+    }
+    case "INTERNAL_ERROR": {
+      return new Error(`trigger.dev internal error (${error.code})`);
+    }
+  }
+}
+__name(createErrorTaskError, "createErrorTaskError");
+var SerializedError = z.object({
+  message: z.string(),
+  name: z.string().optional(),
+  stackTrace: z.string().optional()
+});
+function createJsonErrorObject(error) {
+  switch (error.type) {
+    case "BUILT_IN_ERROR": {
+      return {
+        name: error.name,
+        message: error.message,
+        stackTrace: error.stackTrace
+      };
+    }
+    case "STRING_ERROR": {
+      return {
+        message: error.raw
+      };
+    }
+    case "CUSTOM_ERROR": {
+      return {
+        message: error.raw
+      };
+    }
+    case "INTERNAL_ERROR": {
+      return {
+        message: `trigger.dev internal error (${error.code})`
+      };
+    }
+  }
+}
+__name(createJsonErrorObject, "createJsonErrorObject");
+function correctErrorStackTrace(stackTrace, projectDir, options) {
+  const [errorLine, ...traceLines] = stackTrace.split("\n");
+  return [
+    options?.removeFirstLine ? void 0 : errorLine,
+    ...traceLines.map((line) => correctStackTraceLine(line, projectDir, options?.isDev))
+  ].filter(Boolean).join("\n");
+}
+__name(correctErrorStackTrace, "correctErrorStackTrace");
+var LINES_TO_IGNORE = [
+  /ConsoleInterceptor/,
+  /TriggerTracer/,
+  /TaskExecutor/,
+  /EXECUTE_TASK_RUN/,
+  /@trigger.dev\/core/,
+  /packages\/core\/src\/v3/,
+  /safeJsonProcess/,
+  /__entryPoint.ts/,
+  /ZodIpc/,
+  /startActiveSpan/,
+  /processTicksAndRejections/
+];
+function correctStackTraceLine(line, projectDir, isDev) {
+  if (LINES_TO_IGNORE.some((regex) => regex.test(line))) {
+    return;
+  }
+  if (isDev && projectDir && !line.includes(projectDir)) {
+    return;
+  }
+  return line.trim();
+}
+__name(correctStackTraceLine, "correctStackTraceLine");
+function groupTaskMetadataIssuesByTask(tasks, issues) {
+  return issues.reduce((acc, issue) => {
+    if (issue.path.length === 0) {
+      return acc;
+    }
+    const taskIndex = issue.path[1];
+    if (typeof taskIndex !== "number") {
+      return acc;
+    }
+    const task = tasks[taskIndex];
+    if (!task) {
+      return acc;
+    }
+    const restOfPath = issue.path.slice(2);
+    const taskId = task.id;
+    const taskName = task.exportName;
+    const filePath = task.filePath;
+    const key = taskIndex;
+    const existing = acc[key] ?? {
+      id: taskId,
+      exportName: taskName,
+      filePath,
+      issues: []
+    };
+    existing.issues.push({
+      message: issue.message,
+      path: restOfPath.length === 0 ? void 0 : restOfPath.join(".")
+    });
+    return {
+      ...acc,
+      [key]: existing
+    };
+  }, {});
+}
+__name(groupTaskMetadataIssuesByTask, "groupTaskMetadataIssuesByTask");
 
 // src/v3/schemas/api.ts
 var WhoAmIResponseSchema = z.object({
@@ -719,7 +736,7 @@ var ReplayRunResponse = z.object({
   id: z.string()
 });
 var CanceledRunResponse = z.object({
-  message: z.string()
+  id: z.string()
 });
 var ScheduledTaskPayload = z.object({
   /** The schedule id associated with this run (you can have many schedules for the same task).
@@ -769,17 +786,18 @@ var CreateScheduleOptions = z.object({
   externalId: z.string().optional()
 });
 var UpdateScheduleOptions = CreateScheduleOptions;
+var ScheduleGenerator = z.object({
+  type: z.literal("CRON"),
+  expression: z.string(),
+  description: z.string()
+});
 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()
-  }),
+  generator: ScheduleGenerator,
   nextRun: z.coerce.date().nullish(),
   environments: z.array(z.object({
     id: z.string(),
@@ -803,12 +821,28 @@ var ListScheduleOptions = z.object({
   perPage: z.number().optional()
 });
 var RunStatus = z.enum([
-  "PENDING",
+  /// Task hasn't been deployed yet but is waiting to be executed
+  "WAITING_FOR_DEPLOY",
+  /// Task is waiting to be executed by a worker
+  "QUEUED",
+  /// Task is currently being executed by a worker
   "EXECUTING",
-  "PAUSED",
+  /// Task has failed and is waiting to be retried
+  "REATTEMPTING",
+  /// Task has been paused by the system, and will be resumed by the system
+  "FROZEN",
+  /// Task has been completed successfully
   "COMPLETED",
+  /// Task has been canceled by the user
+  "CANCELED",
+  /// Task has been completed with errors
   "FAILED",
-  "CANCELED"
+  /// Task has crashed and won't be retried, most likely the worker ran out of resources, e.g. memory or storage
+  "CRASHED",
+  /// Task was interrupted during execution, mostly this happens in development environments
+  "INTERRUPTED",
+  /// Task has failed to complete, due to an error in the system
+  "SYSTEM_FAILURE"
 ]);
 var AttemptStatus = z.enum([
   "PENDING",
@@ -818,23 +852,61 @@ var AttemptStatus = z.enum([
   "FAILED",
   "CANCELED"
 ]);
-var RetrieveRunResponse = z.object({
+var RunEnvironmentDetails = z.object({
+  id: z.string(),
+  name: z.string(),
+  user: z.string().optional()
+});
+var RunScheduleDetails = z.object({
+  id: z.string(),
+  externalId: z.string().optional(),
+  deduplicationKey: z.string().optional(),
+  generator: ScheduleGenerator
+});
+var CommonRunFields = {
   id: z.string(),
   status: RunStatus,
   taskIdentifier: z.string(),
   idempotencyKey: z.string().optional(),
   version: z.string().optional(),
+  isQueued: z.boolean(),
+  isExecuting: z.boolean(),
+  isCompleted: z.boolean(),
+  isSuccess: z.boolean(),
+  isFailed: z.boolean(),
+  isCancelled: z.boolean(),
+  isTest: z.boolean(),
   createdAt: z.coerce.date(),
   updatedAt: z.coerce.date(),
+  startedAt: z.coerce.date().optional(),
+  finishedAt: z.coerce.date().optional()
+};
+var RetrieveRunResponse = z.object({
+  ...CommonRunFields,
+  payload: z.any().optional(),
+  output: z.any().optional(),
+  schedule: RunScheduleDetails.optional(),
   attempts: z.array(z.object({
     id: z.string(),
     status: AttemptStatus,
     createdAt: z.coerce.date(),
     updatedAt: z.coerce.date(),
     startedAt: z.coerce.date().optional(),
-    completedAt: z.coerce.date().optional()
+    completedAt: z.coerce.date().optional(),
+    error: SerializedError.optional()
   }).optional())
 });
+var ListRunResponseItem = z.object({
+  ...CommonRunFields,
+  env: RunEnvironmentDetails
+});
+var ListRunResponse = z.object({
+  data: z.array(ListRunResponseItem),
+  pagination: z.object({
+    next: z.string().optional(),
+    previous: z.string().optional()
+  })
+});
 var CreateEnvironmentVariableRequestBody = z.object({
   name: z.string(),
   value: z.string()
@@ -2085,15 +2157,153 @@ var _TaskContextAPI = class _TaskContextAPI {
     return registerGlobal(API_NAME, taskContext2);
   }
 };
-_getTaskContext = new WeakSet();
-getTaskContext_fn = /* @__PURE__ */ __name(function() {
-  return getGlobal(API_NAME);
-}, "#getTaskContext");
-__name(_TaskContextAPI, "TaskContextAPI");
-var TaskContextAPI = _TaskContextAPI;
-
-// src/v3/task-context-api.ts
-var taskContext = TaskContextAPI.getInstance();
+_getTaskContext = new WeakSet();
+getTaskContext_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME);
+}, "#getTaskContext");
+__name(_TaskContextAPI, "TaskContextAPI");
+var TaskContextAPI = _TaskContextAPI;
+
+// src/v3/task-context-api.ts
+var taskContext = TaskContextAPI.getInstance();
+
+// src/v3/apiClient/errors.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()) {
@@ -2201,6 +2411,108 @@ function calculateResetAt2(resets, format, now = Date.now()) {
   return resetAt?.getTime();
 }
 __name(calculateResetAt2, "calculateResetAt");
+
+// src/v3/apiClient/pagination.ts
+var _CursorPage = class _CursorPage {
+  constructor(data, pagination, pageFetcher) {
+    this.pageFetcher = pageFetcher;
+    this.data = data;
+    this.pagination = pagination;
+  }
+  getPaginatedItems() {
+    return this.data ?? [];
+  }
+  hasNextPage() {
+    return !!this.pagination.next;
+  }
+  hasPreviousPage() {
+    return !!this.pagination.previous;
+  }
+  getNextPage() {
+    if (!this.pagination.next) {
+      throw new Error("No next page available");
+    }
+    return this.pageFetcher({
+      after: this.pagination.next
+    });
+  }
+  getPreviousPage() {
+    if (!this.pagination.previous) {
+      throw new Error("No previous page available");
+    }
+    return this.pageFetcher({
+      before: this.pagination.previous
+    });
+  }
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+};
+__name(_CursorPage, "CursorPage");
+var CursorPage = _CursorPage;
+var _OffsetLimitPage = class _OffsetLimitPage {
+  constructor(data, pagination, pageFetcher) {
+    this.pageFetcher = pageFetcher;
+    this.data = data;
+    this.pagination = pagination;
+  }
+  getPaginatedItems() {
+    return this.data ?? [];
+  }
+  hasNextPage() {
+    return this.pagination.currentPage < this.pagination.totalPages;
+  }
+  hasPreviousPage() {
+    return this.pagination.currentPage > 1;
+  }
+  getNextPage() {
+    if (!this.hasNextPage()) {
+      throw new Error("No next page available");
+    }
+    return this.pageFetcher({
+      page: this.pagination.currentPage + 1
+    });
+  }
+  getPreviousPage() {
+    if (!this.hasPreviousPage()) {
+      throw new Error("No previous page available");
+    }
+    return this.pageFetcher({
+      page: this.pagination.currentPage - 1
+    });
+  }
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+};
+__name(_OffsetLimitPage, "OffsetLimitPage");
+var OffsetLimitPage = _OffsetLimitPage;
+
+// src/v3/apiClient/core.ts
 var defaultRetryOptions2 = {
   maxAttempts: 3,
   factor: 2,
@@ -2208,11 +2520,62 @@ var defaultRetryOptions2 = {
   maxTimeoutInMs: 6e4,
   randomize: false
 };
-async function zodfetch(schema, url, requestInit, options) {
-  return await _doZodFetch(schema, url, requestInit, options);
+function zodfetch(schema, url, requestInit, options) {
+  return new ApiPromise(_doZodFetch(schema, url, requestInit, options));
 }
 __name(zodfetch, "zodfetch");
-async function zodupload(schema, url, body, requestInit, options) {
+function zodfetchCursorPage(schema, url, params, requestInit, options) {
+  const query = new URLSearchParams(params.query);
+  if (params.limit) {
+    query.set("page[size]", String(params.limit));
+  }
+  if (params.after) {
+    query.set("page[after]", params.after);
+  }
+  if (params.before) {
+    query.set("page[before]", params.before);
+  }
+  const cursorPageSchema = z.object({
+    data: z.array(schema),
+    pagination: z.object({
+      next: z.string().optional(),
+      previous: z.string().optional()
+    })
+  });
+  const $url = new URL(url);
+  $url.search = query.toString();
+  const fetchResult = _doZodFetch(cursorPageSchema, $url.href, requestInit, options);
+  return new CursorPagePromise(fetchResult, schema, url, params, requestInit, options);
+}
+__name(zodfetchCursorPage, "zodfetchCursorPage");
+function zodfetchOffsetLimitPage(schema, url, params, requestInit, options) {
+  const query = new URLSearchParams(params.query);
+  if (params.limit) {
+    query.set("perPage", String(params.limit));
+  }
+  if (params.page) {
+    query.set("page", String(params.page));
+  }
+  const offsetLimitPageSchema = z.object({
+    data: z.array(schema),
+    pagination: z.object({
+      currentPage: z.coerce.number(),
+      totalPages: z.coerce.number(),
+      count: z.coerce.number()
+    })
+  });
+  const $url = new URL(url);
+  $url.search = query.toString();
+  const fetchResult = _doZodFetch(offsetLimitPageSchema, $url.href, requestInit, options);
+  return new OffsetLimitPagePromise(fetchResult, schema, url, params, requestInit, options);
+}
+__name(zodfetchOffsetLimitPage, "zodfetchOffsetLimitPage");
+function zodupload(schema, url, body, requestInit, options) {
+  const finalRequestInit = createMultipartFormRequestInit(body, requestInit);
+  return new ApiPromise(_doZodFetch(schema, url, finalRequestInit, options));
+}
+__name(zodupload, "zodupload");
+async function createMultipartFormRequestInit(body, requestInit) {
   const form = await createForm(body);
   const encoder = new FormDataEncoder(form);
   const finalHeaders = {};
@@ -2230,9 +2593,9 @@ async function zodupload(schema, url, body, requestInit, options) {
     // @ts-expect-error
     duplex: "half"
   };
-  return await _doZodFetch(schema, url, finalRequestInit, options);
+  return finalRequestInit;
 }
-__name(zodupload, "zodupload");
+__name(createMultipartFormRequestInit, "createMultipartFormRequestInit");
 var createForm = /* @__PURE__ */ __name(async (body) => {
   const form = new FormData();
   await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
@@ -2240,7 +2603,8 @@ var createForm = /* @__PURE__ */ __name(async (body) => {
 }, "createForm");
 async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
   try {
-    const response = await fetch(url, requestInitWithCache(requestInit));
+    const $requestInit = await requestInit;
+    const response = await fetch(url, requestInitWithCache($requestInit));
     const responseHeaders = createResponseHeaders(response.headers);
     if (!response.ok) {
       const retryResult = shouldRetry(response, attempt, options?.retry);
@@ -2251,17 +2615,20 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
         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);
+        throw ApiError.generate(response.status, errJSON, errMessage, responseHeaders);
       }
     }
     const jsonBody = await response.json();
     const parsedResult = schema.safeParse(jsonBody);
     if (parsedResult.success) {
-      return parsedResult.data;
+      return {
+        data: parsedResult.data,
+        response
+      };
     }
     throw fromZodError(parsedResult.error);
   } catch (error) {
-    if (error instanceof APIError) {
+    if (error instanceof ApiError) {
       throw error;
     }
     if (options?.retry) {
@@ -2275,7 +2642,7 @@ async function _doZodFetch(schema, url, requestInit, options, attempt = 1) {
         return await _doZodFetch(schema, url, requestInit, options, attempt + 1);
       }
     }
-    throw new APIConnectionError({
+    throw new ApiConnectionError({
       cause: castToError2(error)
     });
   }
@@ -2448,6 +2815,128 @@ var isUploadable = /* @__PURE__ */ __name((value) => {
   return isFileLike(value) || isResponseLike(value) || isFsReadStream(value);
 }, "isUploadable");
 var isRecordLike = /* @__PURE__ */ __name((value) => value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0 && Object.keys(value).every((key) => typeof key === "string" && typeof value[key] === "string"), "isRecordLike");
+var _ApiPromise = class _ApiPromise extends Promise {
+  constructor(responsePromise) {
+    super((resolve) => {
+      resolve(null);
+    });
+    this.responsePromise = responsePromise;
+  }
+  /**
+  * Gets the raw `Response` instance instead of parsing the response
+  * data.
+  *
+  * If you want to parse the response body but still get the `Response`
+  * instance, you can use {@link withResponse()}.
+  */
+  asResponse() {
+    return this.responsePromise.then((p) => p.response);
+  }
+  /**
+  * Gets the parsed response data and the raw `Response` instance.
+  *
+  * If you just want to get the raw `Response` instance without parsing it,
+  * you can use {@link asResponse()}.
+  */
+  async withResponse() {
+    const [data, response] = await Promise.all([
+      this.parse(),
+      this.asResponse()
+    ]);
+    return {
+      data,
+      response
+    };
+  }
+  parse() {
+    return this.responsePromise.then((result) => result.data);
+  }
+  then(onfulfilled, onrejected) {
+    return this.parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.parse().finally(onfinally);
+  }
+};
+__name(_ApiPromise, "ApiPromise");
+var ApiPromise = _ApiPromise;
+var _fetchPage, fetchPage_fn;
+var _CursorPagePromise = class _CursorPagePromise extends ApiPromise {
+  constructor(result, schema, url, params, requestInit, options) {
+    super(result.then((result2) => ({
+      data: new CursorPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage, fetchPage_fn).bind(this)),
+      response: result2.response
+    })));
+    __privateAdd(this, _fetchPage);
+    this.schema = schema;
+    this.url = url;
+    this.params = params;
+    this.requestInit = requestInit;
+    this.options = options;
+  }
+  /**
+  * Allow auto-paginating iteration on an unawaited list call, eg:
+  *
+  *    for await (const item of client.items.list()) {
+  *      console.log(item)
+  *    }
+  */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+};
+_fetchPage = new WeakSet();
+fetchPage_fn = /* @__PURE__ */ __name(function(params) {
+  return zodfetchCursorPage(this.schema, this.url, {
+    ...this.params,
+    ...params
+  }, this.requestInit, this.options);
+}, "#fetchPage");
+__name(_CursorPagePromise, "CursorPagePromise");
+var CursorPagePromise = _CursorPagePromise;
+var _fetchPage2, fetchPage_fn2;
+var _OffsetLimitPagePromise = class _OffsetLimitPagePromise extends ApiPromise {
+  constructor(result, schema, url, params, requestInit, options) {
+    super(result.then((result2) => ({
+      data: new OffsetLimitPage(result2.data.data, result2.data.pagination, __privateMethod(this, _fetchPage2, fetchPage_fn2).bind(this)),
+      response: result2.response
+    })));
+    __privateAdd(this, _fetchPage2);
+    this.schema = schema;
+    this.url = url;
+    this.params = params;
+    this.requestInit = requestInit;
+    this.options = options;
+  }
+  /**
+  * Allow auto-paginating iteration on an unawaited list call, eg:
+  *
+  *    for await (const item of client.items.list()) {
+  *      console.log(item)
+  *    }
+  */
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+};
+_fetchPage2 = new WeakSet();
+fetchPage_fn2 = /* @__PURE__ */ __name(function(params1) {
+  return zodfetchOffsetLimitPage(this.schema, this.url, {
+    ...this.params,
+    ...params1
+  }, this.requestInit, this.options);
+}, "#fetchPage");
+__name(_OffsetLimitPagePromise, "OffsetLimitPagePromise");
+var OffsetLimitPagePromise = _OffsetLimitPagePromise;
 
 // src/v3/apiClient/index.ts
 var zodFetchOptions = {
@@ -2473,7 +2962,7 @@ var _ApiClient = class _ApiClient {
         headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
       }, zodFetchOptions);
     } catch (error) {
-      if (error instanceof APIError) {
+      if (error instanceof ApiError) {
         if (error.status === 404) {
           return void 0;
         }
@@ -2488,14 +2977,16 @@ var _ApiClient = class _ApiClient {
     }, zodFetchOptions);
   }
   triggerTask(taskId, body, options) {
-    return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/trigger`, {
+    const encodedTaskId = encodeURIComponent(taskId);
+    return zodfetch(TriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${encodedTaskId}/trigger`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
       body: JSON.stringify(body)
     }, zodFetchOptions);
   }
   batchTriggerTask(taskId, body, options) {
-    return zodfetch(BatchTriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${taskId}/batch`, {
+    const encodedTaskId = encodeURIComponent(taskId);
+    return zodfetch(BatchTriggerTaskResponse, `${this.baseUrl}/api/v1/tasks/${encodedTaskId}/batch`, {
       method: "POST",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, options?.spanParentAsLink ?? false),
       body: JSON.stringify(body)
@@ -2519,6 +3010,33 @@ var _ApiClient = class _ApiClient {
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
     }, zodFetchOptions);
   }
+  listRuns(query) {
+    const searchParams = createSearchQueryForListRuns(query);
+    return zodfetchCursorPage(ListRunResponseItem, `${this.baseUrl}/api/v1/runs`, {
+      query: searchParams,
+      limit: query?.limit,
+      after: query?.after,
+      before: query?.before
+    }, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
+  listProjectRuns(projectRef, query) {
+    const searchParams = createSearchQueryForListRuns(query);
+    if (query?.env) {
+      searchParams.append("filter[env]", Array.isArray(query.env) ? query.env.join(",") : query.env);
+    }
+    return zodfetchCursorPage(ListRunResponseItem, `${this.baseUrl}/api/v1/projects/${projectRef}/runs`, {
+      query: searchParams,
+      limit: query?.limit,
+      after: query?.after,
+      before: query?.before
+    }, {
+      method: "GET",
+      headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
+    }, zodFetchOptions);
+  }
   replayRun(runId) {
     return zodfetch(ReplayRunResponse, `${this.baseUrl}/api/v1/runs/${runId}/replay`, {
       method: "POST",
@@ -2546,7 +3064,10 @@ var _ApiClient = class _ApiClient {
     if (options?.perPage) {
       searchParams.append("perPage", options.perPage.toString());
     }
-    return zodfetch(ListSchedulesResult, `${this.baseUrl}/api/v1/schedules${searchParams.size > 0 ? `?${searchParams}` : ""}`, {
+    return zodfetchOffsetLimitPage(ScheduleObject, `${this.baseUrl}/api/v1/schedules`, {
+      page: options?.page,
+      limit: options?.perPage
+    }, {
       method: "GET",
       headers: __privateMethod(this, _getHeaders, getHeaders_fn).call(this, false)
     });
@@ -2647,6 +3168,40 @@ getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
 }, "#getHeaders");
 __name(_ApiClient, "ApiClient");
 var ApiClient = _ApiClient;
+function createSearchQueryForListRuns(query) {
+  const searchParams = new URLSearchParams();
+  if (query) {
+    if (query.status) {
+      searchParams.append("filter[status]", Array.isArray(query.status) ? query.status.join(",") : query.status);
+    }
+    if (query.taskIdentifier) {
+      searchParams.append("filter[taskIdentifier]", Array.isArray(query.taskIdentifier) ? query.taskIdentifier.join(",") : query.taskIdentifier);
+    }
+    if (query.version) {
+      searchParams.append("filter[version]", Array.isArray(query.version) ? query.version.join(",") : query.version);
+    }
+    if (query.bulkAction) {
+      searchParams.append("filter[bulkAction]", query.bulkAction);
+    }
+    if (query.schedule) {
+      searchParams.append("filter[schedule]", query.schedule);
+    }
+    if (typeof query.isTest === "boolean") {
+      searchParams.append("filter[isTest]", String(query.isTest));
+    }
+    if (query.from) {
+      searchParams.append("filter[createdAt][from]", query.from instanceof Date ? query.from.getTime().toString() : query.from.toString());
+    }
+    if (query.to) {
+      searchParams.append("filter[createdAt][to]", query.to instanceof Date ? query.to.getTime().toString() : query.to.toString());
+    }
+    if (query.period) {
+      searchParams.append("filter[createdAt][period]", query.period);
+    }
+  }
+  return searchParams;
+}
+__name(createSearchQueryForListRuns, "createSearchQueryForListRuns");
 var _SimpleClock = class _SimpleClock {
   preciseNow() {
     const now = new PreciseDate();
@@ -2696,149 +3251,6 @@ var ClockAPI = _ClockAPI;
 // src/v3/clock-api.ts
 var clock = ClockAPI.getInstance();
 
-// src/v3/errors.ts
-function parseError(error) {
-  if (error instanceof Error) {
-    return {
-      type: "BUILT_IN_ERROR",
-      name: error.name,
-      message: error.message,
-      stackTrace: error.stack ?? ""
-    };
-  }
-  if (typeof error === "string") {
-    return {
-      type: "STRING_ERROR",
-      raw: error
-    };
-  }
-  try {
-    return {
-      type: "CUSTOM_ERROR",
-      raw: JSON.stringify(error)
-    };
-  } catch (e) {
-    return {
-      type: "CUSTOM_ERROR",
-      raw: String(error)
-    };
-  }
-}
-__name(parseError, "parseError");
-function createErrorTaskError(error) {
-  switch (error.type) {
-    case "BUILT_IN_ERROR": {
-      const e = new Error(error.message);
-      e.name = error.name;
-      e.stack = error.stackTrace;
-      return e;
-    }
-    case "STRING_ERROR": {
-      return error.raw;
-    }
-    case "CUSTOM_ERROR": {
-      return JSON.parse(error.raw);
-    }
-    case "INTERNAL_ERROR": {
-      return new Error(`trigger.dev internal error (${error.code})`);
-    }
-  }
-}
-__name(createErrorTaskError, "createErrorTaskError");
-function createJsonErrorObject(error) {
-  switch (error.type) {
-    case "BUILT_IN_ERROR": {
-      return {
-        name: error.name,
-        message: error.message,
-        stackTrace: error.stackTrace
-      };
-    }
-    case "STRING_ERROR": {
-      return {
-        message: error.raw
-      };
-    }
-    case "CUSTOM_ERROR": {
-      return {
-        message: error.raw
-      };
-    }
-    case "INTERNAL_ERROR": {
-      return {
-        message: `trigger.dev internal error (${error.code})`
-      };
-    }
-  }
-}
-__name(createJsonErrorObject, "createJsonErrorObject");
-function correctErrorStackTrace(stackTrace, projectDir, options) {
-  const [errorLine, ...traceLines] = stackTrace.split("\n");
-  return [
-    options?.removeFirstLine ? void 0 : errorLine,
-    ...traceLines.map((line) => correctStackTraceLine(line, projectDir, options?.isDev))
-  ].filter(Boolean).join("\n");
-}
-__name(correctErrorStackTrace, "correctErrorStackTrace");
-var LINES_TO_IGNORE = [
-  /ConsoleInterceptor/,
-  /TriggerTracer/,
-  /TaskExecutor/,
-  /EXECUTE_TASK_RUN/,
-  /@trigger.dev\/core/,
-  /packages\/core\/src\/v3/,
-  /safeJsonProcess/,
-  /__entryPoint.ts/,
-  /ZodIpc/,
-  /startActiveSpan/,
-  /processTicksAndRejections/
-];
-function correctStackTraceLine(line, projectDir, isDev) {
-  if (LINES_TO_IGNORE.some((regex) => regex.test(line))) {
-    return;
-  }
-  if (isDev && projectDir && !line.includes(projectDir)) {
-    return;
-  }
-  return line.trim();
-}
-__name(correctStackTraceLine, "correctStackTraceLine");
-function groupTaskMetadataIssuesByTask(tasks, issues) {
-  return issues.reduce((acc, issue) => {
-    if (issue.path.length === 0) {
-      return acc;
-    }
-    const taskIndex = issue.path[1];
-    if (typeof taskIndex !== "number") {
-      return acc;
-    }
-    const task = tasks[taskIndex];
-    if (!task) {
-      return acc;
-    }
-    const restOfPath = issue.path.slice(2);
-    const taskId = task.id;
-    const taskName = task.exportName;
-    const filePath = task.filePath;
-    const key = taskIndex;
-    const existing = acc[key] ?? {
-      id: taskId,
-      exportName: taskName,
-      filePath,
-      issues: []
-    };
-    existing.issues.push({
-      message: issue.message,
-      path: restOfPath.length === 0 ? void 0 : restOfPath.join(".")
-    });
-    return {
-      ...acc,
-      [key]: existing
-    };
-  }, {});
-}
-__name(groupTaskMetadataIssuesByTask, "groupTaskMetadataIssuesByTask");
-
 // src/v3/limits.ts
 var OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = 256;
 var OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = 256;
@@ -3870,6 +4282,6 @@ function safeJsonParse2(value) {
 }
 __name(safeJsonParse2, "safeJsonParse");
 
-export { APIConnectionError, APIError, ApiClient, AttemptStatus, AuthenticationError, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BadRequestError, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConflictError, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateEnvironmentVariableRequestBody, CreateScheduleOptions, CreateUploadPayloadUrlResponseBody, DeletedScheduleObject, DeploymentErrorData, EnvironmentType, EnvironmentVariable, EnvironmentVariableResponseBody, EnvironmentVariableValue, EnvironmentVariables, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, ImportEnvironmentVariablesRequestBody, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, InternalServerError, ListScheduleOptions, ListSchedulesResult, Machine, MachineCpu, MachineMemory, NULL_SENTINEL, NotFoundError, OFFLOAD_IO_PACKET_LENGTH_LIMIT, OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT, OTEL_LINK_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_COUNT_LIMIT, OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT, OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT, OTEL_SPAN_EVENT_COUNT_LIMIT, OtherSpanEvent, PRIMARY_VARIANT, PermissionDeniedError, PlatformToCoordinatorMessages, PlatformToProviderMessages, PostStartCauses, PreStopCauses, ProdChildToWorkerMessages, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitError, RateLimitOptions, ReplayRunResponse, RetrieveRunResponse, RetryOptions, RunStatus, ScheduleObject, ScheduledTaskPayload, SemanticInternalAttributes, SharedQueueToClientMessages, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskEventStyle, TaskFileMetadata, TaskMetadata, TaskMetadataFailedToParseData, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionBatch, TaskRunExecutionEnvironment, TaskRunExecutionLazyAttemptPayload, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionQueue, TaskRunExecutionResult, TaskRunExecutionRetry, TaskRunExecutionTask, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, UncaughtExceptionMessage, UnprocessableEntityError, UpdateEnvironmentVariableRequestBody, UpdateScheduleOptions, WaitReason, WhoAmIResponseSchema, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createJsonErrorObject, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, groupTaskMetadataIssuesByTask, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logger, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseError, parsePacket, prettyPrintPacket, primitiveValueOrflattenedAttributes, runtime, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskCatalog, taskContext, unflattenAttributes, workerToChildMessages };
+export { ApiClient, ApiConnectionError, ApiError, AttemptStatus, AuthenticationError, BackgroundWorkerClientMessages, BackgroundWorkerMetadata, BackgroundWorkerProperties, BackgroundWorkerServerMessages, BadRequestError, BatchTaskRunExecutionResult, BatchTriggerTaskRequestBody, BatchTriggerTaskResponse, CanceledRunResponse, CancellationSpanEvent, ClientToSharedQueueMessages, Config, ConflictError, CoordinatorToPlatformMessages, CoordinatorToProdWorkerMessages, CreateAuthorizationCodeResponseSchema, CreateBackgroundWorkerRequestBody, CreateBackgroundWorkerResponse, CreateEnvironmentVariableRequestBody, CreateScheduleOptions, CreateUploadPayloadUrlResponseBody, CursorPage, DeletedScheduleObject, DeploymentErrorData, EnvironmentType, EnvironmentVariable, EnvironmentVariableResponseBody, EnvironmentVariableValue, EnvironmentVariables, EventFilter, ExceptionEventProperties, ExceptionSpanEvent, ExternalBuildData, FetchRetryBackoffStrategy, FetchRetryByStatusOptions, FetchRetryHeadersStrategy, FetchRetryOptions, FetchRetryStrategy, FetchTimeoutOptions, FixedWindowRateLimit, GetBatchResponseBody, GetDeploymentResponseBody, GetEnvironmentVariablesResponseBody, GetPersonalAccessTokenRequestSchema, GetPersonalAccessTokenResponseSchema, GetProjectEnvResponse, GetProjectResponseBody, GetProjectsResponseBody, ImageDetailsMetadata, ImportEnvironmentVariablesRequestBody, InitializeDeploymentRequestBody, InitializeDeploymentResponseBody, InternalServerError, ListRunResponse, ListRunResponseItem, ListScheduleOptions, ListSchedulesResult, Machine, MachineCpu, MachineMemory, NULL_SENTINEL, 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, OffsetLimitPage, OtherSpanEvent, PRIMARY_VARIANT, PermissionDeniedError, PlatformToCoordinatorMessages, PlatformToProviderMessages, PostStartCauses, PreStopCauses, ProdChildToWorkerMessages, ProdTaskRunExecution, ProdTaskRunExecutionPayload, ProdWorkerSocketData, ProdWorkerToChildMessages, ProdWorkerToCoordinatorMessages, ProviderToPlatformMessages, QueueOptions, RateLimitError, RateLimitOptions, ReplayRunResponse, RetrieveRunResponse, RetryOptions, RunEnvironmentDetails, RunScheduleDetails, RunStatus, ScheduleGenerator, ScheduleObject, ScheduledTaskPayload, SemanticInternalAttributes, SerializedError, SharedQueueToClientMessages, SlidingWindowRateLimit, SpanEvent, SpanEvents, SpanMessagingEvent, StartDeploymentIndexingRequestBody, StartDeploymentIndexingResponseBody, TaskEventStyle, TaskFileMetadata, TaskMetadata, TaskMetadataFailedToParseData, TaskMetadataWithFilePath, TaskResource, TaskRun, TaskRunBuiltInError, TaskRunContext, TaskRunCustomErrorObject, TaskRunError, TaskRunErrorCodes, TaskRunExecution, TaskRunExecutionAttempt, TaskRunExecutionBatch, TaskRunExecutionEnvironment, TaskRunExecutionLazyAttemptPayload, TaskRunExecutionOrganization, TaskRunExecutionPayload, TaskRunExecutionProject, TaskRunExecutionQueue, TaskRunExecutionResult, TaskRunExecutionRetry, TaskRunExecutionTask, TaskRunFailedExecutionResult, TaskRunInternalError, TaskRunStringError, TaskRunSuccessfulExecutionResult, TriggerTaskRequestBody, TriggerTaskResponse, TriggerTracer, UncaughtExceptionMessage, UnprocessableEntityError, UpdateEnvironmentVariableRequestBody, UpdateScheduleOptions, WaitReason, WhoAmIResponseSchema, accessoryAttributes, apiClientManager, calculateNextRetryDelay, calculateResetAt2 as calculateResetAt, childToWorkerMessages, clientWebsocketMessages, clock, conditionallyExportPacket, conditionallyImportPacket, correctErrorStackTrace, createErrorTaskError, createJsonErrorObject, createPacketAttributes, createPacketAttributesAsJson, defaultFetchRetryOptions, defaultRetryOptions, detectDependencyVersion, eventFilterMatches, flattenAttributes, formatDuration, formatDurationInDays, formatDurationMilliseconds, formatDurationNanoseconds, groupTaskMetadataIssuesByTask, imposeAttributeLimits, isCancellationSpanEvent, isExceptionSpanEvent, logger, millisecondsToNanoseconds, nanosecondsToMilliseconds, omit, packetRequiresOffloading, parseError, parsePacket, prettyPrintPacket, primitiveValueOrflattenedAttributes, runtime, serverWebsocketMessages, stringPatternMatchers, stringifyIO, taskCatalog, taskContext, unflattenAttributes, workerToChildMessages };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map