@trigger.dev/sdk 3.0.0-beta.5 → 3.0.0-beta.51

package/dist/v3/index.js

@@ -1,409 +1,33 @@
 'use strict';
 
+var v3 = require('@trigger.dev/core/v3');
 var api = require('@opentelemetry/api');
 var semanticConventions = require('@opentelemetry/semantic-conventions');
-var v3 = require('@trigger.dev/core/v3');
 var node_async_hooks = require('node:async_hooks');
+var zodfetch = require('@trigger.dev/core/v3/zodfetch');
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 
 // package.json
-var version = "3.0.0-beta.5";
+var version = "3.0.0-beta.51";
+
+// src/v3/tracer.ts
 var tracer = new v3.TriggerTracer({
   name: "@trigger.dev/sdk",
   version
 });
 
-// src/v3/shared.ts
-function createTask(params) {
-  const task2 = {
-    trigger: async ({ payload, options }) => {
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
-      }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
-      const handle = await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} trigger()`, async (span) => {
-        const response = await apiClient.triggerTask(params.id, {
-          payload,
-          options: {
-            queue: params.queue,
-            concurrencyKey: options?.concurrencyKey,
-            test: v3.taskContextManager.ctx?.run.isTest
-          }
-        }, {
-          spanParentAsLink: true
-        });
-        if (!response.ok) {
-          throw new Error(response.error);
-        }
-        span.setAttribute("messaging.message.id", response.data.id);
-        return response.data;
-      }, {
-        kind: api.SpanKind.PRODUCER,
-        attributes: {
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          ["messaging.client_id"]: v3.taskContextManager.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          ["messaging.message.body.size"]: JSON.stringify(payload).length,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          ...taskMetadata ? v3.accessoryAttributes({
-            items: [
-              {
-                text: `${taskMetadata.exportName}.trigger()`,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          }) : {}
-        }
-      });
-      return handle;
-    },
-    batchTrigger: async ({ items }) => {
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
-      }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
-      const response = await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTrigger()`, async (span) => {
-        const response2 = await apiClient.batchTriggerTask(params.id, {
-          items: items.map((item) => ({
-            payload: item.payload,
-            options: {
-              queue: item.options?.queue ?? params.queue,
-              concurrencyKey: item.options?.concurrencyKey,
-              test: v3.taskContextManager.ctx?.run.isTest
-            }
-          }))
-        }, {
-          spanParentAsLink: true
-        });
-        if (!response2.ok) {
-          throw new Error(response2.error);
-        }
-        span.setAttribute("messaging.message.id", response2.data.batchId);
-        return response2.data;
-      }, {
-        kind: api.SpanKind.PRODUCER,
-        attributes: {
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.batch.message_count"]: items.length,
-          ["messaging.client_id"]: v3.taskContextManager.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          ["messaging.message.body.size"]: items.map((item) => JSON.stringify(item.payload)).join("").length,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          ...taskMetadata ? v3.accessoryAttributes({
-            items: [
-              {
-                text: `${taskMetadata.exportName}.batchTrigger()`,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          }) : {}
-        }
-      });
-      return response;
-    },
-    triggerAndWait: async ({ payload, options }) => {
-      const ctx = v3.taskContextManager.ctx;
-      if (!ctx) {
-        throw new Error("triggerAndWait can only be used from inside a task.run()");
-      }
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
-      }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
-      return await tracer.startActiveSpan(taskMetadata ? "Trigger" : `${params.id} triggerAndWait()`, async (span) => {
-        const response = await apiClient.triggerTask(params.id, {
-          payload,
-          options: {
-            dependentAttempt: ctx.attempt.id,
-            lockToVersion: v3.taskContextManager.worker?.version,
-            queue: params.queue,
-            concurrencyKey: options?.concurrencyKey,
-            test: v3.taskContextManager.ctx?.run.isTest
-          }
-        });
-        if (!response.ok) {
-          throw new Error(response.error);
-        }
-        span.setAttribute("messaging.message.id", response.data.id);
-        const result = await v3.runtime.waitForTask({
-          id: response.data.id,
-          ctx
-        });
-        const runResult = await handleTaskRunExecutionResult(result);
-        if (!runResult.ok) {
-          throw runResult.error;
-        }
-        return runResult.output;
-      }, {
-        kind: api.SpanKind.PRODUCER,
-        attributes: {
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.client_id"]: v3.taskContextManager.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          ...taskMetadata ? v3.accessoryAttributes({
-            items: [
-              {
-                text: `${taskMetadata.exportName}.triggerAndWait()`,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          }) : {}
-        }
-      });
-    },
-    batchTriggerAndWait: async ({ items }) => {
-      const ctx = v3.taskContextManager.ctx;
-      if (!ctx) {
-        throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
-      }
-      const apiClient = v3.apiClientManager.client;
-      if (!apiClient) {
-        throw apiClientMissingError();
-      }
-      const taskMetadata = v3.runtime.getTaskMetadata(params.id);
-      return await tracer.startActiveSpan(taskMetadata ? "Batch trigger" : `${params.id} batchTriggerAndWait()`, async (span) => {
-        const response = await apiClient.batchTriggerTask(params.id, {
-          items: items.map((item) => ({
-            payload: item.payload,
-            options: {
-              lockToVersion: v3.taskContextManager.worker?.version,
-              queue: item.options?.queue ?? params.queue,
-              concurrencyKey: item.options?.concurrencyKey,
-              test: v3.taskContextManager.ctx?.run.isTest
-            }
-          })),
-          dependentAttempt: ctx.attempt.id
-        });
-        if (!response.ok) {
-          throw new Error(response.error);
-        }
-        span.setAttribute("messaging.message.id", response.data.batchId);
-        const result = await v3.runtime.waitForBatch({
-          id: response.data.batchId,
-          runs: response.data.runs,
-          ctx
-        });
-        const runs = await handleBatchTaskRunExecutionResult(result.items);
-        return {
-          id: result.id,
-          runs
-        };
-      }, {
-        kind: api.SpanKind.PRODUCER,
-        attributes: {
-          [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
-          ["messaging.batch.message_count"]: items.length,
-          ["messaging.client_id"]: v3.taskContextManager.worker?.id,
-          [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: params.queue?.name ?? params.id,
-          ["messaging.message.body.size"]: items.map((item) => JSON.stringify(item.payload)).join("").length,
-          [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
-          [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
-          ...taskMetadata ? v3.accessoryAttributes({
-            items: [
-              {
-                text: `${taskMetadata.exportName}.batchTriggerAndWait()`,
-                variant: "normal"
-              }
-            ],
-            style: "codepath"
-          }) : {}
-        }
-      });
-    }
-  };
-  Object.defineProperty(task2, "__trigger", {
-    value: {
-      id: params.id,
-      packageVersion: version,
-      queue: params.queue,
-      retry: params.retry ? {
-        ...v3.defaultRetryOptions,
-        ...params.retry
-      } : void 0,
-      machine: params.machine,
-      fns: {
-        run: params.run,
-        init: params.init,
-        cleanup: params.cleanup,
-        middleware: params.middleware,
-        handleError: params.handleError
-      }
-    },
-    enumerable: false
-  });
-  return task2;
-}
-__name(createTask, "createTask");
-async function handleBatchTaskRunExecutionResult(items) {
-  const someObjectStoreOutputs = items.some((item) => item.ok && item.outputType === "application/store");
-  if (!someObjectStoreOutputs) {
-    const results = await Promise.all(items.map(async (item) => {
-      return await handleTaskRunExecutionResult(item);
-    }));
-    return results;
-  }
-  return await tracer.startActiveSpan("store.downloadPayloads", async (span) => {
-    const results = await Promise.all(items.map(async (item) => {
-      return await handleTaskRunExecutionResult(item);
-    }));
-    return results;
-  }, {
-    kind: api.SpanKind.INTERNAL,
-    [v3.SemanticInternalAttributes.STYLE_ICON]: "cloud-download"
-  });
-}
-__name(handleBatchTaskRunExecutionResult, "handleBatchTaskRunExecutionResult");
-async function handleTaskRunExecutionResult(execution) {
-  if (execution.ok) {
-    const outputPacket = {
-      data: execution.output,
-      dataType: execution.outputType
-    };
-    const importedPacket = await v3.conditionallyImportPacket(outputPacket, tracer);
-    return {
-      ok: true,
-      id: execution.id,
-      output: await v3.parsePacket(importedPacket)
-    };
-  } else {
-    return {
-      ok: false,
-      id: execution.id,
-      error: v3.createErrorTaskError(execution.error)
-    };
-  }
-}
-__name(handleTaskRunExecutionResult, "handleTaskRunExecutionResult");
-function apiClientMissingError() {
-  const hasBaseUrl = !!v3.apiClientManager.baseURL;
-  const hasAccessToken = !!v3.apiClientManager.accessToken;
-  if (!hasBaseUrl && !hasAccessToken) {
-    return `You need to set the TRIGGER_API_URL and TRIGGER_SECRET_KEY environment variables.`;
-  } else if (!hasBaseUrl) {
-    return `You need to set the TRIGGER_API_URL environment variable.`;
-  } else if (!hasAccessToken) {
-    return `You need to set the TRIGGER_SECRET_KEY environment variable.`;
-  }
-  return `Unknown error`;
-}
-__name(apiClientMissingError, "apiClientMissingError");
-
-// src/v3/tasks.ts
-function task(options) {
-  return createTask(options);
-}
-__name(task, "task");
-var wait = {
-  for: async (options) => {
-    return tracer.startActiveSpan(`wait.for()`, async (span) => {
-      const durationInMs = calculateDurationInMs(options);
-      await v3.runtime.waitForDuration(durationInMs);
-    }, {
-      attributes: {
-        [v3.SemanticInternalAttributes.STYLE_ICON]: "wait",
-        ...v3.accessoryAttributes({
-          items: [
-            {
-              text: nameForWaitOptions(options),
-              variant: "normal"
-            }
-          ],
-          style: "codepath"
-        })
-      }
-    });
-  },
-  until: async (options) => {
-    return tracer.startActiveSpan(`wait.until()`, async (span) => {
-      const start = Date.now();
-      if (options.throwIfInThePast && options.date < /* @__PURE__ */ new Date()) {
-        throw new Error("Date is in the past");
-      }
-      const durationInMs = options.date.getTime() - start;
-      await v3.runtime.waitForDuration(durationInMs);
-    }, {
-      attributes: {
-        [v3.SemanticInternalAttributes.STYLE_ICON]: "wait",
-        ...v3.accessoryAttributes({
-          items: [
-            {
-              text: options.date.toISOString(),
-              variant: "normal"
-            }
-          ],
-          style: "codepath"
-        })
-      }
-    });
-  }
-};
-function nameForWaitOptions(options) {
-  if ("seconds" in options) {
-    return options.seconds === 1 ? `1 second` : `${options.seconds} seconds`;
-  }
-  if ("minutes" in options) {
-    return options.minutes === 1 ? `1 minute` : `${options.minutes} minutes`;
-  }
-  if ("hours" in options) {
-    return options.hours === 1 ? `1 hour` : `${options.hours} hours`;
-  }
-  if ("days" in options) {
-    return options.days === 1 ? `1 day` : `${options.days} days`;
-  }
-  if ("weeks" in options) {
-    return options.weeks === 1 ? `1 week` : `${options.weeks} weeks`;
-  }
-  if ("months" in options) {
-    return options.months === 1 ? `1 month` : `${options.months} months`;
-  }
-  if ("years" in options) {
-    return options.years === 1 ? `1 year` : `${options.years} years`;
-  }
-  return "NaN";
-}
-__name(nameForWaitOptions, "nameForWaitOptions");
-function calculateDurationInMs(options) {
-  if ("seconds" in options) {
-    return options.seconds * 1e3;
-  }
-  if ("minutes" in options) {
-    return options.minutes * 1e3 * 60;
-  }
-  if ("hours" in options) {
-    return options.hours * 1e3 * 60 * 60;
-  }
-  if ("days" in options) {
-    return options.days * 1e3 * 60 * 60 * 24;
-  }
-  if ("weeks" in options) {
-    return options.weeks * 1e3 * 60 * 60 * 24 * 7;
-  }
-  if ("months" in options) {
-    return options.months * 1e3 * 60 * 60 * 24 * 30;
-  }
-  if ("years" in options) {
-    return options.years * 1e3 * 60 * 60 * 24 * 365;
-  }
-  throw new Error("Invalid options");
-}
-__name(calculateDurationInMs, "calculateDurationInMs");
+// src/v3/cache.ts
 var _InMemoryCache = class _InMemoryCache {
   constructor() {
     __publicField(this, "_cache", /* @__PURE__ */ new Map());
@@ -500,6 +124,10 @@ function onThrow(fn, options) {
         innerSpan.setStatus({
           code: api.SpanStatusCode.ERROR
         });
+        if (e instanceof Error && e.name === "AbortTaskRunError") {
+          innerSpan.end();
+          throw e;
+        }
         const nextRetryDelay = v3.calculateNextRetryDelay(opts, attempt);
         if (!nextRetryDelay) {
           innerSpan.end();
@@ -878,15 +506,1394 @@ var retry = {
   fetch: retryFetch,
   interceptFetch
 };
-
-Object.defineProperty(exports, 'logger', {
+var runs = {
+  replay: replayRun,
+  cancel: cancelRun,
+  retrieve: retrieveRun,
+  list: listRuns,
+  reschedule: rescheduleRun,
+  poll
+};
+function listRuns(paramsOrProjectRef, paramsOrOptions, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = listRunsRequestOptions(paramsOrProjectRef, paramsOrOptions, requestOptions);
+  if (typeof paramsOrProjectRef === "string") {
+    if (v3.isRequestOptions(paramsOrOptions)) {
+      return apiClient.listProjectRuns(paramsOrProjectRef, {}, $requestOptions);
+    } else {
+      return apiClient.listProjectRuns(paramsOrProjectRef, paramsOrOptions, $requestOptions);
+    }
+  }
+  return apiClient.listRuns(paramsOrProjectRef, $requestOptions);
+}
+__name(listRuns, "listRuns");
+function listRunsRequestOptions(paramsOrProjectRef, paramsOrOptions, requestOptions) {
+  if (typeof paramsOrProjectRef === "string") {
+    if (v3.isRequestOptions(paramsOrOptions)) {
+      return v3.mergeRequestOptions({
+        tracer,
+        name: "runs.list()",
+        icon: "runs",
+        attributes: {
+          projectRef: paramsOrProjectRef,
+          ...v3.accessoryAttributes({
+            items: [
+              {
+                text: paramsOrProjectRef,
+                variant: "normal"
+              }
+            ],
+            style: "codepath"
+          })
+        }
+      }, paramsOrOptions);
+    } else {
+      return v3.mergeRequestOptions({
+        tracer,
+        name: "runs.list()",
+        icon: "runs",
+        attributes: {
+          projectRef: paramsOrProjectRef,
+          ...v3.flattenAttributes(paramsOrOptions, "queryParams"),
+          ...v3.accessoryAttributes({
+            items: [
+              {
+                text: paramsOrProjectRef,
+                variant: "normal"
+              }
+            ],
+            style: "codepath"
+          })
+        }
+      }, requestOptions);
+    }
+  }
+  return v3.mergeRequestOptions({
+    tracer,
+    name: "runs.list()",
+    icon: "runs",
+    attributes: {
+      ...v3.flattenAttributes(paramsOrProjectRef, "queryParams")
+    }
+  }, v3.isRequestOptions(paramsOrOptions) ? paramsOrOptions : requestOptions);
+}
+__name(listRunsRequestOptions, "listRunsRequestOptions");
+function retrieveRun(runId, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "runs.retrieve()",
+    icon: "runs",
+    attributes: {
+      runId: typeof runId === "string" ? runId : runId.id,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: typeof runId === "string" ? runId : runId.id,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  if (typeof runId === "string") {
+    return apiClient.retrieveRun(runId, $requestOptions);
+  } else {
+    return apiClient.retrieveRun(runId.id, $requestOptions);
+  }
+}
+__name(retrieveRun, "retrieveRun");
+function replayRun(runId, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "runs.replay()",
+    icon: "runs",
+    attributes: {
+      runId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: runId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.replayRun(runId, $requestOptions);
+}
+__name(replayRun, "replayRun");
+function cancelRun(runId, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "runs.cancel()",
+    icon: "runs",
+    attributes: {
+      runId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: runId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.cancelRun(runId, $requestOptions);
+}
+__name(cancelRun, "cancelRun");
+function rescheduleRun(runId, body, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "runs.reschedule()",
+    icon: "runs",
+    attributes: {
+      runId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: runId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.rescheduleRun(runId, body, $requestOptions);
+}
+__name(rescheduleRun, "rescheduleRun");
+var MAX_POLL_ATTEMPTS = 500;
+async function poll(runId, options, requestOptions) {
+  let attempts = 0;
+  while (attempts++ < MAX_POLL_ATTEMPTS) {
+    const run = await runs.retrieve(runId, requestOptions);
+    if (run.isCompleted) {
+      return run;
+    }
+    await new Promise((resolve) => setTimeout(resolve, options?.pollIntervalMs ?? 1e3));
+  }
+  throw new Error(`Run ${typeof runId === "string" ? runId : runId.id} did not complete after ${MAX_POLL_ATTEMPTS} attempts`);
+}
+__name(poll, "poll");
+var idempotencyKeys = {
+  create: createIdempotencyKey
+};
+function isIdempotencyKey(value) {
+  return typeof value === "string" && value.length === 64;
+}
+__name(isIdempotencyKey, "isIdempotencyKey");
+async function createIdempotencyKey(key, options) {
+  const idempotencyKey = await generateIdempotencyKey([
+    ...Array.isArray(key) ? key : [
+      key
+    ]
+  ].concat(injectScope(options?.scope ?? "run")));
+  return idempotencyKey;
+}
+__name(createIdempotencyKey, "createIdempotencyKey");
+function injectScope(scope) {
+  switch (scope) {
+    case "run": {
+      if (v3.taskContext?.ctx) {
+        return [
+          v3.taskContext.ctx.run.id
+        ];
+      }
+    }
+    case "attempt": {
+      if (v3.taskContext?.ctx) {
+        return [
+          v3.taskContext.ctx.attempt.id
+        ];
+      }
+    }
+  }
+  return [];
+}
+__name(injectScope, "injectScope");
+async function generateIdempotencyKey(keyMaterial) {
+  const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(keyMaterial.join("-")));
+  return Array.from(new Uint8Array(hash)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+__name(generateIdempotencyKey, "generateIdempotencyKey");
+
+// src/v3/shared.ts
+function queue(options) {
+  return options;
+}
+__name(queue, "queue");
+function createTask(params) {
+  const task3 = {
+    id: params.id,
+    trigger: async (payload, options) => {
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      return await trigger_internal(taskMetadata && taskMetadata.exportName ? `${taskMetadata.exportName}.trigger()` : `trigger()`, params.id, payload, options);
+    },
+    batchTrigger: async (items) => {
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      return await batchTrigger_internal(taskMetadata && taskMetadata.exportName ? `${taskMetadata.exportName}.batchTrigger()` : `batchTrigger()`, params.id, items);
+    },
+    triggerAndWait: async (payload, options) => {
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      return await triggerAndWait_internal(taskMetadata && taskMetadata.exportName ? `${taskMetadata.exportName}.triggerAndWait()` : `triggerAndWait()`, params.id, payload, options);
+    },
+    batchTriggerAndWait: async (items) => {
+      const taskMetadata = v3.taskCatalog.getTaskMetadata(params.id);
+      return await batchTriggerAndWait_internal(taskMetadata && taskMetadata.exportName ? `${taskMetadata.exportName}.batchTriggerAndWait()` : `batchTriggerAndWait()`, params.id, items);
+    }
+  };
+  v3.taskCatalog.registerTaskMetadata({
+    id: params.id,
+    packageVersion: version,
+    queue: params.queue,
+    retry: params.retry ? {
+      ...v3.defaultRetryOptions,
+      ...params.retry
+    } : void 0,
+    machine: params.machine,
+    fns: {
+      run: params.run,
+      init: params.init,
+      cleanup: params.cleanup,
+      middleware: params.middleware,
+      handleError: params.handleError,
+      onSuccess: params.onSuccess,
+      onFailure: params.onFailure,
+      onStart: params.onStart
+    }
+  });
+  return task3;
+}
+__name(createTask, "createTask");
+async function trigger(id, payload, options, requestOptions) {
+  return await trigger_internal("tasks.trigger()", id, payload, options, requestOptions);
+}
+__name(trigger, "trigger");
+async function triggerAndWait(id, payload, options, requestOptions) {
+  return await triggerAndWait_internal("tasks.triggerAndWait()", id, payload, options, requestOptions);
+}
+__name(triggerAndWait, "triggerAndWait");
+async function batchTriggerAndWait(id, items, requestOptions) {
+  return await batchTriggerAndWait_internal("tasks.batchTriggerAndWait()", id, items, requestOptions);
+}
+__name(batchTriggerAndWait, "batchTriggerAndWait");
+async function triggerAndPoll(id, payload, options, requestOptions) {
+  const handle = await trigger(id, payload, options, requestOptions);
+  return runs.poll(handle, options, requestOptions);
+}
+__name(triggerAndPoll, "triggerAndPoll");
+async function batchTrigger(id, items, requestOptions) {
+  return await batchTrigger_internal("tasks.batchTrigger()", id, items, requestOptions);
+}
+__name(batchTrigger, "batchTrigger");
+async function trigger_internal(name2, id, payload, options, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const payloadPacket = await v3.stringifyIO(payload);
+  const handle = await apiClient.triggerTask(id, {
+    payload: payloadPacket.data,
+    options: {
+      queue: options?.queue,
+      concurrencyKey: options?.concurrencyKey,
+      test: v3.taskContext.ctx?.run.isTest,
+      payloadType: payloadPacket.dataType,
+      idempotencyKey: await makeKey(options?.idempotencyKey),
+      delay: options?.delay,
+      ttl: options?.ttl,
+      tags: options?.tags,
+      maxAttempts: options?.maxAttempts
+    }
+  }, {
+    spanParentAsLink: true
+  }, {
+    name: name2,
+    tracer,
+    icon: "trigger",
+    attributes: {
+      [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+      ["messaging.client_id"]: v3.taskContext.worker?.id,
+      [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: id,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    },
+    onResponseBody: (body, span) => {
+      body && typeof body === "object" && !Array.isArray(body) && "id" in body && typeof body.id === "string" && span.setAttribute("messaging.message.id", body.id);
+    },
+    ...requestOptions
+  });
+  return handle;
+}
+__name(trigger_internal, "trigger_internal");
+async function batchTrigger_internal(name2, id, items, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const response = await apiClient.batchTriggerTask(id, {
+    items: await Promise.all(items.map(async (item) => {
+      const payloadPacket = await v3.stringifyIO(item.payload);
+      return {
+        payload: payloadPacket.data,
+        options: {
+          queue: item.options?.queue,
+          concurrencyKey: item.options?.concurrencyKey,
+          test: v3.taskContext.ctx?.run.isTest,
+          payloadType: payloadPacket.dataType,
+          idempotencyKey: await makeKey(item.options?.idempotencyKey),
+          delay: item.options?.delay,
+          ttl: item.options?.ttl,
+          tags: item.options?.tags,
+          maxAttempts: item.options?.maxAttempts
+        }
+      };
+    }))
+  }, {
+    spanParentAsLink: true
+  }, {
+    name: name2,
+    tracer,
+    icon: "trigger",
+    attributes: {
+      [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+      ["messaging.client_id"]: v3.taskContext.worker?.id,
+      [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: id,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    },
+    ...requestOptions
+  });
+  const handle = {
+    batchId: response.batchId,
+    runs: response.runs.map((id2) => ({
+      id: id2
+    }))
+  };
+  return handle;
+}
+__name(batchTrigger_internal, "batchTrigger_internal");
+async function triggerAndWait_internal(name2, id, payload, options, requestOptions) {
+  const ctx = v3.taskContext.ctx;
+  if (!ctx) {
+    throw new Error("triggerAndWait can only be used from inside a task.run()");
+  }
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const payloadPacket = await v3.stringifyIO(payload);
+  return await tracer.startActiveSpan(name2, async (span) => {
+    const response = await apiClient.triggerTask(id, {
+      payload: payloadPacket.data,
+      options: {
+        dependentAttempt: ctx.attempt.id,
+        lockToVersion: v3.taskContext.worker?.version,
+        queue: options?.queue,
+        concurrencyKey: options?.concurrencyKey,
+        test: v3.taskContext.ctx?.run.isTest,
+        payloadType: payloadPacket.dataType,
+        idempotencyKey: await makeKey(options?.idempotencyKey),
+        delay: options?.delay,
+        ttl: options?.ttl,
+        tags: options?.tags,
+        maxAttempts: options?.maxAttempts
+      }
+    }, {}, requestOptions);
+    span.setAttribute("messaging.message.id", response.id);
+    if (options?.idempotencyKey) {
+      const result2 = await apiClient.getRunResult(response.id);
+      if (result2) {
+        v3.logger.log(`Result reused from previous task run with idempotency key '${options.idempotencyKey}'.`, {
+          runId: response.id,
+          idempotencyKey: options.idempotencyKey
+        });
+        return await handleTaskRunExecutionResult(result2);
+      }
+    }
+    const result = await v3.runtime.waitForTask({
+      id: response.id,
+      ctx
+    });
+    return await handleTaskRunExecutionResult(result);
+  }, {
+    kind: api.SpanKind.PRODUCER,
+    attributes: {
+      [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
+      [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+      ["messaging.client_id"]: v3.taskContext.worker?.id,
+      [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: id,
+      [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: id,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  });
+}
+__name(triggerAndWait_internal, "triggerAndWait_internal");
+async function batchTriggerAndWait_internal(name2, id, items, requestOptions) {
+  const ctx = v3.taskContext.ctx;
+  if (!ctx) {
+    throw new Error("batchTriggerAndWait can only be used from inside a task.run()");
+  }
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return await tracer.startActiveSpan(name2, async (span) => {
+    const response = await apiClient.batchTriggerTask(id, {
+      items: await Promise.all(items.map(async (item) => {
+        const payloadPacket = await v3.stringifyIO(item.payload);
+        return {
+          payload: payloadPacket.data,
+          options: {
+            lockToVersion: v3.taskContext.worker?.version,
+            queue: item.options?.queue,
+            concurrencyKey: item.options?.concurrencyKey,
+            test: v3.taskContext.ctx?.run.isTest,
+            payloadType: payloadPacket.dataType,
+            idempotencyKey: await makeKey(item.options?.idempotencyKey),
+            delay: item.options?.delay,
+            ttl: item.options?.ttl,
+            tags: item.options?.tags,
+            maxAttempts: item.options?.maxAttempts
+          }
+        };
+      })),
+      dependentAttempt: ctx.attempt.id
+    }, {}, requestOptions);
+    span.setAttribute("messaging.message.id", response.batchId);
+    const getBatchResults = /* @__PURE__ */ __name(async () => {
+      const hasIdempotencyKey = items.some((item) => item.options?.idempotencyKey);
+      if (hasIdempotencyKey) {
+        const results = await apiClient.getBatchResults(response.batchId);
+        if (results) {
+          return results;
+        }
+      }
+      return {
+        id: response.batchId,
+        items: []
+      };
+    }, "getBatchResults");
+    const existingResults = await getBatchResults();
+    const incompleteRuns = response.runs.filter((runId) => !existingResults.items.some((item) => item.id === runId));
+    if (incompleteRuns.length === 0) {
+      v3.logger.log(`Results reused from previous task runs because of the provided idempotency keys.`);
+      const runs3 = await handleBatchTaskRunExecutionResult(existingResults.items);
+      return {
+        id: existingResults.id,
+        runs: runs3
+      };
+    }
+    const result = await v3.runtime.waitForBatch({
+      id: response.batchId,
+      runs: incompleteRuns,
+      ctx
+    });
+    const combinedItems = [];
+    for (const runId of response.runs) {
+      const existingItem = existingResults.items.find((item) => item.id === runId);
+      if (existingItem) {
+        combinedItems.push(existingItem);
+      } else {
+        const newItem = result.items.find((item) => item.id === runId);
+        if (newItem) {
+          combinedItems.push(newItem);
+        }
+      }
+    }
+    const runs2 = await handleBatchTaskRunExecutionResult(combinedItems);
+    return {
+      id: result.id,
+      runs: runs2
+    };
+  }, {
+    kind: api.SpanKind.PRODUCER,
+    attributes: {
+      [v3.SemanticInternalAttributes.STYLE_ICON]: "trigger",
+      ["messaging.batch.message_count"]: items.length,
+      [semanticConventions.SEMATTRS_MESSAGING_OPERATION]: "publish",
+      ["messaging.client_id"]: v3.taskContext.worker?.id,
+      [semanticConventions.SEMATTRS_MESSAGING_DESTINATION]: id,
+      [semanticConventions.SEMATTRS_MESSAGING_SYSTEM]: "trigger.dev",
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: id,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  });
+}
+__name(batchTriggerAndWait_internal, "batchTriggerAndWait_internal");
+async function handleBatchTaskRunExecutionResult(items) {
+  const someObjectStoreOutputs = items.some((item) => item.ok && item.outputType === "application/store");
+  if (!someObjectStoreOutputs) {
+    const results = await Promise.all(items.map(async (item) => {
+      return await handleTaskRunExecutionResult(item);
+    }));
+    return results;
+  }
+  return await tracer.startActiveSpan("store.downloadPayloads", async (span) => {
+    const results = await Promise.all(items.map(async (item) => {
+      return await handleTaskRunExecutionResult(item);
+    }));
+    return results;
+  }, {
+    kind: api.SpanKind.INTERNAL,
+    [v3.SemanticInternalAttributes.STYLE_ICON]: "cloud-download"
+  });
+}
+__name(handleBatchTaskRunExecutionResult, "handleBatchTaskRunExecutionResult");
+async function handleTaskRunExecutionResult(execution) {
+  if (execution.ok) {
+    const outputPacket = {
+      data: execution.output,
+      dataType: execution.outputType
+    };
+    const importedPacket = await v3.conditionallyImportPacket(outputPacket, tracer);
+    return {
+      ok: true,
+      id: execution.id,
+      output: await v3.parsePacket(importedPacket)
+    };
+  } else {
+    return {
+      ok: false,
+      id: execution.id,
+      error: v3.createErrorTaskError(execution.error)
+    };
+  }
+}
+__name(handleTaskRunExecutionResult, "handleTaskRunExecutionResult");
+function apiClientMissingError() {
+  const hasBaseUrl = !!v3.apiClientManager.baseURL;
+  const hasAccessToken = !!v3.apiClientManager.accessToken;
+  if (!hasBaseUrl && !hasAccessToken) {
+    return `You need to set the TRIGGER_API_URL and TRIGGER_SECRET_KEY environment variables.`;
+  } else if (!hasBaseUrl) {
+    return `You need to set the TRIGGER_API_URL environment variable.`;
+  } else if (!hasAccessToken) {
+    return `You need to set the TRIGGER_SECRET_KEY environment variable.`;
+  }
+  return `Unknown error`;
+}
+__name(apiClientMissingError, "apiClientMissingError");
+async function makeKey(idempotencyKey) {
+  if (!idempotencyKey) {
+    return;
+  }
+  if (isIdempotencyKey(idempotencyKey)) {
+    return idempotencyKey;
+  }
+  return await idempotencyKeys.create(idempotencyKey, {
+    scope: "global"
+  });
+}
+__name(makeKey, "makeKey");
+
+// src/v3/tasks.ts
+function task(options) {
+  return createTask(options);
+}
+__name(task, "task");
+var tasks = {
+  trigger,
+  triggerAndPoll,
+  batchTrigger,
+  triggerAndWait,
+  batchTriggerAndWait
+};
+var wait = {
+  for: async (options) => {
+    return tracer.startActiveSpan(`wait.for()`, async (span) => {
+      const durationInMs = calculateDurationInMs(options);
+      await v3.runtime.waitForDuration(durationInMs);
+    }, {
+      attributes: {
+        [v3.SemanticInternalAttributes.STYLE_ICON]: "wait",
+        ...v3.accessoryAttributes({
+          items: [
+            {
+              text: nameForWaitOptions(options),
+              variant: "normal"
+            }
+          ],
+          style: "codepath"
+        })
+      }
+    });
+  },
+  until: async (options) => {
+    return tracer.startActiveSpan(`wait.until()`, async (span) => {
+      const start = Date.now();
+      if (options.throwIfInThePast && options.date < /* @__PURE__ */ new Date()) {
+        throw new Error("Date is in the past");
+      }
+      const durationInMs = options.date.getTime() - start;
+      await v3.runtime.waitForDuration(durationInMs);
+    }, {
+      attributes: {
+        [v3.SemanticInternalAttributes.STYLE_ICON]: "wait",
+        ...v3.accessoryAttributes({
+          items: [
+            {
+              text: options.date.toISOString(),
+              variant: "normal"
+            }
+          ],
+          style: "codepath"
+        })
+      }
+    });
+  }
+};
+function nameForWaitOptions(options) {
+  if ("seconds" in options) {
+    return options.seconds === 1 ? `1 second` : `${options.seconds} seconds`;
+  }
+  if ("minutes" in options) {
+    return options.minutes === 1 ? `1 minute` : `${options.minutes} minutes`;
+  }
+  if ("hours" in options) {
+    return options.hours === 1 ? `1 hour` : `${options.hours} hours`;
+  }
+  if ("days" in options) {
+    return options.days === 1 ? `1 day` : `${options.days} days`;
+  }
+  if ("weeks" in options) {
+    return options.weeks === 1 ? `1 week` : `${options.weeks} weeks`;
+  }
+  if ("months" in options) {
+    return options.months === 1 ? `1 month` : `${options.months} months`;
+  }
+  if ("years" in options) {
+    return options.years === 1 ? `1 year` : `${options.years} years`;
+  }
+  return "NaN";
+}
+__name(nameForWaitOptions, "nameForWaitOptions");
+function calculateDurationInMs(options) {
+  if ("seconds" in options) {
+    return options.seconds * 1e3;
+  }
+  if ("minutes" in options) {
+    return options.minutes * 1e3 * 60;
+  }
+  if ("hours" in options) {
+    return options.hours * 1e3 * 60 * 60;
+  }
+  if ("days" in options) {
+    return options.days * 1e3 * 60 * 60 * 24;
+  }
+  if ("weeks" in options) {
+    return options.weeks * 1e3 * 60 * 60 * 24 * 7;
+  }
+  if ("months" in options) {
+    return options.months * 1e3 * 60 * 60 * 24 * 30;
+  }
+  if ("years" in options) {
+    return options.years * 1e3 * 60 * 60 * 24 * 365;
+  }
+  throw new Error("Invalid options");
+}
+__name(calculateDurationInMs, "calculateDurationInMs");
+var usage = {
+  /**
+  * Get the current running usage of this task run.
+  *
+  * @example
+  *
+  * ```typescript
+  * import { usage, task } from "@trigger.dev/sdk/v3";
+  *
+  * export const myTask = task({
+  *  id: "my-task",
+  *  run: async (payload, { ctx }) => {
+  *   // ... Do a bunch of work
+  *
+  *   const currentUsage = usage.getCurrent();
+  *
+  *   // You have access to the current compute cost and duration up to this point
+  *   console.log("Current attempt compute cost and duration", {
+  *     cost: currentUsage.compute.attempt.costInCents,
+  *     duration: currentUsage.compute.attempt.durationMs,
+  *   });
+  *
+  *   // You also can see the total compute cost and duration up to this point in the run, across all attempts
+  *   console.log("Current total compute cost and duration", {
+  *     cost: currentUsage.compute.total.costInCents,
+  *     duration: currentUsage.compute.total.durationMs,
+  *   });
+  *
+  *   // You can see the base cost of the run, which is the cost of the run before any compute costs
+  *   console.log("Total cost", {
+  *     cost: currentUsage.totalCostInCents,
+  *     baseCost: currentUsage.baseCostInCents,
+  *   });
+  *  },
+  * });
+  * ```
+  */
+  getCurrent: () => {
+    const sample = v3.usage.sample();
+    const machine = v3.taskContext.ctx?.machine;
+    const run = v3.taskContext.ctx?.run;
+    if (!sample) {
+      return {
+        compute: {
+          attempt: {
+            costInCents: 0,
+            durationMs: 0
+          },
+          total: {
+            costInCents: run?.costInCents ?? 0,
+            durationMs: run?.durationMs ?? 0
+          }
+        },
+        baseCostInCents: run?.baseCostInCents ?? 0,
+        totalCostInCents: (run?.costInCents ?? 0) + (run?.baseCostInCents ?? 0)
+      };
+    }
+    const currentCostInCents = machine?.centsPerMs ? sample.cpuTime * machine.centsPerMs : 0;
+    return {
+      compute: {
+        attempt: {
+          costInCents: currentCostInCents,
+          durationMs: sample.cpuTime
+        },
+        total: {
+          costInCents: (run?.costInCents ?? 0) + currentCostInCents,
+          durationMs: (run?.durationMs ?? 0) + sample.cpuTime
+        }
+      },
+      baseCostInCents: run?.baseCostInCents ?? 0,
+      totalCostInCents: (run?.costInCents ?? 0) + currentCostInCents + (run?.baseCostInCents ?? 0)
+    };
+  },
+  /**
+  * Measure the cost and duration of a function.
+  *
+  * @example
+  *
+  * ```typescript
+  * import { usage } from "@trigger.dev/sdk/v3";
+  *
+  * export const myTask = task({
+  *  id: "my-task",
+  *  run: async (payload, { ctx }) => {
+  *    const { result, compute } = await usage.measure(async () => {
+  *      // Do some work
+  *      return "result";
+  *    });
+  *
+  *    console.log("Result", result);
+  *    console.log("Cost and duration", { cost: compute.costInCents, duration: compute.durationMs });
+  *  },
+  * });
+  * ```
+  */
+  measure: async (cb) => {
+    const measurement = v3.usage.start();
+    const result = await cb();
+    const sample = v3.usage.stop(measurement);
+    const machine = v3.taskContext.ctx?.machine;
+    const costInCents = machine?.centsPerMs ? sample.cpuTime * machine.centsPerMs : 0;
+    return {
+      result,
+      compute: {
+        costInCents,
+        durationMs: sample.cpuTime
+      }
+    };
+  }
+};
+var tags = {
+  add: addTags
+};
+async function addTags(tags2, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const run = v3.taskContext.ctx?.run;
+  if (!run) {
+    throw new Error("Can't set tags outside of a run. You can trigger a task and set tags in the options.");
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "tags.set()",
+    icon: "tag",
+    attributes: {
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: typeof tags2 === "string" ? tags2 : tags2.join(", "),
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  try {
+    await apiClient.addTags(run.id, {
+      tags: tags2
+    }, $requestOptions);
+  } catch (error) {
+    if (error instanceof v3.UnprocessableEntityError) {
+      v3.logger.error(error.message, {
+        existingTags: run.tags,
+        newTags: tags2
+      });
+      return;
+    }
+    v3.logger.error("Failed to set tags", {
+      error
+    });
+    throw error;
+  }
+}
+__name(addTags, "addTags");
+
+// src/v3/schedules/index.ts
+var schedules_exports = {};
+__export(schedules_exports, {
+  activate: () => activate,
+  create: () => create,
+  deactivate: () => deactivate,
+  del: () => del,
+  list: () => list,
+  retrieve: () => retrieve,
+  task: () => task2,
+  timezones: () => timezones,
+  update: () => update
+});
+function task2(params) {
+  const task3 = createTask(params);
+  const cron = params.cron ? typeof params.cron === "string" ? params.cron : params.cron.pattern : void 0;
+  const timezone = (params.cron && typeof params.cron !== "string" ? params.cron.timezone : "UTC") ?? "UTC";
+  v3.taskCatalog.updateTaskMetadata(task3.id, {
+    triggerSource: "schedule",
+    schedule: cron ? {
+      cron,
+      timezone
+    } : void 0
+  });
+  return task3;
+}
+__name(task2, "task");
+function create(options, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.create()",
+    icon: "clock",
+    attributes: {
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: options.cron,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.createSchedule(options, $requestOptions);
+}
+__name(create, "create");
+function retrieve(scheduleId, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.retrieve()",
+    icon: "clock",
+    attributes: {
+      scheduleId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: scheduleId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.retrieveSchedule(scheduleId, $requestOptions);
+}
+__name(retrieve, "retrieve");
+function update(scheduleId, options, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.update()",
+    icon: "clock",
+    attributes: {
+      scheduleId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: scheduleId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.updateSchedule(scheduleId, options, $requestOptions);
+}
+__name(update, "update");
+function del(scheduleId, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.delete()",
+    icon: "clock",
+    attributes: {
+      scheduleId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: scheduleId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.deleteSchedule(scheduleId, $requestOptions);
+}
+__name(del, "del");
+function deactivate(scheduleId, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.deactivate()",
+    icon: "clock",
+    attributes: {
+      scheduleId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: scheduleId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.deactivateSchedule(scheduleId, $requestOptions);
+}
+__name(deactivate, "deactivate");
+function activate(scheduleId, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.activate()",
+    icon: "clock",
+    attributes: {
+      scheduleId,
+      ...v3.accessoryAttributes({
+        items: [
+          {
+            text: scheduleId,
+            variant: "normal"
+          }
+        ],
+        style: "codepath"
+      })
+    }
+  }, requestOptions);
+  return apiClient.activateSchedule(scheduleId, $requestOptions);
+}
+__name(activate, "activate");
+function list(options, requestOptions) {
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  const $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "schedules.list()",
+    icon: "clock"
+  }, requestOptions);
+  return apiClient.listSchedules(options, $requestOptions);
+}
+__name(list, "list");
+function timezones(options) {
+  const baseUrl = v3.apiClientManager.baseURL;
+  if (!baseUrl) {
+    throw apiClientMissingError();
+  }
+  return zodfetch.zodfetch(v3.TimezonesResult, `${baseUrl}/api/v1/timezones${options?.excludeUtc === true ? "?excludeUtc=true" : ""}`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+__name(timezones, "timezones");
+
+// src/v3/envvars.ts
+var envvars_exports = {};
+__export(envvars_exports, {
+  create: () => create2,
+  del: () => del2,
+  list: () => list2,
+  retrieve: () => retrieve2,
+  update: () => update2,
+  upload: () => upload
+});
+function upload(projectRefOrParams, slugOrRequestOptions, params, requestOptions) {
+  let $projectRef;
+  let $params;
+  let $slug;
+  const $requestOptions = overloadRequestOptions("upload", slugOrRequestOptions, requestOptions);
+  if (v3.taskContext.ctx) {
+    if (typeof projectRefOrParams === "string") {
+      $projectRef = projectRefOrParams;
+      $slug = typeof slugOrRequestOptions === "string" ? slugOrRequestOptions : v3.taskContext.ctx.environment.slug;
+      if (!params) {
+        throw new Error("params is required");
+      }
+      $params = params;
+    } else {
+      $params = projectRefOrParams;
+      $projectRef = v3.taskContext.ctx.project.ref;
+      $slug = v3.taskContext.ctx.environment.slug;
+    }
+  } else {
+    if (typeof projectRefOrParams !== "string") {
+      throw new Error("projectRef is required");
+    }
+    if (!slugOrRequestOptions || typeof slugOrRequestOptions !== "string") {
+      throw new Error("slug is required");
+    }
+    if (!params) {
+      throw new Error("params is required");
+    }
+    $projectRef = projectRefOrParams;
+    $slug = slugOrRequestOptions;
+    $params = params;
+  }
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.importEnvVars($projectRef, $slug, $params, $requestOptions);
+}
+__name(upload, "upload");
+function list2(projectRefOrRequestOptions, slug, requestOptions) {
+  const $projectRef = !v3.isRequestOptions(projectRefOrRequestOptions) ? projectRefOrRequestOptions : v3.taskContext.ctx?.project.ref;
+  const $slug = slug ?? v3.taskContext.ctx?.environment.slug;
+  let $requestOptions = v3.isRequestOptions(projectRefOrRequestOptions) ? projectRefOrRequestOptions : requestOptions;
+  if (!$projectRef) {
+    throw new Error("projectRef is required");
+  }
+  if (!$slug) {
+    throw new Error("slug is required");
+  }
+  $requestOptions = v3.mergeRequestOptions({
+    tracer,
+    name: "envvars.list()",
+    icon: "id-badge"
+  }, $requestOptions);
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.listEnvVars($projectRef, $slug, $requestOptions);
+}
+__name(list2, "list");
+function create2(projectRefOrParams, slugOrRequestOptions, params, requestOptions) {
+  let $projectRef;
+  let $slug;
+  let $params;
+  const $requestOptions = overloadRequestOptions("create", slugOrRequestOptions, requestOptions);
+  if (v3.taskContext.ctx) {
+    if (typeof projectRefOrParams === "string") {
+      $projectRef = projectRefOrParams;
+      $slug = typeof slugOrRequestOptions === "string" ? slugOrRequestOptions : v3.taskContext.ctx.environment.slug;
+      if (!params) {
+        throw new Error("params is required");
+      }
+      $params = params;
+    } else {
+      $params = projectRefOrParams;
+      $projectRef = v3.taskContext.ctx.project.ref;
+      $slug = v3.taskContext.ctx.environment.slug;
+    }
+  } else {
+    if (typeof projectRefOrParams !== "string") {
+      throw new Error("projectRef is required");
+    }
+    if (!slugOrRequestOptions || typeof slugOrRequestOptions !== "string") {
+      throw new Error("slug is required");
+    }
+    if (!params) {
+      throw new Error("params is required");
+    }
+    $projectRef = projectRefOrParams;
+    $slug = slugOrRequestOptions;
+    $params = params;
+  }
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.createEnvVar($projectRef, $slug, $params, $requestOptions);
+}
+__name(create2, "create");
+function retrieve2(projectRefOrName, slugOrRequestOptions, name1, requestOptions) {
+  let $projectRef;
+  let $slug;
+  let $name;
+  const $requestOptions = overloadRequestOptions("retrieve", slugOrRequestOptions, requestOptions);
+  if (typeof name1 === "string") {
+    $projectRef = projectRefOrName;
+    $slug = typeof slugOrRequestOptions === "string" ? slugOrRequestOptions : v3.taskContext.ctx?.environment.slug;
+    $name = name1;
+  } else {
+    $projectRef = v3.taskContext.ctx?.project.ref;
+    $slug = v3.taskContext.ctx?.environment.slug;
+    $name = projectRefOrName;
+  }
+  if (!$projectRef) {
+    throw new Error("projectRef is required");
+  }
+  if (!$slug) {
+    throw new Error("slug is required");
+  }
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.retrieveEnvVar($projectRef, $slug, $name, $requestOptions);
+}
+__name(retrieve2, "retrieve");
+function del2(projectRefOrName, slugOrRequestOptions, name1, requestOptions) {
+  let $projectRef;
+  let $slug;
+  let $name;
+  const $requestOptions = overloadRequestOptions("del", slugOrRequestOptions, requestOptions);
+  if (typeof name1 === "string") {
+    $projectRef = projectRefOrName;
+    $slug = typeof slugOrRequestOptions === "string" ? slugOrRequestOptions : v3.taskContext.ctx?.environment.slug;
+    $name = name1;
+  } else {
+    $projectRef = v3.taskContext.ctx?.project.ref;
+    $slug = v3.taskContext.ctx?.environment.slug;
+    $name = projectRefOrName;
+  }
+  if (!$projectRef) {
+    throw new Error("projectRef is required");
+  }
+  if (!$slug) {
+    throw new Error("slug is required");
+  }
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.deleteEnvVar($projectRef, $slug, $name, $requestOptions);
+}
+__name(del2, "del");
+function update2(projectRefOrName, slugOrParams, nameOrRequestOptions, params, requestOptions) {
+  let $projectRef;
+  let $slug;
+  let $name;
+  let $params;
+  const $requestOptions = overloadRequestOptions("update", nameOrRequestOptions, requestOptions);
+  if (v3.taskContext.ctx) {
+    if (typeof slugOrParams === "string") {
+      $projectRef = slugOrParams;
+      $slug = slugOrParams ?? v3.taskContext.ctx.environment.slug;
+      $name = typeof nameOrRequestOptions === "string" ? nameOrRequestOptions : v3.taskContext.ctx.environment.slug;
+      if (!params) {
+        throw new Error("params is required");
+      }
+      $params = params;
+    } else {
+      $params = slugOrParams;
+      $projectRef = v3.taskContext.ctx.project.ref;
+      $slug = v3.taskContext.ctx.environment.slug;
+      $name = projectRefOrName;
+    }
+  } else {
+    if (typeof slugOrParams !== "string") {
+      throw new Error("slug is required");
+    }
+    if (!projectRefOrName) {
+      throw new Error("projectRef is required");
+    }
+    if (!params) {
+      throw new Error("params is required");
+    }
+    $projectRef = projectRefOrName;
+    $slug = slugOrParams;
+    $name = name;
+    $params = params;
+  }
+  const apiClient = v3.apiClientManager.client;
+  if (!apiClient) {
+    throw apiClientMissingError();
+  }
+  return apiClient.updateEnvVar($projectRef, $slug, $name, $params, $requestOptions);
+}
+__name(update2, "update");
+function overloadRequestOptions(name1, slugOrRequestOptions, requestOptions) {
+  if (v3.isRequestOptions(slugOrRequestOptions)) {
+    return v3.mergeRequestOptions({
+      tracer,
+      name: `envvars.${name1}()`,
+      icon: "id-badge"
+    }, slugOrRequestOptions);
+  } else {
+    return v3.mergeRequestOptions({
+      tracer,
+      name: `envvars.${name1}()`,
+      icon: "id-badge"
+    }, requestOptions);
+  }
+}
+__name(overloadRequestOptions, "overloadRequestOptions");
+
+// src/v3/index.ts
+function configure(options) {
+  v3.apiClientManager.setGlobalAPIClientConfiguration(options);
+}
+__name(configure, "configure");
+
+Object.defineProperty(exports, "AbortTaskRunError", {
+  enumerable: true,
+  get: function () { return v3.AbortTaskRunError; }
+});
+Object.defineProperty(exports, "ApiError", {
+  enumerable: true,
+  get: function () { return v3.ApiError; }
+});
+Object.defineProperty(exports, "AuthenticationError", {
+  enumerable: true,
+  get: function () { return v3.AuthenticationError; }
+});
+Object.defineProperty(exports, "BadRequestError", {
+  enumerable: true,
+  get: function () { return v3.BadRequestError; }
+});
+Object.defineProperty(exports, "ConflictError", {
+  enumerable: true,
+  get: function () { return v3.ConflictError; }
+});
+Object.defineProperty(exports, "InternalServerError", {
+  enumerable: true,
+  get: function () { return v3.InternalServerError; }
+});
+Object.defineProperty(exports, "NotFoundError", {
+  enumerable: true,
+  get: function () { return v3.NotFoundError; }
+});
+Object.defineProperty(exports, "PermissionDeniedError", {
+  enumerable: true,
+  get: function () { return v3.PermissionDeniedError; }
+});
+Object.defineProperty(exports, "RateLimitError", {
+  enumerable: true,
+  get: function () { return v3.RateLimitError; }
+});
+Object.defineProperty(exports, "UnprocessableEntityError", {
+  enumerable: true,
+  get: function () { return v3.UnprocessableEntityError; }
+});
+Object.defineProperty(exports, "logger", {
   enumerable: true,
   get: function () { return v3.logger; }
 });
 exports.InMemoryCache = InMemoryCache;
+exports.configure = configure;
 exports.createCache = createCache;
+exports.envvars = envvars_exports;
+exports.idempotencyKeys = idempotencyKeys;
+exports.isIdempotencyKey = isIdempotencyKey;
+exports.queue = queue;
 exports.retry = retry;
+exports.runs = runs;
+exports.schedules = schedules_exports;
+exports.tags = tags;
 exports.task = task;
+exports.tasks = tasks;
+exports.usage = usage;
 exports.wait = wait;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map