inngest 4.7.0 → 4.8.0

package/experimental.js

@@ -1,7 +1,9 @@
 import { getAsyncCtx } from "./components/execution/als.js";
 import { metadataMiddleware } from "./components/InngestMetadata.js";
+import { scoreMiddleware } from "./components/InngestScore.js";
 import { DeferredFunction, createDefer } from "./components/DeferredFunction.js";
 import { PublicInngestSpanProcessor } from "./components/execution/otel/processor.js";
 import { extendedTracesMiddleware } from "./components/execution/otel/middleware.js";
+import { createScorer } from "./components/ScoreFunction.js";
 
-export { DeferredFunction, PublicInngestSpanProcessor as InngestSpanProcessor, createDefer, extendedTracesMiddleware, getAsyncCtx, metadataMiddleware };
+export { DeferredFunction, PublicInngestSpanProcessor as InngestSpanProcessor, createDefer, createScorer, extendedTracesMiddleware, getAsyncCtx, metadataMiddleware, scoreMiddleware };

package/helpers/consts.cjs

@@ -211,6 +211,12 @@ let internalEvents = /* @__PURE__ */ function(internalEvents$1) {
 	internalEvents$1["DeferredSchedule"] = "inngest/deferred.schedule";
 	return internalEvents$1;
 }({});
+/**
+* Reserved input key that carries the `defer(id, { experiment })` ref to the
+* deferred run; the receiver strips it before the handler or schema validation
+* see the data.
+*/
+const deferExperimentKey = "_inngestExperiment";
 const logPrefix = "[Inngest]";
 const debugPrefix = "inngest";
 const dummyEventKey = "NO_EVENT_KEY_SET";
@@ -253,6 +259,7 @@ exports.defaultDevServerHost = defaultDevServerHost;
 exports.defaultInngestApiBaseUrl = defaultInngestApiBaseUrl;
 exports.defaultInngestEventBaseUrl = defaultInngestEventBaseUrl;
 exports.defaultMaxRetries = defaultMaxRetries;
+exports.deferExperimentKey = deferExperimentKey;
 exports.dummyEventKey = dummyEventKey;
 exports.envKeys = envKeys;
 exports.forwardedHeaders = forwardedHeaders;

package/helpers/consts.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"consts.cjs","names":["logPrefix: string"],"sources":["../../src/helpers/consts.ts"],"sourcesContent":["/**\n * Keys for accessing query parameters included in requests from Inngest to run\n * functions.\n *\n * Used internally to create handlers using `InngestCommHandler`, but can be\n * imported to be used if creating a custom handler outside of the package.\n *\n * @public\n */\nexport enum queryKeys {\n  DeployId = \"deployId\",\n  FnId = \"fnId\",\n  Probe = \"probe\",\n  StepId = \"stepId\",\n}\n\nexport enum probe {\n  Trust = \"trust\",\n}\n\nexport enum envKeys {\n  InngestSigningKey = \"INNGEST_SIGNING_KEY\",\n  InngestSigningKeyFallback = \"INNGEST_SIGNING_KEY_FALLBACK\",\n  InngestEventKey = \"INNGEST_EVENT_KEY\",\n\n  /**\n   * @deprecated Removed in v3. Use {@link InngestBaseUrl} instead.\n   */\n  InngestDevServerUrl = \"INNGEST_DEVSERVER_URL\",\n  InngestEnvironment = \"INNGEST_ENV\",\n  InngestBaseUrl = \"INNGEST_BASE_URL\",\n  InngestEventApiBaseUrl = \"INNGEST_EVENT_API_BASE_URL\",\n  InngestApiBaseUrl = \"INNGEST_API_BASE_URL\",\n  InngestServeHost = \"INNGEST_SERVE_HOST\", // Deprecated, use INNGEST_SERVE_ORIGIN\n  InngestServePath = \"INNGEST_SERVE_PATH\",\n  InngestServeOrigin = \"INNGEST_SERVE_ORIGIN\",\n  InngestStreaming = \"INNGEST_STREAMING\",\n  InngestDevMode = \"INNGEST_DEV\",\n  InngestAllowInBandSync = \"INNGEST_ALLOW_IN_BAND_SYNC\",\n  InngestEnableUnauthedSync = \"INNGEST_ENABLE_UNAUTHED_SYNC\",\n  InngestConnectMaxWorkerConcurrency = \"INNGEST_CONNECT_MAX_WORKER_CONCURRENCY\",\n  InngestConnectIsolateExecution = \"INNGEST_CONNECT_ISOLATE_EXECUTION\",\n  InngestConnectGatewayUrl = \"INNGEST_CONNECT_GATEWAY_URL\",\n\n  /**\n   * @deprecated It's unknown what this env var was used for, but we do not\n   * provide explicit support for it. Prefer using `INNGEST_ENV` instead.\n   */\n  BranchName = \"BRANCH_NAME\",\n\n  /**\n   * The git branch of the commit the deployment was triggered by. Example:\n   * `improve-about-page`.\n   *\n   * {@link https://vercel.com/docs/concepts/projects/environment-variables/system-environment-variables#system-environment-variables}\n   */\n  VercelBranch = \"VERCEL_GIT_COMMIT_REF\",\n\n  /**\n   * Expected to be `\"1\"` if defined.\n   */\n  IsVercel = \"VERCEL\",\n\n  /**\n   * The branch name of the current deployment. May only be accessible at build\n   * time, but included here just in case.\n   *\n   * {@link https://developers.cloudflare.com/pages/platform/build-configuration/#environment-variables}\n   */\n  CloudflarePagesBranch = \"CF_PAGES_BRANCH\",\n\n  /**\n   * Expected to be `\"1\"` if defined.\n   */\n  IsCloudflarePages = \"CF_PAGES\",\n\n  /**\n   * The branch name of the deployment from Git to Netlify, if available.\n   *\n   * {@link https://docs.netlify.com/configure-builds/environment-variables/#git-metadata}\n   */\n  NetlifyBranch = \"BRANCH\",\n\n  /**\n   * Expected to be `\"true\"` if defined.\n   */\n  IsNetlify = \"NETLIFY\",\n\n  /**\n   * The Git branch for a service or deploy.\n   *\n   * {@link https://render.com/docs/environment-variables#all-services}\n   */\n  RenderBranch = \"RENDER_GIT_BRANCH\",\n\n  /**\n   * Expected to be `\"true\"` if defined.\n   */\n  IsRender = \"RENDER\",\n\n  /**\n   * The branch that triggered the deployment. Example: `main`\n   *\n   * {@link https://docs.railway.app/develop/variables#railway-provided-variables}\n   */\n  RailwayBranch = \"RAILWAY_GIT_BRANCH\",\n\n  /**\n   * The railway environment for the deployment. Example: `production`\n   *\n   * {@link https://docs.railway.app/develop/variables#railway-provided-variables}\n   */\n  RailwayEnvironment = \"RAILWAY_ENVIRONMENT\",\n\n  VercelEnvKey = \"VERCEL_ENV\",\n\n  /**\n   * Standard Node.js environment indicator (e.g. `\"production\"`, `\"development\"`,\n   * `\"test\"`). Read by some framework adapters to choose the request scheme,\n   * and by prod-mode inference.\n   */\n  NodeEnv = \"NODE_ENV\",\n\n  /**\n   * Netlify's deploy context (e.g. `\"production\"`, `\"deploy-preview\"`). Used\n   * for prod-mode inference.\n   *\n   * {@link https://docs.netlify.com/configure-builds/environment-variables/#build-metadata}\n   */\n  Context = \"CONTEXT\",\n\n  /**\n   * Generic environment name used by some platforms to indicate prod vs\n   * non-prod (e.g. `\"production\"`).\n   */\n  Environment = \"ENVIRONMENT\",\n\n  /**\n   * Set by Deno Deploy. Its presence indicates a Deno Deploy environment,\n   * which we treat as prod.\n   *\n   * {@link https://docs.deno.com/deploy/manual/environment-variables/}\n   */\n  DenoDeployment = \"DENO_DEPLOYMENT_ID\",\n\n  OpenAiApiKey = \"OPENAI_API_KEY\",\n  GeminiApiKey = \"GEMINI_API_KEY\",\n  AnthropicApiKey = \"ANTHROPIC_API_KEY\",\n\n  /**\n   * Framework-prefixed variants of Inngest env vars. CRA's `REACT_APP_` and\n   * Next's `NEXT_PUBLIC_` prefixes expose env vars to bundled client code, so\n   * we accept the prefixed forms in addition to the canonical names.\n   */\n  ReactAppInngestBaseUrl = \"REACT_APP_INNGEST_BASE_URL\",\n  ReactAppInngestDevMode = \"REACT_APP_INNGEST_DEV\",\n  NextPublicInngestBaseUrl = \"NEXT_PUBLIC_INNGEST_BASE_URL\",\n  NextPublicInngestDevMode = \"NEXT_PUBLIC_INNGEST_DEV\",\n}\n\n/**\n * Keys for accessing headers included in requests from Inngest to run\n * functions.\n *\n * Used internally to create handlers using `InngestCommHandler`, but can be\n * imported to be used if creating a custom handler outside of the package.\n *\n * @public\n */\nexport enum headerKeys {\n  ContentType = \"content-type\",\n  Host = \"host\",\n  ForwardedFor = \"x-forwarded-for\",\n  RealIp = \"x-real-ip\",\n  Location = \"location\",\n  ContentLength = \"content-length\",\n  Signature = \"x-inngest-signature\",\n  SdkVersion = \"x-inngest-sdk\",\n  Environment = \"x-inngest-env\",\n  Platform = \"x-inngest-platform\",\n  Framework = \"x-inngest-framework\",\n  NoRetry = \"x-inngest-no-retry\",\n  RequestId = \"x-request-id\",\n  GenerationId = \"x-inngest-generation-id\",\n  InngestJobId = \"x-inngest-job-id\",\n  RequestVersion = \"x-inngest-req-version\",\n  RetryAfter = \"retry-after\",\n  InngestServerKind = \"x-inngest-server-kind\",\n  InngestExpectedServerKind = \"x-inngest-expected-server-kind\",\n  InngestSyncKind = \"x-inngest-sync-kind\",\n  EventIdSeed = \"x-inngest-event-id-seed\",\n  TraceParent = \"traceparent\",\n  TraceState = \"tracestate\",\n  InngestRunId = \"x-run-id\",\n  InngestStepId = \"x-inngest-step-id\",\n  InngestForceStepPlan = \"x-inngest-force-step-plan\",\n  SdkHandled = \"x-inngest-sdk-handled\",\n}\n\n/**\n * Headers that are forwarded from the original request when an Inngest function\n * is invoked.\n */\nexport const forwardedHeaders = [headerKeys.TraceParent, headerKeys.TraceState];\n\nexport const defaultInngestApiBaseUrl = \"https://api.inngest.com/\";\nexport const defaultInngestEventBaseUrl = \"https://inn.gs/\";\nexport const defaultDevServerHost = \"http://localhost:8288/\";\n\n/**\n * Events that Inngest may send internally that can be used to trigger\n * functions.\n *\n * @public\n */\nexport enum internalEvents {\n  /**\n   * A function has failed after exhausting all available retries. This event\n   * will contain the original event and the error that caused the failure.\n   */\n  FunctionFailed = \"inngest/function.failed\",\n  FunctionInvoked = \"inngest/function.invoked\",\n  FunctionFinished = \"inngest/function.finished\",\n  FunctionCancelled = \"inngest/function.cancelled\",\n  ScheduledTimer = \"inngest/scheduled.timer\",\n  HttpRequest = \"inngest/http.request\",\n\n  /**\n   * Triggers a deferred function. The backend emits this.\n   */\n  DeferredSchedule = \"inngest/deferred.schedule\",\n}\n\nexport const logPrefix: string = \"[Inngest]\";\n\nexport const debugPrefix = \"inngest\";\n\nexport const dummyEventKey = \"NO_EVENT_KEY_SET\";\n\nexport enum serverKind {\n  Dev = \"dev\",\n  Cloud = \"cloud\",\n}\n\nexport enum syncKind {\n  InBand = \"in_band\",\n  OutOfBand = \"out_of_band\",\n}\n\n/**\n * The execution models the SDK is aware of.\n *\n * This is used in a number of places to ensure all execution versions are\n * accounted for for a given operation.\n */\nexport enum ExecutionVersion {\n  /**\n   * Uses a more flexible approach to execution and is more lenient about\n   * determinism, allowing non-step async actions and non-determinism.\n   *\n   * Nowhere near as stubborn about determinism and so can silently migrate\n   * between versions after bug fixes.\n   */\n  V1 = 1,\n\n  /**\n   * Identical to V1, but allows the Executor to optimize parallel calls, hugely\n   * reducing traffic going to/from the SDK.\n   */\n  V2 = 2,\n}\n\n/**\n * Default maximum number of retries for function/step executions.\n */\nexport const defaultMaxRetries = 3;\n"],"mappings":";;;;;;;;;;;AASA,IAAY,kDAAL;AACL;AACA;AACA;AACA;;;AAGF,IAAY,0CAAL;AACL;;;AAGF,IAAY,8CAAL;AACL;AACA;AACA;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AAMA;;;;;;;AAQA;;;;AAKA;;;;;;;AAQA;;;;AAKA;;;;;;AAOA;;;;AAKA;;;;;;AAOA;;;;AAKA;;;;;;AAOA;;;;;;AAOA;AAEA;;;;;;AAOA;;;;;;;AAQA;;;;;AAMA;;;;;;;AAQA;AAEA;AACA;AACA;;;;;;AAOA;AACA;AACA;AACA;;;;;;;;;;;;AAYF,IAAY,oDAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAOF,MAAa,mBAAmB,CAAC,WAAW,aAAa,WAAW,WAAW;AAE/E,MAAa,2BAA2B;AACxC,MAAa,6BAA6B;AAC1C,MAAa,uBAAuB;;;;;;;AAQpC,IAAY,4DAAL;;;;;AAKL;AACA;AACA;AACA;AACA;AACA;;;;AAKA;;;AAGF,MAAaA,YAAoB;AAEjC,MAAa,cAAc;AAE3B,MAAa,gBAAgB;AAO7B,IAAY,gDAAL;AACL;AACA;;;;;;;;;AASF,IAAY,gEAAL;;;;;;;;AAQL;;;;;AAMA;;;;;;AAMF,MAAa,oBAAoB"}
+{"version":3,"file":"consts.cjs","names":["logPrefix: string"],"sources":["../../src/helpers/consts.ts"],"sourcesContent":["/**\n * Keys for accessing query parameters included in requests from Inngest to run\n * functions.\n *\n * Used internally to create handlers using `InngestCommHandler`, but can be\n * imported to be used if creating a custom handler outside of the package.\n *\n * @public\n */\nexport enum queryKeys {\n  DeployId = \"deployId\",\n  FnId = \"fnId\",\n  Probe = \"probe\",\n  StepId = \"stepId\",\n}\n\nexport enum probe {\n  Trust = \"trust\",\n}\n\nexport enum envKeys {\n  InngestSigningKey = \"INNGEST_SIGNING_KEY\",\n  InngestSigningKeyFallback = \"INNGEST_SIGNING_KEY_FALLBACK\",\n  InngestEventKey = \"INNGEST_EVENT_KEY\",\n\n  /**\n   * @deprecated Removed in v3. Use {@link InngestBaseUrl} instead.\n   */\n  InngestDevServerUrl = \"INNGEST_DEVSERVER_URL\",\n  InngestEnvironment = \"INNGEST_ENV\",\n  InngestBaseUrl = \"INNGEST_BASE_URL\",\n  InngestEventApiBaseUrl = \"INNGEST_EVENT_API_BASE_URL\",\n  InngestApiBaseUrl = \"INNGEST_API_BASE_URL\",\n  InngestServeHost = \"INNGEST_SERVE_HOST\", // Deprecated, use INNGEST_SERVE_ORIGIN\n  InngestServePath = \"INNGEST_SERVE_PATH\",\n  InngestServeOrigin = \"INNGEST_SERVE_ORIGIN\",\n  InngestStreaming = \"INNGEST_STREAMING\",\n  InngestDevMode = \"INNGEST_DEV\",\n  InngestAllowInBandSync = \"INNGEST_ALLOW_IN_BAND_SYNC\",\n  InngestEnableUnauthedSync = \"INNGEST_ENABLE_UNAUTHED_SYNC\",\n  InngestConnectMaxWorkerConcurrency = \"INNGEST_CONNECT_MAX_WORKER_CONCURRENCY\",\n  InngestConnectIsolateExecution = \"INNGEST_CONNECT_ISOLATE_EXECUTION\",\n  InngestConnectGatewayUrl = \"INNGEST_CONNECT_GATEWAY_URL\",\n\n  /**\n   * @deprecated It's unknown what this env var was used for, but we do not\n   * provide explicit support for it. Prefer using `INNGEST_ENV` instead.\n   */\n  BranchName = \"BRANCH_NAME\",\n\n  /**\n   * The git branch of the commit the deployment was triggered by. Example:\n   * `improve-about-page`.\n   *\n   * {@link https://vercel.com/docs/concepts/projects/environment-variables/system-environment-variables#system-environment-variables}\n   */\n  VercelBranch = \"VERCEL_GIT_COMMIT_REF\",\n\n  /**\n   * Expected to be `\"1\"` if defined.\n   */\n  IsVercel = \"VERCEL\",\n\n  /**\n   * The branch name of the current deployment. May only be accessible at build\n   * time, but included here just in case.\n   *\n   * {@link https://developers.cloudflare.com/pages/platform/build-configuration/#environment-variables}\n   */\n  CloudflarePagesBranch = \"CF_PAGES_BRANCH\",\n\n  /**\n   * Expected to be `\"1\"` if defined.\n   */\n  IsCloudflarePages = \"CF_PAGES\",\n\n  /**\n   * The branch name of the deployment from Git to Netlify, if available.\n   *\n   * {@link https://docs.netlify.com/configure-builds/environment-variables/#git-metadata}\n   */\n  NetlifyBranch = \"BRANCH\",\n\n  /**\n   * Expected to be `\"true\"` if defined.\n   */\n  IsNetlify = \"NETLIFY\",\n\n  /**\n   * The Git branch for a service or deploy.\n   *\n   * {@link https://render.com/docs/environment-variables#all-services}\n   */\n  RenderBranch = \"RENDER_GIT_BRANCH\",\n\n  /**\n   * Expected to be `\"true\"` if defined.\n   */\n  IsRender = \"RENDER\",\n\n  /**\n   * The branch that triggered the deployment. Example: `main`\n   *\n   * {@link https://docs.railway.app/develop/variables#railway-provided-variables}\n   */\n  RailwayBranch = \"RAILWAY_GIT_BRANCH\",\n\n  /**\n   * The railway environment for the deployment. Example: `production`\n   *\n   * {@link https://docs.railway.app/develop/variables#railway-provided-variables}\n   */\n  RailwayEnvironment = \"RAILWAY_ENVIRONMENT\",\n\n  VercelEnvKey = \"VERCEL_ENV\",\n\n  /**\n   * Standard Node.js environment indicator (e.g. `\"production\"`, `\"development\"`,\n   * `\"test\"`). Read by some framework adapters to choose the request scheme,\n   * and by prod-mode inference.\n   */\n  NodeEnv = \"NODE_ENV\",\n\n  /**\n   * Netlify's deploy context (e.g. `\"production\"`, `\"deploy-preview\"`). Used\n   * for prod-mode inference.\n   *\n   * {@link https://docs.netlify.com/configure-builds/environment-variables/#build-metadata}\n   */\n  Context = \"CONTEXT\",\n\n  /**\n   * Generic environment name used by some platforms to indicate prod vs\n   * non-prod (e.g. `\"production\"`).\n   */\n  Environment = \"ENVIRONMENT\",\n\n  /**\n   * Set by Deno Deploy. Its presence indicates a Deno Deploy environment,\n   * which we treat as prod.\n   *\n   * {@link https://docs.deno.com/deploy/manual/environment-variables/}\n   */\n  DenoDeployment = \"DENO_DEPLOYMENT_ID\",\n\n  OpenAiApiKey = \"OPENAI_API_KEY\",\n  GeminiApiKey = \"GEMINI_API_KEY\",\n  AnthropicApiKey = \"ANTHROPIC_API_KEY\",\n\n  /**\n   * Framework-prefixed variants of Inngest env vars. CRA's `REACT_APP_` and\n   * Next's `NEXT_PUBLIC_` prefixes expose env vars to bundled client code, so\n   * we accept the prefixed forms in addition to the canonical names.\n   */\n  ReactAppInngestBaseUrl = \"REACT_APP_INNGEST_BASE_URL\",\n  ReactAppInngestDevMode = \"REACT_APP_INNGEST_DEV\",\n  NextPublicInngestBaseUrl = \"NEXT_PUBLIC_INNGEST_BASE_URL\",\n  NextPublicInngestDevMode = \"NEXT_PUBLIC_INNGEST_DEV\",\n}\n\n/**\n * Keys for accessing headers included in requests from Inngest to run\n * functions.\n *\n * Used internally to create handlers using `InngestCommHandler`, but can be\n * imported to be used if creating a custom handler outside of the package.\n *\n * @public\n */\nexport enum headerKeys {\n  ContentType = \"content-type\",\n  Host = \"host\",\n  ForwardedFor = \"x-forwarded-for\",\n  RealIp = \"x-real-ip\",\n  Location = \"location\",\n  ContentLength = \"content-length\",\n  Signature = \"x-inngest-signature\",\n  SdkVersion = \"x-inngest-sdk\",\n  Environment = \"x-inngest-env\",\n  Platform = \"x-inngest-platform\",\n  Framework = \"x-inngest-framework\",\n  NoRetry = \"x-inngest-no-retry\",\n  RequestId = \"x-request-id\",\n  GenerationId = \"x-inngest-generation-id\",\n  InngestJobId = \"x-inngest-job-id\",\n  RequestVersion = \"x-inngest-req-version\",\n  RetryAfter = \"retry-after\",\n  InngestServerKind = \"x-inngest-server-kind\",\n  InngestExpectedServerKind = \"x-inngest-expected-server-kind\",\n  InngestSyncKind = \"x-inngest-sync-kind\",\n  EventIdSeed = \"x-inngest-event-id-seed\",\n  TraceParent = \"traceparent\",\n  TraceState = \"tracestate\",\n  InngestRunId = \"x-run-id\",\n  InngestStepId = \"x-inngest-step-id\",\n  InngestForceStepPlan = \"x-inngest-force-step-plan\",\n  SdkHandled = \"x-inngest-sdk-handled\",\n}\n\n/**\n * Headers that are forwarded from the original request when an Inngest function\n * is invoked.\n */\nexport const forwardedHeaders = [headerKeys.TraceParent, headerKeys.TraceState];\n\nexport const defaultInngestApiBaseUrl = \"https://api.inngest.com/\";\nexport const defaultInngestEventBaseUrl = \"https://inn.gs/\";\nexport const defaultDevServerHost = \"http://localhost:8288/\";\n\n/**\n * Events that Inngest may send internally that can be used to trigger\n * functions.\n *\n * @public\n */\nexport enum internalEvents {\n  /**\n   * A function has failed after exhausting all available retries. This event\n   * will contain the original event and the error that caused the failure.\n   */\n  FunctionFailed = \"inngest/function.failed\",\n  FunctionInvoked = \"inngest/function.invoked\",\n  FunctionFinished = \"inngest/function.finished\",\n  FunctionCancelled = \"inngest/function.cancelled\",\n  ScheduledTimer = \"inngest/scheduled.timer\",\n  HttpRequest = \"inngest/http.request\",\n\n  /**\n   * Triggers a deferred function. The backend emits this.\n   */\n  DeferredSchedule = \"inngest/deferred.schedule\",\n}\n\n/**\n * Reserved input key that carries the `defer(id, { experiment })` ref to the\n * deferred run; the receiver strips it before the handler or schema validation\n * see the data.\n */\nexport const deferExperimentKey = \"_inngestExperiment\";\n\nexport const logPrefix: string = \"[Inngest]\";\n\nexport const debugPrefix = \"inngest\";\n\nexport const dummyEventKey = \"NO_EVENT_KEY_SET\";\n\nexport enum serverKind {\n  Dev = \"dev\",\n  Cloud = \"cloud\",\n}\n\nexport enum syncKind {\n  InBand = \"in_band\",\n  OutOfBand = \"out_of_band\",\n}\n\n/**\n * The execution models the SDK is aware of.\n *\n * This is used in a number of places to ensure all execution versions are\n * accounted for for a given operation.\n */\nexport enum ExecutionVersion {\n  /**\n   * Uses a more flexible approach to execution and is more lenient about\n   * determinism, allowing non-step async actions and non-determinism.\n   *\n   * Nowhere near as stubborn about determinism and so can silently migrate\n   * between versions after bug fixes.\n   */\n  V1 = 1,\n\n  /**\n   * Identical to V1, but allows the Executor to optimize parallel calls, hugely\n   * reducing traffic going to/from the SDK.\n   */\n  V2 = 2,\n}\n\n/**\n * Default maximum number of retries for function/step executions.\n */\nexport const defaultMaxRetries = 3;\n"],"mappings":";;;;;;;;;;;AASA,IAAY,kDAAL;AACL;AACA;AACA;AACA;;;AAGF,IAAY,0CAAL;AACL;;;AAGF,IAAY,8CAAL;AACL;AACA;AACA;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AAMA;;;;;;;AAQA;;;;AAKA;;;;;;;AAQA;;;;AAKA;;;;;;AAOA;;;;AAKA;;;;;;AAOA;;;;AAKA;;;;;;AAOA;;;;;;AAOA;AAEA;;;;;;AAOA;;;;;;;AAQA;;;;;AAMA;;;;;;;AAQA;AAEA;AACA;AACA;;;;;;AAOA;AACA;AACA;AACA;;;;;;;;;;;;AAYF,IAAY,oDAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAOF,MAAa,mBAAmB,CAAC,WAAW,aAAa,WAAW,WAAW;AAE/E,MAAa,2BAA2B;AACxC,MAAa,6BAA6B;AAC1C,MAAa,uBAAuB;;;;;;;AAQpC,IAAY,4DAAL;;;;;AAKL;AACA;AACA;AACA;AACA;AACA;;;;AAKA;;;;;;;;AAQF,MAAa,qBAAqB;AAElC,MAAaA,YAAoB;AAEjC,MAAa,cAAc;AAE3B,MAAa,gBAAgB;AAO7B,IAAY,gDAAL;AACL;AACA;;;;;;;;;AASF,IAAY,gEAAL;;;;;;;;AAQL;;;;;AAMA;;;;;;AAMF,MAAa,oBAAoB"}

