zexus 1.6.8 → 1.7.2

package/src/zexus/stdlib/websockets.py

@@ -0,0 +1,282 @@
+"""WebSocket client & server module for Zexus standard library.
+
+Provides ``WebSocketServer`` and ``WebSocketClient`` backed by the
+``websockets`` library running on the shared asyncio background loop
+(same one used by the async TCP sockets module).
+"""
+
+import asyncio
+import threading
+from typing import Callable, Optional, Dict, Any, List
+
+# Re-use the background event loop from sockets module
+from .sockets import _get_bg_loop, _run_async
+
+
+# ---------------------------------------------------------------------------
+# Optional dependency guard
+# ---------------------------------------------------------------------------
+try:
+    import websockets
+    import websockets.server
+    import websockets.client
+    _WS_AVAILABLE = True
+except ImportError:
+    _WS_AVAILABLE = False
+
+
+def _require_ws():
+    if not _WS_AVAILABLE:
+        raise RuntimeError(
+            "WebSocket support requires the 'websockets' package. "
+            "Install with: pip install websockets"
+        )
+
+
+# ---------------------------------------------------------------------------
+# WebSocket Module (factory)
+# ---------------------------------------------------------------------------
+
+class WebSocketModule:
+    """Factory for WebSocket servers and clients."""
+
+    @staticmethod
+    def create_server(host: str, port: int, handler: Callable,
+                      path: Optional[str] = None) -> 'WebSocketServer':
+        """Create a WebSocket server.
+
+        Args:
+            host: Host address to bind (e.g. '0.0.0.0').
+            port: Port number.
+            handler: Callback ``action(ws)`` invoked for each connection.
+                     ``ws`` is a *WebSocketConnection* with ``send`` /
+                     ``receive`` / ``close`` methods.
+            path: Optional URL path filter (not enforced; for documentation).
+
+        Returns:
+            WebSocketServer instance (call ``.start()`` to begin listening).
+        """
+        _require_ws()
+        return WebSocketServer(host, port, handler, path)
+
+    @staticmethod
+    def connect(url: str, timeout: float = 10.0) -> 'WebSocketClient':
+        """Open a WebSocket client connection.
+
+        Args:
+            url: WebSocket URL, e.g. ``ws://localhost:8080/path``.
+            timeout: Connection timeout in seconds.
+
+        Returns:
+            WebSocketClient with ``send`` / ``receive`` / ``close``.
+        """
+        _require_ws()
+        return WebSocketClient(url, timeout)
+
+
+# ---------------------------------------------------------------------------
+# WebSocket Server
+# ---------------------------------------------------------------------------
+
+class WebSocketServer:
+    """WebSocket server backed by ``websockets.serve``."""
+
+    def __init__(self, host: str, port: int, handler: Callable,
+                 path: Optional[str] = None):
+        _require_ws()
+        self.host = host
+        self.port = port
+        self.handler = handler
+        self.path = path
+        self.running = False
+        self._server = None
+        self._loop = _get_bg_loop()
+
+    def start(self) -> None:
+        if self.running:
+            raise RuntimeError("WebSocket server is already running")
+        _run_async(self._async_start())
+
+    def stop(self) -> None:
+        if not self.running:
+            return
+        self.running = False
+        if self._server:
+            asyncio.run_coroutine_threadsafe(
+                self._async_stop(), self._loop
+            ).result(timeout=5)
+
+    def is_running(self) -> bool:
+        return self.running
+
+    def get_address(self) -> Dict[str, Any]:
+        return {
+            'host': self.host,
+            'port': self.port,
+            'running': self.running,
+            'path': self.path or '/',
+        }
+
+    # -- async internals ---------------------------------------------------
+
+    async def _async_start(self):
+        self._server = await websockets.server.serve(
+            self._async_handle,
+            self.host,
+            self.port,
+        )
+        self.running = True
+
+    async def _async_stop(self):
+        if self._server:
+            self._server.close()
+            await self._server.wait_closed()
+        self.running = False
+
+    async def _async_handle(self, ws):
+        """Per-connection handler coroutine."""
+        conn = WebSocketConnection(ws)
+        loop = asyncio.get_running_loop()
+        try:
+            # Run sync handler in thread executor to avoid deadlock
+            await loop.run_in_executor(None, self.handler, conn)
+        except Exception as e:
+            print(f"WebSocket handler error: {e}")
+        finally:
+            conn._closed = True
+
+
+# ---------------------------------------------------------------------------
+# WebSocket Client
+# ---------------------------------------------------------------------------
+
+class WebSocketClient:
+    """WebSocket client connection."""
+
+    def __init__(self, url: str, timeout: float = 10.0):
+        _require_ws()
+        self.url = url
+        self._ws = None
+        self._closed = False
+
+        async def _connect():
+            return await asyncio.wait_for(
+                websockets.client.connect(url), timeout=timeout
+            )
+
+        self._ws = _run_async(_connect())
+
+    def send(self, message: str) -> None:
+        """Send a text message."""
+        if self._closed:
+            raise RuntimeError("WebSocket is closed")
+
+        async def _send():
+            await self._ws.send(message)
+
+        _run_async(_send())
+
+    def send_bytes(self, data: bytes) -> None:
+        """Send binary data."""
+        if self._closed:
+            raise RuntimeError("WebSocket is closed")
+
+        async def _send():
+            await self._ws.send(data)
+
+        _run_async(_send())
+
+    def receive(self, timeout: float = 30.0) -> str:
+        """Receive a text message."""
+        if self._closed:
+            raise RuntimeError("WebSocket is closed")
+
+        async def _recv():
+            return await asyncio.wait_for(self._ws.recv(), timeout=timeout)
+
+        return _run_async(_recv())
+
+    def receive_bytes(self, timeout: float = 30.0) -> bytes:
+        """Receive binary data."""
+        return self.receive(timeout)  # websockets handles both
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        try:
+            async def _close():
+                await self._ws.close()
+            _run_async(_close(), timeout=5)
+        except Exception:
+            pass
+
+    def is_connected(self) -> bool:
+        return not self._closed and self._ws is not None
+
+    def get_address(self) -> Dict[str, Any]:
+        return {'url': self.url, 'connected': self.is_connected()}
+
+
+# ---------------------------------------------------------------------------
+# WebSocket Connection (server-side wrapper)
+# ---------------------------------------------------------------------------
+
+class WebSocketConnection:
+    """Wraps a server-side websocket for use in synchronous Zexus handlers."""
+
+    def __init__(self, ws):
+        self._ws = ws
+        self._closed = False
+
+    def send(self, message: str) -> None:
+        """Send a text message to the client."""
+        if self._closed:
+            raise RuntimeError("WebSocket is closed")
+
+        async def _send():
+            await self._ws.send(message)
+
+        _run_async(_send())
+
+    def send_bytes(self, data: bytes) -> None:
+        """Send binary data to the client."""
+        if self._closed:
+            raise RuntimeError("WebSocket is closed")
+
+        async def _send():
+            await self._ws.send(data)
+
+        _run_async(_send())
+
+    def receive(self, timeout: float = 30.0) -> str:
+        """Receive a message from the client."""
+        if self._closed:
+            raise RuntimeError("WebSocket is closed")
+
+        async def _recv():
+            return await asyncio.wait_for(self._ws.recv(), timeout=timeout)
+
+        return _run_async(_recv())
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        try:
+            async def _close():
+                await self._ws.close()
+            _run_async(_close(), timeout=5)
+        except Exception:
+            pass
+
+    def is_connected(self) -> bool:
+        return not self._closed
+
+    def get_address(self) -> Dict[str, Any]:
+        remote = getattr(self._ws, 'remote_address', None) or ('unknown', 0)
+        return {
+            'host': remote[0] if isinstance(remote, tuple) else str(remote),
+            'port': remote[1] if isinstance(remote, tuple) and len(remote) > 1 else 0,
+            'connected': self.is_connected(),
+        }

