// Lines 368-392 in register_factory_internal
if (is_frozen()) {
    interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
        interfaces::registry_action::register_service, type_name,
        interfaces::source_location::current(), false,
        "Container is frozen"));
    return make_error<std::monostate>(
        error_codes::REGISTRY_FROZEN,
        "Cannot register factory: container is frozen",
        "di::service_container"
    );
}

std::unique_lock lock(mutex_);

if (services_.find(interface_type) != services_.end()) {
    interfaces::RegistryAuditLog::log_event(...);
    return make_error<std::monostate>(
        di_error_codes::already_registered,
        "Service already registered: " + type_name,
        "di::service_container"
    );
}

// Lines 418-443 - Nearly identical pattern in register_instance_internal

// Lines 527-535 (singleton branch)
try {
    instance = factory_copy(*this);
} catch (const std::exception& e) {
    return make_error<std::shared_ptr<void>>(
        di_error_codes::factory_error,
        std::string("Factory threw exception: ") + e.what(),
        "di::service_container"
    );
}

// Lines 556-564 (transient branch) - Same pattern
// Lines 586-594 (scoped branch) - Same pattern

// Extract validation helper
private:
    VoidResult validate_registration(
        std::type_index interface_type,
        const std::string& type_name) 
    {
        if (is_frozen()) {
            log_registration_failure(type_name, "Container is frozen");
            return make_error<std::monostate>(
                error_codes::REGISTRY_FROZEN,
                "Cannot register: container is frozen",
                "di::service_container"
            );
        }

        // Lock is handled by caller
        if (services_.find(interface_type) != services_.end()) {
            log_registration_failure(type_name, "Service already registered");
            return make_error<std::monostate>(
                di_error_codes::already_registered,
                "Service already registered: " + type_name,
                "di::service_container"
            );
        }

        return VoidResult::ok({});
    }

    // Extract factory invocation helper
    Result<std::shared_ptr<void>> invoke_factory_safe(
        const std::function<std::shared_ptr<void>(IServiceContainer&)>& factory)
    {
        try {
            return Result<std::shared_ptr<void>>::ok(factory(*this));
        } catch (const std::exception& e) {
            return make_error<std::shared_ptr<void>>(
                di_error_codes::factory_error,
                std::string("Factory threw exception: ") + e.what(),
                "di::service_container"
            );
        }
    }

    // Extract audit logging helper
    void log_registration_failure(
        const std::string& type_name, 
        const std::string& reason)
    {
        interfaces::RegistryAuditLog::log_event(interfaces::registry_event(
            interfaces::registry_action::register_service, type_name,
            interfaces::source_location::current(), false, reason));
    }

VoidResult service_container::register_factory_internal(...) {
    auto validation = validate_registration(interface_type, type_name);
    if (!validation.is_ok()) return validation;

    std::unique_lock lock(mutex_);
    // ... rest of registration
}

// In resolve_with_detection:
case service_lifetime::singleton: {
    if (entry.is_instantiated) {
        return Result<std::shared_ptr<void>>::ok(entry.singleton_instance);
    }
    read_lock.unlock();
    
    auto result = invoke_factory_safe(factory_copy);
    if (!result.is_ok()) return result;
    // ... store instance
}