package/helpers/consts.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"consts.d.cts","names":[],"sources":["../../src/helpers/consts.ts"],"sourcesContent":[],"mappings":";;AASA;AAgKA;AA8CA;AAwCA;;;;;aAtPY,SAAA;;;;;;;;;;;;;;;aAgKA,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8CA,cAAA;;;;;;;;;;;;;;;;;;;;;;aAwCA,gBAAA"}
+{"version":3,"file":"consts.d.cts","names":[],"sources":["../../src/helpers/consts.ts"],"sourcesContent":[],"mappings":";;AASA;AAgKA;AA8CA;AA+CA;;;;;aA7PY,SAAA;;;;;;;;;;;;;;;aAgKA,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8CA,cAAA;;;;;;;;;;;;;;;;;;;;;;aA+CA,gBAAA"}

package/helpers/consts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consts.d.ts","names":[],"sources":["../../src/helpers/consts.ts"],"sourcesContent":[],"mappings":";;AASA;AAgKA;AA8CA;AAwCA;;;;;aAtPY,SAAA;;;;;;;;;;;;;;;aAgKA,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8CA,cAAA;;;;;;;;;;;;;;;;;;;;;;aAwCA,gBAAA"}
+{"version":3,"file":"consts.d.ts","names":[],"sources":["../../src/helpers/consts.ts"],"sourcesContent":[],"mappings":";;AASA;AAgKA;AA8CA;AA+CA;;;;;aA7PY,SAAA;;;;;;;;;;;;;;;aAgKA,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8CA,cAAA;;;;;;;;;;;;;;;;;;;;;;aA+CA,gBAAA"}

package/helpers/consts.js

@@ -210,6 +210,12 @@ let internalEvents = /* @__PURE__ */ function(internalEvents$1) {
 	internalEvents$1["DeferredSchedule"] = "inngest/deferred.schedule";
 	return internalEvents$1;
 }({});
+/**
+* Reserved input key that carries the `defer(id, { experiment })` ref to the
+* deferred run; the receiver strips it before the handler or schema validation
+* see the data.
+*/
+const deferExperimentKey = "_inngestExperiment";
 const logPrefix = "[Inngest]";
 const debugPrefix = "inngest";
 const dummyEventKey = "NO_EVENT_KEY_SET";