package/src/zexus/stdlib_integration.py

@@ -234,10 +234,208 @@ def create_stdlib_module(module_name, evaluator=None):
             except Exception as e:
                 return EvaluationError(f"pbkdf2 error: {str(e)}")
         
+        # generate_keypair(algorithm?) and derive_address(public_key, [prefix])
+        try:
+            from .blockchain.crypto import CryptoPlugin as _BCPlugin
+
+            def _crypto_generate_keypair(*args):
+                algorithm = args[0].value if len(args) > 0 and hasattr(args[0], 'value') else 'ECDSA'
+                try:
+                    private_key, public_key = _BCPlugin.generate_keypair(algorithm)
+                    return Map({
+                        String('private_key'): String(private_key),
+                        String('public_key'): String(public_key)
+                    })
+                except Exception as e:
+                    return EvaluationError(f"Keypair generation error: {str(e)}")
+
+            def _crypto_derive_address(*args):
+                if len(args) < 1 or len(args) > 2:
+                    return EvaluationError("derive_address() expects 1 or 2 arguments: public_key, [prefix]")
+                public_key = args[0].value if hasattr(args[0], 'value') else str(args[0])
+                prefix = None
+                if len(args) > 1:
+                    prefix = args[1].value if hasattr(args[1], 'value') else str(args[1])
+                try:
+                    result = _BCPlugin.derive_address(public_key, prefix=prefix)
+                    return String(result)
+                except Exception as e:
+                    return EvaluationError(f"Address derivation error: {str(e)}")
+
+            env.set("generate_keypair", Builtin(_crypto_generate_keypair))
+            env.set("derive_address", Builtin(_crypto_derive_address))
+            # Also register camelCase aliases used by demo files
+            env.set("generateKeypair", Builtin(_crypto_generate_keypair))
+            env.set("deriveAddress", Builtin(_crypto_derive_address))
+        except ImportError:
+            pass  # blockchain.crypto not available
+
         env.set("hash_sha256", Builtin(_crypto_hash_sha256))
         env.set("keccak256", Builtin(_crypto_keccak256))
         env.set("random_bytes", Builtin(_crypto_random_bytes))
         env.set("pbkdf2", Builtin(_crypto_pbkdf2))
