How to fix Type narrowing from typeof check produces 'never' in TypeScript

function process(value: string | number) {
  if (typeof value === 'string') {
    // value is string here
  } else if (typeof value === 'number') {
    // value is number here
  } else {
    // value is never here - all cases handled
    console.log(value); // Error: value is never
  }
}

type Action = { type: 'add' } | { type: 'remove' };

function handleAction(action: Action) {
  switch (action.type) {
    case 'add':
      return 'Adding';
    case 'remove':
      return 'Removing';
    default:
      // This should be never - proves exhaustiveness
      const _exhaustive: never = action;
      throw new Error(`Unhandled action: ${_exhaustive}`);
  }
}

// Problem: type doesn't include all expected values
let value: string | number = getValue();

if (typeof value === 'boolean') {
  // value is never - boolean not in union
  console.log(value);
}

// Solution: Include all possible types
let value: string | number | boolean = getValue();

if (typeof value === 'boolean') {
  // value is boolean - works correctly
  console.log(value);
}

// Problem: negated check narrows incorrectly
function process(value: string | number | object) {
  if (typeof value !== 'object') {
    // May narrow to never in some TS versions
  }
}

// Solution: Use positive type guards
function process(value: string | number | object) {
  if (typeof value === 'string' || typeof value === 'number') {
    // value is string | number
    console.log(value);
  } else {
    // value is object
    console.log(value);
  }
}

interface Cat { meow(): void }
interface Dog { bark(): void }

type Animal = Cat | Dog;

// Type predicate function
function isCat(animal: Animal): animal is Cat {
  return 'meow' in animal;
}

function handleAnimal(animal: Animal) {
  if (isCat(animal)) {
    animal.meow(); // Correctly narrowed to Cat
  } else {
    animal.bark(); // Correctly narrowed to Dog
  }
}

// Workaround: Type assertion
function process(value: string | number) {
  if (typeof value === 'string') {
    // handle string
  } else {
    // TypeScript thinks this is never incorrectly
    const numValue = value as number;
    console.log(numValue);
  }
}

// Better: Widen the type explicitly
function process(value: string | number) {
  const widened: string | number = value;
  if (typeof widened === 'string') {
    // handle string
  } else {
    console.log(widened); // number, not never
  }
}