Enhance code quality without changing behavior. Tests must continue passing.

Guidelines:

• Extract common patterns into well-named functions
• Apply SOLID principles where appropriate
• Improve type definitions — discriminated unions, branded types
• No test behavior changes
• Run tests after each refactoring step
• Consider mutation testing to verify test quality

TypeScript refactoring pattern:

// Extract validation
function validateCredentials(credentials: {
  email: string
  password: string
}): AuthResult | null {
  if (!credentials.password) {
    return { type: 'error', code: 'MISSING_PASSWORD' }
  }
  if (!isValidEmail(credentials.email)) {
    return { type: 'error', code: 'INVALID_EMAIL' }
  }
  return null
}

// Improve type safety with branded types
type Email = string & { readonly __brand: 'Email' }
type PasswordHash = string & { readonly __brand: 'PasswordHash' }

// Cleaner main function
async function authenticate(credentials: {
  email: string
  password: string
}): Promise<AuthResult> {
  const validationError = validateCredentials(credentials)
  if (validationError) return validationError

  const user = await findUserByEmail(credentials.email)
  if (!user) {
    return { type: 'error', code: 'INVALID_CREDENTIALS' }
  }

  const isValid = await verifyPassword(credentials.password, user.passwordHash)
  if (!isValid) {
    return { type: 'error', code: 'INVALID_CREDENTIALS' }
  }

  return { type: 'success', user }
}

Rust refactoring pattern:

// Extract validation
fn validate_credentials(credentials: &Credentials) -> Result<(), AuthError> {
    if credentials.password.is_empty() {
        return Err(AuthError::MissingPassword);
    }
    if !is_valid_email(&credentials.email) {
        return Err(AuthError::InvalidEmail);
    }
    Ok(())
}

// Use newtype pattern for type safety
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Email(String);

impl Email {
    pub fn new(email: String) -> Result<Self, AuthError> {
        if is_valid_email(&email) {
            Ok(Email(email))
        } else {
            Err(AuthError::InvalidEmail)
        }
    }
}

// Cleaner main function
pub fn authenticate(credentials: &Credentials) -> Result<AuthResult, AuthError> {
    validate_credentials(credentials)?;

    let user = find_user_by_email(&credentials.email)
        .ok_or(AuthError::InvalidCredentials)?;

    verify_password(&credentials.password, &user.password_hash)
        .then_some(AuthResult::Success { user })
        .ok_or(AuthError::InvalidCredentials)
}

Verify refactoring:

# TypeScript - run tests and check mutation score
bun test
bun x stryker run

# Rust - run tests and check coverage
cargo test
cargo tarpaulin

Commit: refactor: [improvement description]

Transition: Mark "Refactor Phase" completed, create "Verify" as in_progress

Final verification: Run full test suite with coverage and mutation testing. Mark "Verify" completed when all checks pass.