{"version":3,"sources":["../../src/v3/cache.ts","../../src/v3/tracer.ts","../../package.json","../../src/v3/retry.ts","../../src/v3/shared.ts","../../src/v3/runs.ts","../../src/v3/idempotencyKeys.ts","../../src/v3/tasks.ts","../../src/v3/wait.ts","../../src/v3/usage.ts","../../src/v3/tags.ts","../../src/v3/index.ts","../../src/v3/schedules/index.ts","../../src/v3/envvars.ts"],"names":["SemanticInternalAttributes","TriggerTracer","tracer","name","version","InMemoryCache","_cache","Map","get","key","set","value","undefined","delete","createCache","store","cache","cacheKey","fn","startActiveSpan","span","setAttribute","STYLE_ICON","cacheEntry","updateName","attributes","metadata","createdTime","Date","now","SpanStatusCode","context","trace","SEMATTRS_HTTP_HOST","SEMATTRS_HTTP_METHOD","SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH","SEMATTRS_HTTP_SCHEME","SEMATTRS_HTTP_STATUS_CODE","SEMATTRS_HTTP_URL","accessoryAttributes","calculateNextRetryDelay","calculateResetAt","defaultRetryOptions","eventFilterMatches","flattenAttributes","runtime","defaultFetchRetryOptions","AsyncLocalStorage","onThrow","options","opts","attempt","maxAttempts","innerSpan","startSpan","items","text","variant","style","contextWithSpanSet","setSpan","active","result","with","end","e","Error","recordException","String","setStatus","code","ERROR","nextRetryDelay","RETRY_AT","toISOString","RETRY_COUNT","RETRY_DELAY","waitForDuration","normalizeUrlFromInput","input","URL","url","normalizeHttpMethod","init","method","toUpperCase","fetchHttpHandlerStorage","fetchWithInterceptors","handlers","getStore","getResponse","request","Request","response","fetch","FetchErrorWithSpan","constructor","originalError","MAX_ATTEMPTS","retryFetch","abortController","AbortController","timeoutId","timeoutInMs","setTimeout","abort","signal","addEventListener","doFetchRequest","clearTimeout","ok","setAttributes","createFetchResponseAttributes","nextRetry","calculateRetryDelayForResponse","resolveDefaults","retry","byStatus","type","nextRetryDate","isInFuture","getTime","waitUntil","timeout","cause","connectionError","createFetchAttributes","createFetchRetryOptionsAttributes","attemptCount","httpMethod","headers","toString","status","statusText","message","strategy","getRetryStrategyForResponse","resetAt","resetHeader","resetTimestamp","resetFormat","statusCodes","Object","keys","clonedResponse","clone","i","length","statusRange","isStatusCodeInRange","bodyFilter","body","safeJsonParse","statusCode","includes","split","map","s","trim","some","start","parseInt","endsWith","prefix","slice","statusCodePrefix","Math","floor","statusCodeString","rangePrefix","startsWith","createAttributesFromHeaders","normalizedHeaderKey","toLowerCase","forEach","json","JSON","parse","interceptFetch","run","current","push","obj","defaults","href","hostname","port","protocol","replace","SpanKind","SEMATTRS_MESSAGING_DESTINATION","SEMATTRS_MESSAGING_OPERATION","SEMATTRS_MESSAGING_SYSTEM","apiClientManager","conditionallyImportPacket","createErrorTaskError","logger","parsePacket","stringifyIO","taskCatalog","taskContext","isRequestOptions","mergeRequestOptions","runs","replay","replayRun","cancel","cancelRun","retrieve","retrieveRun","list","listRuns","reschedule","rescheduleRun","poll","paramsOrProjectRef","paramsOrOptions","requestOptions","apiClient","client","apiClientMissingError","$requestOptions","listRunsRequestOptions","listProjectRuns","icon","projectRef","runId","id","MAX_POLL_ATTEMPTS","attempts","isCompleted","Promise","resolve","pollIntervalMs","idempotencyKeys","create","createIdempotencyKey","isIdempotencyKey","idempotencyKey","generateIdempotencyKey","Array","isArray","concat","injectScope","scope","ctx","keyMaterial","hash","crypto","subtle","digest","TextEncoder","encode","join","from","Uint8Array","byte","padStart","queue","createTask","params","customQueue","task","trigger","payload","taskMetadata","getTaskMetadata","trigger_internal","exportName","batchTrigger","batchTrigger_internal","triggerAndWait","triggerAndWait_internal","batchTriggerAndWait","batchTriggerAndWait_internal","registerTaskMetadata","packageVersion","machine","fns","cleanup","middleware","handleError","onSuccess","onFailure","onStart","triggerAndPoll","handle","payloadPacket","triggerTask","data","concurrencyKey","test","isTest","payloadType","dataType","makeKey","delay","ttl","tags","spanParentAsLink","worker","onResponseBody","batchTriggerTask","all","item","batchId","dependentAttempt","lockToVersion","getRunResult","log","handleTaskRunExecutionResult","waitForTask","kind","PRODUCER","getBatchResults","hasIdempotencyKey","results","existingResults","incompleteRuns","filter","handleBatchTaskRunExecutionResult","waitForBatch","combinedItems","existingItem","find","newItem","someObjectStoreOutputs","outputType","INTERNAL","execution","outputPacket","output","importedPacket","error","hasBaseUrl","baseURL","hasAccessToken","accessToken","tasks","wait","for","durationInMs","calculateDurationInMs","nameForWaitOptions","until","throwIfInThePast","date","seconds","minutes","hours","days","weeks","months","years","usage","usageApi","getCurrent","sample","compute","costInCents","durationMs","total","baseCostInCents","totalCostInCents","currentCostInCents","centsPerMs","cpuTime","measure","cb","measurement","stop","UnprocessableEntityError","add","addTags","existingTags","newTags","ApiError","AuthenticationError","BadRequestError","ConflictError","InternalServerError","NotFoundError","PermissionDeniedError","RateLimitError","AbortTaskRunError","TimezonesResult","zodfetch","cron","pattern","timezone","updateTaskMetadata","triggerSource","schedule","createSchedule","scheduleId","retrieveSchedule","update","updateSchedule","del","deleteSchedule","deactivate","deactivateSchedule","activate","activateSchedule","listSchedules","timezones","baseUrl","excludeUtc","upload","projectRefOrParams","slugOrRequestOptions","$projectRef","$params","$slug","overloadRequestOptions","environment","slug","project","ref","importEnvVars","projectRefOrRequestOptions","listEnvVars","createEnvVar","projectRefOrName","$name","retrieveEnvVar","deleteEnvVar","slugOrParams","nameOrRequestOptions","updateEnvVar","configure","setGlobalAPIClientConfiguration"],"mappings":"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","sourcesContent":["import { SemanticInternalAttributes } from \"@systemfsoftware/trigger.dev_core/v3\";\nimport { tracer } from \"./tracer\";\n\nexport type CacheMetadata = {\n  createdTime: number;\n  ttl?: number | null;\n};\n\nexport type CacheEntry<Value = unknown> = {\n  metadata: CacheMetadata;\n  value: Value;\n};\n\nexport type Eventually<Value> = Value | null | undefined | Promise<Value | null | undefined>;\n\nexport type CacheStore<Value = any> = {\n  name?: string;\n  get: (key: string) => Eventually<CacheEntry<Value>>;\n  set: (key: string, value: CacheEntry<Value>) => unknown | Promise<unknown>;\n  delete: (key: string) => unknown | Promise<unknown>;\n};\n\nexport type CacheFunction = <Value>(\n  cacheKey: string,\n  fn: () => Promise<Value> | Value\n) => Promise<Value> | Value;\n\nexport class InMemoryCache<Value = any> {\n  private _cache: Map<string, CacheEntry<Value>> = new Map();\n\n  get(key: string): Eventually<CacheEntry<Value>> {\n    return this._cache.get(key);\n  }\n\n  set(key: string, value: CacheEntry<Value>): unknown {\n    this._cache.set(key, value);\n\n    return undefined;\n  }\n\n  delete(key: string): unknown {\n    this._cache.delete(key);\n\n    return undefined;\n  }\n}\n\n/**\n * Create a cache function that uses the provided store to cache values. Using InMemoryCache is safe because each task run is isolated.\n * @param store\n * @returns\n */\nexport function createCache(store: CacheStore): CacheFunction {\n  return function cache<Value>(\n    cacheKey: string,\n    fn: () => Promise<Value> | Value\n  ): Promise<Value> | Value {\n    return tracer.startActiveSpan(\"cache\", async (span) => {\n      span.setAttribute(\"cache.key\", cacheKey);\n      span.setAttribute(SemanticInternalAttributes.STYLE_ICON, \"device-sd-card\");\n\n      const cacheEntry = await store.get(cacheKey);\n\n      if (cacheEntry) {\n        span.updateName(`cache.hit ${cacheKey}`);\n\n        return cacheEntry.value;\n      }\n\n      span.updateName(`cache.miss ${cacheKey}`);\n\n      const value = await tracer.startActiveSpan(\n        \"cache.getFreshValue\",\n        async (span) => {\n          return await fn();\n        },\n        {\n          attributes: {\n            \"cache.key\": cacheKey,\n            [SemanticInternalAttributes.STYLE_ICON]: \"device-sd-card\",\n          },\n        }\n      );\n\n      await tracer.startActiveSpan(\n        \"cache.set\",\n        async (span) => {\n          await store.set(cacheKey, {\n            value,\n            metadata: {\n              createdTime: Date.now(),\n            },\n          });\n        },\n        {\n          attributes: {\n            \"cache.key\": cacheKey,\n            [SemanticInternalAttributes.STYLE_ICON]: \"device-sd-card\",\n          },\n        }\n      );\n\n      return value;\n    });\n  };\n}\n","import { TriggerTracer } from \"@systemfsoftware/trigger.dev_core/v3\";\nimport * as packageJson from \"../../package.json\";\n\nexport const tracer = new TriggerTracer({ name: \"@systemfsoftware/trigger.dev_sdk\", version: packageJson.version });\n","{\n  \"name\": \"@systemfsoftware/trigger.dev_sdk\",\n  \"version\": \"2.4.8\",\n  \"description\": \"trigger.dev Node.JS SDK\",\n  \"license\": \"MIT\",\n  \"main\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.ts\",\n  \"module\": \"./dist/index.mjs\",\n  \"publishConfig\": {\n    \"access\": \"public\"\n  },\n  \"files\": [\n    \"dist\"\n  ],\n  \"exports\": {\n    \".\": {\n      \"import\": {\n        \"types\": \"./dist/index.d.mts\",\n        \"default\": \"./dist/index.mjs\"\n      },\n      \"require\": \"./dist/index.js\",\n      \"types\": \"./dist/index.d.ts\"\n    },\n    \"./v3\": {\n      \"import\": {\n        \"types\": \"./dist/v3/index.d.mts\",\n        \"default\": \"./dist/v3/index.mjs\"\n      },\n      \"require\": \"./dist/v3/index.js\",\n      \"types\": \"./dist/v3/index.d.ts\"\n    },\n    \"./package.json\": \"./package.json\"\n  },\n  \"typesVersions\": {\n    \"*\": {\n      \"v3\": [\n        \"./dist/v3/index.d.ts\"\n      ]\n    }\n  },\n  \"scripts\": {\n    \"prepare\": \"pnpm turbo build\",\n    \"clean\": \"rimraf dist\",\n    \"build\": \"pnpm run clean && pnpm run build:tsup\",\n    \"build:tsup\": \"tsup --dts-resolve\",\n    \"typecheck\": \"tsc --noEmit\"\n  },\n  \"dependencies\": {\n    \"@opentelemetry/api\": \"^1.8.0\",\n    \"@opentelemetry/api-logs\": \"^0.48.0\",\n    \"@opentelemetry/semantic-conventions\": \"^1.22.0\",\n    \"@systemfsoftware/trigger.dev_core\": \"workspace:^\",\n    \"@systemfsoftware/trigger.dev_sdk-v2\": \"workspace:^\",\n    \"@systemfsoftware/trigger.dev_core-backend\": \"workspace:^\",\n    \"chalk\": \"^5.2.0\",\n    \"cronstrue\": \"^2.21.0\",\n    \"debug\": \"^4.3.4\",\n    \"evt\": \"^2.4.13\",\n    \"get-caller-file\": \"^2.0.5\",\n    \"git-remote-origin-url\": \"^4.0.0\",\n    \"git-repo-info\": \"^2.1.1\",\n    \"msw\": \"^2.2.1\",\n    \"slug\": \"^6.0.0\",\n    \"terminal-link\": \"^3.0.0\",\n    \"ulid\": \"^2.3.0\",\n    \"uuid\": \"^9.0.0\",\n    \"ws\": \"^8.11.0\"\n  },\n  \"peerDependencies\": {\n    \"zod\": \"3.x\",\n    \"effect\": \"3.x\",\n    \"@effect/schema\": \"0.72.0\"\n  },\n  \"peerDependenciesMeta\": {\n    \"effect\": {\n      \"optional\": false\n    },\n    \"@effect/schema\": {\n      \"optional\": false\n    },\n    \"zod\": {\n      \"optional\": false\n    }\n  },\n  \"devDependencies\": {\n    \"effect\": \"^3.7.0\",\n    \"@effect/schema\": \"0.72.0\",\n    \"zod\": \"3.22.3\",\n    \"@systemfsoftware/trigger.dev_tsconfig\": \"workspace:*\",\n    \"@systemfsoftware/trigger.dev_tsup\": \"workspace:*\",\n    \"@types/debug\": \"^4.1.7\",\n    \"@types/node\": \"^20.16.2\",\n    \"@types/slug\": \"^5.0.3\",\n    \"@types/uuid\": \"^9.0.0\",\n    \"@types/ws\": \"^8.5.3\",\n    \"encoding\": \"^0.1.13\",\n    \"msw\": \"^2.2.1\",\n    \"rimraf\": \"^3.0.2\",\n    \"tsup\": \"8.0.1\",\n    \"typed-emitter\": \"^2.1.0\",\n    \"typescript\": \"5.5.4\"\n  },\n  \"engines\": {\n    \"node\": \">=18.0.0\"\n  }\n}\n","import { Attributes, Span, SpanStatusCode, context, trace } from \"@opentelemetry/api\";\nimport {\n  SEMATTRS_HTTP_HOST,\n  SEMATTRS_HTTP_METHOD,\n  SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH,\n  SEMATTRS_HTTP_SCHEME,\n  SEMATTRS_HTTP_STATUS_CODE,\n  SEMATTRS_HTTP_URL,\n} from \"@opentelemetry/semantic-conventions\";\nimport {\n  FetchRetryByStatusOptions,\n  FetchRetryOptions,\n  FetchRetryStrategy,\n  RetryOptions,\n  SemanticInternalAttributes,\n  accessoryAttributes,\n  calculateNextRetryDelay,\n  calculateResetAt,\n  defaultRetryOptions,\n  eventFilterMatches,\n  flattenAttributes,\n  runtime,\n} from \"@systemfsoftware/trigger.dev_core/v3\";\nimport { defaultFetchRetryOptions } from \"@systemfsoftware/trigger.dev_core/v3\";\nimport type { HttpHandler } from \"msw\";\nimport { AsyncLocalStorage } from \"node:async_hooks\";\nimport { tracer } from \"./tracer\";\n\nexport type { RetryOptions };\n\nfunction onThrow<T>(\n  fn: (options: { attempt: number; maxAttempts: number }) => Promise<T>,\n  options: RetryOptions\n): Promise<T> {\n  const opts = {\n    ...defaultRetryOptions,\n    ...options,\n  };\n\n  return tracer.startActiveSpan(\n    `retry.onThrow()`,\n    async (span) => {\n      let attempt = 1;\n\n      while (attempt <= opts.maxAttempts) {\n        const innerSpan = tracer.startSpan(\"retry.fn()\", {\n          attributes: {\n            [SemanticInternalAttributes.STYLE_ICON]: \"function\",\n            ...accessoryAttributes({\n              items: [\n                {\n                  text: `${attempt}/${opts.maxAttempts}`,\n                  variant: \"normal\",\n                },\n              ],\n              style: \"codepath\",\n            }),\n          },\n        });\n\n        const contextWithSpanSet = trace.setSpan(context.active(), innerSpan);\n\n        try {\n          const result = await context.with(contextWithSpanSet, async () => {\n            return fn({ attempt, maxAttempts: opts.maxAttempts });\n          });\n\n          innerSpan.end();\n\n          return result;\n        } catch (e) {\n          if (e instanceof Error || typeof e === \"string\") {\n            innerSpan.recordException(e);\n          } else {\n            innerSpan.recordException(String(e));\n          }\n\n          innerSpan.setStatus({ code: SpanStatusCode.ERROR });\n\n          if (e instanceof Error && e.name === \"AbortTaskRunError\") {\n            innerSpan.end();\n\n            throw e;\n          }\n\n          const nextRetryDelay = calculateNextRetryDelay(opts, attempt);\n\n          if (!nextRetryDelay) {\n            innerSpan.end();\n\n            throw e;\n          }\n\n          innerSpan.setAttribute(\n            SemanticInternalAttributes.RETRY_AT,\n            new Date(Date.now() + nextRetryDelay).toISOString()\n          );\n          innerSpan.setAttribute(SemanticInternalAttributes.RETRY_COUNT, attempt);\n          innerSpan.setAttribute(SemanticInternalAttributes.RETRY_DELAY, `${nextRetryDelay}ms`);\n          innerSpan.end();\n\n          await runtime.waitForDuration(nextRetryDelay);\n        } finally {\n          attempt++;\n        }\n      }\n\n      throw new Error(\"Max attempts reached\");\n    },\n    {\n      attributes: {\n        [SemanticInternalAttributes.STYLE_ICON]: \"arrow-capsule\",\n      },\n    }\n  );\n}\n\nexport interface RetryFetchRequestInit extends RequestInit {\n  retry?: FetchRetryOptions;\n  timeoutInMs?: number;\n}\n\nconst normalizeUrlFromInput = (input: RequestInfo | URL | string): URL => {\n  if (typeof input === \"string\") {\n    return new URL(input);\n  }\n\n  if (input instanceof URL) {\n    return input;\n  }\n\n  return new URL(input.url);\n};\n\nconst normalizeHttpMethod = (input: RequestInfo | URL | string, init?: RequestInit): string => {\n  if (typeof input === \"string\" || input instanceof URL) {\n    return (init?.method || \"GET\").toUpperCase();\n  }\n\n  return (input.method ?? init?.method ?? \"GET\").toUpperCase();\n};\n\nconst fetchHttpHandlerStorage = new AsyncLocalStorage<Array<HttpHandler>>();\n\nconst fetchWithInterceptors = async (\n  input: RequestInfo | URL,\n  init?: RequestInit\n): Promise<Response> => {\n  const handlers = fetchHttpHandlerStorage.getStore();\n\n  if (handlers) {\n    try {\n      const { getResponse } = await import(\"msw\");\n\n      const request = new Request(input, init);\n\n      const response = await getResponse(handlers, request);\n\n      if (response) {\n        return response;\n      }\n    } catch (e) {\n      // Do nothing\n      return fetch(input, init);\n    }\n  }\n\n  return fetch(input, init);\n};\n\nclass FetchErrorWithSpan extends Error {\n  constructor(\n    public readonly originalError: unknown,\n    public readonly span: Span\n  ) {\n    super(\"Fetch error\");\n  }\n}\n\nconst MAX_ATTEMPTS = 10;\n\nasync function retryFetch(\n  input: RequestInfo | URL,\n  init?: RetryFetchRequestInit | undefined\n): Promise<Response> {\n  return tracer.startActiveSpan(\n    \"retry.fetch()\",\n    async (span) => {\n      let attempt = 1;\n\n      while (true) {\n        try {\n          const abortController = new AbortController();\n\n          const timeoutId = init?.timeoutInMs\n            ? setTimeout(\n                () => {\n                  abortController.abort();\n                },\n                init?.timeoutInMs\n              )\n            : undefined;\n\n          init?.signal?.addEventListener(\"abort\", () => {\n            abortController.abort();\n          });\n\n          const [response, span] = await doFetchRequest(\n            input,\n            { ...(init ?? {}), signal: abortController.signal },\n            attempt\n          );\n\n          if (timeoutId) {\n            clearTimeout(timeoutId);\n          }\n\n          if (response.ok) {\n            span.setAttributes(createFetchResponseAttributes(response));\n\n            span.end();\n\n            return response;\n          }\n\n          const nextRetry = await calculateRetryDelayForResponse(\n            resolveDefaults(init?.retry, \"byStatus\", defaultFetchRetryOptions.byStatus),\n            response,\n            attempt\n          );\n\n          if (!nextRetry) {\n            span.setAttributes(createFetchResponseAttributes(response));\n\n            span.end();\n\n            return response;\n          }\n\n          if (attempt >= MAX_ATTEMPTS) {\n            span.setAttributes(createFetchResponseAttributes(response));\n\n            span.end();\n\n            return response;\n          }\n\n          if (nextRetry.type === \"delay\") {\n            span.setAttribute(\n              SemanticInternalAttributes.RETRY_AT,\n              new Date(Date.now() + nextRetry.value).toISOString()\n            );\n            span.setAttribute(SemanticInternalAttributes.RETRY_COUNT, attempt);\n            span.setAttribute(SemanticInternalAttributes.RETRY_DELAY, `${nextRetry.value}ms`);\n\n            span.end();\n\n            await runtime.waitForDuration(nextRetry.value);\n          } else {\n            const now = Date.now();\n            const nextRetryDate = new Date(nextRetry.value);\n            const isInFuture = nextRetryDate.getTime() > now;\n\n            span.setAttribute(\n              SemanticInternalAttributes.RETRY_AT,\n              new Date(nextRetry.value).toISOString()\n            );\n            span.setAttribute(SemanticInternalAttributes.RETRY_COUNT, attempt);\n\n            if (isInFuture) {\n              span.setAttribute(\n                SemanticInternalAttributes.RETRY_DELAY,\n                `${nextRetry.value - now}ms`\n              );\n            }\n\n            span.end();\n\n            await runtime.waitUntil(new Date(nextRetry.value));\n          }\n        } catch (e) {\n          if (e instanceof FetchErrorWithSpan && e.originalError instanceof Error) {\n            if (e.originalError.name === \"AbortError\") {\n              const nextRetryDelay = calculateNextRetryDelay(\n                resolveDefaults(init?.retry, \"timeout\", defaultFetchRetryOptions.timeout),\n                attempt\n              );\n\n              if (!nextRetryDelay) {\n                e.span.end();\n                throw e;\n              }\n\n              if (attempt >= MAX_ATTEMPTS) {\n                e.span.end();\n                throw e;\n              }\n\n              e.span.setAttribute(\n                SemanticInternalAttributes.RETRY_AT,\n                new Date(Date.now() + nextRetryDelay).toISOString()\n              );\n              e.span.setAttribute(SemanticInternalAttributes.RETRY_COUNT, attempt);\n              e.span.setAttribute(SemanticInternalAttributes.RETRY_DELAY, `${nextRetryDelay}ms`);\n\n              e.span.end();\n\n              await runtime.waitForDuration(nextRetryDelay);\n\n              continue; // Move to the next attempt\n            } else if (\n              e.originalError.name === \"TypeError\" &&\n              \"cause\" in e.originalError &&\n              e.originalError.cause instanceof Error\n            ) {\n              const nextRetryDelay = calculateNextRetryDelay(\n                resolveDefaults(\n                  init?.retry,\n                  \"connectionError\",\n                  defaultFetchRetryOptions.connectionError\n                ),\n                attempt\n              );\n\n              if (!nextRetryDelay) {\n                e.span.end();\n                throw e;\n              }\n\n              if (attempt >= MAX_ATTEMPTS) {\n                e.span.end();\n                throw e;\n              }\n\n              e.span.setAttribute(\n                SemanticInternalAttributes.RETRY_AT,\n                new Date(Date.now() + nextRetryDelay).toISOString()\n              );\n              e.span.setAttribute(SemanticInternalAttributes.RETRY_COUNT, attempt);\n              e.span.setAttribute(SemanticInternalAttributes.RETRY_DELAY, `${nextRetryDelay}ms`);\n\n              e.span.end();\n\n              await runtime.waitForDuration(nextRetryDelay);\n\n              continue; // Move to the next attempt\n            }\n          }\n\n          if (e instanceof FetchErrorWithSpan) {\n            e.span.end();\n          }\n\n          throw e;\n        } finally {\n          attempt++;\n        }\n      }\n    },\n    {\n      attributes: {\n        [SemanticInternalAttributes.STYLE_ICON]: \"arrow-capsule\",\n        ...createFetchAttributes(input, init),\n        ...createFetchRetryOptionsAttributes(init?.retry),\n      },\n    }\n  );\n}\n\nconst doFetchRequest = async (\n  input: RequestInfo | URL | string,\n  init?: RequestInit,\n  attemptCount: number = 0\n): Promise<[Response, Span]> => {\n  const httpMethod = normalizeHttpMethod(input, init);\n\n  const span = tracer.startSpan(`HTTP ${httpMethod}`, {\n    attributes: {\n      [SemanticInternalAttributes.STYLE_ICON]: \"world\",\n      ...(attemptCount > 1 ? { [\"http.request.resend_count\"]: attemptCount - 1 } : {}),\n      ...createFetchAttributes(input, init),\n    },\n  });\n\n  try {\n    const response = await fetchWithInterceptors(input, {\n      ...init,\n      headers: {\n        ...init?.headers,\n        \"x-retry-count\": attemptCount.toString(),\n      },\n    });\n\n    span.setAttributes(createFetchResponseAttributes(response));\n\n    if (!response.ok) {\n      span.recordException(`${response.status}: ${response.statusText}`);\n      span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: `${response.status}: ${response.statusText}`,\n      });\n    }\n\n    return [response, span];\n  } catch (e) {\n    if (typeof e === \"string\" || e instanceof Error) {\n      span.recordException(e);\n    }\n\n    span.setStatus({ code: SpanStatusCode.ERROR });\n    span.setAttribute(SEMATTRS_HTTP_STATUS_CODE, 0);\n    span.setAttribute(\"http.status_text\", \"This operation was aborted.\");\n\n    throw new FetchErrorWithSpan(e, span);\n  }\n};\n\nconst calculateRetryDelayForResponse = async (\n  retry: FetchRetryByStatusOptions | undefined,\n  response: Response,\n  attemptCount: number\n): Promise<{ type: \"delay\"; value: number } | { type: \"timestamp\"; value: number } | undefined> => {\n  if (!retry) {\n    return;\n  }\n\n  const strategy = await getRetryStrategyForResponse(response, retry);\n\n  if (!strategy) {\n    return;\n  }\n\n  switch (strategy.strategy) {\n    case \"backoff\": {\n      const value = calculateNextRetryDelay({ ...defaultRetryOptions, ...strategy }, attemptCount);\n\n      if (value) {\n        return { type: \"delay\", value };\n      }\n\n      break;\n    }\n    case \"headers\": {\n      const resetAt = response.headers.get(strategy.resetHeader);\n\n      if (typeof resetAt === \"string\") {\n        const resetTimestamp = calculateResetAt(\n          resetAt,\n          strategy.resetFormat ?? \"unix_timestamp_in_ms\"\n        );\n\n        if (resetTimestamp) {\n          return { type: \"timestamp\", value: resetTimestamp };\n        }\n      }\n\n      break;\n    }\n  }\n};\n\nconst getRetryStrategyForResponse = async (\n  response: Response,\n  retry: FetchRetryByStatusOptions\n): Promise<FetchRetryStrategy | undefined> => {\n  const statusCodes = Object.keys(retry);\n  const clonedResponse = response.clone();\n\n  for (let i = 0; i < statusCodes.length; i++) {\n    const statusRange = statusCodes[i];\n    const strategy = retry[statusRange];\n\n    if (isStatusCodeInRange(response.status, statusRange)) {\n      if (strategy.bodyFilter) {\n        const body = safeJsonParse(await clonedResponse.text());\n\n        if (!body) {\n          continue;\n        }\n\n        if (eventFilterMatches(body, strategy.bodyFilter)) {\n          return strategy;\n        } else {\n          continue;\n        }\n      }\n\n      return strategy;\n    }\n  }\n};\n\n/**\n * Checks if a given status code falls within a given range.\n * The range can be a single status code (e.g. \"200\"),\n * a range of status codes (e.g. \"500-599\"),\n * a range of status codes with a wildcard (e.g. \"4xx\" for any 4xx status code),\n * or a list of status codes separated by commas (e.g. \"401,403,404,409-412,5xx\").\n * Returns `true` if the status code falls within the range, and `false` otherwise.\n */\nconst isStatusCodeInRange = (statusCode: number, statusRange: string): boolean => {\n  if (statusRange === \"all\") {\n    return true;\n  }\n\n  if (statusRange.includes(\",\")) {\n    const statusCodes = statusRange.split(\",\").map((s) => s.trim());\n\n    return statusCodes.some((s) => isStatusCodeInRange(statusCode, s));\n  }\n\n  const [start, end] = statusRange.split(\"-\");\n\n  if (end) {\n    return statusCode >= parseInt(start, 10) && statusCode <= parseInt(end, 10);\n  }\n\n  if (start.endsWith(\"xx\")) {\n    const prefix = start.slice(0, -2);\n    const statusCodePrefix = Math.floor(statusCode / 100).toString();\n    return statusCodePrefix === prefix;\n  }\n\n  const statusCodeString = statusCode.toString();\n  const rangePrefix = start.slice(0, -1);\n\n  if (start.endsWith(\"x\") && statusCodeString.startsWith(rangePrefix)) {\n    return true;\n  }\n\n  return statusCode === parseInt(start, 10);\n};\n\nconst createAttributesFromHeaders = (headers: Headers): Attributes => {\n  const attributes: Attributes = {};\n\n  const normalizedHeaderKey = (key: string) => {\n    return key.toLowerCase();\n  };\n\n  headers.forEach((value, key) => {\n    attributes[`http.response.header.${normalizedHeaderKey(key)}`] = value;\n  });\n\n  return attributes;\n};\n\nconst safeJsonParse = (json: string): unknown => {\n  try {\n    return JSON.parse(json);\n  } catch (e) {\n    return null;\n  }\n};\n\nconst interceptFetch = (...handlers: Array<HttpHandler>) => {\n  return {\n    run: async <T>(fn: (...args: any[]) => Promise<T>): Promise<T> => {\n      const current = fetchHttpHandlerStorage.getStore();\n\n      if (current) {\n        current.push(...handlers);\n        return fn();\n      } else {\n        return fetchHttpHandlerStorage.run(handlers, fn);\n      }\n    },\n  };\n};\n\n// This function will resolve the defaults of a property within an options object.\n// If the options object is undefined, it will return the defaults for that property (passed in as the 3rd arg).\n// if the options object is defined, and the property exists, then it will return the defaults if the value of the property is undefined or null\nconst resolveDefaults = <\n  TObject extends Record<string, unknown>,\n  K extends keyof TObject,\n  TValue extends TObject[K],\n>(\n  obj: TObject | undefined,\n  key: K,\n  defaults: TValue\n): TValue => {\n  if (!obj) {\n    return defaults;\n  }\n\n  if (obj[key] === undefined || obj[key] === null) {\n    return defaults;\n  }\n\n  return obj[key] as TValue;\n};\n\nconst createFetchAttributes = (\n  input: RequestInfo | URL,\n  init?: RetryFetchRequestInit | undefined\n): Attributes => {\n  const url = normalizeUrlFromInput(input);\n  const httpMethod = normalizeHttpMethod(input, init);\n\n  return {\n    [SEMATTRS_HTTP_METHOD]: httpMethod,\n    [SEMATTRS_HTTP_URL]: url.href,\n    [SEMATTRS_HTTP_HOST]: url.hostname,\n    [\"server.host\"]: url.hostname,\n    [\"server.port\"]: url.port,\n    [SEMATTRS_HTTP_SCHEME]: url.protocol.replace(\":\", \"\"),\n    ...accessoryAttributes({\n      items: [\n        {\n          text: url.hostname,\n          variant: \"normal\",\n        },\n      ],\n      style: \"codepath\",\n    }),\n  };\n};\n\nconst createFetchResponseAttributes = (response: Response): Attributes => {\n  return {\n    [SEMATTRS_HTTP_STATUS_CODE]: response.status,\n    \"http.status_text\": response.statusText,\n    [SEMATTRS_HTTP_RESPONSE_CONTENT_LENGTH]: response.headers.get(\"content-length\") || \"0\",\n    ...createAttributesFromHeaders(response.headers),\n  };\n};\n\nconst createFetchRetryOptionsAttributes = (retry?: FetchRetryOptions): Attributes => {\n  const byStatus = resolveDefaults(retry, \"byStatus\", defaultFetchRetryOptions.byStatus);\n  const connectionError = resolveDefaults(\n    retry,\n    \"connectionError\",\n    defaultFetchRetryOptions.connectionError\n  );\n  const timeout = resolveDefaults(retry, \"timeout\", defaultFetchRetryOptions.timeout);\n\n  return {\n    ...flattenAttributes(byStatus, \"retry.byStatus\"),\n    ...flattenAttributes(connectionError, \"retry.connectionError\"),\n    ...flattenAttributes(timeout, \"retry.timeout\"),\n  };\n};\n\nexport const retry = {\n  onThrow,\n  fetch: retryFetch,\n  interceptFetch,\n};\n","import { SpanKind } from \"@opentelemetry/api\";\nimport {\n  SEMATTRS_MESSAGING_DESTINATION,\n  SEMATTRS_MESSAGING_OPERATION,\n  SEMATTRS_MESSAGING_SYSTEM,\n} from \"@opentelemetry/semantic-conventions\";\nimport {\n  ApiRequestOptions,\n  BatchTaskRunExecutionResult,\n  FailureFnParams,\n  HandleErrorFnParams,\n  HandleErrorResult,\n  InitFnParams,\n  InitOutput,\n  MachineCpu,\n  MachineMemory,\n  MiddlewareFnParams,\n  QueueOptions,\n  RetryOptions,\n  RunFnParams,\n  RunTags,\n  SemanticInternalAttributes,\n  StartFnParams,\n  SuccessFnParams,\n  TaskRunContext,\n  TaskRunExecutionResult,\n  accessoryAttributes,\n  apiClientManager,\n  conditionallyImportPacket,\n  createErrorTaskError,\n  defaultRetryOptions,\n  logger,\n  parsePacket,\n  runtime,\n  stringifyIO,\n  taskCatalog,\n  taskContext,\n} from \"@systemfsoftware/trigger.dev_core/v3\";\nimport * as packageJson from \"../../package.json\";\nimport { tracer } from \"./tracer\";\nimport { PollOptions, RetrieveRunResult, runs } from \"./runs\";\nimport { IdempotencyKey, idempotencyKeys, isIdempotencyKey } from \"./idempotencyKeys\";\n\nexport type Context = TaskRunContext;\n\ntype RequireOne<T, K extends keyof T> = {\n  [X in Exclude<keyof T, K>]?: T[X];\n} & {\n  [P in K]-?: T[P];\n};\n\nexport type Queue = RequireOne<QueueOptions, \"name\">;\n\nexport function queue(options: { name: string } & QueueOptions): Queue {\n  return options;\n}\n\nexport type TaskOptions<\n  TIdentifier extends string,\n  TPayload = void,\n  TOutput = unknown,\n  TInitOutput extends InitOutput = any,\n> = {\n  /** An id for your task. This must be unique inside your project and not change between versions.  */\n  id: TIdentifier;\n  /** The retry settings when an uncaught error is thrown.\n   *\n   * If omitted it will use the values in your `trigger.config.ts` file.\n   * \n   * @example\n   * \n   * ```\n   * export const taskWithRetries = task({\n      id: \"task-with-retries\",\n      retry: {\n        maxAttempts: 10,\n        factor: 1.8,\n        minTimeoutInMs: 500,\n        maxTimeoutInMs: 30_000,\n        randomize: false,\n      },\n      run: async ({ payload, ctx }) => {\n        //...\n      },\n    });\n   * ```\n   * */\n  retry?: RetryOptions;\n  /** Used to configure what should happen when more than one run is triggered at the same time.\n   * \n   * @example \n   * one at a time execution\n   * \n   * ```ts\n   * export const oneAtATime = task({\n      id: \"one-at-a-time\",\n      queue: {\n        concurrencyLimit: 1,\n      },\n      run: async ({ payload, ctx }) => {\n        //...\n      },\n    });\n   * ```\n   */\n  queue?: QueueOptions;\n  /** Configure the spec of the machine you want your task to run on.\n   * \n   * @example\n   * \n   * ```ts\n   * export const heavyTask = task({\n      id: \"heavy-task\",\n      machine: {\n        cpu: 2,\n        memory: 4,\n      },\n      run: async ({ payload, ctx }) => {\n        //...\n      },\n    });\n   * ```\n  */\n  machine?: {\n    /** vCPUs. The default is 0.5.\n     *\n     * Possible values:\n     * - 0.25\n     * - 0.5\n     * - 1\n     * - 2\n     * - 4\n     * @deprecated use preset instead\n     */\n    cpu?: MachineCpu;\n    /** In GBs of RAM. The default is 1.\n     *\n     * Possible values:\n     * - 0.25\n     * - 0.5\n     * - 1\n     * - 2\n     * - 4\n     * - 8\n     * * @deprecated use preset instead\n     */\n    memory?: MachineMemory;\n\n    /** Preset to use for the machine. Defaults to small-1x */\n    preset?:\n      | \"micro\"\n      | \"small-1x\"\n      | \"small-2x\"\n      | \"medium-1x\"\n      | \"medium-2x\"\n      | \"large-1x\"\n      | \"large-2x\";\n  };\n\n  /** This gets called when a task is triggered. It's where you put the code you want to execute.\n   *\n   * @param payload - The payload that is passed to your task when it's triggered. This must be JSON serializable.\n   * @param params - Metadata about the run.\n   */\n  run: (payload: TPayload, params: RunFnParams<TInitOutput>) => Promise<TOutput>;\n\n  /**\n   * init is called before the run function is called. It's useful for setting up any global state.\n   */\n  init?: (payload: TPayload, params: InitFnParams) => Promise<TInitOutput>;\n\n  /**\n   * cleanup is called after the run function has completed.\n   */\n  cleanup?: (payload: TPayload, params: RunFnParams<TInitOutput>) => Promise<void>;\n\n  /**\n   * handleError is called when the run function throws an error. It can be used to modify the error or return new retry options.\n   */\n  handleError?: (\n    payload: TPayload,\n    error: unknown,\n    params: HandleErrorFnParams<TInitOutput>\n  ) => HandleErrorResult;\n\n  /**\n   * middleware allows you to run code \"around\" the run function. This can be useful for logging, metrics, or other cross-cutting concerns.\n   *\n   * When writing middleware, you should always call `next()` to continue the execution of the task:\n   *\n   * ```ts\n   * export const middlewareTask = task({\n   *  id: \"middleware-task\",\n   *  middleware: async (payload, { ctx, next }) => {\n   *   console.log(\"Before run\");\n   *   await next();\n   *   console.log(\"After run\");\n   *  },\n   *  run: async (payload, { ctx }) => {}\n   * });\n   * ```\n   */\n  middleware?: (payload: TPayload, params: MiddlewareFnParams) => Promise<void>;\n\n  /**\n   * onStart is called the first time a task is executed in a run (not before every retry)\n   */\n  onStart?: (payload: TPayload, params: StartFnParams) => Promise<void>;\n\n  /**\n   * onSuccess is called after the run function has successfully completed.\n   */\n  onSuccess?: (\n    payload: TPayload,\n    output: TOutput,\n    params: SuccessFnParams<TInitOutput>\n  ) => Promise<void>;\n\n  /**\n   * onFailure is called after a task run has failed (meaning the run function threw an error and won't be retried anymore)\n   */\n  onFailure?: (\n    payload: TPayload,\n    error: unknown,\n    params: FailureFnParams<TInitOutput>\n  ) => Promise<void>;\n};\n\ndeclare const __output: unique symbol;\ntype BrandOutput<B> = { [__output]: B };\nexport type BrandedOutput<T, B> = T & BrandOutput<B>;\n\nexport type RunHandle<TOutput> = BrandedOutput<\n  {\n    id: string;\n  },\n  TOutput\n>;\n\n/**\n * A BatchRunHandle can be used to retrieve the runs of a batch trigger in a typesafe manner.\n */\nexport type BatchRunHandle<TOutput> = BrandedOutput<\n  {\n    batchId: string;\n    runs: Array<RunHandle<TOutput>>;\n  },\n  TOutput\n>;\n\nexport type RunHandleOutput<TRunHandle> = TRunHandle extends RunHandle<infer TOutput>\n  ? TOutput\n  : never;\n\nexport type TaskRunResult<TOutput = any> =\n  | {\n      ok: true;\n      id: string;\n      output: TOutput;\n    }\n  | {\n      ok: false;\n      id: string;\n      error: unknown;\n    };\n\nexport type BatchResult<TOutput = any> = {\n  id: string;\n  runs: TaskRunResult<TOutput>[];\n};\n\nexport type BatchItem<TInput> = TInput extends void\n  ? { payload?: TInput; options?: TaskRunOptions }\n  : { payload: TInput; options?: TaskRunOptions };\n\nexport interface Task<TIdentifier extends string, TInput = void, TOutput = any> {\n  /**\n   * The id of the task.\n   */\n  id: TIdentifier;\n  /**\n   * Trigger a task with the given payload, and continue without waiting for the result. If you want to wait for the result, use `triggerAndWait`. Returns the id of the triggered task run.\n   * @param payload\n   * @param options\n   * @returns RunHandle\n   * - `id` - The id of the triggered task run.\n   */\n  trigger: (payload: TInput, options?: TaskRunOptions) => Promise<RunHandle<TOutput>>;\n\n  /**\n   * Batch trigger multiple task runs with the given payloads, and continue without waiting for the results. If you want to wait for the results, use `batchTriggerAndWait`. Returns the id of the triggered batch.\n   * @param items\n   * @returns InvokeBatchHandle\n   * - `batchId` - The id of the triggered batch.\n   * - `runs` - The ids of the triggered task runs.\n   */\n  batchTrigger: (items: Array<BatchItem<TInput>>) => Promise<BatchRunHandle<TOutput>>;\n\n  /**\n   * Trigger a task with the given payload, and wait for the result. Returns the result of the task run\n   * @param payload\n   * @param options - Options for the task run\n   * @returns TaskRunResult\n   * @example\n   * ```\n   * const result = await task.triggerAndWait({ foo: \"bar\" });\n   *\n   * if (result.ok) {\n   *  console.log(result.output);\n   * } else {\n   *  console.error(result.error);\n   * }\n   * ```\n   */\n  triggerAndWait: (payload: TInput, options?: TaskRunOptions) => Promise<TaskRunResult<TOutput>>;\n\n  /**\n   * Batch trigger multiple task runs with the given payloads, and wait for the results. Returns the results of the task runs.\n   * @param items\n   * @returns BatchResult\n   * @example\n   * ```\n   * const result = await task.batchTriggerAndWait([\n   *  { payload: { foo: \"bar\" } },\n   *  { payload: { foo: \"baz\" } },\n   * ]);\n   *\n   * for (const run of result.runs) {\n   *  if (run.ok) {\n   *    console.log(run.output);\n   *  } else {\n   *    console.error(run.error);\n   *  }\n   * }\n   * ```\n   */\n  batchTriggerAndWait: (items: Array<BatchItem<TInput>>) => Promise<BatchResult<TOutput>>;\n}\n\nexport type AnyTask = Task<string, any, any>;\n\nexport type TaskPayload<TTask extends AnyTask> = TTask extends Task<string, infer TInput, any>\n  ? TInput\n  : never;\n\nexport type TaskOutput<TTask extends AnyTask> = TTask extends Task<string, any, infer TOutput>\n  ? TOutput\n  : never;\n\nexport type TaskOutputHandle<TTask extends AnyTask> = TTask extends Task<string, any, infer TOutput>\n  ? RunHandle<TOutput>\n  : never;\n\nexport type TaskBatchOutputHandle<TTask extends AnyTask> = TTask extends Task<\n  string,\n  any,\n  infer TOutput\n>\n  ? BatchRunHandle<TOutput>\n  : never;\n\nexport type TaskIdentifier<TTask extends AnyTask> = TTask extends Task<infer TIdentifier, any, any>\n  ? TIdentifier\n  : never;\n\nexport type TaskRunOptions = {\n  /**\n   * A unique key that can be used to ensure that a task is only triggered once per key.\n   *\n   * You can use `idempotencyKeys.create` to create an idempotency key first, and then pass it to the task options.\n   *\n   * @example\n   *\n   * ```typescript\n   * import { idempotencyKeys, task } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n   *\n   * export const myTask = task({\n   *  id: \"my-task\",\n   *  run: async (payload: any) => {\n   *   // scoped to the task run by default\n   *   const idempotencyKey = await idempotencyKeys.create(\"my-task-key\");\n   *\n   *   // Use the idempotency key when triggering child tasks\n   *   await childTask.triggerAndWait(payload, { idempotencyKey });\n   *\n   *   // scoped globally, does not include the task run ID\n   *   const globalIdempotencyKey = await idempotencyKeys.create(\"my-task-key\", { scope: \"global\" });\n   *\n   *   await childTask.triggerAndWait(payload, { idempotencyKey: globalIdempotencyKey });\n   *\n   *   // You can also pass a string directly, which is the same as a global idempotency key\n   *   await childTask.triggerAndWait(payload, { idempotencyKey: \"my-very-unique-key\" });\n   *  }\n   * });\n   * ```\n   *\n   * When triggering a task inside another task, we automatically inject the run ID into the key material.\n   *\n   * If you are triggering a task from your backend, ensure you include some sufficiently unique key material to prevent collisions.\n   *\n   * @example\n   *\n   * ```typescript\n   * import { idempotencyKeys, tasks } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n   *\n   * // Somewhere in your backend\n   * const idempotencyKey = await idempotenceKeys.create([\"my-task-trigger\", \"user-123\"]);\n   * await tasks.trigger(\"my-task\", { foo: \"bar\" }, { idempotencyKey });\n   * ```\n   *\n   */\n  idempotencyKey?: IdempotencyKey | string | string[];\n  maxAttempts?: number;\n  queue?: TaskRunConcurrencyOptions;\n  concurrencyKey?: string;\n  /**\n   * The delay before the task is executed. This can be a string like \"1h\" or a Date object.\n   *\n   * @example\n   * \"1h\" - 1 hour\n   * \"30d\" - 30 days\n   * \"15m\" - 15 minutes\n   * \"2w\" - 2 weeks\n   * \"60s\" - 60 seconds\n   * new Date(\"2025-01-01T00:00:00Z\")\n   */\n  delay?: string | Date;\n\n  /**\n   * Set a time-to-live for this run. If the run is not executed within this time, it will be removed from the queue and never execute.\n   *\n   * @example\n   *\n   * ```ts\n   * await myTask.trigger({ foo: \"bar\" }, { ttl: \"1h\" });\n   * await myTask.trigger({ foo: \"bar\" }, { ttl: 60 * 60 }); // 1 hour\n   * ```\n   *\n   * The minimum value is 1 second. Setting the `ttl` to `0` will disable the TTL and the run will never expire.\n   *\n   * **Note:** Runs in development have a default `ttl` of 10 minutes. You can override this by setting the `ttl` option.\n   */\n  ttl?: string | number;\n\n  /**\n   * Tags to attach to the run. Tags can be used to filter runs in the dashboard and using the SDK.\n   *\n   * You can set up to 5 tags per run, they must be less than 64 characters each.\n   *\n   * We recommend prefixing tags with a namespace using an underscore or colon, like `user_1234567` or `org:9876543`.\n   *\n   * @example\n   *\n   * ```ts\n   * await myTask.trigger({ foo: \"bar\" }, { tags: [\"user:1234567\", \"org:9876543\"] });\n   * ```\n   */\n  tags?: RunTags;\n};\n\ntype TaskRunConcurrencyOptions = Queue;\n\nexport type Prettify<T> = {\n  [K in keyof T]: T[K];\n} & {};\n\nexport type DynamicBaseOptions = {\n  id: string;\n};\n\nexport function createTask<\n  TIdentifier extends string,\n  TInput = void,\n  TOutput = unknown,\n  TInitOutput extends InitOutput = any,\n>(\n  params: TaskOptions<TIdentifier, TInput, TOutput, TInitOutput>\n): Task<TIdentifier, TInput, TOutput> {\n  const customQueue = params.queue\n    ? queue({\n        name: params.queue?.name ?? `task/${params.id}`,\n        ...params.queue,\n      })\n    : undefined;\n\n  const task: Task<TIdentifier, TInput, TOutput> = {\n    id: params.id,\n    trigger: async (payload, options) => {\n      const taskMetadata = taskCatalog.getTaskMetadata(params.id);\n\n      return await trigger_internal<TInput, TOutput>(\n        taskMetadata && taskMetadata.exportName\n          ? `${taskMetadata.exportName}.trigger()`\n          : `trigger()`,\n        params.id,\n        payload,\n        {\n          queue: customQueue,\n          ...options,\n        }\n      );\n    },\n    batchTrigger: async (items) => {\n      const taskMetadata = taskCatalog.getTaskMetadata(params.id);\n\n      return await batchTrigger_internal<TInput, TOutput>(\n        taskMetadata && taskMetadata.exportName\n          ? `${taskMetadata.exportName}.batchTrigger()`\n          : `batchTrigger()`,\n        params.id,\n        items,\n        undefined,\n        customQueue\n      );\n    },\n    triggerAndWait: async (payload, options) => {\n      const taskMetadata = taskCatalog.getTaskMetadata(params.id);\n\n      return await triggerAndWait_internal<TInput, TOutput>(\n        taskMetadata && taskMetadata.exportName\n          ? `${taskMetadata.exportName}.triggerAndWait()`\n          : `triggerAndWait()`,\n        params.id,\n        payload,\n        {\n          queue: customQueue,\n          ...options,\n        }\n      );\n    },\n    batchTriggerAndWait: async (items) => {\n      const taskMetadata = taskCatalog.getTaskMetadata(params.id);\n\n      return await batchTriggerAndWait_internal<TInput, TOutput>(\n        taskMetadata && taskMetadata.exportName\n          ? `${taskMetadata.exportName}.batchTriggerAndWait()`\n          : `batchTriggerAndWait()`,\n        params.id,\n        items,\n        undefined,\n        customQueue\n      );\n    },\n  };\n\n  taskCatalog.registerTaskMetadata({\n    id: params.id,\n    packageVersion: packageJson.version,\n    queue: params.queue,\n    retry: params.retry ? { ...defaultRetryOptions, ...params.retry } : undefined,\n    machine: params.machine,\n    fns: {\n      run: params.run,\n      init: params.init,\n      cleanup: params.cleanup,\n      middleware: params.middleware,\n      handleError: params.handleError,\n      onSuccess: params.onSuccess,\n      onFailure: params.onFailure,\n      onStart: params.onStart,\n    },\n  });\n\n  return task;\n}\n\n/**\n * Trigger a task by its identifier with the given payload. Returns a typesafe `RunHandle`.\n *\n * @example\n *\n * ```ts\n * import { tasks, runs } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n * import type { myTask } from \"./myTasks\"; // Import just the type of the task\n *\n * const handle = await tasks.trigger<typeof myTask>(\"my-task\", { foo: \"bar\" }); // The id and payload are fully typesafe\n * const run = await runs.retrieve(handle);\n * console.log(run.output) // The output is also fully typed\n * ```\n *\n * @returns {RunHandle} An object with the `id` of the run. Can be used to retrieve the completed run output in a typesafe manner.\n */\nexport async function trigger<TTask extends AnyTask>(\n  id: TaskIdentifier<TTask>,\n  payload: TaskPayload<TTask>,\n  options?: TaskRunOptions,\n  requestOptions?: ApiRequestOptions\n): Promise<RunHandle<TaskOutput<TTask>>> {\n  return await trigger_internal<TaskPayload<TTask>, TaskOutput<TTask>>(\n    \"tasks.trigger()\",\n    id,\n    payload,\n    options,\n    requestOptions\n  );\n}\n\n/**\n * Trigger a task with the given payload, and wait for the result. Returns the result of the task run\n * @param id - The id of the task to trigger\n * @param payload\n * @param options - Options for the task run\n * @returns TaskRunResult\n * @example\n * ```ts\n * import { tasks } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n * const result = await tasks.triggerAndWait(\"my-task\", { foo: \"bar\" });\n *\n * if (result.ok) {\n *  console.log(result.output);\n * } else {\n *  console.error(result.error);\n * }\n * ```\n */\nexport async function triggerAndWait<TTask extends AnyTask>(\n  id: TaskIdentifier<TTask>,\n  payload: TaskPayload<TTask>,\n  options?: TaskRunOptions,\n  requestOptions?: ApiRequestOptions\n): Promise<TaskRunResult<TaskOutput<TTask>>> {\n  return await triggerAndWait_internal<TaskPayload<TTask>, TaskOutput<TTask>>(\n    \"tasks.triggerAndWait()\",\n    id,\n    payload,\n    options,\n    requestOptions\n  );\n}\n\n/**\n * Batch trigger multiple task runs with the given payloads, and wait for the results. Returns the results of the task runs.\n * @param id - The id of the task to trigger\n * @param items\n * @returns BatchResult\n * @example\n *\n * ```ts\n * import { tasks } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n *\n * const result = await tasks.batchTriggerAndWait(\"my-task\", [\n *  { payload: { foo: \"bar\" } },\n *  { payload: { foo: \"baz\" } },\n * ]);\n *\n * for (const run of result.runs) {\n *  if (run.ok) {\n *    console.log(run.output);\n *  } else {\n *    console.error(run.error);\n *  }\n * }\n * ```\n */\nexport async function batchTriggerAndWait<TTask extends AnyTask>(\n  id: TaskIdentifier<TTask>,\n  items: Array<BatchItem<TaskPayload<TTask>>>,\n  requestOptions?: ApiRequestOptions\n): Promise<BatchResult<TaskOutput<TTask>>> {\n  return await batchTriggerAndWait_internal<TaskPayload<TTask>, TaskOutput<TTask>>(\n    \"tasks.batchTriggerAndWait()\",\n    id,\n    items,\n    requestOptions\n  );\n}\n\n/**\n * Trigger a task by its identifier with the given payload and poll until the run is completed.\n *\n * @example\n *\n * ```ts\n * import { tasks, runs } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n * import type { myTask } from \"./myTasks\"; // Import just the type of the task\n *\n * const run = await tasks.triggerAndPoll<typeof myTask>(\"my-task\", { foo: \"bar\" }); // The id and payload are fully typesafe\n * console.log(run.output) // The output is also fully typed\n * ```\n *\n * @returns {Run} The completed run, either successful or failed.\n */\nexport async function triggerAndPoll<TTask extends AnyTask>(\n  id: TaskIdentifier<TTask>,\n  payload: TaskPayload<TTask>,\n  options?: TaskRunOptions & PollOptions,\n  requestOptions?: ApiRequestOptions\n): Promise<RetrieveRunResult<RunHandle<TaskOutput<TTask>>>> {\n  const handle = await trigger(id, payload, options, requestOptions);\n\n  return runs.poll(handle, options, requestOptions);\n}\n\nexport async function batchTrigger<TTask extends AnyTask>(\n  id: TaskIdentifier<TTask>,\n  items: Array<BatchItem<TaskPayload<TTask>>>,\n  requestOptions?: ApiRequestOptions\n): Promise<BatchRunHandle<TaskOutput<TTask>>> {\n  return await batchTrigger_internal<TaskPayload<TTask>, TaskOutput<TTask>>(\n    \"tasks.batchTrigger()\",\n    id,\n    items,\n    requestOptions\n  );\n}\n\nasync function trigger_internal<TPayload, TOutput>(\n  name: string,\n  id: string,\n  payload: TPayload,\n  options?: TaskRunOptions,\n  requestOptions?: ApiRequestOptions\n): Promise<RunHandle<TOutput>> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const payloadPacket = await stringifyIO(payload);\n\n  const handle = await apiClient.triggerTask(\n    id,\n    {\n      payload: payloadPacket.data,\n      options: {\n        queue: options?.queue,\n        concurrencyKey: options?.concurrencyKey,\n        test: taskContext.ctx?.run.isTest,\n        payloadType: payloadPacket.dataType,\n        idempotencyKey: await makeKey(options?.idempotencyKey),\n        delay: options?.delay,\n        ttl: options?.ttl,\n        tags: options?.tags,\n        maxAttempts: options?.maxAttempts,\n      },\n    },\n    {\n      spanParentAsLink: true,\n    },\n    {\n      name,\n      tracer,\n      icon: \"trigger\",\n      attributes: {\n        [SEMATTRS_MESSAGING_OPERATION]: \"publish\",\n        [\"messaging.client_id\"]: taskContext.worker?.id,\n        [SEMATTRS_MESSAGING_SYSTEM]: \"trigger.dev\",\n        ...accessoryAttributes({\n          items: [\n            {\n              text: id,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n      onResponseBody: (body, span) => {\n        body &&\n          typeof body === \"object\" &&\n          !Array.isArray(body) &&\n          \"id\" in body &&\n          typeof body.id === \"string\" &&\n          span.setAttribute(\"messaging.message.id\", body.id);\n      },\n      ...requestOptions,\n    }\n  );\n\n  return handle as RunHandle<TOutput>;\n}\n\nasync function batchTrigger_internal<TPayload, TOutput>(\n  name: string,\n  id: string,\n  items: Array<BatchItem<TPayload>>,\n  requestOptions?: ApiRequestOptions,\n  queue?: QueueOptions\n): Promise<BatchRunHandle<TOutput>> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const response = await apiClient.batchTriggerTask(\n    id,\n    {\n      items: await Promise.all(\n        items.map(async (item) => {\n          const payloadPacket = await stringifyIO(item.payload);\n\n          return {\n            payload: payloadPacket.data,\n            options: {\n              queue: item.options?.queue ?? queue,\n              concurrencyKey: item.options?.concurrencyKey,\n              test: taskContext.ctx?.run.isTest,\n              payloadType: payloadPacket.dataType,\n              idempotencyKey: await makeKey(item.options?.idempotencyKey),\n              delay: item.options?.delay,\n              ttl: item.options?.ttl,\n              tags: item.options?.tags,\n              maxAttempts: item.options?.maxAttempts,\n            },\n          };\n        })\n      ),\n    },\n    { spanParentAsLink: true },\n    {\n      name,\n      tracer,\n      icon: \"trigger\",\n      attributes: {\n        [SEMATTRS_MESSAGING_OPERATION]: \"publish\",\n        [\"messaging.client_id\"]: taskContext.worker?.id,\n        [SEMATTRS_MESSAGING_SYSTEM]: \"trigger.dev\",\n        ...accessoryAttributes({\n          items: [\n            {\n              text: id,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n      ...requestOptions,\n    }\n  );\n\n  const handle = {\n    batchId: response.batchId,\n    runs: response.runs.map((id) => ({ id })),\n  };\n\n  return handle as BatchRunHandle<TOutput>;\n}\n\nasync function triggerAndWait_internal<TPayload, TOutput>(\n  name: string,\n  id: string,\n  payload: TPayload,\n  options?: TaskRunOptions,\n  requestOptions?: ApiRequestOptions\n): Promise<TaskRunResult<TOutput>> {\n  const ctx = taskContext.ctx;\n\n  if (!ctx) {\n    throw new Error(\"triggerAndWait can only be used from inside a task.run()\");\n  }\n\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const payloadPacket = await stringifyIO(payload);\n\n  return await tracer.startActiveSpan(\n    name,\n    async (span) => {\n      const response = await apiClient.triggerTask(\n        id,\n        {\n          payload: payloadPacket.data,\n          options: {\n            dependentAttempt: ctx.attempt.id,\n            lockToVersion: taskContext.worker?.version, // Lock to current version because we're waiting for it to finish\n            queue: options?.queue,\n            concurrencyKey: options?.concurrencyKey,\n            test: taskContext.ctx?.run.isTest,\n            payloadType: payloadPacket.dataType,\n            idempotencyKey: await makeKey(options?.idempotencyKey),\n            delay: options?.delay,\n            ttl: options?.ttl,\n            tags: options?.tags,\n            maxAttempts: options?.maxAttempts,\n          },\n        },\n        {},\n        requestOptions\n      );\n\n      span.setAttribute(\"messaging.message.id\", response.id);\n\n      if (options?.idempotencyKey) {\n        // If an idempotency key is provided, we can check if the result is already available\n        const result = await apiClient.getRunResult(response.id);\n\n        if (result) {\n          logger.log(\n            `Result reused from previous task run with idempotency key '${options.idempotencyKey}'.`,\n            {\n              runId: response.id,\n              idempotencyKey: options.idempotencyKey,\n            }\n          );\n\n          return await handleTaskRunExecutionResult<TOutput>(result);\n        }\n      }\n\n      const result = await runtime.waitForTask({\n        id: response.id,\n        ctx,\n      });\n\n      return await handleTaskRunExecutionResult<TOutput>(result);\n    },\n    {\n      kind: SpanKind.PRODUCER,\n      attributes: {\n        [SemanticInternalAttributes.STYLE_ICON]: \"trigger\",\n        [SEMATTRS_MESSAGING_OPERATION]: \"publish\",\n        [\"messaging.client_id\"]: taskContext.worker?.id,\n        [SEMATTRS_MESSAGING_DESTINATION]: id,\n        [SEMATTRS_MESSAGING_SYSTEM]: \"trigger.dev\",\n        ...accessoryAttributes({\n          items: [\n            {\n              text: id,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    }\n  );\n}\n\nasync function batchTriggerAndWait_internal<TPayload, TOutput>(\n  name: string,\n  id: string,\n  items: Array<BatchItem<TPayload>>,\n  requestOptions?: ApiRequestOptions,\n  queue?: QueueOptions\n): Promise<BatchResult<TOutput>> {\n  const ctx = taskContext.ctx;\n\n  if (!ctx) {\n    throw new Error(\"batchTriggerAndWait can only be used from inside a task.run()\");\n  }\n\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  return await tracer.startActiveSpan(\n    name,\n    async (span) => {\n      const response = await apiClient.batchTriggerTask(\n        id,\n        {\n          items: await Promise.all(\n            items.map(async (item) => {\n              const payloadPacket = await stringifyIO(item.payload);\n\n              return {\n                payload: payloadPacket.data,\n                options: {\n                  lockToVersion: taskContext.worker?.version,\n                  queue: item.options?.queue ?? queue,\n                  concurrencyKey: item.options?.concurrencyKey,\n                  test: taskContext.ctx?.run.isTest,\n                  payloadType: payloadPacket.dataType,\n                  idempotencyKey: await makeKey(item.options?.idempotencyKey),\n                  delay: item.options?.delay,\n                  ttl: item.options?.ttl,\n                  tags: item.options?.tags,\n                  maxAttempts: item.options?.maxAttempts,\n                },\n              };\n            })\n          ),\n          dependentAttempt: ctx.attempt.id,\n        },\n        {},\n        requestOptions\n      );\n\n      span.setAttribute(\"messaging.message.id\", response.batchId);\n\n      const getBatchResults = async (): Promise<BatchTaskRunExecutionResult> => {\n        // We need to check if the results are already available, but only if any of the items options has an idempotency key\n        const hasIdempotencyKey = items.some((item) => item.options?.idempotencyKey);\n\n        if (hasIdempotencyKey) {\n          const results = await apiClient.getBatchResults(response.batchId);\n\n          if (results) {\n            return results;\n          }\n        }\n\n        return {\n          id: response.batchId,\n          items: [],\n        };\n      };\n\n      const existingResults = await getBatchResults();\n\n      const incompleteRuns = response.runs.filter(\n        (runId) => !existingResults.items.some((item) => item.id === runId)\n      );\n\n      if (incompleteRuns.length === 0) {\n        logger.log(\n          `Results reused from previous task runs because of the provided idempotency keys.`\n        );\n\n        // All runs are already completed\n        const runs = await handleBatchTaskRunExecutionResult<TOutput>(existingResults.items);\n\n        return {\n          id: existingResults.id,\n          runs,\n        };\n      }\n\n      const result = await runtime.waitForBatch({\n        id: response.batchId,\n        runs: incompleteRuns,\n        ctx,\n      });\n\n      // Combine the already completed runs with the newly completed runs, ordered by the original order\n      const combinedItems: BatchTaskRunExecutionResult[\"items\"] = [];\n\n      for (const runId of response.runs) {\n        const existingItem = existingResults.items.find((item) => item.id === runId);\n\n        if (existingItem) {\n          combinedItems.push(existingItem);\n        } else {\n          const newItem = result.items.find((item) => item.id === runId);\n\n          if (newItem) {\n            combinedItems.push(newItem);\n          }\n        }\n      }\n\n      const runs = await handleBatchTaskRunExecutionResult<TOutput>(combinedItems);\n\n      return {\n        id: result.id,\n        runs,\n      };\n    },\n    {\n      kind: SpanKind.PRODUCER,\n      attributes: {\n        [SemanticInternalAttributes.STYLE_ICON]: \"trigger\",\n        [\"messaging.batch.message_count\"]: items.length,\n        [SEMATTRS_MESSAGING_OPERATION]: \"publish\",\n        [\"messaging.client_id\"]: taskContext.worker?.id,\n        [SEMATTRS_MESSAGING_DESTINATION]: id,\n        [SEMATTRS_MESSAGING_SYSTEM]: \"trigger.dev\",\n        ...accessoryAttributes({\n          items: [\n            {\n              text: id,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    }\n  );\n}\n\nasync function handleBatchTaskRunExecutionResult<TOutput>(\n  items: Array<TaskRunExecutionResult>\n): Promise<Array<TaskRunResult<TOutput>>> {\n  const someObjectStoreOutputs = items.some(\n    (item) => item.ok && item.outputType === \"application/store\"\n  );\n\n  if (!someObjectStoreOutputs) {\n    const results = await Promise.all(\n      items.map(async (item) => {\n        return await handleTaskRunExecutionResult<TOutput>(item);\n      })\n    );\n\n    return results;\n  }\n\n  return await tracer.startActiveSpan(\n    \"store.downloadPayloads\",\n    async (span) => {\n      const results = await Promise.all(\n        items.map(async (item) => {\n          return await handleTaskRunExecutionResult<TOutput>(item);\n        })\n      );\n\n      return results;\n    },\n    {\n      kind: SpanKind.INTERNAL,\n      [SemanticInternalAttributes.STYLE_ICON]: \"cloud-download\",\n    }\n  );\n}\n\nasync function handleTaskRunExecutionResult<TOutput>(\n  execution: TaskRunExecutionResult\n): Promise<TaskRunResult<TOutput>> {\n  if (execution.ok) {\n    const outputPacket = { data: execution.output, dataType: execution.outputType };\n    const importedPacket = await conditionallyImportPacket(outputPacket, tracer);\n\n    return {\n      ok: true,\n      id: execution.id,\n      output: await parsePacket(importedPacket),\n    };\n  } else {\n    return {\n      ok: false,\n      id: execution.id,\n      error: createErrorTaskError(execution.error),\n    };\n  }\n}\n\nexport function apiClientMissingError() {\n  const hasBaseUrl = !!apiClientManager.baseURL;\n  const hasAccessToken = !!apiClientManager.accessToken;\n  if (!hasBaseUrl && !hasAccessToken) {\n    return `You need to set the TRIGGER_API_URL and TRIGGER_SECRET_KEY environment variables.`;\n  } else if (!hasBaseUrl) {\n    return `You need to set the TRIGGER_API_URL environment variable.`;\n  } else if (!hasAccessToken) {\n    return `You need to set the TRIGGER_SECRET_KEY environment variable.`;\n  }\n\n  return `Unknown error`;\n}\n\nasync function makeKey(\n  idempotencyKey?: IdempotencyKey | string | string[]\n): Promise<IdempotencyKey | undefined> {\n  if (!idempotencyKey) {\n    return;\n  }\n\n  if (isIdempotencyKey(idempotencyKey)) {\n    return idempotencyKey;\n  }\n\n  return await idempotencyKeys.create(idempotencyKey, { scope: \"global\" });\n}\n","import type {\n  ApiRequestOptions,\n  ListProjectRunsQueryParams,\n  ListRunsQueryParams,\n  RescheduleRunRequestBody,\n} from \"@systemfsoftware/trigger.dev_core/v3\";\nimport {\n  ApiPromise,\n  CanceledRunResponse,\n  CursorPagePromise,\n  ListRunResponseItem,\n  ReplayRunResponse,\n  RetrieveRunResponse,\n  accessoryAttributes,\n  apiClientManager,\n  flattenAttributes,\n  isRequestOptions,\n  mergeRequestOptions,\n} from \"@systemfsoftware/trigger.dev_core/v3\";\nimport { AnyTask, Prettify, RunHandle, Task, apiClientMissingError } from \"./shared\";\nimport { tracer } from \"./tracer\";\n\nexport type RetrieveRunResult<TRunId> = Prettify<\n  TRunId extends RunHandle<infer TOutput>\n    ? Omit<RetrieveRunResponse, \"output\"> & { output?: TOutput }\n    : TRunId extends Task<string, any, infer TTaskOutput>\n    ? Omit<RetrieveRunResponse, \"output\"> & { output?: TTaskOutput }\n    : TRunId extends string\n    ? RetrieveRunResponse\n    : never\n>;\n\nexport const runs = {\n  replay: replayRun,\n  cancel: cancelRun,\n  retrieve: retrieveRun,\n  list: listRuns,\n  reschedule: rescheduleRun,\n  poll,\n};\n\nexport type ListRunsItem = ListRunResponseItem;\n\nfunction listRuns(\n  projectRef: string,\n  params?: ListProjectRunsQueryParams,\n  requestOptions?: ApiRequestOptions\n): CursorPagePromise<typeof ListRunResponseItem>;\nfunction listRuns(\n  params?: ListRunsQueryParams,\n  requestOptions?: ApiRequestOptions\n): CursorPagePromise<typeof ListRunResponseItem>;\nfunction listRuns(\n  paramsOrProjectRef?: ListRunsQueryParams | string,\n  paramsOrOptions?: ListRunsQueryParams | ListProjectRunsQueryParams | ApiRequestOptions,\n  requestOptions?: ApiRequestOptions\n): CursorPagePromise<typeof ListRunResponseItem> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = listRunsRequestOptions(\n    paramsOrProjectRef,\n    paramsOrOptions,\n    requestOptions\n  );\n\n  if (typeof paramsOrProjectRef === \"string\") {\n    if (isRequestOptions(paramsOrOptions)) {\n      return apiClient.listProjectRuns(paramsOrProjectRef, {}, $requestOptions);\n    } else {\n      return apiClient.listProjectRuns(paramsOrProjectRef, paramsOrOptions, $requestOptions);\n    }\n  }\n\n  return apiClient.listRuns(paramsOrProjectRef, $requestOptions);\n}\n\nfunction listRunsRequestOptions(\n  paramsOrProjectRef?: ListRunsQueryParams | string,\n  paramsOrOptions?: ListRunsQueryParams | ListProjectRunsQueryParams | ApiRequestOptions,\n  requestOptions?: ApiRequestOptions\n): ApiRequestOptions {\n  if (typeof paramsOrProjectRef === \"string\") {\n    if (isRequestOptions(paramsOrOptions)) {\n      return mergeRequestOptions(\n        {\n          tracer,\n          name: \"runs.list()\",\n          icon: \"runs\",\n          attributes: {\n            projectRef: paramsOrProjectRef,\n            ...accessoryAttributes({\n              items: [\n                {\n                  text: paramsOrProjectRef,\n                  variant: \"normal\",\n                },\n              ],\n              style: \"codepath\",\n            }),\n          },\n        },\n        paramsOrOptions\n      );\n    } else {\n      return mergeRequestOptions(\n        {\n          tracer,\n          name: \"runs.list()\",\n          icon: \"runs\",\n          attributes: {\n            projectRef: paramsOrProjectRef,\n            ...flattenAttributes(paramsOrOptions as Record<string, unknown>, \"queryParams\"),\n            ...accessoryAttributes({\n              items: [\n                {\n                  text: paramsOrProjectRef,\n                  variant: \"normal\",\n                },\n              ],\n              style: \"codepath\",\n            }),\n          },\n        },\n        requestOptions\n      );\n    }\n  }\n\n  return mergeRequestOptions(\n    {\n      tracer,\n      name: \"runs.list()\",\n      icon: \"runs\",\n      attributes: {\n        ...flattenAttributes(paramsOrProjectRef as Record<string, unknown>, \"queryParams\"),\n      },\n    },\n    isRequestOptions(paramsOrOptions) ? paramsOrOptions : requestOptions\n  );\n}\n\n// Extract out the expected type of the id, can be either a string or a RunHandle\ntype RunId<TRunId> = TRunId extends RunHandle<any>\n  ? TRunId\n  : TRunId extends AnyTask\n  ? string\n  : TRunId extends string\n  ? TRunId\n  : never;\n\nfunction retrieveRun<TRunId extends RunHandle<any> | AnyTask | string>(\n  runId: RunId<TRunId>,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<RetrieveRunResult<TRunId>> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"runs.retrieve()\",\n      icon: \"runs\",\n      attributes: {\n        runId: typeof runId === \"string\" ? runId : runId.id,\n        ...accessoryAttributes({\n          items: [\n            {\n              text: typeof runId === \"string\" ? runId : runId.id,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  if (typeof runId === \"string\") {\n    return apiClient.retrieveRun(runId, $requestOptions) as ApiPromise<RetrieveRunResult<TRunId>>;\n  } else {\n    return apiClient.retrieveRun(runId.id, $requestOptions) as ApiPromise<\n      RetrieveRunResult<TRunId>\n    >;\n  }\n}\n\nfunction replayRun(\n  runId: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<ReplayRunResponse> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"runs.replay()\",\n      icon: \"runs\",\n      attributes: {\n        runId,\n        ...accessoryAttributes({\n          items: [\n            {\n              text: runId,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  return apiClient.replayRun(runId, $requestOptions);\n}\n\nfunction cancelRun(\n  runId: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<CanceledRunResponse> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"runs.cancel()\",\n      icon: \"runs\",\n      attributes: {\n        runId,\n        ...accessoryAttributes({\n          items: [\n            {\n              text: runId,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  return apiClient.cancelRun(runId, $requestOptions);\n}\n\nfunction rescheduleRun(\n  runId: string,\n  body: RescheduleRunRequestBody,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<RetrieveRunResponse> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"runs.reschedule()\",\n      icon: \"runs\",\n      attributes: {\n        runId,\n        ...accessoryAttributes({\n          items: [\n            {\n              text: runId,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  return apiClient.rescheduleRun(runId, body, $requestOptions);\n}\n\nexport type PollOptions = { pollIntervalMs?: number };\n\nconst MAX_POLL_ATTEMPTS = 500;\n\nasync function poll<TRunId extends RunHandle<any> | AnyTask | string>(\n  runId: RunId<TRunId>,\n  options?: { pollIntervalMs?: number },\n  requestOptions?: ApiRequestOptions\n) {\n  let attempts = 0;\n\n  while (attempts++ < MAX_POLL_ATTEMPTS) {\n    const run = await runs.retrieve(runId, requestOptions);\n\n    if (run.isCompleted) {\n      return run;\n    }\n\n    await new Promise((resolve) => setTimeout(resolve, options?.pollIntervalMs ?? 1000));\n  }\n\n  throw new Error(\n    `Run ${\n      typeof runId === \"string\" ? runId : runId.id\n    } did not complete after ${MAX_POLL_ATTEMPTS} attempts`\n  );\n}\n","import { taskContext } from \"@systemfsoftware/trigger.dev_core/v3\";\n\nexport const idempotencyKeys = {\n  create: createIdempotencyKey,\n};\n\ndeclare const __brand: unique symbol;\ntype Brand<B> = { [__brand]: B };\ntype Branded<T, B> = T & Brand<B>;\n\nexport type IdempotencyKey = Branded<string, \"IdempotencyKey\">;\n\nexport function isIdempotencyKey(\n  value: string | string[] | IdempotencyKey\n): value is IdempotencyKey {\n  // Cannot check the brand at runtime because it doesn't exist (it's a TypeScript-only construct)\n  return typeof value === \"string\" && value.length === 64;\n}\n\n/**\n * Creates a deterministic idempotency key based on the provided key material.\n *\n * If running inside a task, the task run ID is automatically included in the key material, giving you a unique key per task run.\n * This ensures that a given child task is only triggered once per task run, even if the parent task is retried.\n *\n * @param {string | string[]} key The key material to create the idempotency key from.\n * @param {object} [options] Additional options.\n * @param {\"run\" | \"attempt\" | \"global\"} [options.scope=\"run\"] The scope of the idempotency key.\n *\n * @returns {Promise<IdempotencyKey>} The idempotency key as a branded string.\n *\n * @example\n *\n * ```typescript\n * import { idempotencyKeys, task } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n *\n * export const myTask = task({\n *  id: \"my-task\",\n *  run: async (payload: any) => {\n *   const idempotencyKey = await idempotencyKeys.create(\"my-task-key\");\n *\n *   // Use the idempotency key when triggering child tasks\n *   await childTask.triggerAndWait(payload, { idempotencyKey });\n *  }\n * });\n * ```\n *\n * You can also use the `scope` parameter to create a key that is unique per task run, task run attempts (retries of the same run), or globally:\n *\n * ```typescript\n *  await idempotencyKeys.create(\"my-task-key\", { scope: \"attempt\" }); // Creates a key that is unique per task run attempt\n *  await idempotencyKeys.create(\"my-task-key\", { scope: \"global\" }); // Skips including the task run ID\n * ```\n */\nasync function createIdempotencyKey(\n  key: string | string[],\n  options?: { scope?: \"run\" | \"attempt\" | \"global\" }\n): Promise<IdempotencyKey> {\n  const idempotencyKey = await generateIdempotencyKey(\n    [...(Array.isArray(key) ? key : [key])].concat(injectScope(options?.scope ?? \"run\"))\n  );\n\n  return idempotencyKey as IdempotencyKey;\n}\n\nfunction injectScope(scope: \"run\" | \"attempt\" | \"global\"): string[] {\n  switch (scope) {\n    case \"run\": {\n      if (taskContext?.ctx) {\n        return [taskContext.ctx.run.id];\n      }\n    }\n    case \"attempt\": {\n      if (taskContext?.ctx) {\n        return [taskContext.ctx.attempt.id];\n      }\n    }\n  }\n\n  return [];\n}\n\nasync function generateIdempotencyKey(keyMaterial: string[]) {\n  const hash = await crypto.subtle.digest(\n    \"SHA-256\",\n    new TextEncoder().encode(keyMaterial.join(\"-\"))\n  );\n\n  // Return a hex string, using cross-runtime compatible methods\n  return Array.from(new Uint8Array(hash))\n    .map((byte) => byte.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n","import { InitOutput } from \"@systemfsoftware/trigger.dev_core/v3\";\nimport {\n  batchTrigger,\n  batchTriggerAndWait,\n  createTask,\n  trigger,\n  triggerAndPoll,\n  triggerAndWait,\n} from \"./shared\";\n\nimport type {\n  TaskOptions,\n  Task,\n  Queue,\n  RunHandle,\n  BatchRunHandle,\n  TaskRunResult,\n  BatchResult,\n  BatchItem,\n  TaskPayload,\n  TaskOutput,\n  TaskIdentifier,\n  TaskRunOptions,\n  AnyTask,\n} from \"./shared\";\n\nexport type {\n  TaskOptions,\n  Task,\n  Queue,\n  RunHandle,\n  BatchRunHandle,\n  TaskRunResult,\n  BatchResult,\n  BatchItem,\n  TaskPayload,\n  TaskOutput,\n  TaskIdentifier,\n  TaskRunOptions,\n  AnyTask,\n};\n\n/** Creates a task that can be triggered\n * @param options - Task options\n * @example \n * \n * ```ts\n * import { task } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n *\n * export const helloWorld = task({\n    id: \"hello-world\",\n *    run: async (payload: { url: string }) => {\n *    return { hello: \"world\" };\n *  },\n * });\n *\n * ```\n * \n * @returns A task that can be triggered\n */\nexport function task<\n  TIdentifier extends string,\n  TInput = void,\n  TOutput = unknown,\n  TInitOutput extends InitOutput = any,\n>(\n  options: TaskOptions<TIdentifier, TInput, TOutput, TInitOutput>\n): Task<TIdentifier, TInput, TOutput> {\n  return createTask<TIdentifier, TInput, TOutput, TInitOutput>(options);\n}\n\nexport const tasks = {\n  trigger,\n  triggerAndPoll,\n  batchTrigger,\n  triggerAndWait,\n  batchTriggerAndWait,\n};\n","import { SemanticInternalAttributes, accessoryAttributes, runtime } from \"@systemfsoftware/trigger.dev_core/v3\";\nimport { tracer } from \"./tracer\";\n\nexport type WaitOptions =\n  | {\n      seconds: number;\n    }\n  | {\n      minutes: number;\n    }\n  | {\n      hours: number;\n    }\n  | {\n      days: number;\n    }\n  | {\n      weeks: number;\n    }\n  | {\n      months: number;\n    }\n  | {\n      years: number;\n    };\n\nexport const wait = {\n  for: async (options: WaitOptions) => {\n    return tracer.startActiveSpan(\n      `wait.for()`,\n      async (span) => {\n        const start = Date.now();\n        const durationInMs = calculateDurationInMs(options);\n\n        await runtime.waitForDuration(durationInMs);\n      },\n      {\n        attributes: {\n          [SemanticInternalAttributes.STYLE_ICON]: \"wait\",\n          ...accessoryAttributes({\n            items: [\n              {\n                text: nameForWaitOptions(options),\n                variant: \"normal\",\n              },\n            ],\n            style: \"codepath\",\n          }),\n        },\n      }\n    );\n  },\n  until: async (options: { date: Date; throwIfInThePast?: boolean }) => {\n    return tracer.startActiveSpan(\n      `wait.until()`,\n      async (span) => {\n        const start = Date.now();\n\n        if (options.throwIfInThePast && options.date < new Date()) {\n          throw new Error(\"Date is in the past\");\n        }\n\n        const durationInMs = options.date.getTime() - start;\n\n        await runtime.waitForDuration(durationInMs);\n      },\n      {\n        attributes: {\n          [SemanticInternalAttributes.STYLE_ICON]: \"wait\",\n          ...accessoryAttributes({\n            items: [\n              {\n                text: options.date.toISOString(),\n                variant: \"normal\",\n              },\n            ],\n            style: \"codepath\",\n          }),\n        },\n      }\n    );\n  },\n};\n\nfunction nameForWaitOptions(options: WaitOptions): string {\n  if (\"seconds\" in options) {\n    return options.seconds === 1 ? `1 second` : `${options.seconds} seconds`;\n  }\n\n  if (\"minutes\" in options) {\n    return options.minutes === 1 ? `1 minute` : `${options.minutes} minutes`;\n  }\n\n  if (\"hours\" in options) {\n    return options.hours === 1 ? `1 hour` : `${options.hours} hours`;\n  }\n\n  if (\"days\" in options) {\n    return options.days === 1 ? `1 day` : `${options.days} days`;\n  }\n\n  if (\"weeks\" in options) {\n    return options.weeks === 1 ? `1 week` : `${options.weeks} weeks`;\n  }\n\n  if (\"months\" in options) {\n    return options.months === 1 ? `1 month` : `${options.months} months`;\n  }\n\n  if (\"years\" in options) {\n    return options.years === 1 ? `1 year` : `${options.years} years`;\n  }\n\n  return \"NaN\";\n}\n\nfunction calculateDurationInMs(options: WaitOptions): number {\n  if (\"seconds\" in options) {\n    return options.seconds * 1000;\n  }\n\n  if (\"minutes\" in options) {\n    return options.minutes * 1000 * 60;\n  }\n\n  if (\"hours\" in options) {\n    return options.hours * 1000 * 60 * 60;\n  }\n\n  if (\"days\" in options) {\n    return options.days * 1000 * 60 * 60 * 24;\n  }\n\n  if (\"weeks\" in options) {\n    return options.weeks * 1000 * 60 * 60 * 24 * 7;\n  }\n\n  if (\"months\" in options) {\n    return options.months * 1000 * 60 * 60 * 24 * 30;\n  }\n\n  if (\"years\" in options) {\n    return options.years * 1000 * 60 * 60 * 24 * 365;\n  }\n\n  throw new Error(\"Invalid options\");\n}\n\ntype RequestOptions = {\n  to: (url: string) => Promise<void>;\n  timeout: WaitOptions;\n};\n","import { usage as usageApi, taskContext } from \"@systemfsoftware/trigger.dev_core/v3\";\n\nexport type ComputeUsage = {\n  costInCents: number;\n  durationMs: number;\n};\n\n// What about run start cost and what should we call that? Some better names\nexport type CurrentUsage = {\n  compute: {\n    attempt: ComputeUsage;\n    total: ComputeUsage;\n  };\n  baseCostInCents: number;\n  totalCostInCents: number;\n};\n\nexport const usage = {\n  /**\n   * Get the current running usage of this task run.\n   *\n   * @example\n   *\n   * ```typescript\n   * import { usage, task } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n   *\n   * export const myTask = task({\n   *  id: \"my-task\",\n   *  run: async (payload, { ctx }) => {\n   *   // ... Do a bunch of work\n   *\n   *   const currentUsage = usage.getCurrent();\n   *\n   *   // You have access to the current compute cost and duration up to this point\n   *   console.log(\"Current attempt compute cost and duration\", {\n   *     cost: currentUsage.compute.attempt.costInCents,\n   *     duration: currentUsage.compute.attempt.durationMs,\n   *   });\n   *\n   *   // You also can see the total compute cost and duration up to this point in the run, across all attempts\n   *   console.log(\"Current total compute cost and duration\", {\n   *     cost: currentUsage.compute.total.costInCents,\n   *     duration: currentUsage.compute.total.durationMs,\n   *   });\n   *\n   *   // You can see the base cost of the run, which is the cost of the run before any compute costs\n   *   console.log(\"Total cost\", {\n   *     cost: currentUsage.totalCostInCents,\n   *     baseCost: currentUsage.baseCostInCents,\n   *   });\n   *  },\n   * });\n   * ```\n   */\n  getCurrent: (): CurrentUsage => {\n    const sample = usageApi.sample();\n    const machine = taskContext.ctx?.machine;\n    const run = taskContext.ctx?.run;\n\n    if (!sample) {\n      return {\n        compute: {\n          attempt: {\n            costInCents: 0,\n            durationMs: 0,\n          },\n          total: {\n            costInCents: run?.costInCents ?? 0,\n            durationMs: run?.durationMs ?? 0,\n          },\n        },\n        baseCostInCents: run?.baseCostInCents ?? 0,\n        totalCostInCents: (run?.costInCents ?? 0) + (run?.baseCostInCents ?? 0),\n      };\n    }\n\n    const currentCostInCents = machine?.centsPerMs ? sample.cpuTime * machine.centsPerMs : 0;\n\n    return {\n      compute: {\n        attempt: {\n          costInCents: currentCostInCents,\n          durationMs: sample.cpuTime,\n        },\n        total: {\n          costInCents: (run?.costInCents ?? 0) + currentCostInCents,\n          durationMs: (run?.durationMs ?? 0) + sample.cpuTime,\n        },\n      },\n      baseCostInCents: run?.baseCostInCents ?? 0,\n      totalCostInCents: (run?.costInCents ?? 0) + currentCostInCents + (run?.baseCostInCents ?? 0),\n    };\n  },\n  /**\n   * Measure the cost and duration of a function.\n   *\n   * @example\n   *\n   * ```typescript\n   * import { usage } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n   *\n   * export const myTask = task({\n   *  id: \"my-task\",\n   *  run: async (payload, { ctx }) => {\n   *    const { result, compute } = await usage.measure(async () => {\n   *      // Do some work\n   *      return \"result\";\n   *    });\n   *\n   *    console.log(\"Result\", result);\n   *    console.log(\"Cost and duration\", { cost: compute.costInCents, duration: compute.durationMs });\n   *  },\n   * });\n   * ```\n   */\n  measure: async <T>(cb: () => Promise<T>): Promise<{ result: T; compute: ComputeUsage }> => {\n    const measurement = usageApi.start();\n\n    const result = await cb();\n\n    const sample = usageApi.stop(measurement);\n    const machine = taskContext.ctx?.machine;\n\n    const costInCents = machine?.centsPerMs ? sample.cpuTime * machine.centsPerMs : 0;\n\n    return {\n      result,\n      compute: {\n        costInCents,\n        durationMs: sample.cpuTime,\n      },\n    };\n  },\n};\n","import type { ApiRequestOptions, RunTags } from \"@systemfsoftware/trigger.dev_core/v3\";\nimport {\n  UnprocessableEntityError,\n  accessoryAttributes,\n  apiClientManager,\n  logger,\n  mergeRequestOptions,\n  taskContext,\n} from \"@systemfsoftware/trigger.dev_core/v3\";\nimport { apiClientMissingError } from \"./shared\";\nimport { tracer } from \"./tracer\";\n\nexport const tags = {\n  add: addTags,\n};\n\nasync function addTags(tags: RunTags, requestOptions?: ApiRequestOptions) {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const run = taskContext.ctx?.run;\n  if (!run) {\n    throw new Error(\n      \"Can't set tags outside of a run. You can trigger a task and set tags in the options.\"\n    );\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"tags.set()\",\n      icon: \"tag\",\n      attributes: {\n        ...accessoryAttributes({\n          items: [\n            {\n              text: typeof tags === \"string\" ? tags : tags.join(\", \"),\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  try {\n    await apiClient.addTags(run.id, { tags }, $requestOptions);\n  } catch (error) {\n    if (error instanceof UnprocessableEntityError) {\n      logger.error(error.message, {\n        existingTags: run.tags,\n        newTags: tags,\n      });\n      return;\n    }\n\n    logger.error(\"Failed to set tags\", { error });\n\n    throw error;\n  }\n}\n","export * from \"./cache\";\nexport * from \"./config\";\nexport { retry, type RetryOptions } from \"./retry\";\nexport { queue } from \"./shared\";\nexport * from \"./tasks\";\nexport * from \"./wait\";\nexport * from \"./usage\";\nexport * from \"./idempotencyKeys\";\nexport * from \"./tags\";\nexport type { Context };\n\nimport type { Context } from \"./shared\";\n\nimport type { ApiClientConfiguration } from \"@systemfsoftware/trigger.dev_core/v3\";\nimport { apiClientManager } from \"@systemfsoftware/trigger.dev_core/v3\";\n\nexport type { ApiClientConfiguration };\n\nexport {\n  ApiError,\n  AuthenticationError,\n  BadRequestError,\n  ConflictError,\n  InternalServerError,\n  NotFoundError,\n  PermissionDeniedError,\n  RateLimitError,\n  UnprocessableEntityError,\n  AbortTaskRunError,\n  logger,\n  type LogLevel,\n} from \"@systemfsoftware/trigger.dev_core/v3\";\n\nexport { runs } from \"./runs\";\nexport * as schedules from \"./schedules\";\nexport * as envvars from \"./envvars\";\nexport type { ImportEnvironmentVariablesParams } from \"./envvars\";\n\n/**\n * Register the global API client configuration. Alternatively, you can set the `TRIGGER_SECRET_KEY` and `TRIGGER_API_URL` environment variables.\n * @param options The API client configuration.\n * @param options.baseURL The base URL of the Trigger API. (default: `https://api.trigger.dev`)\n * @param options.secretKey The secret key to authenticate with the Trigger API. (default: `process.env.TRIGGER_SECRET_KEY`) This can be found in your Trigger.dev project \"API Keys\" settings.\n *\n * @example\n *\n * ```typescript\n * import { configure } from \"@systemfsoftware/trigger.dev_sdk/v3\";\n *\n * configure({\n *  baseURL: \"https://api.trigger.dev\",\n *  secretKey: \"tr_dev_1234567890\"\n * });\n * ```\n */\nexport function configure(options: ApiClientConfiguration) {\n  apiClientManager.setGlobalAPIClientConfiguration(options);\n}\n","import {\n  ApiPromise,\n  ApiRequestOptions,\n  DeletedScheduleObject,\n  InitOutput,\n  OffsetLimitPagePromise,\n  ScheduleObject,\n  TimezonesResult,\n  accessoryAttributes,\n  apiClientManager,\n  mergeRequestOptions,\n  taskCatalog,\n} from \"@systemfsoftware/trigger.dev_core/v3\";\nimport { zodfetch } from \"@systemfsoftware/trigger.dev_core/v3/zodfetch\";\nimport { Task, TaskOptions, apiClientMissingError, createTask } from \"../shared\";\nimport * as SchedulesAPI from \"./api\";\nimport { tracer } from \"../tracer\";\n\nexport type ScheduleOptions<\n  TIdentifier extends string,\n  TOutput,\n  TInitOutput extends InitOutput,\n> = TaskOptions<TIdentifier, SchedulesAPI.ScheduledTaskPayload, TOutput, TInitOutput> & {\n  /** You can optionally specify a CRON schedule on your task. You can also dynamically add a schedule in the dashboard or using the SDK functions.\n   *\n   * 1. Pass a CRON pattern string\n   * ```ts\n   * \"0 0 * * *\"\n   * ```\n   *\n   * 2. Or an object with a pattern and an optional timezone (default is \"UTC\")\n   * ```ts\n   * {\n   *   pattern: \"0 0 * * *\",\n   *   timezone: \"America/Los_Angeles\"\n   * }\n   * ```\n   *\n   * @link https://trigger.dev/docs/v3/tasks-scheduled\n   */\n  cron?:\n    | string\n    | {\n        pattern: string;\n        timezone?: string;\n      };\n};\n\nexport function task<TIdentifier extends string, TOutput, TInitOutput extends InitOutput>(\n  params: ScheduleOptions<TIdentifier, TOutput, TInitOutput>\n): Task<TIdentifier, SchedulesAPI.ScheduledTaskPayload, TOutput> {\n  const task = createTask(params);\n\n  const cron = params.cron\n    ? typeof params.cron === \"string\"\n      ? params.cron\n      : params.cron.pattern\n    : undefined;\n  const timezone =\n    (params.cron && typeof params.cron !== \"string\" ? params.cron.timezone : \"UTC\") ?? \"UTC\";\n\n  taskCatalog.updateTaskMetadata(task.id, {\n    triggerSource: \"schedule\",\n    schedule: cron\n      ? {\n          cron: cron,\n          timezone,\n        }\n      : undefined,\n  });\n\n  return task;\n}\n\n/**\n * Creates a new schedule\n * @param options\n * @param options.task - The identifier of the task to be scheduled (Must already exist and be a scheduled task)\n * @param options.cron - The cron expression for the schedule (e.g. `0 0 * * *`)\n * @param options.timezone - An optional timezone for the schedule in the IANA format (e.g. `America/Los_Angeles`). Defaults to \"UTC\".\n * @param options.externalId - An optional external identifier for the schedule\n * @param options.deduplicationKey - An optional deduplication key for the schedule\n * @returns The created schedule\n */\nexport function create(\n  options: SchedulesAPI.CreateScheduleOptions,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<ScheduleObject> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"schedules.create()\",\n      icon: \"clock\",\n      attributes: {\n        ...accessoryAttributes({\n          items: [\n            {\n              text: options.cron,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  return apiClient.createSchedule(options, $requestOptions);\n}\n\n/**\n * Retrieves a schedule\n * @param scheduleId - The ID of the schedule to retrieve\n * @returns The retrieved schedule\n */\nexport function retrieve(\n  scheduleId: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<ScheduleObject> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"schedules.retrieve()\",\n      icon: \"clock\",\n      attributes: {\n        scheduleId,\n        ...accessoryAttributes({\n          items: [\n            {\n              text: scheduleId,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  return apiClient.retrieveSchedule(scheduleId, $requestOptions);\n}\n\n/**\n * Updates a schedule\n * @param scheduleId - The ID of the schedule to update\n * @param options - The updated schedule options\n * @param options.task - The identifier of the task to be scheduled (Must already exist and be a scheduled task)\n * @param options.cron - The cron expression for the schedule (e.g. `0 0 * * *`)\n * @param options.timezone - An optional timezone for the schedule in the IANA format (e.g. `America/Los_Angeles`). Defaults to \"UTC\".\n * @param options.externalId - An optional external identifier for the schedule\n * @returns The updated schedule\n */\nexport function update(\n  scheduleId: string,\n  options: SchedulesAPI.UpdateScheduleOptions,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<ScheduleObject> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"schedules.update()\",\n      icon: \"clock\",\n      attributes: {\n        scheduleId,\n        ...accessoryAttributes({\n          items: [\n            {\n              text: scheduleId,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  return apiClient.updateSchedule(scheduleId, options, $requestOptions);\n}\n\n/**\n * Deletes a schedule\n * @param scheduleId - The ID of the schedule to delete\n */\nexport function del(\n  scheduleId: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<DeletedScheduleObject> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"schedules.delete()\",\n      icon: \"clock\",\n      attributes: {\n        scheduleId,\n        ...accessoryAttributes({\n          items: [\n            {\n              text: scheduleId,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  return apiClient.deleteSchedule(scheduleId, $requestOptions);\n}\n\n/**\n * Deactivates a schedule\n * @param scheduleId - The ID of the schedule to deactivate\n */\nexport function deactivate(\n  scheduleId: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<ScheduleObject> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"schedules.deactivate()\",\n      icon: \"clock\",\n      attributes: {\n        scheduleId,\n        ...accessoryAttributes({\n          items: [\n            {\n              text: scheduleId,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  return apiClient.deactivateSchedule(scheduleId, $requestOptions);\n}\n\n/**\n * Activates a schedule\n * @param scheduleId - The ID of the schedule to activate\n */\nexport function activate(\n  scheduleId: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<ScheduleObject> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"schedules.activate()\",\n      icon: \"clock\",\n      attributes: {\n        scheduleId,\n        ...accessoryAttributes({\n          items: [\n            {\n              text: scheduleId,\n              variant: \"normal\",\n            },\n          ],\n          style: \"codepath\",\n        }),\n      },\n    },\n    requestOptions\n  );\n\n  return apiClient.activateSchedule(scheduleId, $requestOptions);\n}\n\n/**\n * Lists schedules\n * @param options - The list options\n * @param options.page - The page number\n * @param options.perPage - The number of schedules per page\n * @returns The list of schedules\n */\nexport function list(\n  options?: SchedulesAPI.ListScheduleOptions,\n  requestOptions?: ApiRequestOptions\n): OffsetLimitPagePromise<typeof ScheduleObject> {\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  const $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"schedules.list()\",\n      icon: \"clock\",\n    },\n    requestOptions\n  );\n\n  return apiClient.listSchedules(options, $requestOptions);\n}\n\n/**\n * Lists the possible timezones we support\n * @param excludeUtc - By default \"UTC\" is included and is first. If true, \"UTC\" will be excluded.\n */\nexport function timezones(options?: { excludeUtc?: boolean }) {\n  const baseUrl = apiClientManager.baseURL;\n\n  if (!baseUrl) {\n    throw apiClientMissingError();\n  }\n\n  return zodfetch(\n    TimezonesResult,\n    `${baseUrl}/api/v1/timezones${options?.excludeUtc === true ? \"?excludeUtc=true\" : \"\"}`,\n    {\n      method: \"GET\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n      },\n    }\n  );\n}\n","import type {\n  ApiPromise,\n  ApiRequestOptions,\n  CreateEnvironmentVariableParams,\n  EnvironmentVariableResponseBody,\n  EnvironmentVariableValue,\n  EnvironmentVariables,\n  ImportEnvironmentVariablesParams,\n  UpdateEnvironmentVariableParams,\n} from \"@systemfsoftware/trigger.dev_core/v3\";\nimport {\n  apiClientManager,\n  isRequestOptions,\n  mergeRequestOptions,\n  taskContext,\n} from \"@systemfsoftware/trigger.dev_core/v3\";\nimport { apiClientMissingError } from \"./shared\";\nimport { tracer } from \"./tracer\";\n\nexport type { CreateEnvironmentVariableParams, ImportEnvironmentVariablesParams };\n\nexport function upload(\n  projectRef: string,\n  slug: string,\n  params: ImportEnvironmentVariablesParams,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody>;\nexport function upload(\n  params: ImportEnvironmentVariablesParams,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody>;\nexport function upload(\n  projectRefOrParams: string | ImportEnvironmentVariablesParams,\n  slugOrRequestOptions?: string | ApiRequestOptions,\n  params?: ImportEnvironmentVariablesParams,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody> {\n  let $projectRef: string;\n  let $params: ImportEnvironmentVariablesParams;\n  let $slug: string;\n  const $requestOptions = overloadRequestOptions(\"upload\", slugOrRequestOptions, requestOptions);\n\n  if (taskContext.ctx) {\n    if (typeof projectRefOrParams === \"string\") {\n      $projectRef = projectRefOrParams;\n      $slug =\n        typeof slugOrRequestOptions === \"string\"\n          ? slugOrRequestOptions\n          : taskContext.ctx.environment.slug;\n\n      if (!params) {\n        throw new Error(\"params is required\");\n      }\n\n      $params = params;\n    } else {\n      $params = projectRefOrParams;\n      $projectRef = taskContext.ctx.project.ref;\n      $slug = taskContext.ctx.environment.slug;\n    }\n  } else {\n    if (typeof projectRefOrParams !== \"string\") {\n      throw new Error(\"projectRef is required\");\n    }\n\n    if (!slugOrRequestOptions || typeof slugOrRequestOptions !== \"string\") {\n      throw new Error(\"slug is required\");\n    }\n\n    if (!params) {\n      throw new Error(\"params is required\");\n    }\n\n    $projectRef = projectRefOrParams;\n    $slug = slugOrRequestOptions;\n    $params = params;\n  }\n\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  return apiClient.importEnvVars($projectRef, $slug, $params, $requestOptions);\n}\n\nexport function list(\n  projectRef: string,\n  slug: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariables>;\nexport function list(requestOptions?: ApiRequestOptions): ApiPromise<EnvironmentVariables>;\nexport function list(\n  projectRefOrRequestOptions?: string | ApiRequestOptions,\n  slug?: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariables> {\n  const $projectRef = !isRequestOptions(projectRefOrRequestOptions)\n    ? projectRefOrRequestOptions\n    : taskContext.ctx?.project.ref;\n  const $slug = slug ?? taskContext.ctx?.environment.slug;\n  let $requestOptions = isRequestOptions(projectRefOrRequestOptions)\n    ? projectRefOrRequestOptions\n    : requestOptions;\n\n  if (!$projectRef) {\n    throw new Error(\"projectRef is required\");\n  }\n\n  if (!$slug) {\n    throw new Error(\"slug is required\");\n  }\n\n  $requestOptions = mergeRequestOptions(\n    {\n      tracer,\n      name: \"envvars.list()\",\n      icon: \"id-badge\",\n    },\n    $requestOptions\n  );\n\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  return apiClient.listEnvVars($projectRef, $slug, $requestOptions);\n}\n\nexport function create(\n  projectRef: string,\n  slug: string,\n  params: CreateEnvironmentVariableParams,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody>;\nexport function create(\n  params: CreateEnvironmentVariableParams,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody>;\nexport function create(\n  projectRefOrParams: string | CreateEnvironmentVariableParams,\n  slugOrRequestOptions?: string | ApiRequestOptions,\n  params?: CreateEnvironmentVariableParams,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody> {\n  let $projectRef: string;\n  let $slug: string;\n  let $params: CreateEnvironmentVariableParams;\n  const $requestOptions = overloadRequestOptions(\"create\", slugOrRequestOptions, requestOptions);\n\n  if (taskContext.ctx) {\n    if (typeof projectRefOrParams === \"string\") {\n      $projectRef = projectRefOrParams;\n      $slug =\n        typeof slugOrRequestOptions === \"string\"\n          ? slugOrRequestOptions\n          : taskContext.ctx.environment.slug;\n\n      if (!params) {\n        throw new Error(\"params is required\");\n      }\n\n      $params = params;\n    } else {\n      $params = projectRefOrParams;\n      $projectRef = taskContext.ctx.project.ref;\n      $slug = taskContext.ctx.environment.slug;\n    }\n  } else {\n    if (typeof projectRefOrParams !== \"string\") {\n      throw new Error(\"projectRef is required\");\n    }\n\n    if (!slugOrRequestOptions || typeof slugOrRequestOptions !== \"string\") {\n      throw new Error(\"slug is required\");\n    }\n\n    if (!params) {\n      throw new Error(\"params is required\");\n    }\n\n    $projectRef = projectRefOrParams;\n    $slug = slugOrRequestOptions;\n    $params = params;\n  }\n\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  return apiClient.createEnvVar($projectRef, $slug, $params, $requestOptions);\n}\n\nexport function retrieve(\n  projectRef: string,\n  slug: string,\n  name: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableValue>;\nexport function retrieve(\n  name: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableValue>;\nexport function retrieve(\n  projectRefOrName: string,\n  slugOrRequestOptions?: string | ApiRequestOptions,\n  name?: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableValue> {\n  let $projectRef: string;\n  let $slug: string;\n  let $name: string;\n  const $requestOptions = overloadRequestOptions(\"retrieve\", slugOrRequestOptions, requestOptions);\n\n  if (typeof name === \"string\") {\n    $projectRef = projectRefOrName;\n    $slug =\n      typeof slugOrRequestOptions === \"string\"\n        ? slugOrRequestOptions\n        : taskContext.ctx?.environment.slug!;\n    $name = name;\n  } else {\n    $projectRef = taskContext.ctx?.project.ref!;\n    $slug = taskContext.ctx?.environment.slug!;\n    $name = projectRefOrName;\n  }\n\n  if (!$projectRef) {\n    throw new Error(\"projectRef is required\");\n  }\n\n  if (!$slug) {\n    throw new Error(\"slug is required\");\n  }\n\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  return apiClient.retrieveEnvVar($projectRef, $slug, $name, $requestOptions);\n}\n\nexport function del(\n  projectRef: string,\n  slug: string,\n  name: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody>;\nexport function del(\n  name: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody>;\nexport function del(\n  projectRefOrName: string,\n  slugOrRequestOptions?: string | ApiRequestOptions,\n  name?: string,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody> {\n  let $projectRef: string;\n  let $slug: string;\n  let $name: string;\n  const $requestOptions = overloadRequestOptions(\"del\", slugOrRequestOptions, requestOptions);\n\n  if (typeof name === \"string\") {\n    $projectRef = projectRefOrName;\n    $slug =\n      typeof slugOrRequestOptions === \"string\"\n        ? slugOrRequestOptions\n        : taskContext.ctx?.environment.slug!;\n    $name = name;\n  } else {\n    $projectRef = taskContext.ctx?.project.ref!;\n    $slug = taskContext.ctx?.environment.slug!;\n    $name = projectRefOrName;\n  }\n\n  if (!$projectRef) {\n    throw new Error(\"projectRef is required\");\n  }\n\n  if (!$slug) {\n    throw new Error(\"slug is required\");\n  }\n\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  return apiClient.deleteEnvVar($projectRef, $slug, $name, $requestOptions);\n}\n\nexport function update(\n  projectRef: string,\n  slug: string,\n  name: string,\n  params: UpdateEnvironmentVariableParams,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody>;\nexport function update(\n  name: string,\n  params: UpdateEnvironmentVariableParams,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody>;\nexport function update(\n  projectRefOrName: string,\n  slugOrParams: string | UpdateEnvironmentVariableParams,\n  nameOrRequestOptions?: string | ApiRequestOptions,\n  params?: UpdateEnvironmentVariableParams,\n  requestOptions?: ApiRequestOptions\n): ApiPromise<EnvironmentVariableResponseBody> {\n  let $projectRef: string;\n  let $slug: string;\n  let $name: string;\n  let $params: UpdateEnvironmentVariableParams;\n  const $requestOptions = overloadRequestOptions(\"update\", nameOrRequestOptions, requestOptions);\n\n  if (taskContext.ctx) {\n    if (typeof slugOrParams === \"string\") {\n      $projectRef = slugOrParams;\n      $slug = slugOrParams ?? taskContext.ctx.environment.slug;\n      $name =\n        typeof nameOrRequestOptions === \"string\"\n          ? nameOrRequestOptions\n          : taskContext.ctx.environment.slug;\n\n      if (!params) {\n        throw new Error(\"params is required\");\n      }\n\n      $params = params;\n    } else {\n      $params = slugOrParams;\n      $projectRef = taskContext.ctx.project.ref;\n      $slug = taskContext.ctx.environment.slug;\n      $name = projectRefOrName;\n    }\n  } else {\n    if (typeof slugOrParams !== \"string\") {\n      throw new Error(\"slug is required\");\n    }\n\n    if (!projectRefOrName) {\n      throw new Error(\"projectRef is required\");\n    }\n\n    if (!params) {\n      throw new Error(\"params is required\");\n    }\n\n    $projectRef = projectRefOrName;\n    $slug = slugOrParams;\n    $name = name!;\n    $params = params;\n  }\n\n  const apiClient = apiClientManager.client;\n\n  if (!apiClient) {\n    throw apiClientMissingError();\n  }\n\n  return apiClient.updateEnvVar($projectRef, $slug, $name, $params, $requestOptions);\n}\n\nfunction overloadRequestOptions(\n  name: string,\n  slugOrRequestOptions?: string | ApiRequestOptions,\n  requestOptions?: ApiRequestOptions\n): ApiRequestOptions {\n  if (isRequestOptions(slugOrRequestOptions)) {\n    return mergeRequestOptions(\n      {\n        tracer,\n        name: `envvars.${name}()`,\n        icon: \"id-badge\",\n      },\n      slugOrRequestOptions\n    );\n  } else {\n    return mergeRequestOptions(\n      {\n        tracer,\n        name: `envvars.${name}()`,\n        icon: \"id-badge\",\n      },\n      requestOptions\n    );\n  }\n}\n"]}