Function _dispatch

helpers/ws.py:559–645

(event, sid, data)

    @socketio_server.on("*", namespace=NAMESPACE)  # type: ignore
    async def _dispatch(event, sid, data):
        incoming = data if isinstance(data, dict) else {}

        try:
            with _contexts_lock:
                ctx = _ws_contexts.get(sid)
                activated = dict(_active_handlers.get(sid, {}))

            correlation_id = incoming.get("correlationId") or uuid.uuid4().hex

            if ctx is None:
                return _error_response("AUTH_REQUIRED",
                                       "No security context", correlation_id)
            if not activated:
                return _error_response("NO_HANDLERS",
                                       "No handlers activated", correlation_id)

            # Pre-filter handlers through security checks
            passing_handlers: list[WsHandler] = []
            security_errors: list[dict[str, Any]] = []
            for path, instance in activated.items():
                error = _check_security(type(instance), ctx)
                if error is not None:
                    security_errors.append({
                        "handlerId": instance.identifier,
                        "ok": False,
                        "correlationId": correlation_id,
                        "error": error,
                    })
                else:
                    passing_handlers.append(instance)

            # Delegate to WsManager for unified processing pipeline
            # (worker thread isolation, diagnostic events, WsResult support)
            if manager is not None and passing_handlers:
                result = await manager.process_client_event(
                    NAMESPACE, event, incoming, sid,
                    handlers=passing_handlers,
                )
                if security_errors:
                    result["results"] = security_errors + result.get("results", [])
                return result

            # All handlers failed security or no manager — return collected errors
            if not passing_handlers:
                return {"correlationId": correlation_id, "results": security_errors}

            # Fallback: inline processing (no manager — should not happen in practice)
            handler_payload: dict[str, Any]
            if "data" in incoming and isinstance(incoming.get("data"), dict):
                handler_payload = dict(incoming["data"])
            else:
                handler_payload = dict(incoming)
            handler_payload["correlationId"] = correlation_id

            results: list[dict[str, Any]] = list(security_errors)
            for path, instance in activated.items():
                if instance not in passing_handlers: