if err != nil {
			gridLogIf(ctx, err)
		}
	}
	// c.queueMsg will reuse m.Payload

	if m.MuxID == 0 {
		gridLogIf(ctx, c.queueMsg(m, &pongMsg{T: ping.T}))
		return
	}
	// Single calls do not support pinging.
	if v, ok := c.inStream.Load(m.MuxID); ok {
		pong := v.ping(m.Seq)
		pong.T = ping.T
		gridLogIf(ctx, c.queueMsg(m, &pong))
	} else {

	start := time.Now()
	defer func() {
		if debugPrint {
			fmt.Println("Mux", m.ID, "Handler took", time.Since(start).Round(time.Millisecond))
		}
		if r := recover(); r != nil {
			gridLogIf(ctx, fmt.Errorf("grid handler (%v) panic: %v", msg.Handler, r))
			err := RemoteErr(fmt.Sprintf("handler panic: %v", r))
			handlerErr = &err
		}
		if debugPrint {

		select {
		case respHandler <- Response{Err: err}:
			xioutil.SafeClose(respHandler)
		default:
			go func() {
				respHandler <- Response{Err: err}
				xioutil.SafeClose(respHandler)
			}()
		}
		gridLogIf(m.ctx, m.sendLocked(message{Op: OpDisconnectServerMux, MuxID: m.MuxID}))
		m.closed = true
	}
}

// respHandler
func (m *muxClient) handleOneWayStream(respHandler chan<- Response, respServer <-chan Response) {

			if debugPrint {
				fmt.Printf("grid: Handler returning from: %v %v\n", req.Method, req.URL)
			}
			if r := recover(); r != nil {
				debug.PrintStack()
				err := fmt.Errorf("grid: panic: %v\n", r)
				gridLogIf(context.Background(), err, err.Error())
				w.WriteHeader(http.StatusInternalServerError)
			}
		}()
		if debugPrint {
			fmt.Printf("grid: Got a %s request for: %v\n", req.Method, req.URL)
		}