+
+    elif module_name == "perf" or module_name == "stdlib/perf":
+        def _perf_vm_stats(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.vm_stats() requires unified executor")
+            stats = evaluator.unified_executor.get_statistics()
+            return _python_to_zexus(stats)
+
+        def _perf_set_vm_thresholds(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.set_vm_thresholds() requires unified executor")
+            workload = evaluator.unified_executor.workload
+            if len(args) >= 1:
+                val = _zexus_to_python(args[0])
+                if isinstance(val, int):
+                    workload.vm_threshold = val
+            if len(args) >= 2:
+                val = _zexus_to_python(args[1])
+                if isinstance(val, int):
+                    workload.jit_threshold = val
+            if len(args) >= 3:
+                val = _zexus_to_python(args[2])
+                if isinstance(val, int):
+                    workload.parallel_threshold = val
+            return Boolean(True)
+
+        def _perf_enable_vm(*args):
+            if evaluator is None:
+                return EvaluationError("perf.enable_vm() requires evaluator")
+            flag = True
+            if len(args) >= 1:
+                val = _zexus_to_python(args[0])
+                flag = bool(val)
+            evaluator.use_vm = flag
+            if evaluator.unified_executor:
+                evaluator.unified_executor.vm_enabled = flag
+            return Boolean(True)
+
+        def _perf_collect_gc(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.collect_gc() requires unified executor")
+            vm = evaluator.unified_executor.vm
+            if vm is None:
+                return EvaluationError("perf.collect_gc() requires VM initialization")
+            force = False
+            if len(args) >= 1:
+                force = bool(_zexus_to_python(args[0]))
+            result = vm.collect_garbage(force=force)
+            return _python_to_zexus(result)
+
+        def _perf_memory_stats(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.memory_stats() requires unified executor")
+            vm = evaluator.unified_executor.vm
+            if vm is None:
+                return EvaluationError("perf.memory_stats() requires VM initialization")
+            stats = vm.get_memory_stats()
+            return _python_to_zexus(stats)
+
+        def _perf_warmup(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.warmup() requires unified executor")
+            workload = evaluator.unified_executor.workload
+            vm_threshold = 1
+            jit_threshold = workload.jit_threshold
+            if len(args) >= 1:
+                val = _zexus_to_python(args[0])
+                if isinstance(val, int):
+                    vm_threshold = val
+            if len(args) >= 2:
+                val = _zexus_to_python(args[1])
+                if isinstance(val, int):
+                    jit_threshold = val
+            workload.vm_threshold = vm_threshold
+            workload.jit_threshold = jit_threshold
+            return Boolean(True)
+
+        def _perf_profile_start(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.profile_start() requires unified executor")
+            evaluator.unified_executor.ensure_vm(profile_active=True)
+            vm = evaluator.unified_executor.vm
+            if vm is None:
+                return EvaluationError("perf.profile_start() requires VM initialization")
+            vm.start_profiling()
+            return Boolean(True)
+
+        def _perf_profile_stop(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.profile_stop() requires unified executor")
+            vm = evaluator.unified_executor.vm
+            if vm is None:
+                return EvaluationError("perf.profile_stop() requires VM initialization")
+            vm.stop_profiling()
+            return Boolean(True)
+
+        def _perf_profile_report(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.profile_report() requires unified executor")
+            evaluator.unified_executor.ensure_vm(profile_active=True)
+            vm = evaluator.unified_executor.vm
+            if vm is None:
+                return EvaluationError("perf.profile_report() requires VM initialization")
+            report_format = "text"
+            top_n = 20
+            if len(args) >= 1:
+                report_format = str(_zexus_to_python(args[0]))
+            if len(args) >= 2:
+                val = _zexus_to_python(args[1])
+                if isinstance(val, int):
+                    top_n = val
+            report = vm.get_profiling_report(format=report_format, top_n=top_n)
+            return String(report)
+
+        def _perf_set_vm_config(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.set_vm_config() requires unified executor")
+            if len(args) < 1:
+                return EvaluationError("perf.set_vm_config() requires 1 argument: config map")
+            config = _zexus_to_python(args[0])
+            if not isinstance(config, dict):
+                return EvaluationError("perf.set_vm_config() expects a map")
+            evaluator.unified_executor.configure_vm(config)
+            return Boolean(True)
+
+        def _perf_set_vm_mode(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.set_vm_mode() requires unified executor")
+            if len(args) < 1:
+                return EvaluationError("perf.set_vm_mode() requires 1 argument: mode")
+            mode_value = _zexus_to_python(args[0])
+            evaluator.unified_executor.configure_vm({"mode": mode_value})
+            return Boolean(True)
+
+        def _perf_force_vm_loops(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.force_vm_loops() requires unified executor")
+            flag = True
+            if len(args) >= 1:
+                flag = bool(_zexus_to_python(args[0]))
+            evaluator.unified_executor.set_force_vm_loops(flag)
+            return Boolean(True)
+
+        def _perf_reset_vm(*args):
+            if evaluator is None or not hasattr(evaluator, "unified_executor") or not evaluator.unified_executor:
+                return EvaluationError("perf.reset_vm() requires unified executor")
+            evaluator.unified_executor.reset_vm()
+            return Boolean(True)
+
+        env.set("vm_stats", Builtin(_perf_vm_stats))
+        env.set("set_vm_thresholds", Builtin(_perf_set_vm_thresholds))
+        env.set("enable_vm", Builtin(_perf_enable_vm))
+        env.set("collect_gc", Builtin(_perf_collect_gc))
+        env.set("memory_stats", Builtin(_perf_memory_stats))
+        env.set("warmup", Builtin(_perf_warmup))
+        env.set("profile_start", Builtin(_perf_profile_start))
+        env.set("profile_stop", Builtin(_perf_profile_stop))
+        env.set("profile_report", Builtin(_perf_profile_report))
+        env.set("set_vm_config", Builtin(_perf_set_vm_config))
+        env.set("set_vm_mode", Builtin(_perf_set_vm_mode))
+        env.set("force_vm_loops", Builtin(_perf_force_vm_loops))
+        env.set("reset_vm", Builtin(_perf_reset_vm))
         
     elif module_name == "blockchain" or module_name == "stdlib/blockchain":
         from .stdlib.blockchain import BlockchainModule
@@ -283,11 +481,180 @@ def create_stdlib_module(module_name, evaluator=None):
             except Exception as e:
                 return EvaluationError(f"create_genesis_block error: {str(e)}")
         
+        def _blockchain_create_block(*args):
+            if len(args) < 4:
+                return EvaluationError("create_block() requires 4 args: index, timestamp, data, previous_hash")
+            index = int(args[0].value if hasattr(args[0], 'value') else args[0])
+            timestamp = float(args[1].value if hasattr(args[1], 'value') else args[1])
+            data = args[2].value if hasattr(args[2], 'value') else str(args[2])
+            prev_hash = args[3].value if hasattr(args[3], 'value') else str(args[3])
+            nonce = int(args[4].value if hasattr(args[4], 'value') else args[4]) if len(args) > 4 else 0
+            try:
+                result = BlockchainModule.create_block(index, timestamp, data, prev_hash, nonce)
+                return _python_to_zexus(result)
+            except Exception as e:
+                return EvaluationError(f"create_block error: {str(e)}")
+
+        def _blockchain_hash_block(*args):
+            if len(args) < 1:
+                return EvaluationError("hash_block() requires 1 argument: block (map)")
+            block_obj = args[0]
+            block = {}
+            if isinstance(block_obj, Map):
+                for k, v in block_obj.pairs.items():
+                    key = k.value if hasattr(k, 'value') else str(k)
+                    val = v.value if hasattr(v, 'value') else str(v)
+                    block[key] = val
+            try:
+                result = BlockchainModule.hash_block(block)
+                return String(result)
+            except Exception as e:
+                return EvaluationError(f"hash_block error: {str(e)}")
+
+        def _blockchain_validate_block(*args):
+            if len(args) < 1:
+                return EvaluationError("validate_block() requires 1 argument: block")
+            block_obj = args[0]
+            block = {}
+            if isinstance(block_obj, Map):
+                for k, v in block_obj.pairs.items():
+                    key = k.value if hasattr(k, 'value') else str(k)
+                    val = v.value if hasattr(v, 'value') else str(v)
+                    block[key] = val
+            prev = None
+            if len(args) > 1 and isinstance(args[1], Map):
+                prev = {}
+                for k, v in args[1].pairs.items():
+                    key = k.value if hasattr(k, 'value') else str(k)
+                    val = v.value if hasattr(v, 'value') else str(v)
+                    prev[key] = val
+            try:
+                result = BlockchainModule.validate_block(block, prev)
+                return Boolean(result)
+            except Exception as e:
+                return EvaluationError(f"validate_block error: {str(e)}")
+
+        def _blockchain_proof_of_work(*args):
+            if len(args) < 1:
+                return EvaluationError("proof_of_work() requires 1 argument: block_data")
+            block_data = args[0].value if hasattr(args[0], 'value') else str(args[0])
+            difficulty = int(args[1].value if hasattr(args[1], 'value') else args[1]) if len(args) > 1 else 4
+            max_iter = int(args[2].value if hasattr(args[2], 'value') else args[2]) if len(args) > 2 else 1000000
+            try:
+                nonce, hash_val = BlockchainModule.proof_of_work(block_data, difficulty, max_iter)
+                return _python_to_zexus({"nonce": nonce, "hash": hash_val})
+            except Exception as e:
+                return EvaluationError(f"proof_of_work error: {str(e)}")
+
+        def _blockchain_create_transaction(*args):
+            if len(args) < 3:
+                return EvaluationError("create_transaction() requires 3 args: sender, recipient, amount")
+            sender = args[0].value if hasattr(args[0], 'value') else str(args[0])
+            recipient = args[1].value if hasattr(args[1], 'value') else str(args[1])
+            amount = float(args[2].value if hasattr(args[2], 'value') else args[2])
+            timestamp = float(args[3].value if hasattr(args[3], 'value') else args[3]) if len(args) > 3 else None
+            try:
+                result = BlockchainModule.create_transaction(sender, recipient, amount, timestamp)
+                return _python_to_zexus(result)
+            except Exception as e:
+                return EvaluationError(f"create_transaction error: {str(e)}")
+
+        def _blockchain_hash_transaction(*args):
+            if len(args) < 1:
+                return EvaluationError("hash_transaction() requires 1 argument: transaction")
+            tx_obj = args[0]
+            tx = {}
+            if isinstance(tx_obj, Map):
+                for k, v in tx_obj.pairs.items():
+                    key = k.value if hasattr(k, 'value') else str(k)
+                    val = v.value if hasattr(v, 'value') else str(v)
+                    tx[key] = val
+            try:
+                result = BlockchainModule.hash_transaction(tx)
+                return String(result)
+            except Exception as e:
+                return EvaluationError(f"hash_transaction error: {str(e)}")
+
+        def _blockchain_validate_chain(*args):
+            if len(args) < 1:
+                return EvaluationError("validate_chain() requires 1 argument: chain (list of blocks)")
+            if not isinstance(args[0], ListObj):
+                return EvaluationError("validate_chain() expects a list of block maps")
+            chain = []
+            for block_obj in args[0].elements:
+                block = {}
+                if isinstance(block_obj, Map):
+                    for k, v in block_obj.pairs.items():
+                        key = k.value if hasattr(k, 'value') else str(k)
+                        val = v.value if hasattr(v, 'value') else str(v)
+                        block[key] = val
+                chain.append(block)
+            try:
+                result = BlockchainModule.validate_chain(chain)
+                return Boolean(result)
+            except Exception as e:
+                return EvaluationError(f"validate_chain error: {str(e)}")
+
         env.set("create_address", Builtin(_blockchain_create_address))
         env.set("validate_address", Builtin(_blockchain_validate_address))
         env.set("calculate_merkle_root", Builtin(_blockchain_calculate_merkle_root))
         env.set("create_genesis_block", Builtin(_blockchain_create_genesis_block))
-    
+        env.set("create_block", Builtin(_blockchain_create_block))
+        env.set("hash_block", Builtin(_blockchain_hash_block))
+        env.set("validate_block", Builtin(_blockchain_validate_block))
+        env.set("proof_of_work", Builtin(_blockchain_proof_of_work))
+        env.set("create_transaction", Builtin(_blockchain_create_transaction))
+        env.set("hash_transaction", Builtin(_blockchain_hash_transaction))
+        env.set("validate_chain", Builtin(_blockchain_validate_chain))
+
+    elif module_name == "websocket" or module_name == "stdlib/websocket":
+        try:
+            from .stdlib.websockets import WebSocketModule
+        except ImportError:
+            return env  # websockets package not installed
+
+        def _ws_create_server(*args):
+            if len(args) < 3:
+                return EvaluationError("ws_create_server() requires 3 args: host, port, handler")
+            host = args[0].value if hasattr(args[0], 'value') else str(args[0])
+            port = int(args[1].value if hasattr(args[1], 'value') else args[1])
+            handler = args[2]  # Zexus Action/Builtin — caller wraps
+            path = args[3].value if len(args) > 3 and hasattr(args[3], 'value') else None
+            try:
+                server = WebSocketModule.create_server(host, port, handler, path)
+                server.start()
+                stop_fn = Builtin(lambda *_a: (server.stop(), Boolean(True))[1])
+                is_running_fn = Builtin(lambda *_a: Boolean(server.is_running()))
+                return Map({
+                    String("stop"): stop_fn,
+                    String("is_running"): is_running_fn,
+                })
+            except Exception as e:
+                return EvaluationError(f"ws_create_server error: {e}")
+
+        def _ws_connect(*args):
+            if len(args) < 1:
+                return EvaluationError("ws_connect() requires 1 arg: url")
+            url = args[0].value if hasattr(args[0], 'value') else str(args[0])
+            timeout = float(args[1].value if len(args) > 1 and hasattr(args[1], 'value') else 10)
+            try:
+                client = WebSocketModule.connect(url, timeout)
+                send_fn = Builtin(lambda *a: (client.send(a[0].value if hasattr(a[0], 'value') else str(a[0])), Boolean(True))[1])
+                recv_fn = Builtin(lambda *a: String(client.receive(float(a[0].value) if a else 30)))
+                close_fn = Builtin(lambda *_a: (client.close(), Boolean(True))[1])
+                connected_fn = Builtin(lambda *_a: Boolean(client.is_connected()))
+                return Map({
+                    String("send"): send_fn,
+                    String("receive"): recv_fn,
+                    String("close"): close_fn,
+                    String("is_connected"): connected_fn,
+                })
+            except Exception as e:
+                return EvaluationError(f"ws_connect error: {e}")
+
+        env.set("create_server", Builtin(_ws_create_server))
+        env.set("connect", Builtin(_ws_connect))
+
     return env
 
 
@@ -323,7 +690,7 @@ def _zexus_to_python(obj):
 
 def is_stdlib_module(module_name):
     """Check if a module name refers to a stdlib module."""
-    stdlib_modules = ['fs', 'http', 'json', 'datetime', 'crypto', 'blockchain']
+    stdlib_modules = ['fs', 'http', 'json', 'datetime', 'crypto', 'blockchain', 'perf', 'websocket']
     
     # Handle both "fs" and "stdlib/fs" formats
     if module_name in stdlib_modules: