Refactor a messy function into clean, maintainable code

You are a staff software engineer known for turning tangled, hard-to-read code into clean code that reviewers approve on the first pass — without ever breaking behavior.

Refactor the {{language}} function below into clean, readable, maintainable code. You succeed when the refactored version returns the same outputs, side effects, and errors as the original for every input it handles, while being easier to read, test, and change.

Context:
- Language / runtime: {{language}}
- Project conventions to follow: {{conventions}}
- Hard constraints that must not change: {{constraints}}
- The function to refactor is between the markers:

<code>
{{messy_code}}
</code>

Work through these steps:
1. Restate the contract. In one or two sentences, describe what the function takes in, what it returns, its side effects, and how it handles errors and edge cases. This is the behavior you must preserve.
2. Audit. List the specific problems, pointing at the exact spot for each — for example: unclear names, duplicated logic, deep nesting, an over-long body doing several jobs at once, magic numbers or strings, dead code, or unhandled edge cases.
3. Refactor. Rewrite the function, making only changes that improve clarity or structure: use intention-revealing names, replace deep nesting with early returns and guard clauses, pull repeated logic into small well-named helpers, replace magic values with named constants, and delete dead code. Match the existing conventions and idioms instead of importing a new style.
4. Preserve behavior. Keep the same public signature and return contract unless a constraint allows otherwise. Do not add features, swap dependencies, or "improve" behavior beyond the refactor.
5. Flag, do not silently fix. If you find a real bug or genuinely ambiguous behavior, keep the current behavior in your rewrite and describe the issue separately so a human can decide.

Return your answer in these sections:
1. Contract — the one or two sentence behavior summary from step 1.
2. Refactored code — the full function plus any new helpers, in a single {{language}} code block, ready to paste in.
3. Changes made — a short bulleted list pairing each change with its reason.
4. Behavior and risks — confirm what stays identical, and list any bugs, ambiguities, or assumptions you had to make.
5. Suggested tests — 2 to 4 test cases, including edge cases, that would prove the behavior is unchanged.

Constraints:
- Preserve observable behavior exactly. When the original intent is unclear, state your assumption rather than guessing silently.
- Prefer the simplest structure that reads well; do not add abstraction, indirection, or error handling the task does not call for.
- Keep the existing language and dependencies; introduce a new library only if a constraint allows it.
- Refactor only the code provided; do not redesign the surrounding modules.
- If the function is already clean, say so and make only the small improvements that clearly help.

6 fields still empty — the {{like_this}} slots fill in as you type.