Inconsistency involving discriminated union and flatMap

The following code works in TS, but errors in Go:
```ts
export type InputOp = { op: "add" } | { op: "remove"; value?: Array };
export type OutputOp = { op: "add" | "remove" };

export function f(operations: InputOp[]): OutputOp[] {
return operations.flatMap((operation) => {
if (operation.op === "remove" && operation.value) {
return [].map(() => ({ op: "remove" }));
} else {
return [operation];
}
});
}
```

The error in Go is:
```ts
src/flatMap.ts:5:29 - error TS2345: Argument of type '(this: undefined, operation: InputOp) => { op: "remove"; }[] | InputOp[]' is not assignable to parameter of type '(this: undefined, value: InputOp, index: number, array: InputOp[]) => readonly { op: "remove"; }[] | { op: "remove"; }'.
Type '{ op: "remove"; }[] | InputOp[]' is not assignable to type 'readonly { op: "remove"; }[] | { op: "remove"; }'.
Type 'InputOp[]' is not assignable to type 'readonly { op: "remove"; }[] | { op: "remove"; }'.
Type 'InputOp[]' is not assignable to type 'readonly { op: "remove"; }[]'.
Type 'InputOp' is not assignable to type '{ op: "remove"; }'.
Type '{ op: "add"; }' is not assignable to type '{ op: "remove"; }'.
Types of property 'op' are incompatible.
Type '"add"' is not assignable to type '"remove"'.

5 return operations.flatMap((operation) => {
~~~~~~~~~~~~~~~~
```

The example is seemingly quite close to minimal: removing the `&& operation.value`, replacing the first case with `[{ op: "remove" }]`, removing either case, replacing `flatMap` with `map`, or adding more explicit annotations, all either make TS error or make Go pass. I guess there's some complicated interaction of how Go is inferring the type of the callback when narrowing? Or maybe those things all let the inference happen some other way that works better, avoiding the problematic case.

(This is simplified from some real code which is a bit more complex, of course it doesn't make sense as-is.)