@vercel/oidc 3.1.0 → 3.2.1

package/dist/token-util.test.js

@@ -25,12 +25,13 @@ var import_vitest = require("vitest");
 var import_token_util = require("./token-util");
 var authConfig = __toESM(require("./auth-config"));
 var oauth = __toESM(require("./oauth"));
+var import_auth_errors = require("./auth-errors");
 import_vitest.vi.mock("fs");
 import_vitest.vi.mock("./token-io", () => ({
   getUserDataDir: import_vitest.vi.fn(() => "/mock/user/data"),
   findRootDir: import_vitest.vi.fn(() => "/mock/root")
 }));
-(0, import_vitest.describe)("getVercelCliToken", () => {
+(0, import_vitest.describe)("getVercelToken", () => {
   (0, import_vitest.beforeEach)(() => {
     import_vitest.vi.clearAllMocks();
   });
@@ -47,14 +48,13 @@ import_vitest.vi.mock("./token-io", () => ({
     import_vitest.vi.spyOn(authConfig, "readAuthConfig").mockReturnValue(validToken);
     import_vitest.vi.spyOn(authConfig, "writeAuthConfig").mockImplementation(() => {
     });
-    const token = await (0, import_token_util.getVercelCliToken)();
+    const token = await (0, import_token_util.getVercelToken)();
     (0, import_vitest.expect)(token).toBe("valid-access-token");
     (0, import_vitest.expect)(authConfig.writeAuthConfig).not.toHaveBeenCalled();
   });
-  (0, import_vitest.it)("should return null if auth config does not exist", async () => {
+  (0, import_vitest.it)("should throw AccessTokenMissingError if auth config does not exist", async () => {
     import_vitest.vi.spyOn(authConfig, "readAuthConfig").mockReturnValue(null);
-    const token = await (0, import_token_util.getVercelCliToken)();
-    (0, import_vitest.expect)(token).toBeNull();
+    await (0, import_vitest.expect)((0, import_token_util.getVercelToken)()).rejects.toThrow(import_auth_errors.AccessTokenMissingError);
   });
   (0, import_vitest.it)("should refresh token if expired and refresh token exists", async () => {
     const expiredToken = {
@@ -76,7 +76,7 @@ import_vitest.vi.mock("./token-io", () => ({
     import_vitest.vi.spyOn(authConfig, "writeAuthConfig").mockImplementation(() => {
     });
     import_vitest.vi.spyOn(oauth, "refreshTokenRequest").mockResolvedValue(mockResponse);
-    const token = await (0, import_token_util.getVercelCliToken)();
+    const token = await (0, import_token_util.getVercelToken)();
     (0, import_vitest.expect)(token).toBe("new-access-token");
     (0, import_vitest.expect)(oauth.refreshTokenRequest).toHaveBeenCalledWith({
       refresh_token: "valid-refresh-token"
@@ -89,7 +89,7 @@ import_vitest.vi.mock("./token-io", () => ({
       })
     );
   });
-  (0, import_vitest.it)("should clear auth and return null if token expired and no refresh token", async () => {
+  (0, import_vitest.it)("should clear auth and throw RefreshAccessTokenFailedError if token expired and no refresh token", async () => {
     const expiredTokenNoRefresh = {
       token: "expired-access-token",
       expiresAt: Math.floor(Date.now() / 1e3) - 3600
@@ -99,11 +99,12 @@ import_vitest.vi.mock("./token-io", () => ({
     );
     import_vitest.vi.spyOn(authConfig, "writeAuthConfig").mockImplementation(() => {
     });
-    const token = await (0, import_token_util.getVercelCliToken)();
-    (0, import_vitest.expect)(token).toBeNull();
+    await (0, import_vitest.expect)((0, import_token_util.getVercelToken)()).rejects.toThrow(
+      import_auth_errors.RefreshAccessTokenFailedError
+    );
     (0, import_vitest.expect)(authConfig.writeAuthConfig).toHaveBeenCalledWith({});
   });
-  (0, import_vitest.it)("should clear auth if refresh fails with OAuth error", async () => {
+  (0, import_vitest.it)("should clear auth and throw RefreshAccessTokenFailedError if refresh fails with OAuth error", async () => {
     const expiredToken = {
       token: "expired-access-token",
       refreshToken: "invalid-refresh-token",
@@ -120,11 +121,12 @@ import_vitest.vi.mock("./token-io", () => ({
     import_vitest.vi.spyOn(authConfig, "writeAuthConfig").mockImplementation(() => {
     });
     import_vitest.vi.spyOn(oauth, "refreshTokenRequest").mockResolvedValue(mockErrorResponse);
-    const token = await (0, import_token_util.getVercelCliToken)();
-    (0, import_vitest.expect)(token).toBeNull();
+    await (0, import_vitest.expect)((0, import_token_util.getVercelToken)()).rejects.toThrow(
+      import_auth_errors.RefreshAccessTokenFailedError
+    );
     (0, import_vitest.expect)(authConfig.writeAuthConfig).toHaveBeenCalledWith({});
   });
-  (0, import_vitest.it)("should clear auth if refresh fails with network error", async () => {
+  (0, import_vitest.it)("should clear auth and throw RefreshAccessTokenFailedError if refresh fails with network error", async () => {
     const expiredToken = {
       token: "expired-access-token",
       refreshToken: "valid-refresh-token",
@@ -136,8 +138,9 @@ import_vitest.vi.mock("./token-io", () => ({
     import_vitest.vi.spyOn(oauth, "refreshTokenRequest").mockRejectedValue(
       new Error("Network error")
     );
-    const token = await (0, import_token_util.getVercelCliToken)();
-    (0, import_vitest.expect)(token).toBeNull();
+    await (0, import_vitest.expect)((0, import_token_util.getVercelToken)()).rejects.toThrow(
+      import_auth_errors.RefreshAccessTokenFailedError
+    );
     (0, import_vitest.expect)(authConfig.writeAuthConfig).toHaveBeenCalledWith({});
   });
   (0, import_vitest.it)("should treat token as valid if expiresAt is missing (--token case)", async () => {
@@ -147,7 +150,7 @@ import_vitest.vi.mock("./token-io", () => ({
     import_vitest.vi.spyOn(authConfig, "readAuthConfig").mockReturnValue(tokenWithoutExpiry);
     import_vitest.vi.spyOn(authConfig, "writeAuthConfig").mockImplementation(() => {
     });
-    const token = await (0, import_token_util.getVercelCliToken)();
+    const token = await (0, import_token_util.getVercelToken)();
     (0, import_vitest.expect)(token).toBe("cli-provided-token");
     (0, import_vitest.expect)(authConfig.writeAuthConfig).not.toHaveBeenCalled();
   });
@@ -170,7 +173,7 @@ import_vitest.vi.mock("./token-io", () => ({
     import_vitest.vi.spyOn(authConfig, "writeAuthConfig").mockImplementation(() => {
     });
     import_vitest.vi.spyOn(oauth, "refreshTokenRequest").mockResolvedValue(mockResponse);
-    await (0, import_token_util.getVercelCliToken)();
+    await (0, import_token_util.getVercelToken)();
     (0, import_vitest.expect)(authConfig.writeAuthConfig).toHaveBeenCalledWith(
       import_vitest.expect.objectContaining({
         refreshToken: "new-refresh-token"
@@ -196,7 +199,7 @@ import_vitest.vi.mock("./token-io", () => ({
     import_vitest.vi.spyOn(authConfig, "writeAuthConfig").mockImplementation(() => {
     });
     import_vitest.vi.spyOn(oauth, "refreshTokenRequest").mockResolvedValue(mockResponse);
-    await (0, import_token_util.getVercelCliToken)();
+    await (0, import_token_util.getVercelToken)();
     const writeCall = import_vitest.vi.mocked(authConfig.writeAuthConfig).mock.calls[0][0];
     (0, import_vitest.expect)(writeCall).not.toHaveProperty("refreshToken");
   });
@@ -220,7 +223,7 @@ import_vitest.vi.mock("./token-io", () => ({
     });
     import_vitest.vi.spyOn(oauth, "refreshTokenRequest").mockResolvedValue(mockResponse);
     const beforeCall = Math.floor(Date.now() / 1e3);
-    await (0, import_token_util.getVercelCliToken)();
+    await (0, import_token_util.getVercelToken)();
     const afterCall = Math.floor(Date.now() / 1e3);
     const writeCall = import_vitest.vi.mocked(authConfig.writeAuthConfig).mock.calls[0][0];
     (0, import_vitest.expect)(writeCall.expiresAt).toBeGreaterThanOrEqual(beforeCall + 7200);

package/dist/token.d.ts

@@ -1 +1,19 @@
-export declare function refreshToken(): Promise<void>;
+export interface RefreshTokenOptions {
+    /**
+     * Team ID (team_*) or slug to use for token refresh.
+     * When provided, this team will be used instead of reading from `.vercel/project.json`.
+     */
+    team?: string;
+    /**
+     * Project ID (prj_*) or slug to use for token refresh.
+     * When provided, this project will be used instead of reading from `.vercel/project.json`.
+     */
+    project?: string;
+    /**
+     * Optional time buffer in milliseconds before token expiry to consider it expired.
+     * When provided, the token will be refreshed if it expires within this buffer time.
+     * @default 0
+     */
+    expirationBufferMs?: number;
+}
+export declare function refreshToken(options?: RefreshTokenOptions): Promise<void>;

package/dist/token.js

@@ -23,21 +23,28 @@ __export(token_exports, {
 module.exports = __toCommonJS(token_exports);
 var import_token_error = require("./token-error");
 var import_token_util = require("./token-util");
-async function refreshToken() {
-  const { projectId, teamId } = (0, import_token_util.findProjectInfo)();
+async function refreshToken(options) {
+  let projectId = options?.project;
+  let teamId = options?.team;
+  if (!projectId && !teamId) {
+    const projectInfo = (0, import_token_util.findProjectInfo)();
+    projectId = projectInfo.projectId;
+    teamId = projectInfo.teamId;
+  } else if (!projectId || !teamId) {
+    const projectInfo = (0, import_token_util.findProjectInfo)();
+    projectId = projectId ?? projectInfo.projectId;
+    teamId = teamId ?? projectInfo.teamId;
+  }
+  if (!projectId) {
+    throw new import_token_error.VercelOidcTokenError(
+      "Failed to refresh OIDC token: No project specified. Try re-linking your project with `vc link`"
+    );
+  }
   let maybeToken = (0, import_token_util.loadToken)(projectId);
-  if (!maybeToken || (0, import_token_util.isExpired)((0, import_token_util.getTokenPayload)(maybeToken.token))) {
-    const authToken = await (0, import_token_util.getVercelCliToken)();
-    if (!authToken) {
-      throw new import_token_error.VercelOidcTokenError(
-        "Failed to refresh OIDC token: Log in to Vercel CLI and link your project with `vc link`"
-      );
-    }
-    if (!projectId) {
-      throw new import_token_error.VercelOidcTokenError(
-        "Failed to refresh OIDC token: Try re-linking your project with `vc link`"
-      );
-    }
+  if (!maybeToken || (0, import_token_util.isExpired)((0, import_token_util.getTokenPayload)(maybeToken.token), options?.expirationBufferMs)) {
+    const authToken = await (0, import_token_util.getVercelToken)({
+      expirationBufferMs: options?.expirationBufferMs
+    });
     maybeToken = await (0, import_token_util.getVercelOidcToken)(authToken, projectId, teamId);
     if (!maybeToken) {
       throw new import_token_error.VercelOidcTokenError("Failed to refresh OIDC token");

package/dist/token.test.js

@@ -35,7 +35,7 @@ import_vitest.vi.mock("./token-io");
   let userDataDir;
   let cliDataDir;
   let tokenDataDir;
-  const projectId = "test-project-id";
+  const projectId = "prj_test123";
   (0, import_vitest.beforeEach)(() => {
     import_vitest.vi.clearAllMocks();
     process.env.VERCEL_OIDC_TOKEN = void 0;
@@ -57,7 +57,7 @@ import_vitest.vi.mock("./token-io");
     import_vitest.vi.spyOn(process, "cwd").mockReturnValue(rootDir);
     import_vitest.vi.mocked(import_token_io.findRootDir).mockReturnValue(rootDir);
     import_vitest.vi.mocked(import_token_io.getUserDataDir).mockReturnValue(userDataDir);
-    import_vitest.vi.spyOn(tokenUtil, "getVercelCliToken").mockResolvedValue("test");
+    import_vitest.vi.spyOn(tokenUtil, "getVercelToken").mockResolvedValue("test");
     import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken").mockResolvedValue({
       token: "test-token"
     });
@@ -81,4 +81,110 @@ import_vitest.vi.mock("./token-io");
     const token = JSON.parse(fs.readFileSync(tokenPath, "utf8"));
     (0, import_vitest.expect)(token).toEqual({ token: "test-token" });
   });
+  (0, import_vitest.test)("should use provided team and project instead of reading project.json", async () => {
+    const customProjectId = "prj_custom123";
+    const customTeamId = "team_custom456";
+    const getVercelOidcTokenSpy = import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken");
+    const findRootDirSpy = import_vitest.vi.mocked(import_token_io.findRootDir);
+    await (0, import_token.refreshToken)({ team: customTeamId, project: customProjectId });
+    (0, import_vitest.expect)(findRootDirSpy).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(getVercelOidcTokenSpy).toHaveBeenCalledWith(
+      "test",
+      customProjectId,
+      customTeamId
+    );
+    const tokenPath = path.join(tokenDataDir, `${customProjectId}.json`);
+    (0, import_vitest.expect)(fs.existsSync(tokenPath)).toBe(true);
+    const savedToken = JSON.parse(fs.readFileSync(tokenPath, "utf8"));
+    (0, import_vitest.expect)(savedToken).toEqual({ token: "test-token" });
+  });
+  (0, import_vitest.test)("should merge provided project with team from project.json", async () => {
+    const customProjectId = "prj_custom234";
+    const projectTeamId = "team_fromproject567";
+    fs.writeFileSync(
+      path.join(rootDir, ".vercel", "project.json"),
+      JSON.stringify({ projectId, orgId: projectTeamId })
+    );
+    const getVercelOidcTokenSpy = import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken");
+    await (0, import_token.refreshToken)({ project: customProjectId });
+    (0, import_vitest.expect)(getVercelOidcTokenSpy).toHaveBeenCalledWith(
+      "test",
+      customProjectId,
+      projectTeamId
+    );
+  });
+  (0, import_vitest.test)("should merge provided team with project from project.json", async () => {
+    const customTeamId = "team_custom789";
+    const projectProjectId = "prj_fromjson123";
+    fs.writeFileSync(
+      path.join(rootDir, ".vercel", "project.json"),
+      JSON.stringify({ projectId: projectProjectId, orgId: "original-team" })
+    );
+    const getVercelOidcTokenSpy = import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken");
+    await (0, import_token.refreshToken)({ team: customTeamId });
+    (0, import_vitest.expect)(getVercelOidcTokenSpy).toHaveBeenCalledWith(
+      "test",
+      projectProjectId,
+      customTeamId
+    );
+  });
+  (0, import_vitest.test)("should use cached token when valid with custom project", async () => {
+    const customProjectId = "prj_customcached123";
+    const customTeamId = "team_customcached456";
+    const cachedToken = { token: "cached-valid-token" };
+    const tokenPath = path.join(tokenDataDir, `${customProjectId}.json`);
+    fs.writeFileSync(tokenPath, JSON.stringify(cachedToken));
+    const getVercelOidcTokenSpy = import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken");
+    await (0, import_token.refreshToken)({ team: customTeamId, project: customProjectId });
+    (0, import_vitest.expect)(getVercelOidcTokenSpy).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(process.env.VERCEL_OIDC_TOKEN).toBe("cached-valid-token");
+  });
+  (0, import_vitest.test)("should refresh token when cached token expires within buffer", async () => {
+    const customProjectId = "prj_buffertest123";
+    const customTeamId = "team_buffertest456";
+    const cachedToken = { token: "expiring-soon-token" };
+    const tokenPath = path.join(tokenDataDir, `${customProjectId}.json`);
+    fs.writeFileSync(tokenPath, JSON.stringify(cachedToken));
+    const expiresIn3Minutes = Math.floor((Date.now() + 18e4) / 1e3);
+    import_vitest.vi.spyOn(tokenUtil, "getTokenPayload").mockReturnValue({
+      sub: "test-sub",
+      name: "test-name",
+      exp: expiresIn3Minutes
+    });
+    const getVercelOidcTokenSpy = import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken").mockResolvedValue({ token: "fresh-token" });
+    await (0, import_token.refreshToken)({
+      team: customTeamId,
+      project: customProjectId,
+      expirationBufferMs: 3e5
+    });
+    (0, import_vitest.expect)(getVercelOidcTokenSpy).toHaveBeenCalledWith(
+      "test",
+      customProjectId,
+      customTeamId
+    );
+    (0, import_vitest.expect)(process.env.VERCEL_OIDC_TOKEN).toBe("fresh-token");
+    const savedToken = JSON.parse(fs.readFileSync(tokenPath, "utf8"));
+    (0, import_vitest.expect)(savedToken).toEqual({ token: "fresh-token" });
+  });
+  (0, import_vitest.test)("should use cached token when it does not expire within buffer", async () => {
+    const customProjectId = "prj_buffervalid123";
+    const customTeamId = "team_buffervalid456";
+    const cachedToken = { token: "valid-cached-token" };
+    const tokenPath = path.join(tokenDataDir, `${customProjectId}.json`);
+    fs.writeFileSync(tokenPath, JSON.stringify(cachedToken));
+    const expiresIn10Minutes = Math.floor((Date.now() + 6e5) / 1e3);
+    import_vitest.vi.spyOn(tokenUtil, "getTokenPayload").mockReturnValue({
+      sub: "test-sub",
+      name: "test-name",
+      exp: expiresIn10Minutes
+    });
+    const getVercelOidcTokenSpy = import_vitest.vi.spyOn(tokenUtil, "getVercelOidcToken");
+    await (0, import_token.refreshToken)({
+      team: customTeamId,
+      project: customProjectId,
+      expirationBufferMs: 3e5
+    });
+    (0, import_vitest.expect)(getVercelOidcTokenSpy).not.toHaveBeenCalled();
+    (0, import_vitest.expect)(process.env.VERCEL_OIDC_TOKEN).toBe("valid-cached-token");
+  });
 });

package/docs/README.md

@@ -2,11 +2,17 @@
 
 ## Table of contents
 
+### Classes
+
+- [AccessTokenMissingError](classes/AccessTokenMissingError.md)
+- [RefreshAccessTokenFailedError](classes/RefreshAccessTokenFailedError.md)
+
 ### Functions
 
 - [getContext](README.md#getcontext)
 - [getVercelOidcToken](README.md#getverceloidctoken)
 - [getVercelOidcTokenSync](README.md#getverceloidctokensync)
+- [getVercelToken](README.md#getverceltoken)
 
 ## Functions
 
@@ -20,13 +26,13 @@
 
 #### Defined in
 
-[get-context.ts:7](https://github.com/vercel/vercel/blob/main/packages/oidc/src/get-context.ts#L7)
+[packages/oidc/src/get-context.ts:7](https://github.com/vercel/vercel/blob/main/packages/oidc/src/get-context.ts#L7)
 
 ---
 
 ### getVercelOidcToken
 
-▸ **getVercelOidcToken**(): [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)<`string`\>
+▸ **getVercelOidcToken**(`options?`): [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)<`string`\>
 
 Gets the current OIDC token from the request context or the environment variable.
 
@@ -56,6 +62,25 @@ getVercelOidcToken()
   });
 ```
 
+**`Example`**
+
+```js
+// Using the OIDC token with explicit team and project (supports IDs and slugs)
+getVercelOidcToken({ team: 'my-team', project: 'my-project' })
+  .then(token => {
+    console.log('OIDC Token:', token);
+  })
+  .catch(error => {
+    console.error('Error:', error.message);
+  });
+```
+
+#### Parameters
+
+| Name       | Type                        | Description                                 |
+| :--------- | :-------------------------- | :------------------------------------------ |
+| `options?` | `GetVercelOidcTokenOptions` | Optional configuration for token retrieval. |
+
 #### Returns
 
 [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)<`string`\>
@@ -64,7 +89,7 @@ A promise that resolves to the OIDC token.
 
 #### Defined in
 
-[get-vercel-oidc-token.ts:30](https://github.com/vercel/vercel/blob/main/packages/oidc/src/get-vercel-oidc-token.ts#L30)
+[packages/oidc/src/get-vercel-oidc-token.ts:64](https://github.com/vercel/vercel/blob/main/packages/oidc/src/get-vercel-oidc-token.ts#L64)
 
 ---
 
@@ -101,4 +126,24 @@ The OIDC token.
 
 #### Defined in
 
-[get-vercel-oidc-token.ts:85](https://github.com/vercel/vercel/blob/main/packages/oidc/src/get-vercel-oidc-token.ts#L85)
+[packages/oidc/src/get-vercel-oidc-token.ts:124](https://github.com/vercel/vercel/blob/main/packages/oidc/src/get-vercel-oidc-token.ts#L124)
+
+---
+
+### getVercelToken
+
+▸ **getVercelToken**(`options?`): [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)<`string`\>
+
+#### Parameters
+
+| Name       | Type                    |
+| :--------- | :---------------------- |
+| `options?` | `GetVercelTokenOptions` |
+
+#### Returns
+
+[`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)<`string`\>
+
+#### Defined in
+
+[packages/oidc/src/token-util.ts:35](https://github.com/vercel/vercel/blob/main/packages/oidc/src/token-util.ts#L35)

package/docs/classes/AccessTokenMissingError.md

@@ -0,0 +1,160 @@
+# Class: AccessTokenMissingError
+
+Error thrown when no authentication configuration is found.
+This typically means the user needs to log in.
+
+## Hierarchy
+
+- [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+
+  ↳ **`AccessTokenMissingError`**
+
+## Table of contents
+
+### Constructors
+
+- [constructor](AccessTokenMissingError.md#constructor)
+
+### Properties
+
+- [message](AccessTokenMissingError.md#message)
+- [name](AccessTokenMissingError.md#name)
+- [stack](AccessTokenMissingError.md#stack)
+- [prepareStackTrace](AccessTokenMissingError.md#preparestacktrace)
+- [stackTraceLimit](AccessTokenMissingError.md#stacktracelimit)
+
+### Methods
+
+- [captureStackTrace](AccessTokenMissingError.md#capturestacktrace)
+
+## Constructors
+
+### constructor
+
+• **new AccessTokenMissingError**()
+
+#### Overrides
+
+Error.constructor
+
+#### Defined in
+
+[packages/oidc/src/auth-errors.ts:7](https://github.com/vercel/vercel/blob/main/packages/oidc/src/auth-errors.ts#L7)
+
+## Properties
+
+### message
+
+• **message**: `string`
+
+#### Inherited from
+
+Error.message
+
+#### Defined in
+
+node_modules/.pnpm/typescript@4.9.5/node_modules/typescript/lib/lib.es5.d.ts:1054
+
+---
+
+### name
+
+• **name**: `string` = `'AccessTokenMissingError'`
+
+#### Overrides
+
+Error.name
+
+#### Defined in
+
+[packages/oidc/src/auth-errors.ts:6](https://github.com/vercel/vercel/blob/main/packages/oidc/src/auth-errors.ts#L6)
+
+---
+
+### stack
+
+• `Optional` **stack**: `string`
+
+#### Inherited from
+
+Error.stack
+
+#### Defined in
+
+node_modules/.pnpm/typescript@4.9.5/node_modules/typescript/lib/lib.es5.d.ts:1055
+
+---
+
+### prepareStackTrace
+
+▪ `Static` `Optional` **prepareStackTrace**: (`err`: [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error), `stackTraces`: `CallSite`[]) => `any`
+
+#### Type declaration
+
+▸ (`err`, `stackTraces`): `any`
+
+Optional override for formatting stack traces
+
+**`See`**
+
+https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+
+##### Parameters
+
+| Name          | Type                                                                                              |
+| :------------ | :------------------------------------------------------------------------------------------------ |
+| `err`         | [`Error`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) |
+| `stackTraces` | `CallSite`[]                                                                                      |
+
+##### Returns
+
+`any`
+
+#### Inherited from
+
+Error.prepareStackTrace
+
+#### Defined in
+
+node_modules/.pnpm/@types+node@20.11.0/node_modules/@types/node/globals.d.ts:28
+
+---
+
+### stackTraceLimit
+
+▪ `Static` **stackTraceLimit**: `number`
+
+#### Inherited from
+
+Error.stackTraceLimit
+
+#### Defined in
+
+node_modules/.pnpm/@types+node@20.11.0/node_modules/@types/node/globals.d.ts:30
+
+## Methods
+
+### captureStackTrace
+
+▸ `Static` **captureStackTrace**(`targetObject`, `constructorOpt?`): `void`
+
+Create .stack property on a target object
+
+#### Parameters
+
+| Name              | Type                                                                                                    |
+| :---------------- | :------------------------------------------------------------------------------------------------------ |
+| `targetObject`    | `object`                                                                                                |
+| `constructorOpt?` | [`Function`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function) |
+
+#### Returns
+
+`void`
+
+#### Inherited from
+
+Error.captureStackTrace
+
+#### Defined in
+
+node_modules/.pnpm/@types+node@20.11.0/node_modules/@types/node/globals.d.ts:21