1 files changed, 36 insertions, 31 deletions

diff --git a/src/zenhorde/hordetransport.h b/src/zenhorde/hordetransport.h
index 1b178dc0f..b5e841d7a 100644
--- a/src/zenhorde/hordetransport.h
+++ b/src/zenhorde/hordetransport.h
@@ -8,55 +8,60 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <functional>
 #include <memory>
+#include <system_error>
 
-#if ZEN_PLATFORM_WINDOWS
-#	undef SendMessage
-#endif
+namespace asio {
+class io_context;
+}
 
 namespace zen::horde {
 
-/** Abstract base interface for compute transports.
+/** Handler types for async transport operations. */
+using AsyncConnectHandler = std::function<void(const std::error_code&)>;
+using AsyncIoHandler	  = std::function<void(const std::error_code&, size_t)>;
+
+/** Abstract base for asynchronous compute transports.
  *
- *  Matches the UE FComputeTransport pattern. Concrete implementations handle
- *  the underlying I/O (TCP, AES-wrapped, etc.) while this interface provides
- *  blocking message helpers on top.
+ *  All callbacks are invoked on the io_context that was provided at construction.
+ *  Callers are responsible for strand serialization if needed.
  */
-class ComputeTransport
+class AsyncComputeTransport
 {
 public:
-	virtual ~ComputeTransport() = default;
+	virtual ~AsyncComputeTransport() = default;
+
+	virtual bool IsValid() const = 0;
 
-	virtual bool   IsValid() const					   = 0;
-	virtual size_t Send(const void* Data, size_t Size) = 0;
-	virtual size_t Recv(void* Data, size_t Size)	   = 0;
-	virtual void   MarkComplete()					   = 0;
-	virtual void   Close()							   = 0;
+	/** Asynchronous write of exactly Size bytes. Handler called on completion or error. */
+	virtual void AsyncWrite(const void* Data, size_t Size, AsyncIoHandler Handler) = 0;
 
-	/** Blocking send that loops until all bytes are transferred. Returns false on error. */
-	bool SendMessage(const void* Data, size_t Size);
+	/** Asynchronous read of exactly Size bytes into Data. Handler called on completion or error. */
+	virtual void AsyncRead(void* Data, size_t Size, AsyncIoHandler Handler) = 0;
 
-	/** Blocking receive that loops until all bytes are transferred. Returns false on error. */
-	bool RecvMessage(void* Data, size_t Size);
+	virtual void Close() = 0;
 };
 
-/** TCP socket transport using ASIO.
+/** Async TCP transport using ASIO.
  *
- *  Connects to the Horde compute endpoint specified by MachineInfo and provides
- *  raw TCP send/receive. ASIO internals are hidden behind a pimpl to keep the
- *  header clean.
+ *  Connects to the Horde compute endpoint and provides async send/receive.
+ *  The socket is created on a caller-provided io_context (shared across agents).
  */
-class TcpComputeTransport final : public ComputeTransport
+class AsyncTcpComputeTransport final : public AsyncComputeTransport
 {
 public:
-	explicit TcpComputeTransport(const MachineInfo& Info);
-	~TcpComputeTransport() override;
-
-	bool   IsValid() const override;
-	size_t Send(const void* Data, size_t Size) override;
-	size_t Recv(void* Data, size_t Size) override;
-	void   MarkComplete() override;
-	void   Close() override;
+	/** Construct a transport on the given io_context. Does not connect yet. */
+	explicit AsyncTcpComputeTransport(asio::io_context& IoContext);
+	~AsyncTcpComputeTransport() override;
+
+	/** Asynchronously connect to the endpoint and send the nonce. */
+	void AsyncConnect(const MachineInfo& Info, AsyncConnectHandler Handler);
+
+	bool IsValid() const override;
+	void AsyncWrite(const void* Data, size_t Size, AsyncIoHandler Handler) override;
+	void AsyncRead(void* Data, size_t Size, AsyncIoHandler Handler) override;
+	void Close() override;
 
 private:
 	LoggerRef Log() { return m_Log; }