feat(architectures): declare variant enums per architecture and guard the unions

[Pfannkuchensack]

Stacked on #28, which is stacked on #27. Base is refactor/arch-latent-space-facet; the diff
shown here is against it. Review #27 → #28 → this.

Third of the series from .ideas/Backend Modularization Plan.md. No behaviour changes.

Why

One list of eleven variant enums is written by hand four times — AnyVariant, the
variant_type_adapter subscript, that adapter's runtime argument (all three in taxonomy.py), and
ModelRecordChanges.variant. Nothing checked that they agreed.

Nothing checked the invariant they all rest on either: variant values must be globally unique,
because build_common_fields resolves a bare variant string without knowing the base
(configs/factory.py). That invariant has already cost something — it is why
Krea2VariantType.Turbo is krea2_turbo rather than turbo — and until now it lived only in a
docstring.

The plan was wrong about the shape, and the code says so

The spec assumed one variant enum per base. It is not:

enum	key	base-keyed?
WanVariantType	Wan × Main
WanLoRAVariantType	Wan × LoRA	same base, different enum
PiDDecoderVariantType	five bases × PiDDecoder	one enum, many bases
ClipVariantType, Qwen3VariantType	base=Any	impossible — Any is a sentinel the registry refuses

So VariantFacet carries a {ModelType: enum} mapping. Wan's two enums are not interchangeable —
an A14B LoRA (inner_dim=5120) against a TI2V-5B main (3072) crashes in the layer patcher, which is
why the separate enum exists at all.

The mapping was derived, not read off. A script walked Config_Base.CONFIG_CLASSES and extracted
every variant field's annotation. That corrected my hand-reading in one place: sdxl-refiner
mains carry ModelVariantType, which I would have missed.

Keeping the completeness check honest

Two enums cannot be declared by any architecture. Left implicit, the check would silently cover 9 of
11 while looking total. So there is a named BASE_AGNOSTIC_VARIANT_ENUMS allowlist — and a second
test asserting nothing in it is used by a real architecture, so it cannot become a dumping ground
for whatever makes CI pass.

Four architectures — CogView4, ERNIE-Image, Ideogram 4, Anima — model no variants and omit the
facet. An empty facet would be indistinguishable from an absent one.

configs/factory.py is deliberately untouched

Base-aware resolution would still need a fallback for the base=Any models, so it would move the
trap rather than close it — at the cost of touching the identification path, which the spec marks as
the one place not to take risks. The invariant is pinned by a test instead, in two forms:

1. enum values are globally unique;
2. variant_type_adapter.validate_strings(value) returns the right enum type for every value —
   the behavioural version of (1), through the exact call factory.py makes.

The facet is checked against reality

test_every_facet_declaration_matches_the_config_classes derives the expected mapping from the
config classes and checks both directions: a (base, type) the configs give a variant must be
declared, and a declaration the configs do not back must not exist.

Verified against both mistakes, then reverted:

VariantFacet declarations disagree with the model config classes:
  wan x lora: registry says WanVariantType, configs say WanLoRAVariantType
  wan x vae: registry declares WanVariantType, but no config class for that combination has a variant field

That message needed a fix: assert problems == [] printed nothing outside pytest's assertion
rewriting, so the assert now carries the list explicitly.

Noted, not fixed

configs/main.py's from_base signature lists only six of the enums and omits
QwenImageVariantType. Left alone — that annotation is on the way out in the capabilities PR, which
derives from_base from the registry.

Verification

• pytest tests/backend/architectures tests/app/util tests/test_imports.py — 230 passed
• mypy invokeai/backend/architectures (strict) — clean
• ruff@0.11.2 check . + format --check — clean
• openapi.json regenerated and compared normalized — identical. No Pydantic class, invocation
  field or enum is touched.

🤖 Generated with Claude Code