diff --git a/.changeset/tidy-beans-smile.md b/.changeset/tidy-beans-smile.md
new file mode 100644
index 00000000000..627d1d9ef34
--- /dev/null
+++ b/.changeset/tidy-beans-smile.md
@@ -0,0 +1,5 @@
+---
+'react-docgen': patch
+---
+
+Support Babel 8 dependency overrides for parsing and traversal, including TypeScript generic props, inherited interfaces, function types, and mapped types. Preserve Babel 7 compatibility.
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index a6a023e8df2..e56fd706e21 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -15,16 +15,35 @@ env:
 jobs:
   tests:
     strategy:
+      fail-fast: false
       matrix:
-        node: ["20.9.0", "22", "24", "25"]
-        os: ["ubuntu"]
+        babel: ['7', '8']
+        node: ['20.9.0', '22', '24', '25']
+        os: ['ubuntu']
+        exclude:
+          # Keep Node.js 20 support for Babel 7; Babel 8 requires a newer Node.js.
+          - babel: '8'
+            node: '20.9.0'
         include:
+          - os: ubuntu
+            node: '22.18.0'
+            babel: '8'
           - os: macos
-            node: "24"
+            node: '24'
+            babel: '7'
+          - os: macos
+            node: '24'
+            babel: '8'
+          - os: windows
+            node: '24'
+            babel: '7'
           - os: windows
-            node: "24"
+            node: '24'
+            babel: '8'
 
-    name: Tests (Node.js v${{ matrix.node }}, ${{ matrix.os }})
+    name:
+      Tests (Babel ${{ matrix.babel }}, Node.js v${{ matrix.node }}, ${{
+      matrix.os }})
     runs-on: ${{ matrix.os }}-latest
 
     steps:
@@ -38,26 +57,43 @@ jobs:
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6
         with:
           node-version: ${{ matrix.node }}
-          cache: "pnpm"
+          cache: 'pnpm'
 
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
+      # Compile against the declared Babel 7 types before testing each runtime.
+      - name: Build packages
+        run: pnpm build
+
+      - name: Install Babel 8 runtime
+        if: "${{ matrix.babel == '8' }}"
+        run:
+          pnpm --filter react-docgen add --save-exact @babel/core@8.0.1
+          @babel/traverse@8.0.4 @babel/types@8.0.4
+
+      - name: Check consumer declarations
+        run: pnpm --filter react-docgen exec tsc -p tests/types/tsconfig.json
+
       - name: Unit tests with coverage
-        if: "${{ matrix.node == env.NODE_VERSION }}"
-        run: pnpm test -- --coverage
+        if: '${{ matrix.node == env.NODE_VERSION }}'
+        run:
+          pnpm --filter react-docgen --filter @react-docgen/cli --parallel
+          --no-bail test --coverage
 
       - name: Unit tests
-        if: "${{ matrix.node != env.NODE_VERSION }}"
-        run: pnpm test
+        if: '${{ matrix.node != env.NODE_VERSION }}'
+        run:
+          pnpm --filter react-docgen --filter @react-docgen/cli --parallel
+          --no-bail test
 
       - name: Upload coverage
-        if: "${{ matrix.node == env.NODE_VERSION }}"
+        if: '${{ matrix.node == env.NODE_VERSION }}'
         continue-on-error: true
         uses: coverallsapp/github-action@5cbfd81b66ca5d10c19b062c04de0199c215fb6e # v2
         with:
           parallel: true
-          flag-name: test-${{ matrix.os }}
+          flag-name: test-babel-${{ matrix.babel }}-${{ matrix.os }}
 
   finish:
     needs: tests