@@ -246,5 +252,5 @@ let ExecutionVersion = /* @__PURE__ */ function(ExecutionVersion$1) {
 const defaultMaxRetries = 3;
 
 //#endregion
-export { ExecutionVersion, debugPrefix, defaultDevServerHost, defaultInngestApiBaseUrl, defaultInngestEventBaseUrl, defaultMaxRetries, dummyEventKey, envKeys, forwardedHeaders, headerKeys, internalEvents, logPrefix, probe, queryKeys, syncKind };
+export { ExecutionVersion, debugPrefix, defaultDevServerHost, defaultInngestApiBaseUrl, defaultInngestEventBaseUrl, defaultMaxRetries, deferExperimentKey, dummyEventKey, envKeys, forwardedHeaders, headerKeys, internalEvents, logPrefix, probe, queryKeys, syncKind };
 //# sourceMappingURL=consts.js.map

package/helpers/consts.js.map

@@ -1 +1 @@
-{"version":3,"file":"consts.js","names":["logPrefix: string"],"sources":["../../src/helpers/consts.ts"],"sourcesContent":["/**\n * Keys for accessing query parameters included in requests from Inngest to run\n * functions.\n *\n * Used internally to create handlers using `InngestCommHandler`, but can be\n * imported to be used if creating a custom handler outside of the package.\n *\n * @public\n */\nexport enum queryKeys {\n  DeployId = \"deployId\",\n  FnId = \"fnId\",\n  Probe = \"probe\",\n  StepId = \"stepId\",\n}\n\nexport enum probe {\n  Trust = \"trust\",\n}\n\nexport enum envKeys {\n  InngestSigningKey = \"INNGEST_SIGNING_KEY\",\n  InngestSigningKeyFallback = \"INNGEST_SIGNING_KEY_FALLBACK\",\n  InngestEventKey = \"INNGEST_EVENT_KEY\",\n\n  /**\n   * @deprecated Removed in v3. Use {@link InngestBaseUrl} instead.\n   */\n  InngestDevServerUrl = \"INNGEST_DEVSERVER_URL\",\n  InngestEnvironment = \"INNGEST_ENV\",\n  InngestBaseUrl = \"INNGEST_BASE_URL\",\n  InngestEventApiBaseUrl = \"INNGEST_EVENT_API_BASE_URL\",\n  InngestApiBaseUrl = \"INNGEST_API_BASE_URL\",\n  InngestServeHost = \"INNGEST_SERVE_HOST\", // Deprecated, use INNGEST_SERVE_ORIGIN\n  InngestServePath = \"INNGEST_SERVE_PATH\",\n  InngestServeOrigin = \"INNGEST_SERVE_ORIGIN\",\n  InngestStreaming = \"INNGEST_STREAMING\",\n  InngestDevMode = \"INNGEST_DEV\",\n  InngestAllowInBandSync = \"INNGEST_ALLOW_IN_BAND_SYNC\",\n  InngestEnableUnauthedSync = \"INNGEST_ENABLE_UNAUTHED_SYNC\",\n  InngestConnectMaxWorkerConcurrency = \"INNGEST_CONNECT_MAX_WORKER_CONCURRENCY\",\n  InngestConnectIsolateExecution = \"INNGEST_CONNECT_ISOLATE_EXECUTION\",\n  InngestConnectGatewayUrl = \"INNGEST_CONNECT_GATEWAY_URL\",\n\n  /**\n   * @deprecated It's unknown what this env var was used for, but we do not\n   * provide explicit support for it. Prefer using `INNGEST_ENV` instead.\n   */\n  BranchName = \"BRANCH_NAME\",\n\n  /**\n   * The git branch of the commit the deployment was triggered by. Example:\n   * `improve-about-page`.\n   *\n   * {@link https://vercel.com/docs/concepts/projects/environment-variables/system-environment-variables#system-environment-variables}\n   */\n  VercelBranch = \"VERCEL_GIT_COMMIT_REF\",\n\n  /**\n   * Expected to be `\"1\"` if defined.\n   */\n  IsVercel = \"VERCEL\",\n\n  /**\n   * The branch name of the current deployment. May only be accessible at build\n   * time, but included here just in case.\n   *\n   * {@link https://developers.cloudflare.com/pages/platform/build-configuration/#environment-variables}\n   */\n  CloudflarePagesBranch = \"CF_PAGES_BRANCH\",\n\n  /**\n   * Expected to be `\"1\"` if defined.\n   */\n  IsCloudflarePages = \"CF_PAGES\",\n\n  /**\n   * The branch name of the deployment from Git to Netlify, if available.\n   *\n   * {@link https://docs.netlify.com/configure-builds/environment-variables/#git-metadata}\n   */\n  NetlifyBranch = \"BRANCH\",\n\n  /**\n   * Expected to be `\"true\"` if defined.\n   */\n  IsNetlify = \"NETLIFY\",\n\n  /**\n   * The Git branch for a service or deploy.\n   *\n   * {@link https://render.com/docs/environment-variables#all-services}\n   */\n  RenderBranch = \"RENDER_GIT_BRANCH\",\n\n  /**\n   * Expected to be `\"true\"` if defined.\n   */\n  IsRender = \"RENDER\",\n\n  /**\n   * The branch that triggered the deployment. Example: `main`\n   *\n   * {@link https://docs.railway.app/develop/variables#railway-provided-variables}\n   */\n  RailwayBranch = \"RAILWAY_GIT_BRANCH\",\n\n  /**\n   * The railway environment for the deployment. Example: `production`\n   *\n   * {@link https://docs.railway.app/develop/variables#railway-provided-variables}\n   */\n  RailwayEnvironment = \"RAILWAY_ENVIRONMENT\",\n\n  VercelEnvKey = \"VERCEL_ENV\",\n\n  /**\n   * Standard Node.js environment indicator (e.g. `\"production\"`, `\"development\"`,\n   * `\"test\"`). Read by some framework adapters to choose the request scheme,\n   * and by prod-mode inference.\n   */\n  NodeEnv = \"NODE_ENV\",\n\n  /**\n   * Netlify's deploy context (e.g. `\"production\"`, `\"deploy-preview\"`). Used\n   * for prod-mode inference.\n   *\n   * {@link https://docs.netlify.com/configure-builds/environment-variables/#build-metadata}\n   */\n  Context = \"CONTEXT\",\n\n  /**\n   * Generic environment name used by some platforms to indicate prod vs\n   * non-prod (e.g. `\"production\"`).\n   */\n  Environment = \"ENVIRONMENT\",\n\n  /**\n   * Set by Deno Deploy. Its presence indicates a Deno Deploy environment,\n   * which we treat as prod.\n   *\n   * {@link https://docs.deno.com/deploy/manual/environment-variables/}\n   */\n  DenoDeployment = \"DENO_DEPLOYMENT_ID\",\n\n  OpenAiApiKey = \"OPENAI_API_KEY\",\n  GeminiApiKey = \"GEMINI_API_KEY\",\n  AnthropicApiKey = \"ANTHROPIC_API_KEY\",\n\n  /**\n   * Framework-prefixed variants of Inngest env vars. CRA's `REACT_APP_` and\n   * Next's `NEXT_PUBLIC_` prefixes expose env vars to bundled client code, so\n   * we accept the prefixed forms in addition to the canonical names.\n   */\n  ReactAppInngestBaseUrl = \"REACT_APP_INNGEST_BASE_URL\",\n  ReactAppInngestDevMode = \"REACT_APP_INNGEST_DEV\",\n  NextPublicInngestBaseUrl = \"NEXT_PUBLIC_INNGEST_BASE_URL\",\n  NextPublicInngestDevMode = \"NEXT_PUBLIC_INNGEST_DEV\",\n}\n\n/**\n * Keys for accessing headers included in requests from Inngest to run\n * functions.\n *\n * Used internally to create handlers using `InngestCommHandler`, but can be\n * imported to be used if creating a custom handler outside of the package.\n *\n * @public\n */\nexport enum headerKeys {\n  ContentType = \"content-type\",\n  Host = \"host\",\n  ForwardedFor = \"x-forwarded-for\",\n  RealIp = \"x-real-ip\",\n  Location = \"location\",\n  ContentLength = \"content-length\",\n  Signature = \"x-inngest-signature\",\n  SdkVersion = \"x-inngest-sdk\",\n  Environment = \"x-inngest-env\",\n  Platform = \"x-inngest-platform\",\n  Framework = \"x-inngest-framework\",\n  NoRetry = \"x-inngest-no-retry\",\n  RequestId = \"x-request-id\",\n  GenerationId = \"x-inngest-generation-id\",\n  InngestJobId = \"x-inngest-job-id\",\n  RequestVersion = \"x-inngest-req-version\",\n  RetryAfter = \"retry-after\",\n  InngestServerKind = \"x-inngest-server-kind\",\n  InngestExpectedServerKind = \"x-inngest-expected-server-kind\",\n  InngestSyncKind = \"x-inngest-sync-kind\",\n  EventIdSeed = \"x-inngest-event-id-seed\",\n  TraceParent = \"traceparent\",\n  TraceState = \"tracestate\",\n  InngestRunId = \"x-run-id\",\n  InngestStepId = \"x-inngest-step-id\",\n  InngestForceStepPlan = \"x-inngest-force-step-plan\",\n  SdkHandled = \"x-inngest-sdk-handled\",\n}\n\n/**\n * Headers that are forwarded from the original request when an Inngest function\n * is invoked.\n */\nexport const forwardedHeaders = [headerKeys.TraceParent, headerKeys.TraceState];\n\nexport const defaultInngestApiBaseUrl = \"https://api.inngest.com/\";\nexport const defaultInngestEventBaseUrl = \"https://inn.gs/\";\nexport const defaultDevServerHost = \"http://localhost:8288/\";\n\n/**\n * Events that Inngest may send internally that can be used to trigger\n * functions.\n *\n * @public\n */\nexport enum internalEvents {\n  /**\n   * A function has failed after exhausting all available retries. This event\n   * will contain the original event and the error that caused the failure.\n   */\n  FunctionFailed = \"inngest/function.failed\",\n  FunctionInvoked = \"inngest/function.invoked\",\n  FunctionFinished = \"inngest/function.finished\",\n  FunctionCancelled = \"inngest/function.cancelled\",\n  ScheduledTimer = \"inngest/scheduled.timer\",\n  HttpRequest = \"inngest/http.request\",\n\n  /**\n   * Triggers a deferred function. The backend emits this.\n   */\n  DeferredSchedule = \"inngest/deferred.schedule\",\n}\n\nexport const logPrefix: string = \"[Inngest]\";\n\nexport const debugPrefix = \"inngest\";\n\nexport const dummyEventKey = \"NO_EVENT_KEY_SET\";\n\nexport enum serverKind {\n  Dev = \"dev\",\n  Cloud = \"cloud\",\n}\n\nexport enum syncKind {\n  InBand = \"in_band\",\n  OutOfBand = \"out_of_band\",\n}\n\n/**\n * The execution models the SDK is aware of.\n *\n * This is used in a number of places to ensure all execution versions are\n * accounted for for a given operation.\n */\nexport enum ExecutionVersion {\n  /**\n   * Uses a more flexible approach to execution and is more lenient about\n   * determinism, allowing non-step async actions and non-determinism.\n   *\n   * Nowhere near as stubborn about determinism and so can silently migrate\n   * between versions after bug fixes.\n   */\n  V1 = 1,\n\n  /**\n   * Identical to V1, but allows the Executor to optimize parallel calls, hugely\n   * reducing traffic going to/from the SDK.\n   */\n  V2 = 2,\n}\n\n/**\n * Default maximum number of retries for function/step executions.\n */\nexport const defaultMaxRetries = 3;\n"],"mappings":";;;;;;;;;;AASA,IAAY,kDAAL;AACL;AACA;AACA;AACA;;;AAGF,IAAY,0CAAL;AACL;;;AAGF,IAAY,8CAAL;AACL;AACA;AACA;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AAMA;;;;;;;AAQA;;;;AAKA;;;;;;;AAQA;;;;AAKA;;;;;;AAOA;;;;AAKA;;;;;;AAOA;;;;AAKA;;;;;;AAOA;;;;;;AAOA;AAEA;;;;;;AAOA;;;;;;;AAQA;;;;;AAMA;;;;;;;AAQA;AAEA;AACA;AACA;;;;;;AAOA;AACA;AACA;AACA;;;;;;;;;;;;AAYF,IAAY,oDAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAOF,MAAa,mBAAmB,CAAC,WAAW,aAAa,WAAW,WAAW;AAE/E,MAAa,2BAA2B;AACxC,MAAa,6BAA6B;AAC1C,MAAa,uBAAuB;;;;;;;AAQpC,IAAY,4DAAL;;;;;AAKL;AACA;AACA;AACA;AACA;AACA;;;;AAKA;;;AAGF,MAAaA,YAAoB;AAEjC,MAAa,cAAc;AAE3B,MAAa,gBAAgB;AAO7B,IAAY,gDAAL;AACL;AACA;;;;;;;;;AASF,IAAY,gEAAL;;;;;;;;AAQL;;;;;AAMA;;;;;;AAMF,MAAa,oBAAoB"}
+{"version":3,"file":"consts.js","names":["logPrefix: string"],"sources":["../../src/helpers/consts.ts"],"sourcesContent":["/**\n * Keys for accessing query parameters included in requests from Inngest to run\n * functions.\n *\n * Used internally to create handlers using `InngestCommHandler`, but can be\n * imported to be used if creating a custom handler outside of the package.\n *\n * @public\n */\nexport enum queryKeys {\n  DeployId = \"deployId\",\n  FnId = \"fnId\",\n  Probe = \"probe\",\n  StepId = \"stepId\",\n}\n\nexport enum probe {\n  Trust = \"trust\",\n}\n\nexport enum envKeys {\n  InngestSigningKey = \"INNGEST_SIGNING_KEY\",\n  InngestSigningKeyFallback = \"INNGEST_SIGNING_KEY_FALLBACK\",\n  InngestEventKey = \"INNGEST_EVENT_KEY\",\n\n  /**\n   * @deprecated Removed in v3. Use {@link InngestBaseUrl} instead.\n   */\n  InngestDevServerUrl = \"INNGEST_DEVSERVER_URL\",\n  InngestEnvironment = \"INNGEST_ENV\",\n  InngestBaseUrl = \"INNGEST_BASE_URL\",\n  InngestEventApiBaseUrl = \"INNGEST_EVENT_API_BASE_URL\",\n  InngestApiBaseUrl = \"INNGEST_API_BASE_URL\",\n  InngestServeHost = \"INNGEST_SERVE_HOST\", // Deprecated, use INNGEST_SERVE_ORIGIN\n  InngestServePath = \"INNGEST_SERVE_PATH\",\n  InngestServeOrigin = \"INNGEST_SERVE_ORIGIN\",\n  InngestStreaming = \"INNGEST_STREAMING\",\n  InngestDevMode = \"INNGEST_DEV\",\n  InngestAllowInBandSync = \"INNGEST_ALLOW_IN_BAND_SYNC\",\n  InngestEnableUnauthedSync = \"INNGEST_ENABLE_UNAUTHED_SYNC\",\n  InngestConnectMaxWorkerConcurrency = \"INNGEST_CONNECT_MAX_WORKER_CONCURRENCY\",\n  InngestConnectIsolateExecution = \"INNGEST_CONNECT_ISOLATE_EXECUTION\",\n  InngestConnectGatewayUrl = \"INNGEST_CONNECT_GATEWAY_URL\",\n\n  /**\n   * @deprecated It's unknown what this env var was used for, but we do not\n   * provide explicit support for it. Prefer using `INNGEST_ENV` instead.\n   */\n  BranchName = \"BRANCH_NAME\",\n\n  /**\n   * The git branch of the commit the deployment was triggered by. Example:\n   * `improve-about-page`.\n   *\n   * {@link https://vercel.com/docs/concepts/projects/environment-variables/system-environment-variables#system-environment-variables}\n   */\n  VercelBranch = \"VERCEL_GIT_COMMIT_REF\",\n\n  /**\n   * Expected to be `\"1\"` if defined.\n   */\n  IsVercel = \"VERCEL\",\n\n  /**\n   * The branch name of the current deployment. May only be accessible at build\n   * time, but included here just in case.\n   *\n   * {@link https://developers.cloudflare.com/pages/platform/build-configuration/#environment-variables}\n   */\n  CloudflarePagesBranch = \"CF_PAGES_BRANCH\",\n\n  /**\n   * Expected to be `\"1\"` if defined.\n   */\n  IsCloudflarePages = \"CF_PAGES\",\n\n  /**\n   * The branch name of the deployment from Git to Netlify, if available.\n   *\n   * {@link https://docs.netlify.com/configure-builds/environment-variables/#git-metadata}\n   */\n  NetlifyBranch = \"BRANCH\",\n\n  /**\n   * Expected to be `\"true\"` if defined.\n   */\n  IsNetlify = \"NETLIFY\",\n\n  /**\n   * The Git branch for a service or deploy.\n   *\n   * {@link https://render.com/docs/environment-variables#all-services}\n   */\n  RenderBranch = \"RENDER_GIT_BRANCH\",\n\n  /**\n   * Expected to be `\"true\"` if defined.\n   */\n  IsRender = \"RENDER\",\n\n  /**\n   * The branch that triggered the deployment. Example: `main`\n   *\n   * {@link https://docs.railway.app/develop/variables#railway-provided-variables}\n   */\n  RailwayBranch = \"RAILWAY_GIT_BRANCH\",\n\n  /**\n   * The railway environment for the deployment. Example: `production`\n   *\n   * {@link https://docs.railway.app/develop/variables#railway-provided-variables}\n   */\n  RailwayEnvironment = \"RAILWAY_ENVIRONMENT\",\n\n  VercelEnvKey = \"VERCEL_ENV\",\n\n  /**\n   * Standard Node.js environment indicator (e.g. `\"production\"`, `\"development\"`,\n   * `\"test\"`). Read by some framework adapters to choose the request scheme,\n   * and by prod-mode inference.\n   */\n  NodeEnv = \"NODE_ENV\",\n\n  /**\n   * Netlify's deploy context (e.g. `\"production\"`, `\"deploy-preview\"`). Used\n   * for prod-mode inference.\n   *\n   * {@link https://docs.netlify.com/configure-builds/environment-variables/#build-metadata}\n   */\n  Context = \"CONTEXT\",\n\n  /**\n   * Generic environment name used by some platforms to indicate prod vs\n   * non-prod (e.g. `\"production\"`).\n   */\n  Environment = \"ENVIRONMENT\",\n\n  /**\n   * Set by Deno Deploy. Its presence indicates a Deno Deploy environment,\n   * which we treat as prod.\n   *\n   * {@link https://docs.deno.com/deploy/manual/environment-variables/}\n   */\n  DenoDeployment = \"DENO_DEPLOYMENT_ID\",\n\n  OpenAiApiKey = \"OPENAI_API_KEY\",\n  GeminiApiKey = \"GEMINI_API_KEY\",\n  AnthropicApiKey = \"ANTHROPIC_API_KEY\",\n\n  /**\n   * Framework-prefixed variants of Inngest env vars. CRA's `REACT_APP_` and\n   * Next's `NEXT_PUBLIC_` prefixes expose env vars to bundled client code, so\n   * we accept the prefixed forms in addition to the canonical names.\n   */\n  ReactAppInngestBaseUrl = \"REACT_APP_INNGEST_BASE_URL\",\n  ReactAppInngestDevMode = \"REACT_APP_INNGEST_DEV\",\n  NextPublicInngestBaseUrl = \"NEXT_PUBLIC_INNGEST_BASE_URL\",\n  NextPublicInngestDevMode = \"NEXT_PUBLIC_INNGEST_DEV\",\n}\n\n/**\n * Keys for accessing headers included in requests from Inngest to run\n * functions.\n *\n * Used internally to create handlers using `InngestCommHandler`, but can be\n * imported to be used if creating a custom handler outside of the package.\n *\n * @public\n */\nexport enum headerKeys {\n  ContentType = \"content-type\",\n  Host = \"host\",\n  ForwardedFor = \"x-forwarded-for\",\n  RealIp = \"x-real-ip\",\n  Location = \"location\",\n  ContentLength = \"content-length\",\n  Signature = \"x-inngest-signature\",\n  SdkVersion = \"x-inngest-sdk\",\n  Environment = \"x-inngest-env\",\n  Platform = \"x-inngest-platform\",\n  Framework = \"x-inngest-framework\",\n  NoRetry = \"x-inngest-no-retry\",\n  RequestId = \"x-request-id\",\n  GenerationId = \"x-inngest-generation-id\",\n  InngestJobId = \"x-inngest-job-id\",\n  RequestVersion = \"x-inngest-req-version\",\n  RetryAfter = \"retry-after\",\n  InngestServerKind = \"x-inngest-server-kind\",\n  InngestExpectedServerKind = \"x-inngest-expected-server-kind\",\n  InngestSyncKind = \"x-inngest-sync-kind\",\n  EventIdSeed = \"x-inngest-event-id-seed\",\n  TraceParent = \"traceparent\",\n  TraceState = \"tracestate\",\n  InngestRunId = \"x-run-id\",\n  InngestStepId = \"x-inngest-step-id\",\n  InngestForceStepPlan = \"x-inngest-force-step-plan\",\n  SdkHandled = \"x-inngest-sdk-handled\",\n}\n\n/**\n * Headers that are forwarded from the original request when an Inngest function\n * is invoked.\n */\nexport const forwardedHeaders = [headerKeys.TraceParent, headerKeys.TraceState];\n\nexport const defaultInngestApiBaseUrl = \"https://api.inngest.com/\";\nexport const defaultInngestEventBaseUrl = \"https://inn.gs/\";\nexport const defaultDevServerHost = \"http://localhost:8288/\";\n\n/**\n * Events that Inngest may send internally that can be used to trigger\n * functions.\n *\n * @public\n */\nexport enum internalEvents {\n  /**\n   * A function has failed after exhausting all available retries. This event\n   * will contain the original event and the error that caused the failure.\n   */\n  FunctionFailed = \"inngest/function.failed\",\n  FunctionInvoked = \"inngest/function.invoked\",\n  FunctionFinished = \"inngest/function.finished\",\n  FunctionCancelled = \"inngest/function.cancelled\",\n  ScheduledTimer = \"inngest/scheduled.timer\",\n  HttpRequest = \"inngest/http.request\",\n\n  /**\n   * Triggers a deferred function. The backend emits this.\n   */\n  DeferredSchedule = \"inngest/deferred.schedule\",\n}\n\n/**\n * Reserved input key that carries the `defer(id, { experiment })` ref to the\n * deferred run; the receiver strips it before the handler or schema validation\n * see the data.\n */\nexport const deferExperimentKey = \"_inngestExperiment\";\n\nexport const logPrefix: string = \"[Inngest]\";\n\nexport const debugPrefix = \"inngest\";\n\nexport const dummyEventKey = \"NO_EVENT_KEY_SET\";\n\nexport enum serverKind {\n  Dev = \"dev\",\n  Cloud = \"cloud\",\n}\n\nexport enum syncKind {\n  InBand = \"in_band\",\n  OutOfBand = \"out_of_band\",\n}\n\n/**\n * The execution models the SDK is aware of.\n *\n * This is used in a number of places to ensure all execution versions are\n * accounted for for a given operation.\n */\nexport enum ExecutionVersion {\n  /**\n   * Uses a more flexible approach to execution and is more lenient about\n   * determinism, allowing non-step async actions and non-determinism.\n   *\n   * Nowhere near as stubborn about determinism and so can silently migrate\n   * between versions after bug fixes.\n   */\n  V1 = 1,\n\n  /**\n   * Identical to V1, but allows the Executor to optimize parallel calls, hugely\n   * reducing traffic going to/from the SDK.\n   */\n  V2 = 2,\n}\n\n/**\n * Default maximum number of retries for function/step executions.\n */\nexport const defaultMaxRetries = 3;\n"],"mappings":";;;;;;;;;;AASA,IAAY,kDAAL;AACL;AACA;AACA;AACA;;;AAGF,IAAY,0CAAL;AACL;;;AAGF,IAAY,8CAAL;AACL;AACA;AACA;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AAMA;;;;;;;AAQA;;;;AAKA;;;;;;;AAQA;;;;AAKA;;;;;;AAOA;;;;AAKA;;;;;;AAOA;;;;AAKA;;;;;;AAOA;;;;;;AAOA;AAEA;;;;;;AAOA;;;;;;;AAQA;;;;;AAMA;;;;;;;AAQA;AAEA;AACA;AACA;;;;;;AAOA;AACA;AACA;AACA;;;;;;;;;;;;AAYF,IAAY,oDAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAOF,MAAa,mBAAmB,CAAC,WAAW,aAAa,WAAW,WAAW;AAE/E,MAAa,2BAA2B;AACxC,MAAa,6BAA6B;AAC1C,MAAa,uBAAuB;;;;;;;AAQpC,IAAY,4DAAL;;;;;AAKL;AACA;AACA;AACA;AACA;AACA;;;;AAKA;;;;;;;;AAQF,MAAa,qBAAqB;AAElC,MAAaA,YAAoB;AAEjC,MAAa,cAAc;AAE3B,MAAa,gBAAgB;AAO7B,IAAY,gDAAL;AACL;AACA;;;;;;;;;AASF,IAAY,gEAAL;;;;;;;;AAQL;;;;;AAMA;;;;;;AAMF,MAAa,oBAAoB"}

package/helpers/errors.cjs

@@ -9,6 +9,7 @@ let serialize_error_cjs = require("serialize-error-cjs");
 var errors_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
 	ErrCode: () => ErrCode,
 	OutgoingResultError: () => OutgoingResultError,
+	UnreachableError: () => UnreachableError,
 	deserializeError: () => deserializeError,
 	fixEventKeyMissingSteps: () => fixEventKeyMissingSteps,
 	getErrorMessage: () => getErrorMessage,
@@ -208,9 +209,24 @@ const rethrowError = (prefix) => {
 		}
 	};
 };
