How to fix Type is not assignable to itself in TypeScript

npm ls <package-name>
# Example: npm ls @babel/types

yarn why <package-name>
# Example: yarn why @babel/types

pnpm why <package-name>

{
  "resolutions": {
    "@babel/types": "^7.23.0",
    "@types/node": "^20.0.0"
  }
}

rm -rf node_modules yarn.lock
yarn install

{
  "overrides": {
    "@babel/types": "^7.23.0",
    "@types/node": "^20.0.0"
  }
}

rm -rf node_modules package-lock.json
npm install

npm cache clean --force

yarn cache clean

pnpm store prune

rm -rf node_modules
npm install  # or yarn install / pnpm install

// Don't do this - circular inheritance
interface A extends B {}
interface B extends A {}

// Or this - type alias referencing itself
type Tree = {
  value: string;
  children: Tree[];  // This can work as a property
}
type BadTree = Tree | BadTree[];  // But not in a union

// Use properties instead of inheritance
interface Node {
  next?: Node;  // Property reference is OK
  value: string;
}

// Or use an interface for recursive structures
interface TreeNode {
  value: string;
  children: TreeNode[];  // Interfaces handle recursion better
}

type Extract<T> = T extends Foo<infer U> ? U : T;

function process<T>(value: T): Extract<T> {
  // Type is not assignable to itself
  return value;
}

// Add explicit type annotations
function process<T>(value: T): Extract<T> {
  return value as Extract<T>;
}

// Or restructure to avoid conditional in return type
function process<T extends Foo<any>>(value: T): T extends Foo<infer U> ? U : never {
  // ...
}

type Unwrap<T> = T extends Foo<infer U> ? U : never;

function process<T extends Foo<any>>(value: T): Unwrap<T> {
  return value.inner;
}