@@ -85,7 +121,7 @@ jobs:
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6
         with:
           node-version: lts/*
-          cache: "pnpm"
+          cache: 'pnpm'
 
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
@@ -108,7 +144,7 @@ jobs:
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6
         with:
           node-version: lts/*
-          cache: "pnpm"
+          cache: 'pnpm'
 
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7b34655b005..919841b8444 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,25 +1,54 @@
 # Contributing to react-docgen
+
 We want to make contributing to this project as easy and transparent as
 possible.
 
 ## Our Development Process
-The majority of development on react-docgen will occur through GitHub. Accordingly,
-the process for contributing will follow standard GitHub protocol.
+
+The majority of development on react-docgen will occur through GitHub.
+Accordingly, the process for contributing will follow standard GitHub protocol.
 
 ## Pull Requests
+
 We actively welcome your pull requests.
+
 1. Fork the repo and create your branch from `main`.
 2. If you've added code that should be tested, add tests
 3. If you've changed APIs, update the documentation.
 4. Ensure the test suite passes.
 5. Make sure your code lints and typechecks.
 
+## Babel compatibility tests
+
+CI runs all library and CLI tests separately with Babel 7 and Babel 8. Both runs
+build with the declared Babel 7 dependencies first. The Babel 8 run then
+replaces the runtime dependencies, including those used by CLI subprocesses.
+This checks runtime compatibility, not compilation with Babel 8 types.
+
+To reproduce the Babel 8 run in a clean checkout:
+
+Use Node.js 22.18.0 or newer on the 22.x line, or Node.js 24.11.0 or newer.
+
+```sh
+pnpm install --frozen-lockfile
+pnpm build
+pnpm --filter react-docgen add --save-exact @babel/core@8.0.1 @babel/traverse@8.0.4 @babel/types@8.0.4
+pnpm --filter react-docgen --filter @react-docgen/cli --parallel --no-bail test --coverage
+```
+
+The install command changes `packages/react-docgen/package.json` and
+`pnpm-lock.yaml`. After testing, restore those two files and run
+`pnpm install --frozen-lockfile` to return to Babel 7.
+
 ## Issues
+
 We use GitHub issues to track public bugs. Please ensure your description is
 clear and has sufficient instructions to be able to reproduce the issue.
 
 ## License
-react-docgen is [MIT licensed](https://github.com/reactjs/react-docgen/blob/master/LICENSE).
 
-By contributing to react-docgen, you agree that your contributions will be licensed
-under its MIT license.
+react-docgen is
+[MIT licensed](https://github.com/reactjs/react-docgen/blob/master/LICENSE).
+
+By contributing to react-docgen, you agree that your contributions will be
+licensed under its MIT license.
diff --git a/packages/react-docgen-cli/tests/integration/utils/withFixture.ts b/packages/react-docgen-cli/tests/integration/utils/withFixture.ts
index 73b8fd3c042..7e7780e19e8 100644
--- a/packages/react-docgen-cli/tests/integration/utils/withFixture.ts
+++ b/packages/react-docgen-cli/tests/integration/utils/withFixture.ts
@@ -24,6 +24,8 @@ export default async function withFixture(
   async function run(args: readonly string[]) {
     return execaNode(cliBinary, args, {
       cwd: tempDir,
+      // Pinned browser data ages independently of the CLI behavior under test.
+      env: { BROWSERSLIST_IGNORE_OLD_DATA: 'true' },
       lines: false,
       reject: false,
     });
diff --git a/packages/react-docgen/package.json b/packages/react-docgen/package.json
index 493c1f129ed..16114d780c1 100644
--- a/packages/react-docgen/package.json
+++ b/packages/react-docgen/package.json
@@ -44,6 +44,7 @@
     "@babel/types": "^7.28.2",
     "@types/babel__core": "^7.20.5",
     "@types/babel__traverse": "^7.20.7",
+    "@types/convert-source-map": "^2.0.3",
     "@types/doctrine": "^0.0.9",
     "@types/resolve": "^1.20.2",
     "doctrine": "^3.0.0",
diff --git a/packages/react-docgen/src/FileState.ts b/packages/react-docgen/src/FileState.ts
index 239a533e673..e08370f8dd8 100644
--- a/packages/react-docgen/src/FileState.ts
+++ b/packages/react-docgen/src/FileState.ts
@@ -3,13 +3,13 @@ import babelTraverse, { NodePath } from '@babel/traverse';
 import type { File, Node, Program } from '@babel/types';
 import type { Importer, ImportPath } from './importer/index.js';
 import babelParse from './babelParser.js';
-import type { TransformOptions } from '@babel/core';
+import type { Config } from './config.js';
 
 // Workaround while babel is not a proper ES module
 const traverse = babelTraverse.default ?? (babelTraverse as never);
 
 export default class FileState {
-  opts: TransformOptions;
+  opts: NonNullable<Config['babelOptions']>;
   path: NodePath<Program>;
   ast: File;
   scope: Scope;
@@ -39,7 +39,7 @@ export default class FileState {
   };
 
   constructor(
-    options: TransformOptions,
+    options: NonNullable<Config['babelOptions']>,
     { code, ast, importer }: { code: string; ast: File; importer: Importer },
   ) {
     this.opts = options;
diff --git a/packages/react-docgen/src/__tests__/parserCompatibility-test.ts b/packages/react-docgen/src/__tests__/parserCompatibility-test.ts
new file mode 100644
index 00000000000..c7e91239747
--- /dev/null
+++ b/packages/react-docgen/src/__tests__/parserCompatibility-test.ts
@@ -0,0 +1,139 @@
+import { version } from '@babel/core';
+import { parse } from '../main.js';
+import { expect, test } from 'vitest';
+
+test('parses components', () => {
+  const result = parse('export function Button() { return <button />; }');
+
+  expect(result).toHaveLength(1);
+});
+
+test('parses TypeScript function props', () => {
+  const result = parse(
+    `export type MenuProps = {
+      onOpenChange?: (open: boolean) => void;
+    };
+
+    export function Menu(_props: MenuProps) {
+      return <div />;
+    }`,
+    { filename: 'index.tsx' },
+  );
+
+  expect(result[0]?.props?.onOpenChange?.tsType).toEqual({
+    name: 'signature',
+    type: 'function',
+    raw: '(open: boolean) => void',
+    signature: {
+      arguments: [
+        {
+          name: 'open',
+          type: { name: 'boolean' },
+        },
+      ],
+      return: { name: 'void' },
+    },
+  });
+});
+
+test('parses generic arrow functions in TypeScript files', () => {
+  const result = parse(
+    `import React from 'react';
+
+    export const mockDomain = <Entity>(
+      entities: Record<string, Entity> = {},
+    ) => ({ entities });
+
+    export function Button() {
+      return React.createElement('button');
+    }`,
+    { filename: 'store.ts' },
+  );
+
+  expect(result).toHaveLength(1);
+});
+
+test('parses mapped TypeScript props', () => {
+  const result = parse(
+    `export type StatusFiltersProps<K extends string = string> = {
+      statuses?: { readonly [Key in K]: number };
+    };
+
+    export function StatusFilters<K extends string = string>(
+      _props: StatusFiltersProps<K>,
+    ) {
+      return <div />;
+    }`,
+    { filename: 'index.tsx' },
+  );
+
+  expect(result[0]?.props?.statuses?.tsType).toMatchObject({
+    name: 'signature',
+    type: 'object',
+  });
+});
+
+// Babel 7 has historically accepted JSX in every TypeScript extension.
+test.skipIf(Number.parseInt(version, 10) >= 8).each(['ts', 'cts', 'mts'])(
+  'preserves Babel 7 JSX parsing in .%s files',
+  (extension) => {
+    const result = parse('export function Button() { return <button />; }', {
+      filename: `component.${extension}`,
+    });
+
+    expect(result[0]?.displayName).toBe('Button');
+  },
+);
+
+test('preserves nested TypeScript method return types', () => {
+  const result = parse(
+    `interface Props {
+      config: { run(value: string): number; stop?(): void };
+    }
+
+    export function Button(_props: Props) { return <button />; }`,
+    { filename: 'component.tsx' },
+  );
+
+  expect(result[0]?.props?.config?.tsType).toMatchObject({
+    signature: {
+      properties: [
+        { key: 'run', value: { name: 'number', required: true } },
+        { key: 'stop', value: { name: 'void', required: false } },
+      ],
+    },
+  });
+});
+
+test.each(['`size-${number}`', '`row-${number}-${string}`'])(
+  'preserves the template literal type %s',
+  (type) => {
+    const result = parse(
+      `interface Props { value: ${type} }
+      export function Button(_props: Props) { return <button />; }`,
+      { filename: 'component.tsx' },
+    );
+
+    expect(result[0]?.props?.value?.tsType).toEqual({
+      name: 'literal',
+      value: type,
+    });
+  },
+);
+
+test.each([undefined, true])(
+  'marks dynamic import defaults as computed (createImportExpressions: %s)',
+  (createImportExpressions) => {
+    const result = parse(
+      `export function Button({ lazy = import('./thing.js') }) {
+        return <button />;
+      }`,
+      { babelOptions: { parserOpts: { createImportExpressions } } },
+    );
+
+    expect(result[0]?.props?.lazy?.defaultValue).toEqual({
+      value: "import('./thing.js')",
+      computed: true,
+    });
+  },
+);
diff --git a/packages/react-docgen/src/babelParser.ts b/packages/react-docgen/src/babelParser.ts
index 8c323c5a99c..ddffc4aac6a 100644
--- a/packages/react-docgen/src/babelParser.ts
+++ b/packages/react-docgen/src/babelParser.ts
@@ -1,38 +1,67 @@
-import type { ParserOptions, TransformOptions } from '@babel/core';
-import { loadPartialConfig, parseSync } from '@babel/core';
+import type { ParserOptions } from '@babel/core';
+import type { Config } from './config.js';
+import * as babel from '@babel/core';
 import type { File } from '@babel/types';
 import { extname } from 'path';
 
+type BabelOptions = NonNullable<Config['babelOptions']>;
+
 const TYPESCRIPT_EXTS = new Set(['.cts', '.mts', '.ts', '.tsx']);
+const { parseSync, version } = babel;
+// Babel 7 exports this at runtime, but its DefinitelyTyped definitions omit it.
+const loadPartialConfigSync = (
+  babel as typeof babel & {
+    loadPartialConfigSync: typeof babel.loadPartialConfig;
+  }
+).loadPartialConfigSync;
+const IS_BABEL_8 = Number.parseInt(version, 10) >= 8;
 
 function getDefaultPlugins(
-  options: TransformOptions,
+  options: BabelOptions,
 ): NonNullable<ParserOptions['plugins']> {
-  return [
-    'jsx',
-    options.filename && TYPESCRIPT_EXTS.has(extname(options.filename))
-      ? 'typescript'
-      : 'flow',
+  const extension = options.filename ? extname(options.filename) : '';
+  const isTypeScript = TYPESCRIPT_EXTS.has(extension);
+  const plugins: NonNullable<ParserOptions['plugins']> = [
+    ...(IS_BABEL_8 && isTypeScript && extension !== '.tsx'
+      ? []
+      : ['jsx' as const]),
+    isTypeScript ? 'typescript' : 'flow',
     'asyncDoExpressions',
-    'decimal',
+  ];
+
+  if (!IS_BABEL_8) {
+    plugins.push('decimal');
+  }
+
+  plugins.push(
     ['decorators', { decoratorsBeforeExport: false }],
     'decoratorAutoAccessors',
     'destructuringPrivate',
     'doExpressions',
     'exportDefaultFrom',
     'functionBind',
-    'importAssertions',
-    'moduleBlocks',
-    'partialApplication',
-    ['pipelineOperator', { proposal: 'minimal' }],
-    ['recordAndTuple', { syntaxType: 'bar' }],
-    'regexpUnicodeSets',
-    'throwExpressions',
-  ];
+  );
+
+  if (!IS_BABEL_8) {
+    plugins.push('importAssertions');
+  }
+
+  plugins.push('moduleBlocks', 'partialApplication', [
+    'pipelineOperator',
+    { proposal: IS_BABEL_8 ? 'fsharp' : 'minimal' },
+  ]);
+
+  if (!IS_BABEL_8) {
+    plugins.push(['recordAndTuple', { syntaxType: 'bar' }]);
+  }
+
+  plugins.push('regexpUnicodeSets', 'throwExpressions');
+
+  return plugins;
 }
 
 function buildPluginList(
-  options: TransformOptions,
+  options: BabelOptions,
 ): NonNullable<ParserOptions['plugins']> {
   let plugins: NonNullable<ParserOptions['plugins']> = [];
 
@@ -42,7 +71,7 @@ function buildPluginList(
 
   // Let's check if babel finds a config file for this source file
   // If babel does find a config file we do not apply our defaults
-  const partialConfig = loadPartialConfig(options);
+  const partialConfig = loadPartialConfigSync(options);
 
   if (
     plugins.length === 0 &&
@@ -57,7 +86,7 @@ function buildPluginList(
   return plugins.filter((plugin) => plugin !== 'estree');
 }
 
-function buildParserOptions(options: TransformOptions): ParserOptions {
+function buildParserOptions(options: BabelOptions): ParserOptions {
   const plugins = buildPluginList(options);
 
   return {
@@ -70,10 +99,10 @@ function buildParserOptions(options: TransformOptions): ParserOptions {
 
 export default function babelParser(
   src: string,
-  options: TransformOptions = {},
+  options: BabelOptions = {},
 ): File {
   const parserOpts = buildParserOptions(options);
-  const opts: TransformOptions = {
+  const opts: BabelOptions = {
     ...options,
     parserOpts,
   };
diff --git a/packages/react-docgen/src/config.ts b/packages/react-docgen/src/config.ts
index 19eb6263210..bcf679e2679 100644
--- a/packages/react-docgen/src/config.ts
+++ b/packages/react-docgen/src/config.ts
@@ -1,4 +1,4 @@
-import type { TransformOptions } from '@babel/core';
+import type { parseSync } from '@babel/core';
 import type { Handler } from './handlers/index.js';
 import {
   childContextTypeHandler,
@@ -32,7 +32,7 @@ export interface Config {
    * to an relative path that is relative to the `babelOptions.cwd`.
    */
   filename?: string;