+/**
+* An error that indicates that a code path that was thought to be unreachable
+* has been reached.
+*
+* This is useful for exhaustiveness checks in places where we think we've
+* handled all possible cases, but want to be sure that if we haven't, we get a
+* clear error.
+*/
+var UnreachableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnreachableError";
+	}
+};
 
 //#endregion
 exports.ErrCode = ErrCode;
+exports.UnreachableError = UnreachableError;
 exports.deserializeError = deserializeError;
 Object.defineProperty(exports, 'errors_exports', {
   enumerable: true,

package/helpers/errors.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.cjs","names":["errorConstructors","NonRetriableError","target: unknown","z","requiredFields: (keyof SerializedError)[]"],"sources":["../../src/helpers/errors.ts"],"sourcesContent":["import stringify from \"json-stringify-safe\";\nimport {\n  type SerializedError as CjsSerializedError,\n  deserializeError as cjsDeserializeError,\n  serializeError as cjsSerializeError,\n  errorConstructors,\n} from \"serialize-error-cjs\";\nimport { z } from \"zod/v3\";\nimport { NonRetriableError } from \"../components/NonRetriableError.ts\";\nimport type { ClientOptions, OutgoingOp } from \"../types.ts\";\n\nconst SERIALIZED_KEY = \"__serialized\";\nconst SERIALIZED_VALUE = true;\n\n/**\n * Add first-class support for certain errors that we control, in addition to\n * built-in errors such as `TypeError`.\n *\n * Adding these allows these non-standard errors to be correctly serialized,\n * sent to Inngest, then deserialized back into the correct error type for users\n * to react to correctly.\n *\n * Note that these errors only support `message?: string | undefined` as the\n * input; more custom errors are not supported with this current strategy.\n */\nerrorConstructors.set(\n  \"NonRetriableError\",\n  NonRetriableError as ErrorConstructor,\n);\n\nexport interface SerializedError extends Readonly<CjsSerializedError> {\n  readonly [SERIALIZED_KEY]: typeof SERIALIZED_VALUE;\n}\n\n/**\n * Serialise an error to a serialized JSON string.\n *\n * Errors do not serialise nicely to JSON, so we use this function to convert\n * them to a serialized JSON string. Doing this is also non-trivial for some\n * errors, so we use the `serialize-error` package to do it for us.\n *\n * See {@link https://www.npmjs.com/package/serialize-error}\n *\n * This function is a small wrapper around that package to also add a `type`\n * property to the serialised error, so that we can distinguish between\n * serialised errors and other objects.\n *\n * Will not reserialise existing serialised errors.\n */\nexport const serializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : SerializedError = TAllowUnknown extends true ? unknown : SerializedError,\n>(\n  /**\n   * The suspected error to serialize.\n   */\n  subject: unknown,\n\n  /**\n   * If `true` and the error is not serializable, will return the original value\n   * as `unknown` instead of coercing it to a serialized error.\n   */\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  try {\n    // Try to understand if this is already done.\n    // Will handle stringified errors.\n    const existingSerializedError = isSerializedError(subject);\n\n    if (existingSerializedError) {\n      return existingSerializedError as TOutput;\n    }\n\n    if (typeof subject === \"object\" && subject !== null) {\n      // Is an object, so let's try and serialize it.\n      const serializedErr = cjsSerializeError(subject as Error);\n\n      // Not a proper error was caught, so give us a chance to return `unknown`.\n      if (!serializedErr.name && allowUnknown) {\n        return subject as TOutput;\n      }\n\n      // Serialization can succeed but assign no name or message, so we'll\n      // map over the result here to ensure we have everything.\n      // We'll just stringify the entire subject for the message, as this at\n      // least provides some context for the user.\n      const ret = {\n        // Ensure we spread to also capture additional properties such as\n        // `cause`.\n        ...serializedErr,\n\n        name: serializedErr.name || \"Error\",\n        message:\n          serializedErr.message ||\n          stringify(subject) ||\n          \"Unknown error; error serialization could not find a message.\",\n        stack: serializedErr.stack || \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as const;\n\n      // If we have a cause, make sure we recursively serialize them too. We are\n      // lighter with causes though; attempt to recursively serialize them, but\n      // stop if we find something that doesn't work and just return `unknown`.\n      let target: unknown = ret;\n      const maxDepth = 5;\n      for (let i = 0; i < maxDepth; i++) {\n        if (\n          typeof target === \"object\" &&\n          target !== null &&\n          \"cause\" in target &&\n          target.cause\n        ) {\n          target = target.cause = serializeError(target.cause, true);\n          continue;\n        }\n\n        break;\n      }\n\n      return ret as TOutput;\n    }\n\n    // If it's not an object, it's hard to parse this as an Error. In this case,\n    // we'll throw an error to start attempting backup strategies.\n    throw new Error(\"Error is not an object; strange throw value.\");\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    try {\n      // If serialization fails, fall back to a regular Error and use the\n      // original object as the message for an Error. We don't know what this\n      // object looks like, so we can't do anything else with it.\n      return {\n        ...serializeError(\n          new Error(typeof subject === \"string\" ? subject : stringify(subject)),\n          false,\n        ),\n        // Remove the stack; it's not relevant here\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    } catch {\n      // If this failed, then stringifying the object also failed, so we'll just\n      // return a completely generic error.\n      // Failing to stringify the object is very unlikely.\n      return {\n        name: \"Could not serialize source error\",\n        message: \"Serializing the source error failed.\",\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    }\n  }\n};\n\n/**\n * Check if an object or a string is a serialised error created by\n * {@link serializeError}.\n */\nexport const isSerializedError = (\n  value: unknown,\n): SerializedError | undefined => {\n  try {\n    if (typeof value === \"string\") {\n      const parsed = z\n        .object({\n          [SERIALIZED_KEY]: z.literal(SERIALIZED_VALUE),\n          name: z.enum([...Array.from(errorConstructors.keys())] as [\n            string,\n            ...string[],\n          ]),\n          message: z.string(),\n          stack: z.string(),\n        })\n        .passthrough()\n        .safeParse(JSON.parse(value));\n\n      if (parsed.success) {\n        return parsed.data as SerializedError;\n      }\n    }\n\n    if (typeof value === \"object\" && value !== null) {\n      const objIsSerializedErr =\n        Object.hasOwn(value, SERIALIZED_KEY) &&\n        (value as { [SERIALIZED_KEY]: unknown })[SERIALIZED_KEY] ===\n          SERIALIZED_VALUE;\n\n      if (objIsSerializedErr) {\n        return value as SerializedError;\n      }\n    }\n  } catch {\n    // no-op; we'll return undefined if parsing failed, as it isn't a serialized\n    // error\n  }\n\n  return;\n};\n\n/**\n * Deserialise an error created by {@link serializeError}.\n *\n * Ensures we only deserialise errors that meet a minimum level of\n * applicability, inclusive of error handling to ensure that badly serialized\n * errors are still handled.\n */\nexport const deserializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : Error = TAllowUnknown extends true ? unknown : Error,\n>(\n  subject: Partial<SerializedError>,\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  const requiredFields: (keyof SerializedError)[] = [\"name\", \"message\"];\n\n  try {\n    const hasRequiredFields = requiredFields.every((field) => {\n      return Object.hasOwn(subject, field);\n    });\n\n    if (!hasRequiredFields) {\n      throw new Error();\n    }\n\n    const deserializedErr = cjsDeserializeError(subject as SerializedError);\n\n    if (\"cause\" in deserializedErr) {\n      deserializedErr.cause = deserializeError(\n        deserializedErr.cause as Partial<SerializedError>,\n        true,\n      );\n    }\n\n    return deserializedErr as TOutput;\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    const err = new Error(\"Unknown error; could not reserialize\");\n\n    /**\n     * Remove the stack so that it's not misleadingly shown as the Inngest\n     * internals.\n     */\n    err.stack = undefined;\n\n    return err as TOutput;\n  }\n};\n\nexport enum ErrCode {\n  NESTING_STEPS = \"NESTING_STEPS\",\n\n  /**\n   * Legacy v0 execution error code for when a function has changed and no\n   * longer matches its in-progress state.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  NON_DETERMINISTIC_FUNCTION = \"NON_DETERMINISTIC_FUNCTION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * async actions after memoziation has occurred, which v0 doesn't support.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  ASYNC_DETECTED_AFTER_MEMOIZATION = \"ASYNC_DETECTED_AFTER_MEMOIZATION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * steps after a non-step async action has occurred.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  STEP_USED_AFTER_ASYNC = \"STEP_USED_AFTER_ASYNC\",\n\n  AUTOMATIC_PARALLEL_INDEXING = \"AUTOMATIC_PARALLEL_INDEXING\",\n\n  NONDETERMINISTIC_STEPS = \"NONDETERMINISTIC_STEPS\",\n}\n\n/**\n * Given an `unknown` object, retrieve the `message` property from it, or fall\n * back to the `fallback` string if it doesn't exist or is empty.\n */\nexport const getErrorMessage = (err: unknown, fallback: string): string => {\n  const { message } = z\n    .object({ message: z.string().min(1) })\n    .catch({ message: fallback })\n    .parse(err);\n\n  return message;\n};\n\nexport const fixEventKeyMissingSteps = [\n  \"Set the `INNGEST_EVENT_KEY` environment variable\",\n  `Pass a key to the \\`new Inngest()\\` constructor using the \\`${\n    \"eventKey\" satisfies keyof ClientOptions\n  }\\` option`,\n];\n\n/**\n * An error that, when thrown, indicates internally that an outgoing operation\n * contains an error.\n *\n * We use this because serialized `data` sent back to Inngest may differ from\n * the error instance itself due to middleware.\n *\n * @internal\n */\nexport class OutgoingResultError extends Error {\n  public readonly result: Pick<OutgoingOp, \"data\" | \"error\">;\n\n  constructor(result: Pick<OutgoingOp, \"data\" | \"error\">) {\n    super(\"OutgoingOpError\");\n    this.result = result;\n  }\n}\n\n/**\n * Create a function that will rethrow an error with a prefix added to the\n * message.\n *\n * Useful for adding context to errors that are rethrown.\n *\n * @example\n * ```ts\n * await doSomeAction().catch(rethrowError(\"Failed to do some action\"));\n * ```\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport const rethrowError = (prefix: string): ((err: any) => never) => {\n  return (err) => {\n    try {\n      err.message &&= `${prefix}; ${err.message}`;\n    } catch (_noopErr) {\n      // no-op\n    } finally {\n      // biome-ignore lint/correctness/noUnsafeFinally: intentional\n      throw err;\n    }\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"errors.cjs","names":["errorConstructors","NonRetriableError","target: unknown","z","requiredFields: (keyof SerializedError)[]"],"sources":["../../src/helpers/errors.ts"],"sourcesContent":["import stringify from \"json-stringify-safe\";\nimport {\n  type SerializedError as CjsSerializedError,\n  deserializeError as cjsDeserializeError,\n  serializeError as cjsSerializeError,\n  errorConstructors,\n} from \"serialize-error-cjs\";\nimport { z } from \"zod/v3\";\nimport { NonRetriableError } from \"../components/NonRetriableError.ts\";\nimport type { ClientOptions, OutgoingOp } from \"../types.ts\";\n\nconst SERIALIZED_KEY = \"__serialized\";\nconst SERIALIZED_VALUE = true;\n\n/**\n * Add first-class support for certain errors that we control, in addition to\n * built-in errors such as `TypeError`.\n *\n * Adding these allows these non-standard errors to be correctly serialized,\n * sent to Inngest, then deserialized back into the correct error type for users\n * to react to correctly.\n *\n * Note that these errors only support `message?: string | undefined` as the\n * input; more custom errors are not supported with this current strategy.\n */\nerrorConstructors.set(\n  \"NonRetriableError\",\n  NonRetriableError as ErrorConstructor,\n);\n\nexport interface SerializedError extends Readonly<CjsSerializedError> {\n  readonly [SERIALIZED_KEY]: typeof SERIALIZED_VALUE;\n}\n\n/**\n * Serialise an error to a serialized JSON string.\n *\n * Errors do not serialise nicely to JSON, so we use this function to convert\n * them to a serialized JSON string. Doing this is also non-trivial for some\n * errors, so we use the `serialize-error` package to do it for us.\n *\n * See {@link https://www.npmjs.com/package/serialize-error}\n *\n * This function is a small wrapper around that package to also add a `type`\n * property to the serialised error, so that we can distinguish between\n * serialised errors and other objects.\n *\n * Will not reserialise existing serialised errors.\n */\nexport const serializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : SerializedError = TAllowUnknown extends true ? unknown : SerializedError,\n>(\n  /**\n   * The suspected error to serialize.\n   */\n  subject: unknown,\n\n  /**\n   * If `true` and the error is not serializable, will return the original value\n   * as `unknown` instead of coercing it to a serialized error.\n   */\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  try {\n    // Try to understand if this is already done.\n    // Will handle stringified errors.\n    const existingSerializedError = isSerializedError(subject);\n\n    if (existingSerializedError) {\n      return existingSerializedError as TOutput;\n    }\n\n    if (typeof subject === \"object\" && subject !== null) {\n      // Is an object, so let's try and serialize it.\n      const serializedErr = cjsSerializeError(subject as Error);\n\n      // Not a proper error was caught, so give us a chance to return `unknown`.\n      if (!serializedErr.name && allowUnknown) {\n        return subject as TOutput;\n      }\n\n      // Serialization can succeed but assign no name or message, so we'll\n      // map over the result here to ensure we have everything.\n      // We'll just stringify the entire subject for the message, as this at\n      // least provides some context for the user.\n      const ret = {\n        // Ensure we spread to also capture additional properties such as\n        // `cause`.\n        ...serializedErr,\n\n        name: serializedErr.name || \"Error\",\n        message:\n          serializedErr.message ||\n          stringify(subject) ||\n          \"Unknown error; error serialization could not find a message.\",\n        stack: serializedErr.stack || \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as const;\n\n      // If we have a cause, make sure we recursively serialize them too. We are\n      // lighter with causes though; attempt to recursively serialize them, but\n      // stop if we find something that doesn't work and just return `unknown`.\n      let target: unknown = ret;\n      const maxDepth = 5;\n      for (let i = 0; i < maxDepth; i++) {\n        if (\n          typeof target === \"object\" &&\n          target !== null &&\n          \"cause\" in target &&\n          target.cause\n        ) {\n          target = target.cause = serializeError(target.cause, true);\n          continue;\n        }\n\n        break;\n      }\n\n      return ret as TOutput;\n    }\n\n    // If it's not an object, it's hard to parse this as an Error. In this case,\n    // we'll throw an error to start attempting backup strategies.\n    throw new Error(\"Error is not an object; strange throw value.\");\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    try {\n      // If serialization fails, fall back to a regular Error and use the\n      // original object as the message for an Error. We don't know what this\n      // object looks like, so we can't do anything else with it.\n      return {\n        ...serializeError(\n          new Error(typeof subject === \"string\" ? subject : stringify(subject)),\n          false,\n        ),\n        // Remove the stack; it's not relevant here\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    } catch {\n      // If this failed, then stringifying the object also failed, so we'll just\n      // return a completely generic error.\n      // Failing to stringify the object is very unlikely.\n      return {\n        name: \"Could not serialize source error\",\n        message: \"Serializing the source error failed.\",\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    }\n  }\n};\n\n/**\n * Check if an object or a string is a serialised error created by\n * {@link serializeError}.\n */\nexport const isSerializedError = (\n  value: unknown,\n): SerializedError | undefined => {\n  try {\n    if (typeof value === \"string\") {\n      const parsed = z\n        .object({\n          [SERIALIZED_KEY]: z.literal(SERIALIZED_VALUE),\n          name: z.enum([...Array.from(errorConstructors.keys())] as [\n            string,\n            ...string[],\n          ]),\n          message: z.string(),\n          stack: z.string(),\n        })\n        .passthrough()\n        .safeParse(JSON.parse(value));\n\n      if (parsed.success) {\n        return parsed.data as SerializedError;\n      }\n    }\n\n    if (typeof value === \"object\" && value !== null) {\n      const objIsSerializedErr =\n        Object.hasOwn(value, SERIALIZED_KEY) &&\n        (value as { [SERIALIZED_KEY]: unknown })[SERIALIZED_KEY] ===\n          SERIALIZED_VALUE;\n\n      if (objIsSerializedErr) {\n        return value as SerializedError;\n      }\n    }\n  } catch {\n    // no-op; we'll return undefined if parsing failed, as it isn't a serialized\n    // error\n  }\n\n  return;\n};\n\n/**\n * Deserialise an error created by {@link serializeError}.\n *\n * Ensures we only deserialise errors that meet a minimum level of\n * applicability, inclusive of error handling to ensure that badly serialized\n * errors are still handled.\n */\nexport const deserializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : Error = TAllowUnknown extends true ? unknown : Error,\n>(\n  subject: Partial<SerializedError>,\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  const requiredFields: (keyof SerializedError)[] = [\"name\", \"message\"];\n\n  try {\n    const hasRequiredFields = requiredFields.every((field) => {\n      return Object.hasOwn(subject, field);\n    });\n\n    if (!hasRequiredFields) {\n      throw new Error();\n    }\n\n    const deserializedErr = cjsDeserializeError(subject as SerializedError);\n\n    if (\"cause\" in deserializedErr) {\n      deserializedErr.cause = deserializeError(\n        deserializedErr.cause as Partial<SerializedError>,\n        true,\n      );\n    }\n\n    return deserializedErr as TOutput;\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    const err = new Error(\"Unknown error; could not reserialize\");\n\n    /**\n     * Remove the stack so that it's not misleadingly shown as the Inngest\n     * internals.\n     */\n    err.stack = undefined;\n\n    return err as TOutput;\n  }\n};\n\nexport enum ErrCode {\n  NESTING_STEPS = \"NESTING_STEPS\",\n\n  /**\n   * Legacy v0 execution error code for when a function has changed and no\n   * longer matches its in-progress state.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  NON_DETERMINISTIC_FUNCTION = \"NON_DETERMINISTIC_FUNCTION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * async actions after memoziation has occurred, which v0 doesn't support.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  ASYNC_DETECTED_AFTER_MEMOIZATION = \"ASYNC_DETECTED_AFTER_MEMOIZATION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * steps after a non-step async action has occurred.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  STEP_USED_AFTER_ASYNC = \"STEP_USED_AFTER_ASYNC\",\n\n  AUTOMATIC_PARALLEL_INDEXING = \"AUTOMATIC_PARALLEL_INDEXING\",\n\n  NONDETERMINISTIC_STEPS = \"NONDETERMINISTIC_STEPS\",\n}\n\n/**\n * Given an `unknown` object, retrieve the `message` property from it, or fall\n * back to the `fallback` string if it doesn't exist or is empty.\n */\nexport const getErrorMessage = (err: unknown, fallback: string): string => {\n  const { message } = z\n    .object({ message: z.string().min(1) })\n    .catch({ message: fallback })\n    .parse(err);\n\n  return message;\n};\n\nexport const fixEventKeyMissingSteps = [\n  \"Set the `INNGEST_EVENT_KEY` environment variable\",\n  `Pass a key to the \\`new Inngest()\\` constructor using the \\`${\n    \"eventKey\" satisfies keyof ClientOptions\n  }\\` option`,\n];\n\n/**\n * An error that, when thrown, indicates internally that an outgoing operation\n * contains an error.\n *\n * We use this because serialized `data` sent back to Inngest may differ from\n * the error instance itself due to middleware.\n *\n * @internal\n */\nexport class OutgoingResultError extends Error {\n  public readonly result: Pick<OutgoingOp, \"data\" | \"error\">;\n\n  constructor(result: Pick<OutgoingOp, \"data\" | \"error\">) {\n    super(\"OutgoingOpError\");\n    this.result = result;\n  }\n}\n\n/**\n * Create a function that will rethrow an error with a prefix added to the\n * message.\n *\n * Useful for adding context to errors that are rethrown.\n *\n * @example\n * ```ts\n * await doSomeAction().catch(rethrowError(\"Failed to do some action\"));\n * ```\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport const rethrowError = (prefix: string): ((err: any) => never) => {\n  return (err) => {\n    try {\n      err.message &&= `${prefix}; ${err.message}`;\n    } catch (_noopErr) {\n      // no-op\n    } finally {\n      // biome-ignore lint/correctness/noUnsafeFinally: intentional\n      throw err;\n    }\n  };\n};\n\n/**\n * An error that indicates that a code path that was thought to be unreachable\n * has been reached.\n *\n * This is useful for exhaustiveness checks in places where we think we've\n * handled all possible cases, but want to be sure that if we haven't, we get a\n * clear error.\n */\nexport class UnreachableError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"UnreachableError\";\n  }\n}\n"],"mappings":"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"}

