Behavior-Preserving Refactor

Refactor the code below. The hard constraint: observable behavior must not change, same outputs, same side effects, same error behavior, same performance characteristics within reason.

What hurts about the current code: [THE PAIN, e.g. "600-line function", "logic duplicated in 4 places", "impossible to test"]
Test coverage: [WHAT TESTS EXIST, or "none", in which case start with step 0]
Scope fence, files/functions you may touch: [LIST. Nothing outside this list.]

Code:
"""
[PASTE CODE]
"""

Work like this:
1. **Invariants first**: list the observable behaviors that must survive: inputs → outputs, side effects and their order, thrown errors and their types, anything callers depend on. If tests don't cover an invariant, write the missing test BEFORE refactoring (step 0), so we're never flying blind.
2. **Stepwise plan**: break the refactor into steps of one named technique each (extract function, inline variable, replace conditional with lookup, move responsibility). Every step must leave the code compiling and tests passing, no step depends on a later step to restore correctness.
3. **Execute**: show the result after each step, not one final blob. For each step: which technique, what moved, and one line on why the behavior is provably unchanged.
4. **Summary**: before/after comparison: lines, duplication removed, what's now testable that wasn't. And list anything you noticed but did NOT fix because it was outside the scope fence or would change behavior. Flag it, don't touch it.

Rules: no renaming beyond what the refactor requires, no "while I'm here" improvements, no new dependencies, no API changes unless I explicitly listed them as in scope.