exporting to socket rather than file?

Question

From what I remember John Cormack developed a networked Quake level editor one could use to edit a level cooperatively over a network. The modern Cube game supposedly offers similar functionality. Many people have gotten tcp servers working in Blender. Exporting to sockets , rather than files, seems cleaner to me and more fun. Are there any accounts online or in the literature on the use of the network for exporting Blender assets? Here's a small server, that works in Blender, so you can see it's possible:

import asyncio

from threading import Thread

class Server:
    def __init__(self):
        self.enable(True)

    def __del__(self):
        self.enable(False)

    @property
    def enabled(self):
        return hasattr(self, "server") and self.server.is_serving()

    @enabled.setter
    def enabled(self, e):
        self.enable(e)

    #
    def enable(self, e):
        if (self.enabled != e):
            if (e):
                self.loop = asyncio.new_event_loop()

                def start_loop():
                    asyncio.set_event_loop(self.loop)

                    self.loop.run_forever()
                    self.loop.close()

                self.thread = Thread(target=start_loop, daemon=True)
                self.thread.start()

                async def start_server():
                    async def handle_request(reader, writer):
                        writer.write("test".encode())
                        await writer.drain()

                        writer.close()
                        await writer.wait_closed()

                    self.server = await asyncio.start_server(
                        handle_request,
                        '127.0.0.1',
                        7777
                    )

                    async with self.server:
                        await self.server.serve_forever()

                asyncio.run_coroutine_threadsafe(start_server(), self.loop)
            else:
                self.server.close()
                self.loop.stop()