-  babelOptions?: TransformOptions;
+  babelOptions?: NonNullable<Parameters<typeof parseSync>[1]>;
 }
 export type InternalConfig = Omit<Required<Config>, 'filename'>;
 
diff --git a/packages/react-docgen/src/handlers/codeTypeHandler.ts b/packages/react-docgen/src/handlers/codeTypeHandler.ts
index 75310b4b3d8..b1980baa0c0 100644
--- a/packages/react-docgen/src/handlers/codeTypeHandler.ts
+++ b/packages/react-docgen/src/handlers/codeTypeHandler.ts
@@ -55,7 +55,9 @@ function setPropDescriptor(
         },
         typeParams,
       );
-    } else if (!argument.has('typeParameters')) {
+    } else if (
+      !('typeParameters' in argument.node && argument.node.typeParameters)
+    ) {
       documentation.addComposes(id.node.name);
     }
   } else if (path.isObjectTypeProperty()) {
diff --git a/packages/react-docgen/src/handlers/defaultPropsHandler.ts b/packages/react-docgen/src/handlers/defaultPropsHandler.ts
index ccf515b9d02..19d5dfc0e77 100644
--- a/packages/react-docgen/src/handlers/defaultPropsHandler.ts
+++ b/packages/react-docgen/src/handlers/defaultPropsHandler.ts
@@ -51,6 +51,7 @@ function getDefaultValue(path: NodePath): DefaultValueDescriptor | null {
       value: defaultValue,
       computed:
         valuePath.isCallExpression() ||
+        valuePath.isImportExpression() ||
         valuePath.isMemberExpression() ||
         valuePath.isIdentifier(),
     };
diff --git a/packages/react-docgen/src/handlers/displayNameHandler.ts b/packages/react-docgen/src/handlers/displayNameHandler.ts
index 09501b80eba..5f1394d2737 100644
--- a/packages/react-docgen/src/handlers/displayNameHandler.ts
+++ b/packages/react-docgen/src/handlers/displayNameHandler.ts
@@ -24,7 +24,7 @@ const displayNameHandler: Handler = function (
     if (
       (componentDefinition.isClassDeclaration() ||
         componentDefinition.isFunctionDeclaration()) &&
-      componentDefinition.has('id')
+      componentDefinition.node.id
     ) {
       documentation.set(
         'displayName',
diff --git a/packages/react-docgen/src/importer/makeFsImporter.ts b/packages/react-docgen/src/importer/makeFsImporter.ts
index bbd8b0cdf50..417690422f9 100644
--- a/packages/react-docgen/src/importer/makeFsImporter.ts
+++ b/packages/react-docgen/src/importer/makeFsImporter.ts
@@ -196,13 +196,14 @@ export default function makeFsImporter(
           }
         } else if (
           declaration.hasNode() &&
-          declaration.has('id') &&
+          'id' in declaration.node &&
+          declaration.node.id &&
           (declaration.get('id') as NodePath).isIdentifier({ name })
         ) {
           // export function/class/type/interface/enum ...
 
           state.resultPath = declaration;
-        } else if (path.has('specifiers')) {
+        } else if (path.node.specifiers.length > 0) {
           // export { ... } or export x from ... or export * as x from ...
 
           for (const specifierPath of path.get('specifiers')) {
@@ -213,7 +214,7 @@ export default function makeFsImporter(
 
             if (exported.isIdentifier({ name })) {
               // export ... from ''
-              if (path.has('source')) {
+              if (path.node.source) {
                 const local = specifierPath.isExportSpecifier()
                   ? specifierPath.node.local.name
                   : 'default';
diff --git a/packages/react-docgen/src/utils/__tests__/getTypeParameters-test.ts b/packages/react-docgen/src/utils/__tests__/getTypeParameters-test.ts
index e715c21effd..62b40bac783 100644
--- a/packages/react-docgen/src/utils/__tests__/getTypeParameters-test.ts
+++ b/packages/react-docgen/src/utils/__tests__/getTypeParameters-test.ts
@@ -1,3 +1,4 @@
+import getTypeArguments from '../getTypeArguments.js';
 import type {
   TSTypeAliasDeclaration,
   TSTypeParameterDeclaration,
@@ -20,9 +21,9 @@ describe('getTypeParameters', () => {
       expect(
         getTypeParameters(
           path.get('typeParameters') as NodePath<TSTypeParameterDeclaration>,
-          path
-            .get('typeAnnotation')
-            .get('typeParameters') as NodePath<TSTypeParameterInstantiation>,
+          getTypeArguments(
+            path.get('typeAnnotation'),
+          ) as NodePath<TSTypeParameterInstantiation>,
           null,
         ),
       ).toMatchSnapshot();
@@ -35,9 +36,9 @@ describe('getTypeParameters', () => {
       expect(
         getTypeParameters(
           path.get('typeParameters') as NodePath<TSTypeParameterDeclaration>,
-          path
-            .get('typeAnnotation')
-            .get('typeParameters') as NodePath<TSTypeParameterInstantiation>,
+          getTypeArguments(
+            path.get('typeAnnotation'),
+          ) as NodePath<TSTypeParameterInstantiation>,
           null,
         ),
       ).toMatchSnapshot();
diff --git a/packages/react-docgen/src/utils/getFlowType.ts b/packages/react-docgen/src/utils/getFlowType.ts
index 246fb64364e..2fe12a040d4 100644
--- a/packages/react-docgen/src/utils/getFlowType.ts
+++ b/packages/react-docgen/src/utils/getFlowType.ts
@@ -174,7 +174,11 @@ function handleGenericTypeAnnotation(
   const resolvedPath =
     (typeParams && typeParams[type.name]) || resolveToValue(path.get('id'));
 
-  if (typeParameters.hasNode() && resolvedPath.has('typeParameters')) {
+  if (
+    typeParameters.hasNode() &&
+    'typeParameters' in resolvedPath.node &&
+    resolvedPath.node.typeParameters
+  ) {
     typeParams = getTypeParameters(
       resolvedPath.get('typeParameters') as NodePath<TypeParameterDeclaration>,
       typeParameters,
@@ -195,7 +199,7 @@ function handleGenericTypeAnnotation(
     );
   }
 
-  if (resolvedPath && resolvedPath.has('right')) {
+  if (resolvedPath && 'right' in resolvedPath.node && resolvedPath.node.right) {
     type = getFlowTypeWithResolvedTypes(
       resolvedPath.get('right') as NodePath<FlowType>,
       typeParams,
diff --git a/packages/react-docgen/src/utils/getPropertyName.ts b/packages/react-docgen/src/utils/getPropertyName.ts
index 72e27dc3144..349b2226e20 100644
--- a/packages/react-docgen/src/utils/getPropertyName.ts
+++ b/packages/react-docgen/src/utils/getPropertyName.ts
@@ -42,7 +42,7 @@ export default function getPropertyName(
     }
 
     return null;
-  } else if (propertyPath.has('computed')) {
+  } else if ('computed' in propertyPath.node && propertyPath.node.computed) {
     const key = propertyPath.get('key') as NodePath<Expression>;
 
     // Try to resolve variables and member expressions
diff --git a/packages/react-docgen/src/utils/getTSType.ts b/packages/react-docgen/src/utils/getTSType.ts
index 74c30ec2da1..2b06a1c3442 100644
--- a/packages/react-docgen/src/utils/getTSType.ts
+++ b/packages/react-docgen/src/utils/getTSType.ts
@@ -1,3 +1,4 @@
+import getTypeArguments from './getTypeArguments.js';
 import getPropertyName from './getPropertyName.js';
 import printValue from './printValue.js';
 import getTypeAnnotation from '../utils/getTypeAnnotation.js';
@@ -77,6 +78,10 @@ const namedTypes: Record<
   TSTypeOperator: handleTSTypeOperator,
   TSIndexedAccessType: handleTSIndexedAccessType,
   TSLiteralType: handleTSLiteralType,
+  TSTemplateLiteralType: (path) => ({
+    name: 'literal',
+    value: printValue(path),
+  }),
 };
 
 function handleTSQualifiedName(
@@ -132,12 +137,15 @@ function handleTSTypeReference(
     (typeParams && typeParams[type.name]) ||
     resolveToValue(path.get('typeName'));
 
-  const typeParameters = path.get('typeParameters');
+  const typeParameters = getTypeArguments(path);
   const resolvedTypeParameters = resolvedPath.get('typeParameters') as NodePath<
     TSTypeParameterDeclaration | null | undefined
   >;
 
-  if (typeParameters.hasNode() && resolvedTypeParameters.hasNode()) {
+  if (
+    typeParameters.isTSTypeParameterInstantiation() &&
+    resolvedTypeParameters.hasNode()
+  ) {
     typeParams = getTypeParameters(
       resolvedTypeParameters,
       typeParameters,
@@ -159,7 +167,7 @@ function handleTSTypeReference(
 
   if (resolvedTypeAnnotation.hasNode()) {
     type = getTSTypeWithResolvedTypes(resolvedTypeAnnotation, typeParams);
-  } else if (typeParameters.hasNode()) {
+  } else if (typeParameters.isTSTypeParameterInstantiation()) {
     const params = typeParameters.get('params');
 
     type = {
@@ -198,9 +206,9 @@ function handleTSTypeLiteral(
   };
 
   path.get('members').forEach((param) => {
-    const typeAnnotation = param.get('typeAnnotation') as NodePath<
-      TSTypeAnnotation | null | undefined
-    >;
+    const typeAnnotation = param.get(
+      'returnType' in param.node ? 'returnType' : 'typeAnnotation',
+    ) as NodePath<TSTypeAnnotation | null | undefined>;
 
     if (
       (param.isTSPropertySignature() || param.isTSMethodSignature()) &&
@@ -287,10 +295,12 @@ function handleTSMappedType(
   path: NodePath<TSMappedType>,
   typeParams: TypeParameters | null,
 ): ObjectSignatureType<TSFunctionSignatureType> {
-  const key = getTSTypeWithResolvedTypes(
-    path.get('typeParameter').get('constraint') as NodePath<TSType>,
-    typeParams,
-  );
+  const constraint = (
+    'constraint' in path.node
+      ? path.get('constraint')
+      : path.get('typeParameter').get('constraint')
+  ) as NodePath<TSType>;
+  const key = getTSTypeWithResolvedTypes(constraint, typeParams);
 
   key.required = !path.node.optional;
 
@@ -323,8 +333,11 @@ function handleTSFunctionType(
   typeParams: TypeParameters | null,
 ): TSFunctionSignatureType {
   let returnType: TypeDescriptor<TSFunctionSignatureType> | undefined;
+  const usesBabel8Fields = 'params' in path.node;
 
-  const annotation = path.get('typeAnnotation');
+  const annotation = path.get(
+    usesBabel8Fields ? 'returnType' : 'typeAnnotation',
+  ) as NodePath<TSTypeAnnotation | null | undefined>;
 
   if (annotation.hasNode()) {
     returnType = getTSTypeWithResolvedTypes(annotation, typeParams);
@@ -340,7 +353,11 @@ function handleTSFunctionType(
     },
   };
 
-  path.get('parameters').forEach((param) => {
+  const parameters = path.get(
+    usesBabel8Fields ? 'params' : 'parameters',
+  ) as Array<NodePath<TSFunctionType['parameters'][number]>>;
+
+  parameters.forEach((param) => {
     const typeAnnotation = getTypeAnnotation<TSType>(param);
 
     const arg: FunctionArgumentType<TSFunctionSignatureType> = {
@@ -408,7 +425,10 @@ function handleTSTypeQuery(
   if (exprName.isIdentifier()) {
     const resolvedPath = resolveToValue(path.get('exprName'));
 
-    if (resolvedPath.has('typeAnnotation')) {
+    if (
+      'typeAnnotation' in resolvedPath.node &&
+      resolvedPath.node.typeAnnotation
+    ) {
       return getTSTypeWithResolvedTypes(
         resolvedPath.get('typeAnnotation') as NodePath<TypeScript>,
         typeParams,
diff --git a/packages/react-docgen/src/utils/getTypeAnnotation.ts b/packages/react-docgen/src/utils/getTypeAnnotation.ts
index 3424700b150..df9a83a633f 100644
--- a/packages/react-docgen/src/utils/getTypeAnnotation.ts
+++ b/packages/react-docgen/src/utils/getTypeAnnotation.ts
@@ -6,16 +6,26 @@ import type { FlowType, Node, TSType } from '@babel/types';
  * can be found null is returned
  */
 export default function getTypeAnnotation<T extends Node = FlowType | TSType>(
-  path: NodePath<Node | null | undefined>,
+  // Babel 7 permits undefined paths; Babel 8 constrains them to nodes or null.
+  path: NodePath<
+    InstanceType<typeof NodePath>['node'] & (Node | null | undefined)
+  >,
 ): NodePath<T> | null {
-  if (!path.has('typeAnnotation')) return null;
+  if (
+    !path.node ||
+    !('typeAnnotation' in path.node) ||
+    !path.node.typeAnnotation
+  )
+    return null;
 
   let resultPath = path;
 
   do {
     resultPath = resultPath.get('typeAnnotation') as NodePath;
   } while (
-    resultPath.has('typeAnnotation') &&
+    resultPath.node &&
+    'typeAnnotation' in resultPath.node &&
+    resultPath.node.typeAnnotation &&
     !resultPath.isFlowType() &&
     !resultPath.isTSType()
   );
diff --git a/packages/react-docgen/src/utils/getTypeArguments.ts b/packages/react-docgen/src/utils/getTypeArguments.ts
new file mode 100644
index 00000000000..07517da57cf
--- /dev/null
+++ b/packages/react-docgen/src/utils/getTypeArguments.ts
@@ -0,0 +1,30 @@
+import type { NodePath } from '@babel/traverse';
+import type {
+  TSTypeParameterInstantiation,
+  TypeParameterInstantiation,
+} from '@babel/types';
+
+/** Reads type arguments from both Babel 7 and Babel 8 ASTs. */
+export default function getTypeArguments(
+  path: NodePath,
+): NodePath<
+  InstanceType<typeof NodePath>['node'] &
+    (
+      | TSTypeParameterInstantiation
+      | TypeParameterInstantiation
+      | null
+      | undefined
+    )
+> {
+  return path.get(
+    'typeArguments' in path.node ? 'typeArguments' : 'typeParameters',
+  ) as NodePath<
+    InstanceType<typeof NodePath>['node'] &
+      (
+        | TSTypeParameterInstantiation
+        | TypeParameterInstantiation
+        | null
+        | undefined
+      )
+  >;
+}
diff --git a/packages/react-docgen/src/utils/getTypeFromReactComponent.ts b/packages/react-docgen/src/utils/getTypeFromReactComponent.ts
index 028be7e28f7..87800dabfd4 100644
--- a/packages/react-docgen/src/utils/getTypeFromReactComponent.ts
+++ b/packages/react-docgen/src/utils/getTypeFromReactComponent.ts
@@ -1,3 +1,4 @@
+import getTypeArguments from './getTypeArguments.js';
 import type { NodePath } from '@babel/traverse';
 import type Documentation from '../Documentation.js';
 import getMemberValuePath from './getMemberValuePath.js';
@@ -36,11 +37,9 @@ function getStatelessPropsPath(
 function getForwardRefGenericsType(
   componentDefinition: NodePath,
 ): NodePath<TSType> | null {
-  const typeParameters = componentDefinition.get('typeParameters') as NodePath<
-    TSTypeParameterInstantiation | null | undefined
-  >;
+  const typeParameters = getTypeArguments(componentDefinition);
 
-  if (typeParameters && typeParameters.hasNode()) {
+  if (typeParameters.isTSTypeParameterInstantiation()) {
     const params = typeParameters.get('params');
 
     return params[1] ?? null;
@@ -71,9 +70,9 @@ function findAssignedVariableType(
       isReactBuiltinReference(typeName, 'VoidFunctionComponent') ||
       isReactBuiltinReference(typeName, 'VFC')
     ) {
-      const typeParameters = typeAnnotation.get('typeParameters');
+      const typeParameters = getTypeArguments(typeAnnotation);
 
-      if (typeParameters.hasNode()) {
+      if (typeParameters.isTSTypeParameterInstantiation()) {
         return typeParameters.get('params')[0] ?? null;
       }
     }
@@ -92,7 +91,16 @@ export default (componentDefinition: NodePath): NodePath[] => {
   const typePaths: NodePath[] = [];
 
   if (isReactComponentClass(componentDefinition)) {
-    const superTypes = componentDefinition.get('superTypeParameters');
+    const superTypes = componentDefinition.get(
+      'superTypeArguments' in componentDefinition.node
+        ? 'superTypeArguments'
+        : 'superTypeParameters',
+    ) as NodePath<
+      | TSTypeParameterInstantiation
+      | TypeParameterInstantiation
+      | null
+      | undefined
+    >;
 
     if (superTypes.hasNode()) {
       const params = superTypes.get('params');
@@ -236,17 +244,18 @@ function applyExtends(
       const resolvedPath = resolveGenericTypeAnnotation(extendsPath);
 
       if (resolvedPath) {
-        if (
-          resolvedPath.has('typeParameters') &&
-          extendsPath.node.typeParameters
-        ) {
+        const typeArguments = getTypeArguments(extendsPath);
+        const typeParameters = resolvedPath.get('typeParameters') as NodePath<
+          | TSTypeParameterDeclaration
+          | TypeParameterDeclaration
+          | null
+          | undefined
+        >;
+
+        if (typeParameters.hasNode() && typeArguments.hasNode()) {
           typeParams = getTypeParameters(
-            resolvedPath.get('typeParameters') as NodePath<
-              TSTypeParameterDeclaration | TypeParameterDeclaration
-            >,
-            extendsPath.get('typeParameters') as NodePath<
-              TSTypeParameterInstantiation | TypeParameterInstantiation
-            >,
+            typeParameters,
+            typeArguments,
             typeParams,
           );
         }
diff --git a/packages/react-docgen/src/utils/getTypeIdentifier.ts b/packages/react-docgen/src/utils/getTypeIdentifier.ts
index 99e3f1c154f..039463379ad 100644
--- a/packages/react-docgen/src/utils/getTypeIdentifier.ts
+++ b/packages/react-docgen/src/utils/getTypeIdentifier.ts
@@ -1,12 +1,18 @@
 import type { NodePath } from '@babel/traverse';
 
 export default function getTypeIdentifier(path: NodePath): NodePath | null {
-  if (path.has('id')) {
+  if ('id' in path.node && path.node.id) {
     return path.get('id') as NodePath;
   } else if (path.isTSTypeReference()) {
     return path.get('typeName');
-  } else if (path.isTSExpressionWithTypeArguments()) {
-    return path.get('expression');
+  } else if (
+    [
+      'TSExpressionWithTypeArguments',
+      'TSInterfaceHeritage',
+      'TSClassImplements',
+    ].includes(path.node.type)
+  ) {
+    return path.get('expression') as NodePath;
   }
 
   return null;
diff --git a/packages/react-docgen/src/utils/getTypeParameters.ts b/packages/react-docgen/src/utils/getTypeParameters.ts
index da676462c29..cddf5cbd9d9 100644
--- a/packages/react-docgen/src/utils/getTypeParameters.ts
+++ b/packages/react-docgen/src/utils/getTypeParameters.ts
@@ -29,7 +29,8 @@ export default function getTypeParameters(
   declaration
     .get('params')
     .forEach((paramPath: NodePath<TSTypeParameter | TypeParameter>) => {
-      const key = paramPath.node.name;
+      const name = paramPath.node.name as Identifier | string;
+      const key = typeof name === 'string' ? name : name.name;
       const defaultProp = paramPath.get('default');
       const defaultTypePath = defaultProp.hasNode() ? defaultProp : null;
       const typePath =
diff --git a/packages/react-docgen/src/utils/normalizeClassDefinition.ts b/packages/react-docgen/src/utils/normalizeClassDefinition.ts
index 5704fcc47d3..532d0c01894 100644
--- a/packages/react-docgen/src/utils/normalizeClassDefinition.ts
+++ b/packages/react-docgen/src/utils/normalizeClassDefinition.ts
@@ -30,7 +30,7 @@ const explodedVisitors = visitors.explode<TraverseState>({
 
         if (
           member &&
-          !member.path.has('computed') &&
+          !('computed' in member.path.node && member.path.node.computed) &&
           !member.path.isPrivateName()
         ) {
           const property = classProperty(
diff --git a/packages/react-docgen/src/utils/resolveExportDeclaration.ts b/packages/react-docgen/src/utils/resolveExportDeclaration.ts
index 5081ab23ef9..3d3e2cbea64 100644
--- a/packages/react-docgen/src/utils/resolveExportDeclaration.ts
+++ b/packages/react-docgen/src/utils/resolveExportDeclaration.ts
@@ -13,7 +13,7 @@ export default function resolveExportDeclaration(
   if (path.isExportDefaultDeclaration()) {
     definitions.push(path.get('declaration'));
   } else if (path.isExportNamedDeclaration()) {
-    if (path.has('declaration')) {
+    if (path.node.declaration) {
       const declaration = path.get('declaration');
 
       if (declaration.isVariableDeclaration()) {
@@ -23,7 +23,7 @@ export default function resolveExportDeclaration(
       } else if (declaration.isDeclaration()) {
         definitions.push(declaration);
       }
-    } else if (path.has('specifiers')) {
+    } else if (path.node.specifiers.length > 0) {
       path.get('specifiers').forEach((specifier) => {
         if (specifier.isExportSpecifier()) {
           definitions.push(specifier.get('local'));
diff --git a/packages/react-docgen/src/utils/traverse.ts b/packages/react-docgen/src/utils/traverse.ts
index 3066ac486ce..a2fef6e8246 100644
--- a/packages/react-docgen/src/utils/traverse.ts
+++ b/packages/react-docgen/src/utils/traverse.ts
@@ -1,6 +1,8 @@
 import type { NodePath } from '@babel/traverse';
 
-export function ignore<T>(path: NodePath<T>): void {
+export function ignore<T extends InstanceType<typeof NodePath>['node']>(
+  path: NodePath | NodePath<T>,
+): void {
   path.skip();
 }
 
diff --git a/packages/react-docgen/src/utils/unwrapBuiltinTSPropTypes.ts b/packages/react-docgen/src/utils/unwrapBuiltinTSPropTypes.ts
index 06f3cee24d4..645b5737309 100644
--- a/packages/react-docgen/src/utils/unwrapBuiltinTSPropTypes.ts
+++ b/packages/react-docgen/src/utils/unwrapBuiltinTSPropTypes.ts
@@ -1,3 +1,4 @@
+import getTypeArguments from './getTypeArguments.js';
 import type { NodePath } from '@babel/traverse';
 import isReactBuiltinReference from './isReactBuiltinReference.js';
 
@@ -15,7 +16,7 @@ export default function unwrapBuiltinTSPropTypes(typePath: NodePath): NodePath {
       isReactBuiltinReference(typeName, 'PropsWithRef') ||
       isReactBuiltinReference(typeName, 'PropsWithChildren')
     ) {
-      const typeParameters = typePath.get('typeParameters');
+      const typeParameters = getTypeArguments(typePath);
 
       if (typeParameters.hasNode()) {
         const innerType = typeParameters.get('params')[0];
diff --git a/packages/react-docgen/tests/types/consumer.ts b/packages/react-docgen/tests/types/consumer.ts
new file mode 100644
index 00000000000..2eb4a1a1546
--- /dev/null
+++ b/packages/react-docgen/tests/types/consumer.ts
@@ -0,0 +1,26 @@
+import { parse, utils } from '../../dist/main.js';
+import type { Handler, NodePath, babelTypes } from '../../dist/main.js';
+
+const handler: Handler = (documentation, definition) => {
+  const node: babelTypes.Node = definition.node;
+  const path: NodePath = definition;
+
+  documentation.set('nodeType', node.type);
+  utils.getTypeAnnotation(path);
+  utils.traverse.ignore(path);
+};
+
+parse('export function Button() { return <button />; }', {
+  filename: 'component.tsx',
+  handlers: [handler],
+  babelOptions: {
+    babelrc: false,
+    configFile: false,
+    parserOpts: { plugins: ['typescript', 'jsx'] },
+  },
+});
+
+declare const emptyPath: NodePath<null>;
+
+utils.getTypeAnnotation(emptyPath);
+utils.traverse.ignore(emptyPath);
diff --git a/packages/react-docgen/tests/types/tsconfig.json b/packages/react-docgen/tests/types/tsconfig.json
new file mode 100644
index 00000000000..53d4c39f6e4
--- /dev/null
+++ b/packages/react-docgen/tests/types/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "skipLibCheck": false
+  },
+  "include": ["consumer.ts", "../../dist/**/*.d.ts"]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 74271537471..d92a9205e45 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -116,6 +116,9 @@ importers:
       '@types/babel__traverse':
         specifier: ^7.20.7
         version: 7.28.0
+      '@types/convert-source-map':
+        specifier: ^2.0.3
+        version: 2.0.3
       '@types/doctrine':
         specifier: ^0.0.9
         version: 0.0.9
@@ -1531,6 +1534,9 @@ packages:
   '@types/chai@5.2.3':
     resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
 
+  '@types/convert-source-map@2.0.3':
+    resolution: {integrity: sha512-ag0BfJLZf6CQz8VIuRIEYQ5Ggwk/82uvTQf27RcpyDNbY0Vw49LIPqAxk5tqYfrCs9xDaIMvl4aj7ZopnYL8bA==}
+
   '@types/d3-array@3.2.2':
     resolution: {integrity: sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==}
 
@@ -6513,6 +6519,8 @@ snapshots:
       '@types/deep-eql': 4.0.2
       assertion-error: 2.0.1
 
+  '@types/convert-source-map@2.0.3': {}
+
   '@types/d3-array@3.2.2': {}
 
   '@types/d3-axis@3.0.6':