How is a type being narrowed via discriminated union when the discriminator is non specific?

Consider an enum:

enum TaskType {
  WithId = 'WithId',
  WithValues="WithValues",
  WithNothing = 'WithNothing',
}

and corresponding classes which use the enum as a discriminator, but does not correctly assign the TaskWithId value:

class TaskWithId {
  type: TaskType; // note type is assigned the enum type and not a specific value
  id: number;
}

class TaskWithValues {
  type: TaskType.WithValues; // use specific enum value
  values: number[];
}

class TaskWithNothing {
  type: TaskType.WithNothing; // use specific enum value
}

export type Task = TaskWithId | TaskWithValues | TaskWithNothing;

If I use a switch to narrow the type, it infers the TaskWithId type correctly, despite specifying the discriminator enum incorrectly:

switch (task.type) {
    case TaskType.WithId:
      const id = task.id; // task type is inferred as TaskWithId despite non specific discriminator
      break;
  }

How is this ‘working’?

Furthemore, if I try and narrow TaskWithValues, it does not work despite using a specific discriminator:

 case TaskType.WithValues:
      // const values = task.values; // task type includes TaskWithId, despite specific discriminator

Stackblitz: https://stackblitz.com/edit/typescript-fkha8n?file=index.ts