fix(ts): flatten annotated non-flatten oneofs to match the wire format

[hishamank]

What

Fixes a pre-existing wire mismatch in the TS generators (protoc-gen-ts-client, protoc-gen-ts-server) for annotated non-flatten oneofs: the TS types wrapped the union in a property named after the oneof, but that property never exists in the JSON.

The mismatch

For NestedEvent (oneof content, discriminator kind), the generated Go MarshalJSONSebuf writes the discriminator directly onto the parent object (raw["kind"] = "text") and leaves the variant key where protojson put it — also on the parent:

{ "id": "...", "kind": "text", "text": { "body": "..." } }

The OpenAPI generator already documents exactly this flat shape (oneOf variant schemas with text/image at the parent level). TypeScript was the only generator disagreeing with the Go serialization:

// before — describes JSON that never exists
export interface NestedEvent {
  id: string;
  content?: { kind: "text"; text?: TextContent } | ...;
}

Since the generated clients are raw-cast (JSON.stringify(req) / resp.json() as T, no conversion layer), event.content was always undefined at runtime, and requests built through the type were rejected by UnmarshalJSON (no kind at the top level).

After

Non-flatten annotated oneofs render flat, intersected with the base fields — same structure the flatten path already used:

export type NestedEventContent =
  | { kind: "text"; text: TextContent; image?: never; video?: never }
  | { kind: "image"; image: ImageContent; text?: never; video?: never }
  | { kind: "vid"; video: VideoContent; text?: never; image?: never }
  | { kind?: never; text?: never; image?: never; video?: never };

export interface NestedEventBase { id: string; }
export type NestedEvent = NestedEventBase & NestedEventContent;

• Non-optional payloads: oneof fields have explicit presence — a set member is always emitted by protojson, so after narrowing on kind the payload is guaranteed.
• ?: never sibling guards: narrowing on the discriminator also types the other variant keys as absent, and constructing an object with two members set is a compile error.
• All-never unset arm: MarshalJSON omits the discriminator entirely when the oneof is unset (default: branch), so the unset case is representable. Flattened oneofs gain the same arm ({ type?: never }).

With every oneof now rendering flat on the parent, the wrapper-property branch in GenerateStandardInterface is unreachable and removed — which also removes the bug where multi-word oneof names leaked into TS as raw snake_case wrapper properties (e.g. super_title_image?:).

Stacked on #199

Based on feat/ts-oneof-style: it builds on the presence-union routing introduced there (GenerateOneofDiscriminatedUnionType dispatch, intersection emission for oneof-bearing messages). The two changes restore the same invariant — the TS types describe exactly the JSON the Go marshaler produces — #199's follow-up commit for un-annotated oneofs, this PR for annotated ones.

Tests

• Golden fixtures regenerated (oneof_discriminator client + server).
• TestOneofDiscriminatorTypeScriptTypes extended to assert the flat NestedEvent shape: intersection alias, non-optional payload with never guards, and the unset arm.
• Regenerated golden typechecks under tsc --strict.
• Full suite + staticcheck green.

🤖 Generated with Claude Code