package/helpers/errors.d.cts

@@ -3,7 +3,7 @@ import { SerializedError } from "serialize-error-cjs";
 
 //#region src/helpers/errors.d.ts
 declare namespace errors_d_exports {
-  export { ErrCode, OutgoingResultError, SerializedError$1 as SerializedError, deserializeError, fixEventKeyMissingSteps, getErrorMessage, isSerializedError, rethrowError, serializeError };
+  export { ErrCode, OutgoingResultError, SerializedError$1 as SerializedError, UnreachableError, deserializeError, fixEventKeyMissingSteps, getErrorMessage, isSerializedError, rethrowError, serializeError };
 }
 declare const SERIALIZED_KEY = "__serialized";
 declare const SERIALIZED_VALUE = true;
@@ -105,6 +105,17 @@ declare class OutgoingResultError extends Error {
  * ```
  */
 declare const rethrowError: (prefix: string) => ((err: any) => never);
+/**
+ * An error that indicates that a code path that was thought to be unreachable
+ * has been reached.
+ *
+ * This is useful for exhaustiveness checks in places where we think we've
+ * handled all possible cases, but want to be sure that if we haven't, we get a
+ * clear error.
+ */
+declare class UnreachableError extends Error {
+  constructor(message: string);
+}
 //#endregion
 export { errors_d_exports, serializeError };
 //# sourceMappingURL=errors.d.cts.map

package/helpers/errors.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.cts","names":[],"sources":["../../src/helpers/errors.ts"],"sourcesContent":[],"mappings":";;;;;;;cAWM,cAAA;cACA,gBAAA;UAkBW,iBAAA,SAAwB,SAAS;YACtC,cAAA,UAAwB;;;;;;;;;;;AAtByB;AAEzC;AAmBpB;;;;AACY,cAkBC,cAlBD,EAAA,CAAA,sBAAA,OAAA,GAAA,KAAA,EAAA,iBAoBM,aApBN,SAAA,IAAA,GAAA,OAAA,GAsBN,iBAtBM,KAsBY,aAtBZ,SAAA,IAAA,GAAA,OAAA,GAsBmD,iBAtBnD,EAAA;;;AAkBZ;OA8GC,EAAA,OAAA;;;;;YA/Fe,CAAA,EAAA,aAAA,EAAA,GACb,OADa;;;AAqGhB;AAgDA;AA+CC,cA/FY,iBA+FZ,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GA7FE,iBA6FF,GAAA,SAAA;;;;;;;;AAvCE,cARU,gBAQV,EAAA,CAAA,sBAAA,OAAA,GAAA,KAAA,EAAA,iBANe,aAMf,SAAA,IAAA,GAAA,OAAA,GAJG,KAIH,KAJW,aAIX,SAAA,IAAA,GAAA,OAAA,GAJkD,KAIlD,EAAA,CAAA,OAAA,EAFQ,OAER,CAFgB,iBAEhB,CAAA,EAAA,YAAA,CAAA,EADa,aACb,EAAA,GAAA,OAAA;AAuCF,aAEW,OAAA;EAAA,aAAO,GAAA,eAAA;EAoCN;AASb;AAgBA;;;;4BAG2B,GAAA,4BAAA;;;;AAkB3B;;;;;;;;;;;;;;;;;;cA9Ca;cASA;;;;;;;;;;cAgBA,mBAAA,SAA4B,KAAA;mBACf,KAAK;sBAET,KAAK;;;;;;;;;;;;;cAkBd"}
+{"version":3,"file":"errors.d.cts","names":[],"sources":["../../src/helpers/errors.ts"],"sourcesContent":[],"mappings":";;;;;;;cAWM,cAAA;cACA,gBAAA;UAkBW,iBAAA,SAAwB,SAAS;YACtC,cAAA,UAAwB;;;;;;;;;;;;AAtByB;AAEzC;AAmBpB;;;AACoC,cAkBvB,cAlBuB,EAAA,CAAA,sBAAA,OAAA,GAAA,KAAA,EAAA,iBAoBlB,aApBkB,SAAA,IAAA,GAAA,OAAA,GAsB9B,iBAtB8B,KAsBZ,aAtBY,SAAA,IAAA,GAAA,OAAA,GAsB2B,iBAtB3B,EAAA;;;;AAkBpC,OAAa,EAAA,OAAA;;;;;YAIkD,CAAA,EAW/C,aAX+C,EAAA,GAY5D,OAZ4D;;;;AAgH/D;AAgDa,cAhDA,iBA+FZ,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GA7FE,iBA6FF,GAAA,SAAA;;;;;;;;AAxCe,cAPH,gBAOG,EAAA,CAAA,sBAAA,OAAA,GAAA,KAAA,EAAA,iBALE,aAKF,SAAA,IAAA,GAAA,OAAA,GAHV,KAGU,KAHF,aAGE,SAAA,IAAA,GAAA,OAAA,GAHqC,KAGrC,EAAA,CAAA,OAAA,EADL,OACK,CADG,iBACH,CAAA,EAAA,YAAA,CAAA,EAAA,aAAA,EAAA,GACb,OADa;AACb,aAyCS,OAAA;EAFX,aAAA,GAAA,eAAA;EAEW;AAoCZ;AASA;AAgBA;;;4BAC0B,GAAA,4BAAA;;;;;AAoB1B;AAqBA;;;;;;;;;;;;;;;;cAnEa;cASA;;;;;;;;;;cAgBA,mBAAA,SAA4B,KAAA;mBACf,KAAK;sBAET,KAAK;;;;;;;;;;;;;cAkBd;;;;;;;;;cAqBA,gBAAA,SAAyB,KAAA"}

package/helpers/errors.d.ts

@@ -3,7 +3,7 @@ import { SerializedError } from "serialize-error-cjs";
 
 //#region src/helpers/errors.d.ts
 declare namespace errors_d_exports {
-  export { ErrCode, OutgoingResultError, SerializedError$1 as SerializedError, deserializeError$1 as deserializeError, fixEventKeyMissingSteps, getErrorMessage, isSerializedError, rethrowError, serializeError$1 as serializeError };
+  export { ErrCode, OutgoingResultError, SerializedError$1 as SerializedError, UnreachableError, deserializeError$1 as deserializeError, fixEventKeyMissingSteps, getErrorMessage, isSerializedError, rethrowError, serializeError$1 as serializeError };
 }
 declare const SERIALIZED_KEY = "__serialized";
 declare const SERIALIZED_VALUE = true;
@@ -105,6 +105,17 @@ declare class OutgoingResultError extends Error {
  * ```
  */
 declare const rethrowError: (prefix: string) => ((err: any) => never);
+/**
+ * An error that indicates that a code path that was thought to be unreachable
+ * has been reached.
+ *
+ * This is useful for exhaustiveness checks in places where we think we've
+ * handled all possible cases, but want to be sure that if we haven't, we get a
+ * clear error.
+ */
+declare class UnreachableError extends Error {
+  constructor(message: string);
+}
 //#endregion
 export { errors_d_exports, serializeError$1 as serializeError };
 //# sourceMappingURL=errors.d.ts.map

package/helpers/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/helpers/errors.ts"],"sourcesContent":[],"mappings":";;;;;;;cAWM,cAAA;cACA,gBAAA;UAkBW,iBAAA,SAAwB,SAAS;YACtC,cAAA,UAAwB;;;;;;;;;;;AAtByB;AAEzC;AAmBpB;;;;AACY,cAkBC,gBAlBD,EAAA,CAAA,sBAAA,OAAA,GAAA,KAAA,EAAA,iBAoBM,aApBN,SAAA,IAAA,GAAA,OAAA,GAsBN,iBAtBM,KAsBY,aAtBZ,SAAA,IAAA,GAAA,OAAA,GAsBmD,iBAtBnD,EAAA;;;AAkBZ;OA8GC,EAAA,OAAA;;;;;YA/Fe,CAAA,EAAA,aAAA,EAAA,GACb,OADa;;;AAqGhB;AAgDA;AA+CC,cA/FY,iBA+FZ,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GA7FE,iBA6FF,GAAA,SAAA;;;;;;;;AAvCE,cARU,kBAQV,EAAA,CAAA,sBAAA,OAAA,GAAA,KAAA,EAAA,iBANe,aAMf,SAAA,IAAA,GAAA,OAAA,GAJG,KAIH,KAJW,aAIX,SAAA,IAAA,GAAA,OAAA,GAJkD,KAIlD,EAAA,CAAA,OAAA,EAFQ,OAER,CAFgB,iBAEhB,CAAA,EAAA,YAAA,CAAA,EADa,aACb,EAAA,GAAA,OAAA;AAuCF,aAEW,OAAA;EAAA,aAAO,GAAA,eAAA;EAoCN;AASb;AAgBA;;;;4BAG2B,GAAA,4BAAA;;;;AAkB3B;;;;;;;;;;;;;;;;;;cA9Ca;cASA;;;;;;;;;;cAgBA,mBAAA,SAA4B,KAAA;mBACf,KAAK;sBAET,KAAK;;;;;;;;;;;;;cAkBd"}
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/helpers/errors.ts"],"sourcesContent":[],"mappings":";;;;;;;cAWM,cAAA;cACA,gBAAA;UAkBW,iBAAA,SAAwB,SAAS;YACtC,cAAA,UAAwB;;;;;;;;;;;;AAtByB;AAEzC;AAmBpB;;;AACoC,cAkBvB,gBAlBuB,EAAA,CAAA,sBAAA,OAAA,GAAA,KAAA,EAAA,iBAoBlB,aApBkB,SAAA,IAAA,GAAA,OAAA,GAsB9B,iBAtB8B,KAsBZ,aAtBY,SAAA,IAAA,GAAA,OAAA,GAsB2B,iBAtB3B,EAAA;;;;AAkBpC,OAAa,EAAA,OAAA;;;;;YAIkD,CAAA,EAW/C,aAX+C,EAAA,GAY5D,OAZ4D;;;;AAgH/D;AAgDa,cAhDA,iBA+FZ,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GA7FE,iBA6FF,GAAA,SAAA;;;;;;;;AAxCe,cAPH,kBAOG,EAAA,CAAA,sBAAA,OAAA,GAAA,KAAA,EAAA,iBALE,aAKF,SAAA,IAAA,GAAA,OAAA,GAHV,KAGU,KAHF,aAGE,SAAA,IAAA,GAAA,OAAA,GAHqC,KAGrC,EAAA,CAAA,OAAA,EADL,OACK,CADG,iBACH,CAAA,EAAA,YAAA,CAAA,EAAA,aAAA,EAAA,GACb,OADa;AACb,aAyCS,OAAA;EAFX,aAAA,GAAA,eAAA;EAEW;AAoCZ;AASA;AAgBA;;;4BAC0B,GAAA,4BAAA;;;;;AAoB1B;AAqBA;;;;;;;;;;;;;;;;cAnEa;cASA;;;;;;;;;;cAgBA,mBAAA,SAA4B,KAAA;mBACf,KAAK;sBAET,KAAK;;;;;;;;;;;;;cAkBd;;;;;;;;;cAqBA,gBAAA,SAAyB,KAAA"}

package/helpers/errors.js

@@ -8,6 +8,7 @@ import { deserializeError, errorConstructors, serializeError } from "serialize-e
 var errors_exports = /* @__PURE__ */ __export({
 	ErrCode: () => ErrCode,
 	OutgoingResultError: () => OutgoingResultError,
+	UnreachableError: () => UnreachableError,
 	deserializeError: () => deserializeError$1,
 	fixEventKeyMissingSteps: () => fixEventKeyMissingSteps,
 	getErrorMessage: () => getErrorMessage,
@@ -207,7 +208,21 @@ const rethrowError = (prefix) => {
 		}
 	};
 };
+/**
+* An error that indicates that a code path that was thought to be unreachable
+* has been reached.
+*
+* This is useful for exhaustiveness checks in places where we think we've
+* handled all possible cases, but want to be sure that if we haven't, we get a
+* clear error.
+*/
+var UnreachableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnreachableError";
+	}
+};
 
 //#endregion
