Panic when parsing client messages with tokio-tungstenite

I've another related problem... It seems like I don't receive the world message:

// level/level.rs: Level
// ...
    pub fn next_frame(&mut self, delta: Duration, peers: Peers) {
        // Send the world to every peer
        let world = self.world(Arc::clone(&peers));
        let world_serialized = serde_json::to_string(&world).unwrap();
        for (_, peer) in peers.lock().unwrap().iter() {
            peer.sender.unbounded_send(Message::Text(world_serialized.clone())).unwrap();
        }

        // Step physics simulation forward.
        // ...

Any idea? This is where the frame interval lies:

async fn run_server(address: String) {
    let listener = TcpListener::bind(address.as_str()).await.unwrap();
    println!("Server running at {address}");

    let peers = Arc::new(Mutex::new(HashMap::new()));
    let mut level = Arc::new(Mutex::new(Level::new()));
    let mut interval = interval(FRAME_DURATION);

    tokio::spawn({
        let level = Arc::clone(&mut level);
        let peers = Arc::clone(&peers);
        async move {
            let tick = interval.tick().await;
            level.lock().unwrap().next_frame(tick.elapsed(), peers);
        }
    });

    // Peer connections
    while let Ok((stream, address)) = listener.accept().await {
        tokio::spawn(handle_connection(peers.clone(), stream, address, Arc::clone(&level)));
    }
}

Here's the related client code in TypeScript:

export default class Socket {
    readonly onMessage = new EventEmitter<SocketServerMessage>();
    private _socket: WebSocket | undefined = undefined;

    /**
     * @throws {SocketConnectError}
     */
    connect(): Promise<void> {
        if (this._socket != undefined) {
            this._socket!.close();
            this._socket = undefined;
        }
        return new Promise<void>((resolve, reject) => {
            this._socket = new WebSocket('ws://127.0.0.1:8080');
            this._socket.addEventListener('open', _ => {
                resolve(undefined);
            });
            this._socket.addEventListener('error', _ => {
                reject(new SocketConnectError("Failed to connect to the WebSocket server."));
            });
            this._socket.addEventListener('message', event => {
                if (typeof event.data === "string") {
                    this.onMessage.emit(JSON.parse(event.data));
                }
            });
        });
    }

    send(message: SocketClientMessage) {
        this._socket?.send(JSON.stringify(message));
    }

    disconnect() {
        this._socket?.close();
        this._socket = undefined;
    }
}

Level.ts:

export default class Level {
    private _displaying: boolean = false;
    private _resizeListener: any = undefined;
    private _application: pixi.Application | undefined = undefined;
    private _displayVariables: LevelDisplayVariables | undefined = undefined;
    private _socket: Socket = new Socket();

    constructor() {
        let counter = 0;
        this._socket.onMessage.listen(message => {
            if (message.type == "World") {
                const pixiStage = this._application!.stage;
                pixiStage.removeChildren();
                const { world } = message;
                for (const entity of world.entities) {
                    if (entity.type == "Car") {
                        const orient = (sprite: pixi.Sprite) => {
                            sprite.anchor.set(0.5);
                            sprite.position.set(entity.x, entity.y);
                            sprite.rotation = entity.rotationRadians;
                            if (counter == 0) {
                                console.log(`(${entity.x}, ${entity.y})`);
                            }
                            counter += 1;
                            counter %= 1_000;
                        };
                        const shadow = new pixi.Sprite(pixi.Texture.from("assets/carShadow/car-shadow.png"));
                        shadow.scale.set(1.3, 1.6);
                        const car = new pixi.Sprite(pixi.Texture.from("assets/carSkins/porsche-carrera-gt.png"));
                        pixiStage.addChild(shadow);
                        pixiStage.addChild(car);
                        orient(shadow);
                        orient(car);
                    }
                }
            }
        });
    }
// ...

Logs nothing!