fix(bridge): update call sites for Result<T> factory migration

libs/network-udp/src/secure_messaging_udp_client.cpp

@@ -297,8 +297,17 @@ auto secure_messaging_udp_client::do_start_impl(
 	asio::ip::udp::socket udp_socket(*io_context_, asio::ip::udp::v4());
 
 	// Create DTLS socket
-	socket_ = std::make_shared<internal::dtls_socket>(
+	auto socket_result = internal::dtls_socket::create(
 		std::move(udp_socket), ssl_ctx_);
+	if (!socket_result.is_ok())
+	{
+		SSL_CTX_free(ssl_ctx_);
+		ssl_ctx_ = nullptr;
+		return error_void(error_codes::common_errors::internal_error,
+		                  "Failed to create DTLS socket",
+		                  "secure_messaging_udp_client::do_start_impl");
+	}
+	socket_ = socket_result.value();
 
 	// Set peer endpoint
 	{

libs/network-udp/src/secure_messaging_udp_server.cpp

@@ -349,8 +349,13 @@ auto secure_messaging_udp_server::create_session(
 		asio::ip::udp::socket client_socket(*io_context_, asio::ip::udp::v4());
 
 		auto session = std::make_shared<dtls_session>();
-		session->socket = std::make_shared<internal::dtls_socket>(
+		auto socket_result = internal::dtls_socket::create(
 			std::move(client_socket), ssl_ctx_);
+		if (!socket_result.is_ok())
+		{
+			return nullptr;
+		}
+		session->socket = socket_result.value();
 		session->socket->set_peer_endpoint(client_endpoint);
 
 		// Set receive callback

src/integration/network_system_bridge.cpp

@@ -313,8 +313,10 @@ std::shared_ptr<NetworkSystemBridge> NetworkSystemBridge::create_default() {
 
     // Try to create thread pool from thread_system if available
 #if KCENON_WITH_THREAD_SYSTEM
-    auto thread_pool_bridge = ThreadPoolBridge::from_thread_system("network_pool");
-    bridge->set_thread_pool_bridge(thread_pool_bridge);
+    auto thread_pool_result = ThreadPoolBridge::from_thread_system("network_pool");
+    if (thread_pool_result.is_ok()) {
+        bridge->set_thread_pool_bridge(thread_pool_result.value());
+    }
 #endif
 
     return bridge;
@@ -325,8 +327,10 @@ std::shared_ptr<NetworkSystemBridge> NetworkSystemBridge::with_thread_system(
     auto bridge = std::make_shared<NetworkSystemBridge>();
 
 #if KCENON_WITH_THREAD_SYSTEM
-    auto thread_pool_bridge = ThreadPoolBridge::from_thread_system(pool_name);
-    bridge->set_thread_pool_bridge(thread_pool_bridge);
+    auto thread_pool_result = ThreadPoolBridge::from_thread_system(pool_name);
+    if (thread_pool_result.is_ok()) {
+        bridge->set_thread_pool_bridge(thread_pool_result.value());
+    }
 #endif
 
     return bridge;
@@ -342,8 +346,10 @@ std::shared_ptr<NetworkSystemBridge> NetworkSystemBridge::with_common_system(
 
     // Set up thread pool bridge
     if (executor) {
-        auto thread_pool_bridge = ThreadPoolBridge::from_common_system(executor);
-        bridge->set_thread_pool_bridge(thread_pool_bridge);
+        auto thread_pool_result = ThreadPoolBridge::from_common_system(executor);
+        if (thread_pool_result.is_ok()) {
+            bridge->set_thread_pool_bridge(thread_pool_result.value());
+        }
     }
 
     // Set up logger
@@ -370,9 +376,11 @@ std::shared_ptr<NetworkSystemBridge> NetworkSystemBridge::with_custom(
     auto bridge = std::make_shared<NetworkSystemBridge>();
 
     if (thread_pool) {
-        auto thread_pool_bridge = std::make_shared<ThreadPoolBridge>(
+        auto thread_pool_result = ThreadPoolBridge::create(
             thread_pool, ThreadPoolBridge::BackendType::Custom);
-        bridge->set_thread_pool_bridge(thread_pool_bridge);
+        if (thread_pool_result.is_ok()) {
+            bridge->set_thread_pool_bridge(thread_pool_result.value());
+        }
     }
 
     if (logger) {

src/integration/thread_system_adapter.cpp

@@ -147,7 +147,8 @@ std::shared_ptr<thread_system_pool_adapter> thread_system_pool_adapter::create_d
     }
 
     (void)pool->start(); // best-effort start; ignore error to keep adapter usable
-    return std::make_shared<thread_system_pool_adapter>(std::move(pool));
+    auto result = thread_system_pool_adapter::create(std::move(pool));
+    return result.is_ok() ? result.value() : nullptr;
 }
 
 std::shared_ptr<thread_system_pool_adapter> thread_system_pool_adapter::from_service_or_default(
@@ -156,7 +157,8 @@ std::shared_ptr<thread_system_pool_adapter> thread_system_pool_adapter::from_ser
     try {
         auto& sc = kcenon::thread::service_container::global();
         if (auto existing = sc.resolve<kcenon::thread::thread_pool>()) {
-            return std::make_shared<thread_system_pool_adapter>(std::move(existing));
+            auto result = thread_system_pool_adapter::create(std::move(existing));
+            if (result.is_ok()) return result.value();
         }
     } catch (...) {
         // ignore and fallback

src/internal/integration/thread_pool_adapters.h

@@ -277,16 +277,17 @@ class common_to_network_thread_adapter : public thread_pool_interface {
      * @param executor The common_system executor to adapt
      * @return Result with adapter or error if executor is nullptr
      */
-    [[nodiscard]] static Result<std::shared_ptr<common_to_network_thread_adapter>>
+    [[nodiscard]] static ::kcenon::common::Result<std::shared_ptr<common_to_network_thread_adapter>>
     create(std::shared_ptr<::kcenon::common::interfaces::IExecutor> executor) {
         if (!executor) {
-            return error<std::shared_ptr<common_to_network_thread_adapter>>(
-                error_codes::common_errors::invalid_argument,
+            return ::kcenon::common::Result<std::shared_ptr<common_to_network_thread_adapter>>::err(
+                ::kcenon::common::error_codes::INVALID_ARGUMENT,
                 "common_to_network_thread_adapter requires non-null executor",
                 "common_to_network_thread_adapter::create");
         }
-        return ok(std::shared_ptr<common_to_network_thread_adapter>(
-            new common_to_network_thread_adapter(std::move(executor))));
+        return ::kcenon::common::Result<std::shared_ptr<common_to_network_thread_adapter>>::ok(
+            std::shared_ptr<common_to_network_thread_adapter>(
+                new common_to_network_thread_adapter(std::move(executor))));
     }
 
     /**

src/internal/utils/message_validator.h

@@ -19,7 +19,7 @@
  * @example
  * @code
  * // Validate incoming message size
- * if (!message_validator::validate_size(data.size())) {
+ * if (message_validator::validate_size(data.size()) != validation_result::ok) {
  *     return error::message_too_large;
  * }
  *
@@ -125,24 +125,11 @@ class message_validator {
      *
      * @param size Size to validate
      * @param max_size Maximum allowed size (default: MAX_MESSAGE_SIZE)
-     * @return true if size is within limit, false otherwise
-     */
-    [[nodiscard]] static bool validate_size(
-            size_t size,
-            size_t max_size = message_limits::MAX_MESSAGE_SIZE) noexcept {
-        return size <= max_size;
-    }
-
-    /**
-     * @brief Validate message size against limit
-     *
-     * @param size Size to validate
-     * @param max_size Maximum allowed size
      * @return validation_result::ok if valid, validation_result::size_exceeded otherwise
      */
     [[nodiscard]] static validation_result validate_size(
             size_t size,
-            size_t max_size = message_limits::MAX_MESSAGE_SIZE) {
+            size_t max_size = message_limits::MAX_MESSAGE_SIZE) noexcept {
         if (size > max_size) {
             return validation_result::size_exceeded;
         }

tests/unit/message_validator_extended_test.cpp

@@ -53,8 +53,8 @@ TEST(ValidationResultToStringTest, AllEnumValues)
 
 TEST(MessageValidatorExtendedTest, ValidateZeroSize)
 {
-	EXPECT_TRUE(message_validator::validate_size(0));
-	EXPECT_TRUE(message_validator::validate_size(0, 0));
+	EXPECT_EQ(message_validator::validate_size(0), validation_result::ok);
+	EXPECT_EQ(message_validator::validate_size(0, 0), validation_result::ok);
 }
 
 TEST(MessageValidatorExtendedTest, ValidateSizeResultCustomLimit)

tests/unit/test_dtls_socket.cpp

@@ -101,29 +101,25 @@ class DtlsSocketTest : public ::testing::Test
 // Construction Tests
 // ============================================================================
 
-TEST_F(DtlsSocketTest, ConstructWithValidContext)
+TEST_F(DtlsSocketTest, CreateWithValidContext)
 {
 	auto socket = create_server_socket();
-	EXPECT_NO_THROW({
-		auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
-		EXPECT_NE(dtls, nullptr);
-	});
+	auto result = dtls_socket::create(std::move(socket), server_ctx_.get());
+	EXPECT_TRUE(result.is_ok());
+	EXPECT_NE(result.value(), nullptr);
 }
 
-TEST_F(DtlsSocketTest, ConstructWithNullContextThrows)
+TEST_F(DtlsSocketTest, CreateWithNullContextReturnsError)
 {
 	auto socket = create_server_socket();
-	EXPECT_THROW(
-		{
-			auto dtls = std::make_shared<dtls_socket>(std::move(socket), nullptr);
-		},
-		std::runtime_error);
+	auto result = dtls_socket::create(std::move(socket), nullptr);
+	EXPECT_TRUE(result.is_err());
 }
 
 TEST_F(DtlsSocketTest, InitialStateNotHandshakeComplete)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	EXPECT_FALSE(dtls->is_handshake_complete());
 }
@@ -135,7 +131,7 @@ TEST_F(DtlsSocketTest, InitialStateNotHandshakeComplete)
 TEST_F(DtlsSocketTest, SetReceiveCallback)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	std::atomic<bool> callback_set{false};
 
@@ -151,7 +147,7 @@ TEST_F(DtlsSocketTest, SetReceiveCallback)
 TEST_F(DtlsSocketTest, SetErrorCallback)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	EXPECT_NO_THROW({
 		dtls->set_error_callback([](std::error_code) {});
@@ -161,7 +157,7 @@ TEST_F(DtlsSocketTest, SetErrorCallback)
 TEST_F(DtlsSocketTest, SetPeerEndpoint)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	asio::ip::udp::endpoint peer(asio::ip::make_address("127.0.0.1"), 12345);
 	dtls->set_peer_endpoint(peer);
@@ -177,7 +173,7 @@ TEST_F(DtlsSocketTest, SetPeerEndpoint)
 TEST_F(DtlsSocketTest, StartReceiveDoesNotThrow)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	EXPECT_NO_THROW({
 		dtls->start_receive();
@@ -189,7 +185,7 @@ TEST_F(DtlsSocketTest, StartReceiveDoesNotThrow)
 TEST_F(DtlsSocketTest, StopReceiveDoesNotThrow)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	EXPECT_NO_THROW({
 		dtls->stop_receive();
@@ -199,7 +195,7 @@ TEST_F(DtlsSocketTest, StopReceiveDoesNotThrow)
 TEST_F(DtlsSocketTest, MultipleStartReceiveCalls)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	// Multiple start calls should be safe
 	EXPECT_NO_THROW({
@@ -218,7 +214,7 @@ TEST_F(DtlsSocketTest, MultipleStartReceiveCalls)
 TEST_F(DtlsSocketTest, SendBeforeHandshakeFails)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	std::promise<std::error_code> send_promise;
 	auto send_future = send_promise.get_future();
@@ -252,11 +248,11 @@ TEST_F(DtlsSocketTest, ClientServerHandshake)
 {
 	// Create server DTLS socket
 	auto server_udp = create_server_socket();
-	auto server_dtls = std::make_shared<dtls_socket>(std::move(server_udp), server_ctx_.get());
+	auto server_dtls = dtls_socket::create(std::move(server_udp), server_ctx_.get()).value();
 
 	// Create client DTLS socket
 	auto client_udp = create_client_socket();
-	auto client_dtls = std::make_shared<dtls_socket>(std::move(client_udp), client_ctx_.get());
+	auto client_dtls = dtls_socket::create(std::move(client_udp), client_ctx_.get()).value();
 
 	// Set peer endpoints
 	asio::ip::udp::endpoint server_endpoint(asio::ip::make_address("127.0.0.1"), test_port_);
@@ -336,7 +332,7 @@ TEST_F(DtlsSocketTest, ClientServerHandshake)
 TEST_F(DtlsSocketTest, ConcurrentCallbackRegistration)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	std::atomic<int> registration_count{0};
 	const int num_registrations = 100;
@@ -373,7 +369,7 @@ TEST_F(DtlsSocketTest, ConcurrentCallbackRegistration)
 TEST_F(DtlsSocketTest, ConcurrentEndpointAccess)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	std::atomic<int> operation_count{0};
 	const int num_operations = 100;
@@ -419,7 +415,7 @@ TEST_F(DtlsSocketTest, SocketAccessReturnsValidSocket)
 	auto socket = create_server_socket();
 	auto expected_port = socket.local_endpoint().port();
 
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	EXPECT_TRUE(dtls->socket().is_open());
 	EXPECT_EQ(dtls->socket().local_endpoint().port(), expected_port);
@@ -434,7 +430,7 @@ TEST_F(DtlsSocketTest, DestructorAfterStartReceive)
 	// Test that destructor properly cleans up after start_receive
 	EXPECT_NO_THROW({
 		auto socket = create_server_socket();
-		auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+		auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 		dtls->start_receive();
 		// Destructor called when dtls goes out of scope
 	});
@@ -446,7 +442,7 @@ TEST_F(DtlsSocketTest, DestructorAfterStartReceive)
 TEST_F(DtlsSocketTest, MultipleStopReceiveCalls)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	dtls->start_receive();
 
@@ -518,11 +514,11 @@ TEST_F(DtlsSocketIntegrationTest, SendReceiveAfterHandshake)
 {
 	// Create server DTLS socket
 	auto server_udp = create_server_socket();
-	auto server_dtls = std::make_shared<dtls_socket>(std::move(server_udp), server_ctx_.get());
+	auto server_dtls = dtls_socket::create(std::move(server_udp), server_ctx_.get()).value();
 
 	// Create client DTLS socket
 	auto client_udp = create_client_socket();
-	auto client_dtls = std::make_shared<dtls_socket>(std::move(client_udp), client_ctx_.get());
+	auto client_dtls = dtls_socket::create(std::move(client_udp), client_ctx_.get()).value();
 
 	// Set peer endpoints
 	asio::ip::udp::endpoint server_endpoint(asio::ip::make_address("127.0.0.1"), test_port_);
@@ -595,11 +591,11 @@ TEST_F(DtlsSocketIntegrationTest, BidirectionalCommunication)
 {
 	// Create server DTLS socket
 	auto server_udp = create_server_socket();
-	auto server_dtls = std::make_shared<dtls_socket>(std::move(server_udp), server_ctx_.get());
+	auto server_dtls = dtls_socket::create(std::move(server_udp), server_ctx_.get()).value();
 
 	// Create client DTLS socket
 	auto client_udp = create_client_socket();
-	auto client_dtls = std::make_shared<dtls_socket>(std::move(client_udp), client_ctx_.get());
+	auto client_dtls = dtls_socket::create(std::move(client_udp), client_ctx_.get()).value();
 
 	// Set peer endpoints
 	asio::ip::udp::endpoint server_endpoint(asio::ip::make_address("127.0.0.1"), test_port_);
@@ -685,7 +681,7 @@ TEST_F(DtlsSocketIntegrationTest, BidirectionalCommunication)
 TEST_F(DtlsSocketTest, ErrorCallbackInvokedOnSocketClose)
 {
 	auto socket = create_server_socket();
-	auto dtls = std::make_shared<dtls_socket>(std::move(socket), server_ctx_.get());
+	auto dtls = dtls_socket::create(std::move(socket), server_ctx_.get()).value();
 
 	std::promise<std::error_code> error_promise;
 	auto error_future = error_promise.get_future();
@@ -725,11 +721,11 @@ TEST_F(DtlsSocketIntegrationTest, LargePayload)
 {
 	// Create server DTLS socket
 	auto server_udp = create_server_socket();
-	auto server_dtls = std::make_shared<dtls_socket>(std::move(server_udp), server_ctx_.get());
+	auto server_dtls = dtls_socket::create(std::move(server_udp), server_ctx_.get()).value();
 
 	// Create client DTLS socket
 	auto client_udp = create_client_socket();
-	auto client_dtls = std::make_shared<dtls_socket>(std::move(client_udp), client_ctx_.get());
+	auto client_dtls = dtls_socket::create(std::move(client_udp), client_ctx_.get()).value();
 
 	// Set peer endpoints
 	asio::ip::udp::endpoint server_endpoint(asio::ip::make_address("127.0.0.1"), test_port_);