-export { ErrCode, deserializeError$1 as deserializeError, errors_exports, fixEventKeyMissingSteps, getErrorMessage, rethrowError, serializeError$1 as serializeError };
+export { ErrCode, UnreachableError, deserializeError$1 as deserializeError, errors_exports, fixEventKeyMissingSteps, getErrorMessage, rethrowError, serializeError$1 as serializeError };
 //# sourceMappingURL=errors.js.map

package/helpers/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","names":["serializeError","cjsSerializeError","target: unknown","deserializeError","requiredFields: (keyof SerializedError)[]","cjsDeserializeError"],"sources":["../../src/helpers/errors.ts"],"sourcesContent":["import stringify from \"json-stringify-safe\";\nimport {\n  type SerializedError as CjsSerializedError,\n  deserializeError as cjsDeserializeError,\n  serializeError as cjsSerializeError,\n  errorConstructors,\n} from \"serialize-error-cjs\";\nimport { z } from \"zod/v3\";\nimport { NonRetriableError } from \"../components/NonRetriableError.ts\";\nimport type { ClientOptions, OutgoingOp } from \"../types.ts\";\n\nconst SERIALIZED_KEY = \"__serialized\";\nconst SERIALIZED_VALUE = true;\n\n/**\n * Add first-class support for certain errors that we control, in addition to\n * built-in errors such as `TypeError`.\n *\n * Adding these allows these non-standard errors to be correctly serialized,\n * sent to Inngest, then deserialized back into the correct error type for users\n * to react to correctly.\n *\n * Note that these errors only support `message?: string | undefined` as the\n * input; more custom errors are not supported with this current strategy.\n */\nerrorConstructors.set(\n  \"NonRetriableError\",\n  NonRetriableError as ErrorConstructor,\n);\n\nexport interface SerializedError extends Readonly<CjsSerializedError> {\n  readonly [SERIALIZED_KEY]: typeof SERIALIZED_VALUE;\n}\n\n/**\n * Serialise an error to a serialized JSON string.\n *\n * Errors do not serialise nicely to JSON, so we use this function to convert\n * them to a serialized JSON string. Doing this is also non-trivial for some\n * errors, so we use the `serialize-error` package to do it for us.\n *\n * See {@link https://www.npmjs.com/package/serialize-error}\n *\n * This function is a small wrapper around that package to also add a `type`\n * property to the serialised error, so that we can distinguish between\n * serialised errors and other objects.\n *\n * Will not reserialise existing serialised errors.\n */\nexport const serializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : SerializedError = TAllowUnknown extends true ? unknown : SerializedError,\n>(\n  /**\n   * The suspected error to serialize.\n   */\n  subject: unknown,\n\n  /**\n   * If `true` and the error is not serializable, will return the original value\n   * as `unknown` instead of coercing it to a serialized error.\n   */\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  try {\n    // Try to understand if this is already done.\n    // Will handle stringified errors.\n    const existingSerializedError = isSerializedError(subject);\n\n    if (existingSerializedError) {\n      return existingSerializedError as TOutput;\n    }\n\n    if (typeof subject === \"object\" && subject !== null) {\n      // Is an object, so let's try and serialize it.\n      const serializedErr = cjsSerializeError(subject as Error);\n\n      // Not a proper error was caught, so give us a chance to return `unknown`.\n      if (!serializedErr.name && allowUnknown) {\n        return subject as TOutput;\n      }\n\n      // Serialization can succeed but assign no name or message, so we'll\n      // map over the result here to ensure we have everything.\n      // We'll just stringify the entire subject for the message, as this at\n      // least provides some context for the user.\n      const ret = {\n        // Ensure we spread to also capture additional properties such as\n        // `cause`.\n        ...serializedErr,\n\n        name: serializedErr.name || \"Error\",\n        message:\n          serializedErr.message ||\n          stringify(subject) ||\n          \"Unknown error; error serialization could not find a message.\",\n        stack: serializedErr.stack || \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as const;\n\n      // If we have a cause, make sure we recursively serialize them too. We are\n      // lighter with causes though; attempt to recursively serialize them, but\n      // stop if we find something that doesn't work and just return `unknown`.\n      let target: unknown = ret;\n      const maxDepth = 5;\n      for (let i = 0; i < maxDepth; i++) {\n        if (\n          typeof target === \"object\" &&\n          target !== null &&\n          \"cause\" in target &&\n          target.cause\n        ) {\n          target = target.cause = serializeError(target.cause, true);\n          continue;\n        }\n\n        break;\n      }\n\n      return ret as TOutput;\n    }\n\n    // If it's not an object, it's hard to parse this as an Error. In this case,\n    // we'll throw an error to start attempting backup strategies.\n    throw new Error(\"Error is not an object; strange throw value.\");\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    try {\n      // If serialization fails, fall back to a regular Error and use the\n      // original object as the message for an Error. We don't know what this\n      // object looks like, so we can't do anything else with it.\n      return {\n        ...serializeError(\n          new Error(typeof subject === \"string\" ? subject : stringify(subject)),\n          false,\n        ),\n        // Remove the stack; it's not relevant here\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    } catch {\n      // If this failed, then stringifying the object also failed, so we'll just\n      // return a completely generic error.\n      // Failing to stringify the object is very unlikely.\n      return {\n        name: \"Could not serialize source error\",\n        message: \"Serializing the source error failed.\",\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    }\n  }\n};\n\n/**\n * Check if an object or a string is a serialised error created by\n * {@link serializeError}.\n */\nexport const isSerializedError = (\n  value: unknown,\n): SerializedError | undefined => {\n  try {\n    if (typeof value === \"string\") {\n      const parsed = z\n        .object({\n          [SERIALIZED_KEY]: z.literal(SERIALIZED_VALUE),\n          name: z.enum([...Array.from(errorConstructors.keys())] as [\n            string,\n            ...string[],\n          ]),\n          message: z.string(),\n          stack: z.string(),\n        })\n        .passthrough()\n        .safeParse(JSON.parse(value));\n\n      if (parsed.success) {\n        return parsed.data as SerializedError;\n      }\n    }\n\n    if (typeof value === \"object\" && value !== null) {\n      const objIsSerializedErr =\n        Object.hasOwn(value, SERIALIZED_KEY) &&\n        (value as { [SERIALIZED_KEY]: unknown })[SERIALIZED_KEY] ===\n          SERIALIZED_VALUE;\n\n      if (objIsSerializedErr) {\n        return value as SerializedError;\n      }\n    }\n  } catch {\n    // no-op; we'll return undefined if parsing failed, as it isn't a serialized\n    // error\n  }\n\n  return;\n};\n\n/**\n * Deserialise an error created by {@link serializeError}.\n *\n * Ensures we only deserialise errors that meet a minimum level of\n * applicability, inclusive of error handling to ensure that badly serialized\n * errors are still handled.\n */\nexport const deserializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : Error = TAllowUnknown extends true ? unknown : Error,\n>(\n  subject: Partial<SerializedError>,\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  const requiredFields: (keyof SerializedError)[] = [\"name\", \"message\"];\n\n  try {\n    const hasRequiredFields = requiredFields.every((field) => {\n      return Object.hasOwn(subject, field);\n    });\n\n    if (!hasRequiredFields) {\n      throw new Error();\n    }\n\n    const deserializedErr = cjsDeserializeError(subject as SerializedError);\n\n    if (\"cause\" in deserializedErr) {\n      deserializedErr.cause = deserializeError(\n        deserializedErr.cause as Partial<SerializedError>,\n        true,\n      );\n    }\n\n    return deserializedErr as TOutput;\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    const err = new Error(\"Unknown error; could not reserialize\");\n\n    /**\n     * Remove the stack so that it's not misleadingly shown as the Inngest\n     * internals.\n     */\n    err.stack = undefined;\n\n    return err as TOutput;\n  }\n};\n\nexport enum ErrCode {\n  NESTING_STEPS = \"NESTING_STEPS\",\n\n  /**\n   * Legacy v0 execution error code for when a function has changed and no\n   * longer matches its in-progress state.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  NON_DETERMINISTIC_FUNCTION = \"NON_DETERMINISTIC_FUNCTION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * async actions after memoziation has occurred, which v0 doesn't support.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  ASYNC_DETECTED_AFTER_MEMOIZATION = \"ASYNC_DETECTED_AFTER_MEMOIZATION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * steps after a non-step async action has occurred.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  STEP_USED_AFTER_ASYNC = \"STEP_USED_AFTER_ASYNC\",\n\n  AUTOMATIC_PARALLEL_INDEXING = \"AUTOMATIC_PARALLEL_INDEXING\",\n\n  NONDETERMINISTIC_STEPS = \"NONDETERMINISTIC_STEPS\",\n}\n\n/**\n * Given an `unknown` object, retrieve the `message` property from it, or fall\n * back to the `fallback` string if it doesn't exist or is empty.\n */\nexport const getErrorMessage = (err: unknown, fallback: string): string => {\n  const { message } = z\n    .object({ message: z.string().min(1) })\n    .catch({ message: fallback })\n    .parse(err);\n\n  return message;\n};\n\nexport const fixEventKeyMissingSteps = [\n  \"Set the `INNGEST_EVENT_KEY` environment variable\",\n  `Pass a key to the \\`new Inngest()\\` constructor using the \\`${\n    \"eventKey\" satisfies keyof ClientOptions\n  }\\` option`,\n];\n\n/**\n * An error that, when thrown, indicates internally that an outgoing operation\n * contains an error.\n *\n * We use this because serialized `data` sent back to Inngest may differ from\n * the error instance itself due to middleware.\n *\n * @internal\n */\nexport class OutgoingResultError extends Error {\n  public readonly result: Pick<OutgoingOp, \"data\" | \"error\">;\n\n  constructor(result: Pick<OutgoingOp, \"data\" | \"error\">) {\n    super(\"OutgoingOpError\");\n    this.result = result;\n  }\n}\n\n/**\n * Create a function that will rethrow an error with a prefix added to the\n * message.\n *\n * Useful for adding context to errors that are rethrown.\n *\n * @example\n * ```ts\n * await doSomeAction().catch(rethrowError(\"Failed to do some action\"));\n * ```\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport const rethrowError = (prefix: string): ((err: any) => never) => {\n  return (err) => {\n    try {\n      err.message &&= `${prefix}; ${err.message}`;\n    } catch (_noopErr) {\n      // no-op\n    } finally {\n      // biome-ignore lint/correctness/noUnsafeFinally: intentional\n      throw err;\n    }\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"errors.js","names":["serializeError","cjsSerializeError","target: unknown","deserializeError","requiredFields: (keyof SerializedError)[]","cjsDeserializeError"],"sources":["../../src/helpers/errors.ts"],"sourcesContent":["import stringify from \"json-stringify-safe\";\nimport {\n  type SerializedError as CjsSerializedError,\n  deserializeError as cjsDeserializeError,\n  serializeError as cjsSerializeError,\n  errorConstructors,\n} from \"serialize-error-cjs\";\nimport { z } from \"zod/v3\";\nimport { NonRetriableError } from \"../components/NonRetriableError.ts\";\nimport type { ClientOptions, OutgoingOp } from \"../types.ts\";\n\nconst SERIALIZED_KEY = \"__serialized\";\nconst SERIALIZED_VALUE = true;\n\n/**\n * Add first-class support for certain errors that we control, in addition to\n * built-in errors such as `TypeError`.\n *\n * Adding these allows these non-standard errors to be correctly serialized,\n * sent to Inngest, then deserialized back into the correct error type for users\n * to react to correctly.\n *\n * Note that these errors only support `message?: string | undefined` as the\n * input; more custom errors are not supported with this current strategy.\n */\nerrorConstructors.set(\n  \"NonRetriableError\",\n  NonRetriableError as ErrorConstructor,\n);\n\nexport interface SerializedError extends Readonly<CjsSerializedError> {\n  readonly [SERIALIZED_KEY]: typeof SERIALIZED_VALUE;\n}\n\n/**\n * Serialise an error to a serialized JSON string.\n *\n * Errors do not serialise nicely to JSON, so we use this function to convert\n * them to a serialized JSON string. Doing this is also non-trivial for some\n * errors, so we use the `serialize-error` package to do it for us.\n *\n * See {@link https://www.npmjs.com/package/serialize-error}\n *\n * This function is a small wrapper around that package to also add a `type`\n * property to the serialised error, so that we can distinguish between\n * serialised errors and other objects.\n *\n * Will not reserialise existing serialised errors.\n */\nexport const serializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : SerializedError = TAllowUnknown extends true ? unknown : SerializedError,\n>(\n  /**\n   * The suspected error to serialize.\n   */\n  subject: unknown,\n\n  /**\n   * If `true` and the error is not serializable, will return the original value\n   * as `unknown` instead of coercing it to a serialized error.\n   */\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  try {\n    // Try to understand if this is already done.\n    // Will handle stringified errors.\n    const existingSerializedError = isSerializedError(subject);\n\n    if (existingSerializedError) {\n      return existingSerializedError as TOutput;\n    }\n\n    if (typeof subject === \"object\" && subject !== null) {\n      // Is an object, so let's try and serialize it.\n      const serializedErr = cjsSerializeError(subject as Error);\n\n      // Not a proper error was caught, so give us a chance to return `unknown`.\n      if (!serializedErr.name && allowUnknown) {\n        return subject as TOutput;\n      }\n\n      // Serialization can succeed but assign no name or message, so we'll\n      // map over the result here to ensure we have everything.\n      // We'll just stringify the entire subject for the message, as this at\n      // least provides some context for the user.\n      const ret = {\n        // Ensure we spread to also capture additional properties such as\n        // `cause`.\n        ...serializedErr,\n\n        name: serializedErr.name || \"Error\",\n        message:\n          serializedErr.message ||\n          stringify(subject) ||\n          \"Unknown error; error serialization could not find a message.\",\n        stack: serializedErr.stack || \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as const;\n\n      // If we have a cause, make sure we recursively serialize them too. We are\n      // lighter with causes though; attempt to recursively serialize them, but\n      // stop if we find something that doesn't work and just return `unknown`.\n      let target: unknown = ret;\n      const maxDepth = 5;\n      for (let i = 0; i < maxDepth; i++) {\n        if (\n          typeof target === \"object\" &&\n          target !== null &&\n          \"cause\" in target &&\n          target.cause\n        ) {\n          target = target.cause = serializeError(target.cause, true);\n          continue;\n        }\n\n        break;\n      }\n\n      return ret as TOutput;\n    }\n\n    // If it's not an object, it's hard to parse this as an Error. In this case,\n    // we'll throw an error to start attempting backup strategies.\n    throw new Error(\"Error is not an object; strange throw value.\");\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    try {\n      // If serialization fails, fall back to a regular Error and use the\n      // original object as the message for an Error. We don't know what this\n      // object looks like, so we can't do anything else with it.\n      return {\n        ...serializeError(\n          new Error(typeof subject === \"string\" ? subject : stringify(subject)),\n          false,\n        ),\n        // Remove the stack; it's not relevant here\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    } catch {\n      // If this failed, then stringifying the object also failed, so we'll just\n      // return a completely generic error.\n      // Failing to stringify the object is very unlikely.\n      return {\n        name: \"Could not serialize source error\",\n        message: \"Serializing the source error failed.\",\n        stack: \"\",\n        [SERIALIZED_KEY]: SERIALIZED_VALUE,\n      } as TOutput;\n    }\n  }\n};\n\n/**\n * Check if an object or a string is a serialised error created by\n * {@link serializeError}.\n */\nexport const isSerializedError = (\n  value: unknown,\n): SerializedError | undefined => {\n  try {\n    if (typeof value === \"string\") {\n      const parsed = z\n        .object({\n          [SERIALIZED_KEY]: z.literal(SERIALIZED_VALUE),\n          name: z.enum([...Array.from(errorConstructors.keys())] as [\n            string,\n            ...string[],\n          ]),\n          message: z.string(),\n          stack: z.string(),\n        })\n        .passthrough()\n        .safeParse(JSON.parse(value));\n\n      if (parsed.success) {\n        return parsed.data as SerializedError;\n      }\n    }\n\n    if (typeof value === \"object\" && value !== null) {\n      const objIsSerializedErr =\n        Object.hasOwn(value, SERIALIZED_KEY) &&\n        (value as { [SERIALIZED_KEY]: unknown })[SERIALIZED_KEY] ===\n          SERIALIZED_VALUE;\n\n      if (objIsSerializedErr) {\n        return value as SerializedError;\n      }\n    }\n  } catch {\n    // no-op; we'll return undefined if parsing failed, as it isn't a serialized\n    // error\n  }\n\n  return;\n};\n\n/**\n * Deserialise an error created by {@link serializeError}.\n *\n * Ensures we only deserialise errors that meet a minimum level of\n * applicability, inclusive of error handling to ensure that badly serialized\n * errors are still handled.\n */\nexport const deserializeError = <\n  TAllowUnknown extends boolean = false,\n  TOutput extends TAllowUnknown extends true\n    ? unknown\n    : Error = TAllowUnknown extends true ? unknown : Error,\n>(\n  subject: Partial<SerializedError>,\n  allowUnknown: TAllowUnknown = false as TAllowUnknown,\n): TOutput => {\n  const requiredFields: (keyof SerializedError)[] = [\"name\", \"message\"];\n\n  try {\n    const hasRequiredFields = requiredFields.every((field) => {\n      return Object.hasOwn(subject, field);\n    });\n\n    if (!hasRequiredFields) {\n      throw new Error();\n    }\n\n    const deserializedErr = cjsDeserializeError(subject as SerializedError);\n\n    if (\"cause\" in deserializedErr) {\n      deserializedErr.cause = deserializeError(\n        deserializedErr.cause as Partial<SerializedError>,\n        true,\n      );\n    }\n\n    return deserializedErr as TOutput;\n  } catch {\n    if (allowUnknown) {\n      // If we are allowed to return unknown, we'll just return the original\n      // value.\n      return subject as TOutput;\n    }\n\n    const err = new Error(\"Unknown error; could not reserialize\");\n\n    /**\n     * Remove the stack so that it's not misleadingly shown as the Inngest\n     * internals.\n     */\n    err.stack = undefined;\n\n    return err as TOutput;\n  }\n};\n\nexport enum ErrCode {\n  NESTING_STEPS = \"NESTING_STEPS\",\n\n  /**\n   * Legacy v0 execution error code for when a function has changed and no\n   * longer matches its in-progress state.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  NON_DETERMINISTIC_FUNCTION = \"NON_DETERMINISTIC_FUNCTION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * async actions after memoziation has occurred, which v0 doesn't support.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  ASYNC_DETECTED_AFTER_MEMOIZATION = \"ASYNC_DETECTED_AFTER_MEMOIZATION\",\n\n  /**\n   * Legacy v0 execution error code for when a function is found to be using\n   * steps after a non-step async action has occurred.\n   *\n   * @deprecated Not for use in latest execution method.\n   */\n  STEP_USED_AFTER_ASYNC = \"STEP_USED_AFTER_ASYNC\",\n\n  AUTOMATIC_PARALLEL_INDEXING = \"AUTOMATIC_PARALLEL_INDEXING\",\n\n  NONDETERMINISTIC_STEPS = \"NONDETERMINISTIC_STEPS\",\n}\n\n/**\n * Given an `unknown` object, retrieve the `message` property from it, or fall\n * back to the `fallback` string if it doesn't exist or is empty.\n */\nexport const getErrorMessage = (err: unknown, fallback: string): string => {\n  const { message } = z\n    .object({ message: z.string().min(1) })\n    .catch({ message: fallback })\n    .parse(err);\n\n  return message;\n};\n\nexport const fixEventKeyMissingSteps = [\n  \"Set the `INNGEST_EVENT_KEY` environment variable\",\n  `Pass a key to the \\`new Inngest()\\` constructor using the \\`${\n    \"eventKey\" satisfies keyof ClientOptions\n  }\\` option`,\n];\n\n/**\n * An error that, when thrown, indicates internally that an outgoing operation\n * contains an error.\n *\n * We use this because serialized `data` sent back to Inngest may differ from\n * the error instance itself due to middleware.\n *\n * @internal\n */\nexport class OutgoingResultError extends Error {\n  public readonly result: Pick<OutgoingOp, \"data\" | \"error\">;\n\n  constructor(result: Pick<OutgoingOp, \"data\" | \"error\">) {\n    super(\"OutgoingOpError\");\n    this.result = result;\n  }\n}\n\n/**\n * Create a function that will rethrow an error with a prefix added to the\n * message.\n *\n * Useful for adding context to errors that are rethrown.\n *\n * @example\n * ```ts\n * await doSomeAction().catch(rethrowError(\"Failed to do some action\"));\n * ```\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport const rethrowError = (prefix: string): ((err: any) => never) => {\n  return (err) => {\n    try {\n      err.message &&= `${prefix}; ${err.message}`;\n    } catch (_noopErr) {\n      // no-op\n    } finally {\n      // biome-ignore lint/correctness/noUnsafeFinally: intentional\n      throw err;\n    }\n  };\n};\n\n/**\n * An error that indicates that a code path that was thought to be unreachable\n * has been reached.\n *\n * This is useful for exhaustiveness checks in places where we think we've\n * handled all possible cases, but want to be sure that if we haven't, we get a\n * clear error.\n */\nexport class UnreachableError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"UnreachableError\";\n  }\n}\n"],"mappings":"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"}

