Starts a connection and returns it at once. It never waits: the connection reads "asking" while the user decides and "connecting" until the other side answers. Set onState to be told when that changes. Returns nil and a sentence only when the arguments are not a host and a port. Every other outcome (refused, blocked, too many) is a connection whose state says so.

One question at a time. While the user is being asked about one address for your mod, a try at a different address is turned away on the spot (state "denied", nothing remembered). Try it again once the first is answered. Another try at the same address waits on the same answer.

Limits, per mod: 8 connections at once, 5 connects a second, 1 MB waiting to be sent and 1 MB waiting to be read. A connect that has not finished after 5 seconds fails.

local ls = net.connect("127.0.0.1", 16834)    -- LiveSplit Server's default

ls:onState(function(state, why)
    if state == "open" then
        -- Asked four times a second by the engine; you hear only changes.
        ls:watch("getcurrentsplitindex\r\n", 250)
    end
end)
ls:onReceive(function(data)
    print("LiveSplit is now on", data)
end)

-- Later, whenever it is time:
ls:send("split\r\n")

One of:

Hands the bytes to the engine's network thread, which sends them at once. You may send before the connection is open: the bytes wait and go out once it opens, or are dropped if it never does. Returns false and why once the connection is closed, failed or denied, or when more than 1 MB is already waiting.

Calls fn(data) with what arrived, when something arrives, and never otherwise. TCP is a stream, not messages: a reply can arrive in pieces or two at once, so collect until you see your delimiter. While it is set, what arrives goes to it and not to receive(). nil removes it.

Calls fn(state, why) when the state changes, and once straight away with the state it is in now, so a connection that was already refused is still reported. why is what error() would say, or nil. nil removes it.

Both callbacks run on the frame loop, between frames, like everything else in your mod. A function that uses its connection keeps it alive; close() lets go of both callbacks.

For a program that has to be asked what changed, as LiveSplit does. The engine sends text every everyMs on its own clock, reads the answers itself, and passes a line on to onReceive only when it differs from the line before it. Your mod is not called at all while the answer stays the same. The first answer of a new watch always comes through. Call it again to change it, or with nil to stop.

Lines are split at \n and compared whole, so the program's answers have to be one per line. What you send yourself in between is answered on the same stream; a different line comes through, the same one does not.

Like watch, but every answer comes through: for a keep-alive, or when you need each reply. One per connection, shared with watch; the newest call wins.

Everything that has arrived since the last call, or "", for a mod that would rather look than be told. Not needed with onReceive.

Why the connection is closed, failed or denied, in a sentence. nil while nothing went wrong.

Closes it. A connection you drop all references to is closed when the collector takes it, and all of your mod's connections close when it is unloaded.