coro-channel: resuming before having a chance to yield about lit HOT 2 OPEN

  local function wait()
    local thread = coroutine.running()
    return function (err)
      print("reaching assertResume")
      assertResume(thread, err)
    end
  end

    print("reaching socket:write")
    local success, err = socket:write(chunk, wait())
    if not success then
      closer.errored = err
      closer.check()
      print("reaching return")
      return nil, err
    end
    print("reaching coroutine.yield")
    err = coroutine.yield()
    return not err, err

local function makeWrite(socket, closer)

  local hasYielded, hasReturned = false, false
  local function wait()
    local thread = coroutine.running()
    return function (err)
      if hasYielded then
        print("states: ", hasYielded, hasReturned)
        assertResume(thread, err)
        print("Resumed thread")
      else
        print("Skipped resuming, not yielded")
        hasReturned = err
      end
    end
  end

  local function write(chunk)
    hasYielded, hasReturned = false, false
    if closer.written then
      return nil, "already shutdown"
    end

    -- p("->", chunk)

    if chunk == nil then
      closer.written = true
      closer.check()
      local success, err = socket:shutdown(wait())
      if not success then
        return nil, err
      end
      err = coroutine.yield()
      return not err, err
    end

    local success, err = socket:write(chunk, wait())
    if not success then
      closer.errored = err
      closer.check()
      print("Write not successful")
      return nil, err
    end
    print("State before yielding:", hasYielded == true)
    if hasReturned then
      print("Returning without yielding")
      return not hasReturned, hasReturned
    else
      hasYielded = true
      print("got yielded")
      err = coroutine.yield()
      print("Returning after yielded")
      return not err, err
    end
  end

  return write
end