package/helpers/types.cjs

@@ -3,7 +3,11 @@
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
 
 //#endregion
+exports.isFiniteNumber = isFiniteNumber;
 exports.isRecord = isRecord;
 //# sourceMappingURL=types.cjs.map

package/helpers/types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.cjs","names":[],"sources":["../../src/helpers/types.ts"],"sourcesContent":["import type { EventPayload } from \"../types.ts\";\n\n/**\n * Returns the given generic as either itself or an array of itself.\n */\nexport type SingleOrArray<T> = T | T[];\n\n/**\n * Given type `T`, return it as an array if it is not already an array.\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport type AsArray<T> = T extends any[] ? T : [T];\n\n/**\n * Given type `T`, return a tuple of `T` that contains at least one element,\n * where `T` is not distributed, such that each array element could be any type\n * that satisfies `T`.\n *\n * See also {@link AsDistributedTuple}.\n *\n * @example\n * ```ts\n * // [\"foo\", ...\"foo\"[]]\n * type T0 = AsTuple<\"foo\">;\n *\n * // [\"foo\" | \"bar\", ...(\"foo\" | \"bar\")[]]\n * type T1 = AsTuple<\"foo\" | \"bar\">;\n */\nexport type AsTuple<T> = Simplify<[T, ...T[]]>;\n\n/**\n * Given type `T`, return a tuple of `T` that contains at least one element,\n * where `T` is also distributed, such that the array can be type narrowed by\n * checking a single element.\n *\n * See also {@link AsTuple}.\n *\n * @example\n * ```ts\n *  // [\"foo\", ...\"foo\"[]]\n * type T0 = AsDistributedTuple<\"foo\">;\n *\n * // [\"foo\", ...\"foo\"[]] | [\"bar\", ...\"bar\"[]]\n * type T1 = AsDistributedTuple<\"foo\" | \"bar\">;\n * ```\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport type AsDistributedTuple<T> = T extends any ? [T, ...T[]] : never;\n\n/**\n * Returns the given generic as either itself or a promise of itself.\n */\nexport type MaybePromise<T> = T | Promise<T>;\n\n/**\n * Acts like `Partial<T>` but only for the keys in `K`, leaving the rest alone.\n */\nexport type PartialK<T, K extends PropertyKey = PropertyKey> = Partial<\n  Pick<T, Extract<keyof T, K>>\n> &\n  Omit<T, K> extends infer O\n  ? { [P in keyof O]: O[P] }\n  : never;\n\n/**\n * A payload that could be sent to Inngest.\n */\nexport type SendEventPayload = SingleOrArray<\n  PartialK<Omit<EventPayload, \"v\">, \"ts\">\n>;\n\n/**\n * @public\n */\nexport type WithoutInternal<T extends Record<string, EventPayload>> = {\n  [K in keyof T as WithoutInternalStr<K & string>]: T[K];\n};\n\nexport type WithoutInternalStr<T extends string> = T extends `inngest/${string}`\n  ? never\n  : T;\n\n/**\n * A list of simple, JSON-compatible, primitive types that contain no other\n * values.\n */\nexport type Primitive =\n  | null\n  | undefined\n  | string\n  | number\n  | boolean\n  | symbol\n  | bigint;\n\n/**\n * Returns all keys from objects in the union `T`.\n *\n * @public\n */\nexport type UnionKeys<T> = T extends T ? keyof T : never;\n\n/**\n * Enforces strict union comformity by ensuring that all potential keys in a\n * union of objects are accounted for in every object.\n *\n * Requires two generics to be used, so is abstracted by {@link StrictUnion}.\n *\n * @public\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport type StrictUnionHelper<T, TAll> = T extends any\n  ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>>\n  : never;\n\n/**\n * Enforces strict union comformity by ensuring that all potential keys in a\n * union of objects are accounted for in every object.\n *\n * @public\n */\nexport type StrictUnion<T> = StrictUnionHelper<T, T>;\n\n/**\n * Returns `true` if the given generic `T` is a string literal, e.g. `\"foo\"`, or\n * `false` if it is a string type, e.g. `string`.\n *\n * Useful for checking whether the keys of an object are known or not.\n *\n * @example\n * ```ts\n * // false\n * type ObjIsGeneric = IsStringLiteral<keyof Record<string, boolean>>;\n *\n * // true\n * type ObjIsKnown = IsStringLiteral<keyof { foo: boolean; }>; // true\n * ```\n *\n * @internal\n */\nexport type IsStringLiteral<T extends string> = string extends T ? false : true;\n\n/**\n * Returns `true` if the given generic `T` is `any`, or `false` if it is not.\n */\nexport type IsAny<T> = 0 extends 1 & T ? true : false;\n\n/**\n * Given a function T, return the awaited return type of that function,\n * ignoring the fact that T may be undefined.\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport type Await<T extends ((...args: any[]) => any) | undefined> = Awaited<\n  ReturnType<NonNullable<T>>\n>;\n\n/**\n * Given an object TAcc and an array of objects TArr, return a new object that\n * is the result of merging all of the objects in TArr into TAcc.\n */\nexport type ObjectAssign<TArr, TAcc = {}> = TArr extends [\n  infer TFirst,\n  ...infer TRest,\n]\n  ? Simplify<ObjectAssign<TRest, Omit<TAcc, keyof TFirst> & TFirst>>\n  : TAcc;\n\n/**\n * Make a type's keys mutually exclusive.\n *\n * @example\n * Make 1 key mutually exclusive with 1 other key.\n *\n * ```ts\n * type MyType = ExclusiveKeys<{a: number, b: number}, \"a\", \"b\">\n *\n * const valid1: MyType = { a: 1 }\n * const valid2: MyType = { b: 1 }\n * const invalid1: MyType = { a: 1, b: 1 }\n * ```\n *\n * @example\n * Make 1 key mutually exclusive with 2 other keys.\n *\n * ```ts\n * type MyType = ExclusiveKeys<{a: number, b: number, c: number}, \"a\", \"b\" | \"c\">\n *\n * const valid1: MyType = { a: 1 };\n * const valid2: MyType = { b: 1, c: 1 };\n * const invalid1: MyType = { a: 1, b: 1 };\n * const invalid2: MyType = { a: 1, c: 1 };\n * const invalid3: MyType = { a: 1, b: 1, c: 1 };\n * ```\n */\nexport type ExclusiveKeys<T, Keys1 extends keyof T, Keys2 extends keyof T> =\n  | (Omit<T, Keys1> & { [K in Keys1]?: never })\n  | (Omit<T, Keys2> & { [K in Keys2]?: never });\n\n/**\n * A type that represents either `A` or `B`. Shared properties retain their\n * types and unique properties are marked as optional.\n */\nexport type Either<A, B> = Partial<A> & Partial<B> & (A | B);\n\n/**\n * Given a function `T`, return the parameters of that function, except for the\n * first one.\n */\nexport type ParametersExceptFirst<T> = T extends (\n  // biome-ignore lint/suspicious/noExplicitAny: intentional\n  arg0: any,\n  ...rest: infer U\n  // biome-ignore lint/suspicious/noExplicitAny: intentional\n) => any\n  ? U\n  : never;\n\n/**\n * Given an object `T`, return `true` if it contains no keys, or `false` if it\n * contains any keys.\n *\n * Useful for detecting the passing of a `{}` (any non-nullish) type.\n */\nexport type IsEmptyObject<T> = {} extends T\n  ? T extends {}\n    ? true\n    : false\n  : false;\n\n/**\n * Create a tuple that can be of length 1 to `TLength`, where each element is\n * of type `TElement`.\n */\nexport type RecursiveTuple<\n  TElement,\n  TLength extends number,\n  TAccumulator extends TElement[] = [TElement],\n> = TAccumulator[\"length\"] extends TLength\n  ? TAccumulator\n  :\n      | RecursiveTuple<TElement, TLength, [TElement, ...TAccumulator]>\n      | TAccumulator;\n\nexport type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};\n\nexport type ConditionalSimplifyDeep<\n  Type,\n  ExcludeType = never,\n  IncludeType = unknown,\n> = Type extends ExcludeType\n  ? Type\n  : Type extends IncludeType\n    ? {\n        [TypeKey in keyof Type]: ConditionalSimplifyDeep<\n          Type[TypeKey],\n          ExcludeType,\n          IncludeType\n        >;\n      }\n    : Type;\n\nexport type SimplifyDeep<Type> = ConditionalSimplifyDeep<\n  Type,\n  Function | Iterable<unknown>,\n  object\n>;\n\n/**\nReturns a boolean for whether the given type is `null`.\n*/\nexport type IsNull<T> = [T] extends [null] ? true : false;\n\n/**\nReturns a boolean for whether the given type is `unknown`.\n\n{@link https://github.com/dsherret/conditional-type-checks/pull/16}\n\nUseful in type utilities, such as when dealing with unknown data from API calls.\n\n@example\n```\nimport type {IsUnknown} from 'type-fest';\n\n// https://github.com/pajecawav/tiny-global-store/blob/master/src/index.ts\ntype Action<TState, TPayload = void> =\n\tIsUnknown<TPayload> extends true\n\t\t? (state: TState) => TState,\n\t\t: (state: TState, payload: TPayload) => TState;\n\nclass Store<TState> {\n\tconstructor(private state: TState) {}\n\n\texecute<TPayload = void>(action: Action<TState, TPayload>, payload?: TPayload): TState {\n\t\tthis.state = action(this.state, payload);\n\t\treturn this.state;\n\t}\n\n\t// ... other methods\n}\n\nconst store = new Store({value: 1});\ndeclare const someExternalData: unknown;\n\nstore.execute(state => ({value: state.value + 1}));\n//=> `TPayload` is `void`\n\nstore.execute((state, payload) => ({value: state.value + payload}), 5);\n//=> `TPayload` is `5`\n\nstore.execute((state, payload) => ({value: state.value + payload}), someExternalData);\n//=> Errors: `action` is `(state: TState) => TState`\n```\n*/\nexport type IsUnknown<T> = unknown extends T // `T` can be `unknown` or `any`\n  ? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be\n    ? true\n    : false\n  : false;\n\n/**\nReturns a boolean for whether the two given types are equal.\n\n{@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650}\n{@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796}\n\nUse-cases:\n- If you want to make a conditional branch based on the result of a comparison of two types.\n\n@example\n```\nimport type {IsEqual} from 'type-fest';\n\n// This type returns a boolean for whether the given array includes the given item.\n// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.\ntype Includes<Value extends readonly any[], Item> =\n\tValue extends readonly [Value[0], ...infer rest]\n\t\t? IsEqual<Value[0], Item> extends true\n\t\t\t? true\n\t\t\t: Includes<rest, Item>\n\t\t: false;\n```\n*/\nexport type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <\n  G,\n>() => G extends B ? 1 : 2\n  ? true\n  : false;\n\n/**\n * Returns a boolean for whether the given type `T` is `never`.\n */\nexport type IsNever<T> = [T] extends [never] ? true : false;\n\n/**\n * Given a type `T`, return `Then` if `T` is a string, number, or symbol\n * literal, else `Else`.\n *\n * `Then` defaults to `true` and `Else` defaults to `false`.\n *\n * Useful for determining if an object is a generic type or has known keys.\n *\n * @example\n * ```ts\n * type IsLiteralType = IsLiteral<\"foo\">; // true\n * type IsLiteralType = IsLiteral<string>; // false\n *\n * type IsLiteralType = IsLiteral<1>; // true\n * type IsLiteralType = IsLiteral<number>; // false\n *\n * type IsLiteralType = IsLiteral<symbol>; // true\n * type IsLiteralType = IsLiteral<typeof Symbol.iterator>; // false\n *\n * type T0 = { foo: string };\n * type HasAllKnownKeys = IsLiteral<keyof T0>; // true\n *\n * type T1 = { [x: string]: any; foo: boolean };\n * type HasAllKnownKeys = IsLiteral<keyof T1>; // false\n * ```\n */\nexport type IsLiteral<T, Then = true, Else = false> = string extends T\n  ? Else\n  : number extends T\n    ? Else\n    : symbol extends T\n      ? Else\n      : Then;\n\n/**\n * Given an object `T`, return the keys of that object that are known literals.\n *\n * Useful for filtering out generic mapped types from objects.\n *\n * @example\n * ```ts\n * type T0 = { foo: string };\n * type RegularKeys = keyof T0; // \"foo\"\n * type KnownKeys = KnownLiteralKeys<T0>; // \"foo\"\n *\n * type T1 = { [x: string]: any; foo: boolean };\n * type RegularKeys = keyof T1; // string | number\n * type KnownKeys = KnownLiteralKeys<T1>; // \"foo\"\n * ```\n */\nexport type KnownKeys<T> = keyof {\n  [K in keyof T as IsLiteral<K, K, never>]: T[K];\n};\n\n/**\n * Given an object `T`, return the keys of that object that are public, ignoring\n * `private` and `protected` keys.\n *\n * This shouldn't commonly be used or exposed in user-facing types, as it can\n * skew extension checks.\n */\nexport type Public<T> = { [K in keyof T]: T[K] };\n\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n"],"mappings":";;AAgaA,SAAgB,SAAS,OAAkD;AACzE,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,MAAM"}
+{"version":3,"file":"types.cjs","names":[],"sources":["../../src/helpers/types.ts"],"sourcesContent":["import type { EventPayload } from \"../types.ts\";\n\n/**\n * Returns the given generic as either itself or an array of itself.\n */\nexport type SingleOrArray<T> = T | T[];\n\n/**\n * Given type `T`, return it as an array if it is not already an array.\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport type AsArray<T> = T extends any[] ? T : [T];\n\n/**\n * Given type `T`, return a tuple of `T` that contains at least one element,\n * where `T` is not distributed, such that each array element could be any type\n * that satisfies `T`.\n *\n * See also {@link AsDistributedTuple}.\n *\n * @example\n * ```ts\n * // [\"foo\", ...\"foo\"[]]\n * type T0 = AsTuple<\"foo\">;\n *\n * // [\"foo\" | \"bar\", ...(\"foo\" | \"bar\")[]]\n * type T1 = AsTuple<\"foo\" | \"bar\">;\n */\nexport type AsTuple<T> = Simplify<[T, ...T[]]>;\n\n/**\n * Given type `T`, return a tuple of `T` that contains at least one element,\n * where `T` is also distributed, such that the array can be type narrowed by\n * checking a single element.\n *\n * See also {@link AsTuple}.\n *\n * @example\n * ```ts\n *  // [\"foo\", ...\"foo\"[]]\n * type T0 = AsDistributedTuple<\"foo\">;\n *\n * // [\"foo\", ...\"foo\"[]] | [\"bar\", ...\"bar\"[]]\n * type T1 = AsDistributedTuple<\"foo\" | \"bar\">;\n * ```\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport type AsDistributedTuple<T> = T extends any ? [T, ...T[]] : never;\n\n/**\n * Returns the given generic as either itself or a promise of itself.\n */\nexport type MaybePromise<T> = T | Promise<T>;\n\n/**\n * Acts like `Partial<T>` but only for the keys in `K`, leaving the rest alone.\n */\nexport type PartialK<T, K extends PropertyKey = PropertyKey> = Partial<\n  Pick<T, Extract<keyof T, K>>\n> &\n  Omit<T, K> extends infer O\n  ? { [P in keyof O]: O[P] }\n  : never;\n\n/**\n * A payload that could be sent to Inngest.\n */\nexport type SendEventPayload = SingleOrArray<\n  PartialK<Omit<EventPayload, \"v\">, \"ts\">\n>;\n\n/**\n * @public\n */\nexport type WithoutInternal<T extends Record<string, EventPayload>> = {\n  [K in keyof T as WithoutInternalStr<K & string>]: T[K];\n};\n\nexport type WithoutInternalStr<T extends string> = T extends `inngest/${string}`\n  ? never\n  : T;\n\n/**\n * A list of simple, JSON-compatible, primitive types that contain no other\n * values.\n */\nexport type Primitive =\n  | null\n  | undefined\n  | string\n  | number\n  | boolean\n  | symbol\n  | bigint;\n\n/**\n * Returns all keys from objects in the union `T`.\n *\n * @public\n */\nexport type UnionKeys<T> = T extends T ? keyof T : never;\n\n/**\n * Enforces strict union comformity by ensuring that all potential keys in a\n * union of objects are accounted for in every object.\n *\n * Requires two generics to be used, so is abstracted by {@link StrictUnion}.\n *\n * @public\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport type StrictUnionHelper<T, TAll> = T extends any\n  ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>>\n  : never;\n\n/**\n * Enforces strict union comformity by ensuring that all potential keys in a\n * union of objects are accounted for in every object.\n *\n * @public\n */\nexport type StrictUnion<T> = StrictUnionHelper<T, T>;\n\n/**\n * Returns `true` if the given generic `T` is a string literal, e.g. `\"foo\"`, or\n * `false` if it is a string type, e.g. `string`.\n *\n * Useful for checking whether the keys of an object are known or not.\n *\n * @example\n * ```ts\n * // false\n * type ObjIsGeneric = IsStringLiteral<keyof Record<string, boolean>>;\n *\n * // true\n * type ObjIsKnown = IsStringLiteral<keyof { foo: boolean; }>; // true\n * ```\n *\n * @internal\n */\nexport type IsStringLiteral<T extends string> = string extends T ? false : true;\n\n/**\n * Returns `true` if the given generic `T` is `any`, or `false` if it is not.\n */\nexport type IsAny<T> = 0 extends 1 & T ? true : false;\n\n/**\n * Given a function T, return the awaited return type of that function,\n * ignoring the fact that T may be undefined.\n */\n// biome-ignore lint/suspicious/noExplicitAny: intentional\nexport type Await<T extends ((...args: any[]) => any) | undefined> = Awaited<\n  ReturnType<NonNullable<T>>\n>;\n\n/**\n * Given an object TAcc and an array of objects TArr, return a new object that\n * is the result of merging all of the objects in TArr into TAcc.\n */\nexport type ObjectAssign<TArr, TAcc = {}> = TArr extends [\n  infer TFirst,\n  ...infer TRest,\n]\n  ? Simplify<ObjectAssign<TRest, Omit<TAcc, keyof TFirst> & TFirst>>\n  : TAcc;\n\n/**\n * Make a type's keys mutually exclusive.\n *\n * @example\n * Make 1 key mutually exclusive with 1 other key.\n *\n * ```ts\n * type MyType = ExclusiveKeys<{a: number, b: number}, \"a\", \"b\">\n *\n * const valid1: MyType = { a: 1 }\n * const valid2: MyType = { b: 1 }\n * const invalid1: MyType = { a: 1, b: 1 }\n * ```\n *\n * @example\n * Make 1 key mutually exclusive with 2 other keys.\n *\n * ```ts\n * type MyType = ExclusiveKeys<{a: number, b: number, c: number}, \"a\", \"b\" | \"c\">\n *\n * const valid1: MyType = { a: 1 };\n * const valid2: MyType = { b: 1, c: 1 };\n * const invalid1: MyType = { a: 1, b: 1 };\n * const invalid2: MyType = { a: 1, c: 1 };\n * const invalid3: MyType = { a: 1, b: 1, c: 1 };\n * ```\n */\nexport type ExclusiveKeys<T, Keys1 extends keyof T, Keys2 extends keyof T> =\n  | (Omit<T, Keys1> & { [K in Keys1]?: never })\n  | (Omit<T, Keys2> & { [K in Keys2]?: never });\n\n/**\n * A type that represents either `A` or `B`. Shared properties retain their\n * types and unique properties are marked as optional.\n */\nexport type Either<A, B> = Partial<A> & Partial<B> & (A | B);\n\n/**\n * Given a function `T`, return the parameters of that function, except for the\n * first one.\n */\nexport type ParametersExceptFirst<T> = T extends (\n  // biome-ignore lint/suspicious/noExplicitAny: intentional\n  arg0: any,\n  ...rest: infer U\n  // biome-ignore lint/suspicious/noExplicitAny: intentional\n) => any\n  ? U\n  : never;\n\n/**\n * Given an object `T`, return `true` if it contains no keys, or `false` if it\n * contains any keys.\n *\n * Useful for detecting the passing of a `{}` (any non-nullish) type.\n */\nexport type IsEmptyObject<T> = {} extends T\n  ? T extends {}\n    ? true\n    : false\n  : false;\n\n/**\n * Create a tuple that can be of length 1 to `TLength`, where each element is\n * of type `TElement`.\n */\nexport type RecursiveTuple<\n  TElement,\n  TLength extends number,\n  TAccumulator extends TElement[] = [TElement],\n> = TAccumulator[\"length\"] extends TLength\n  ? TAccumulator\n  :\n      | RecursiveTuple<TElement, TLength, [TElement, ...TAccumulator]>\n      | TAccumulator;\n\nexport type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};\n\nexport type ConditionalSimplifyDeep<\n  Type,\n  ExcludeType = never,\n  IncludeType = unknown,\n> = Type extends ExcludeType\n  ? Type\n  : Type extends IncludeType\n    ? {\n        [TypeKey in keyof Type]: ConditionalSimplifyDeep<\n          Type[TypeKey],\n          ExcludeType,\n          IncludeType\n        >;\n      }\n    : Type;\n\nexport type SimplifyDeep<Type> = ConditionalSimplifyDeep<\n  Type,\n  Function | Iterable<unknown>,\n  object\n>;\n\n/**\nReturns a boolean for whether the given type is `null`.\n*/\nexport type IsNull<T> = [T] extends [null] ? true : false;\n\n/**\nReturns a boolean for whether the given type is `unknown`.\n\n{@link https://github.com/dsherret/conditional-type-checks/pull/16}\n\nUseful in type utilities, such as when dealing with unknown data from API calls.\n\n@example\n```\nimport type {IsUnknown} from 'type-fest';\n\n// https://github.com/pajecawav/tiny-global-store/blob/master/src/index.ts\ntype Action<TState, TPayload = void> =\n\tIsUnknown<TPayload> extends true\n\t\t? (state: TState) => TState,\n\t\t: (state: TState, payload: TPayload) => TState;\n\nclass Store<TState> {\n\tconstructor(private state: TState) {}\n\n\texecute<TPayload = void>(action: Action<TState, TPayload>, payload?: TPayload): TState {\n\t\tthis.state = action(this.state, payload);\n\t\treturn this.state;\n\t}\n\n\t// ... other methods\n}\n\nconst store = new Store({value: 1});\ndeclare const someExternalData: unknown;\n\nstore.execute(state => ({value: state.value + 1}));\n//=> `TPayload` is `void`\n\nstore.execute((state, payload) => ({value: state.value + payload}), 5);\n//=> `TPayload` is `5`\n\nstore.execute((state, payload) => ({value: state.value + payload}), someExternalData);\n//=> Errors: `action` is `(state: TState) => TState`\n```\n*/\nexport type IsUnknown<T> = unknown extends T // `T` can be `unknown` or `any`\n  ? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be\n    ? true\n    : false\n  : false;\n\n/**\nReturns a boolean for whether the two given types are equal.\n\n{@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650}\n{@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796}\n\nUse-cases:\n- If you want to make a conditional branch based on the result of a comparison of two types.\n\n@example\n```\nimport type {IsEqual} from 'type-fest';\n\n// This type returns a boolean for whether the given array includes the given item.\n// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.\ntype Includes<Value extends readonly any[], Item> =\n\tValue extends readonly [Value[0], ...infer rest]\n\t\t? IsEqual<Value[0], Item> extends true\n\t\t\t? true\n\t\t\t: Includes<rest, Item>\n\t\t: false;\n```\n*/\nexport type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <\n  G,\n>() => G extends B ? 1 : 2\n  ? true\n  : false;\n\n/**\n * Returns a boolean for whether the given type `T` is `never`.\n */\nexport type IsNever<T> = [T] extends [never] ? true : false;\n\n/**\n * Given a type `T`, return `Then` if `T` is a string, number, or symbol\n * literal, else `Else`.\n *\n * `Then` defaults to `true` and `Else` defaults to `false`.\n *\n * Useful for determining if an object is a generic type or has known keys.\n *\n * @example\n * ```ts\n * type IsLiteralType = IsLiteral<\"foo\">; // true\n * type IsLiteralType = IsLiteral<string>; // false\n *\n * type IsLiteralType = IsLiteral<1>; // true\n * type IsLiteralType = IsLiteral<number>; // false\n *\n * type IsLiteralType = IsLiteral<symbol>; // true\n * type IsLiteralType = IsLiteral<typeof Symbol.iterator>; // false\n *\n * type T0 = { foo: string };\n * type HasAllKnownKeys = IsLiteral<keyof T0>; // true\n *\n * type T1 = { [x: string]: any; foo: boolean };\n * type HasAllKnownKeys = IsLiteral<keyof T1>; // false\n * ```\n */\nexport type IsLiteral<T, Then = true, Else = false> = string extends T\n  ? Else\n  : number extends T\n    ? Else\n    : symbol extends T\n      ? Else\n      : Then;\n\n/**\n * Given an object `T`, return the keys of that object that are known literals.\n *\n * Useful for filtering out generic mapped types from objects.\n *\n * @example\n * ```ts\n * type T0 = { foo: string };\n * type RegularKeys = keyof T0; // \"foo\"\n * type KnownKeys = KnownLiteralKeys<T0>; // \"foo\"\n *\n * type T1 = { [x: string]: any; foo: boolean };\n * type RegularKeys = keyof T1; // string | number\n * type KnownKeys = KnownLiteralKeys<T1>; // \"foo\"\n * ```\n */\nexport type KnownKeys<T> = keyof {\n  [K in keyof T as IsLiteral<K, K, never>]: T[K];\n};\n\n/**\n * Given an object `T`, return the keys of that object that are public, ignoring\n * `private` and `protected` keys.\n *\n * This shouldn't commonly be used or exposed in user-facing types, as it can\n * skew extension checks.\n */\nexport type Public<T> = { [K in keyof T]: T[K] };\n\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nexport function isFiniteNumber(value: unknown): value is number {\n  return typeof value === \"number\" && Number.isFinite(value);\n}\n"],"mappings":";;AAgaA,SAAgB,SAAS,OAAkD;AACzE,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,MAAM;;AAG7E,SAAgB,eAAe,OAAiC;AAC9D,QAAO,OAAO,UAAU,YAAY,OAAO,SAAS,MAAM"}

package/helpers/types.js

@@ -2,7 +2,10 @@
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
 
 //#endregion
-export { isRecord };
+export { isFiniteNumber, isRecord };
 //# sourceMappingURL=types.js.map