@axpecter/lync 1.5.1 → 2.0.0

package/README.md

@@ -13,7 +13,7 @@
 
 ```toml
 [dependencies]
-Lync = "axp3cter/lync@1.5.1"
+Lync = "axp3cter/lync@2.0.0"
 ```
 
 **npm (roblox-ts)**
@@ -85,12 +85,12 @@ local Players = game:GetService("Players")
 
 local alive = Lync.createGroup("alive")
 
-Lync.onSend(function(data, name)
+Lync.onSend(function(data, name, player)
     print("[out]", name)
     return data
 end)
 
-Lync.onDrop(function(player, reason, name)
+Lync.onDrop(function(player, reason, name, data)
     warn(player.Name, "dropped", name, reason)
 end)
 
@@ -125,7 +125,7 @@ Net.Hit:listen(function(data, player)
     }, Lync.except(target))
 end)
 
-Net.Ping:listen(function()
+Net.Ping:listen(function(request, player)
     return os.clock()
 end)
 ```
@@ -163,7 +163,7 @@ end
 | | What it does |
 |:---------|:------------|
 | `Lync.start()` | Sets up transport. Server creates remotes, client connects. Call once after all definitions. |
-| `Lync.VERSION` | `"1.5.1"` |
+| `Lync.VERSION` | `"2.0.0"` |
 
 ## Packets
 
@@ -176,6 +176,7 @@ end
 | `rateLimit` | `{ maxPerSecond, burstAllowance? }` | No | Server-side token bucket. Burst defaults to maxPerSecond if you dont set it. |
 | `validate` | `(data, player) → (bool, string?)` | No | Server-side. Return `false, "reason"` to drop. Runs after NaN scan. |
 | `maxPayloadBytes` | number | No | Server-side. Max bytes a single batch of this packet can consume. Fires `onDrop` with reason `"size"` if exceeded. |
+| `timestamp` | `"frame" \| "offset" \| "full"` | No | Prepends a timestamp to each item. `"frame"` = u8 wrapping counter (1B), `"offset"` = u16 ms (2B), `"full"` = f64 clock (8B). Listeners receive it as a third argument. |
 
 **Server, single `send` with targets:**
 
@@ -198,8 +199,8 @@ packet:send(data)  -- send to server
 
 | Method | What it does |
 |:-------|:------------|
-| `packet:listen(fn(data, sender))` | Sender is `Player` on server, `nil` on client. Returns a Connection. |
-| `packet:once(fn(data, sender))` | Auto-disconnects after one fire. |
+| `packet:listen(fn(data, sender, timestamp?))` | Sender is `Player` on server, `nil` on client. `timestamp` is present when the packet has a `timestamp` config. Returns a Connection. |
+| `packet:once(fn(data, sender, timestamp?))` | Auto-disconnects after one fire. |
 | `packet:wait()` | Returns `(data, sender)`. |
 | `packet:disconnectAll()` | Kills all listeners on this packet. |
 
@@ -271,7 +272,7 @@ Access packets and queries by their short name on the returned object: `ns.Packe
 
 | Method | What it does |
 |:-------|:------------|
-| `ns:listenAll(fn(name, data, sender))` | Listens to every packet in the namespace. `name` is the short name without prefix. Returns a Connection. |
+| `ns:listenAll(fn(name, data, sender, timestamp?))` | Listens to every packet in the namespace. `name` is the short name without prefix. Returns a Connection. |
 | `ns:onSend(fn(data, name, player) → data?)` | Send middleware that only runs for this namespace. Returns a remover. |
 | `ns:onReceive(fn(data, name, player) → data?)` | Receive middleware that only runs for this namespace. Returns a remover. |
 | `ns:disconnectAll()` | Kills all listeners made through `listenAll`. |
@@ -386,7 +387,7 @@ Used as the second argument to `packet:send()` on the server.
 | `Lync.f16` | 2 | ±65,504, roughly 3 digits of precision |
 | `Lync.f32` | 4 | IEEE 754 single |
 | `Lync.f64` | 8 | IEEE 754 double |
-| `Lync.bool` | 1 | true/false. Gets packed into bitfields when inside structs. |
+| `Lync.bool` | 1 | true/false. Gets packed into bitfields when inside structs, and 8-per-byte when inside arrays. |
 
 ### Datatypes
 
@@ -417,7 +418,7 @@ Used as the second argument to `packet:send()` on the server.
 | Constructor | What it does |
 |:------------|:------------|
 | `Lync.struct({ key = codec })` | Named fields. Bools get packed into bitfields automatically. |
-| `Lync.array(codec, maxCount?)` | Variable length list with varint count. Optional `maxCount` rejects on read if exceeded. |
+| `Lync.array(codec, maxCount?)` | Variable length list with varint count. Optional `maxCount` rejects on read if exceeded. Bool arrays are bitpacked (8 per byte). |
 | `Lync.map(keyCodec, valueCodec, maxCount?)` | Key-value pairs with varint count. Optional `maxCount` rejects on read if exceeded. |
 | `Lync.optional(codec)` | 1 byte flag, value only if present. |
 | `Lync.tuple(codec, codec, ...)` | Ordered positional values, no keys. |
@@ -502,17 +503,109 @@ Same data shapes and methodology as [Blink's benchmark suite](https://github.com
 > [!NOTE]
 > Lync benchmarks run on Ryzen 7 7800X3D, 32GB DDR5-4800. Other tool numbers are from [Blink's published benchmarks](https://github.com/1Axen/blink/blob/main/benchmark/Benchmarks.md) (v0.17.1, Ryzen 9 7900X, 34GB DDR5-4800). Different CPUs so FPS numbers arent directly comparable but bandwidth numbers are since Kbps is scaled by 60/FPS. Lync hits the 60 FPS frame cap in both tests.
 
+## Stats
+
+Off by default. Call `Lync.enableStats()` before `Lync.start()` to activate. When disabled, zero overhead on send and receive paths.
+
+Per-packet counters are available directly on the Packet object. Per-player counters are available via `Lync.getPlayerStats()`.
+
+```luau
+Lync.enableStats()
+Lync.start()
+
+-- Per-packet (both sides)
+print(Net.State:getBytesSent(), Net.State:getFires(), Net.State:getDrops())
+
+-- Per-player (server only)
+local stats = Lync.getPlayerStats(player)
+if stats then
+    print(stats.bytesSent, stats.bytesReceived)
+end
+
+Lync.resetStats()  -- zeros everything in-place
+```
+
+| Function / Method | What it does |
+|:-------|:----------------|
+| `Lync.enableStats()` | Activates stat counters. Call before `start()`. |
+| `packet:getBytesSent()` | Wire bytes produced (includes batch header overhead). |
+| `packet:getBytesReceived()` | Wire bytes consumed on receive. |
+| `packet:getFires()` | Send fire count. |
+| `packet:getRecvFires()` | Receive fire count. |
+| `packet:getDrops()` | Gate rejections (rate limit, NaN, validate). |
+| `Lync.getPlayerStats(player)` | Returns `{ bytesSent, bytesReceived }` or nil. Server only. |
+| `Lync.resetStats()` | Zeros all counters in-place. |
+
+## Flush Control
+
+By default Lync flushes at 60hz (every Heartbeat). You can change this at runtime.
+
+```luau
+Lync.setFlushRate(30)  -- flush every ~33ms instead of ~16ms
+Lync.flush()           -- force an immediate flush, resets the accumulator
+```
+
+| Function | What it does |
+|:---------|:------------|
+| `Lync.setFlushRate(hz)` | 1 to 60. Default 60. Callable at runtime. At 60hz, flushes every Heartbeat directly (no accumulator). Below 60, uses an elapsed-time accumulator with drift correction. |
+| `Lync.flush()` | Immediate flush. Skips the next scheduled Heartbeat flush to prevent double-sending and XOR chain desync. |
+
+## Security
+
+### Bandwidth Throttle
+
+Server-side per-player bandwidth strike counter. Counts consecutive oversized frames with decay. Protects against clients flooding the server.
+
+```luau
+Lync.setBandwidthLimit(16384, 10)  -- 16KB soft limit, 10 strikes before drop
+```
+
+Fires `onDrop` with reason `"bandwidth"` when a player exceeds the threshold. Read failures (corrupted buffers, XOR desync) also count as strikes.
+
+### Unknown Codec Warning
+
+If a packet uses `Lync.unknown` anywhere in its codec tree without a `validate` callback, Lync prints a warning at define time. The `unknown` codec bypasses schema validation entirely; client data goes through Roblox's sidecar without type checking. Adding `validate` suppresses the warning.
+
+## Packet Capture
+
+Server-only debug tool. Records raw and XOR'd buffer hex for analysis.
+
+```luau
+Lync.startCapture("My test")
+-- fire packets...
+Lync.flush()
+Lync.stopCapture()
+
+Lync.startCapture("Another test")
+-- fire packets...
+Lync.flush()
+Lync.stopCapture()
+
+Lync.dumpCaptures()  -- writes JSON to ServerStorage.LyncCapture
+```
+
+Each entry contains the label, frame number, raw hex (pre-XOR), XOR'd hex (post-XOR, nil for unreliable), byte count, and refs count. Hex is capped at 512 bytes per buffer to keep the output manageable.
+
+| Function | What it does |
+|:---------|:------------|
+| `Lync.startCapture(label?)` | Start recording. Tags entries with the label. |
+| `Lync.stopCapture()` | Stop recording. |
+| `Lync.dumpCaptures()` | Writes all entries as JSON to a StringValue in ServerStorage, then clears. |
+
 ## Limits & Configuration
 
-Call these before `Lync.start()`.
+Call these before `Lync.start()` unless noted otherwise.
 
 | What | Default | How to change | Notes |
 |:-----|--------:|:--------------|:------|
 | Packet types | 255 | Cant change | u8 on the wire. Each query eats 2 IDs. |
 | Buffer per channel per frame | 256 KB | `Lync.setChannelMaxSize(n)` | 4 KB to 1 MB. |
-| Concurrent queries | 65,536 | Cant change | u16 correlation IDs. Freed on response or timeout. `Lync.queryPendingCount()` returns in-flight count. |
+| Concurrent queries | 65,536 | Cant change | Varint correlation IDs. Freed on response or timeout. `Lync.queryPendingCount()` returns in-flight count. Queries default to 30/s rate limit. |
+| Stats | Off | `Lync.enableStats()` | Zero overhead when off. Counters on packets and players. |
 | NaN/inf scan depth | 16 | `Lync.setValidationDepth(n)` | 4 to 32. |
 | Channel pool | 16 | `Lync.setPoolSize(n)` | 2 to 128. Extra gets GCd. |
+| Flush rate | 60 hz | `Lync.setFlushRate(n)` | 1 to 60. Runtime-safe. |
+| Bandwidth limit | 16 KB / 10 strikes | `Lync.setBandwidthLimit(n, m)` | Server-only. Per-player. |
 | Namespaces | 64 | Cant change | |
 | Delta + unreliable | Nope | Cant change | Errors at define time. |
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@axpecter/lync",
-    "version": "1.5.1",
-    "description": "Buffer networking for Roblox. Delta compression, XOR framing, built-in security.",
+    "version": "2.0.0",
+    "description": "Buffer networking for Roblox. Delta compression, XOR framing, built-in security",
     "main": "src/init.luau",
     "types": "src/index.d.ts",
     "module": "commonjs",

package/src/Types.luau

@@ -41,6 +41,7 @@ export type PacketConfig<T> = {
     rateLimit: RateLimitConfig?,
     validate: ((data: T, player: Player) -> (boolean, string?))?,
     maxPayloadBytes: number?,
+    timestamp: ("frame" | "offset" | "full")?,
 }
 
 export type QueryConfig<Req, Resp> = {
@@ -76,6 +77,15 @@ export type Registration = {
     validate: ((data: any, player: Player) -> (boolean, string?))?,
     needsGate: boolean,
     maxPayloadBytes: number?,
+    timestampMode: number,
+    _openFn: (ch: ChannelState, id: number, name: string) -> (), -- resolved at define time (#2)
+
+    -- Stats counters (mutable, incremented at runtime)
+    bytesSent: number,
+    bytesReceived: number,
+    fires: number,
+    recvFires: number,
+    drops: number,
 }
 
 export type Connection = {

package/src/api/Namespace.luau

@@ -62,7 +62,12 @@ export type Namespace = typeof(setmetatable({} :: NamespaceFields, NamespaceImpl
 -- Listens on every packet in this namespace. Returns a Connection.
 function NamespaceImpl.listenAll(
     self: Namespace,
-    callback: (name: string, data: any, sender: Player?) -> ()
+    callback: (
+        name: string,
+        data: any,
+        sender: Player?,
+        timestamp: number?
+    ) -> ()
 ): Connection
     local connections = {} :: { Connection }
     local prefix = self._name .. "."
@@ -70,8 +75,8 @@ function NamespaceImpl.listenAll(
 
     for fullName, packet in self._packets do
         local shortName = string.sub(fullName, prefixLen + 1)
-        local conn = packet:listen(function(data: any, sender: Player?): ()
-            callback(shortName, data, sender)
+        local conn = packet:listen(function(data: any, sender: Player?, timestamp: number?): ()
+            callback(shortName, data, sender, timestamp)
         end)
         table.insert(connections, conn)
         table.insert(self._tracked, conn)

package/src/api/Packet.luau

@@ -4,6 +4,7 @@
 
 local RunService = game:GetService("RunService")
 
+local Channel = require(script.Parent.Parent.internal.Channel)
 local Client = require(script.Parent.Parent.transport.Client)
 local Registry = require(script.Parent.Parent.internal.Registry)
 local Server = require(script.Parent.Parent.transport.Server)
@@ -14,34 +15,44 @@ type Connection = Types.Connection
 type Codec<T> = Types.Codec<T>
 type InternalCodec<T> = Types.InternalCodec<T>
 type PacketConfig<T> = Types.PacketConfig<T>
+type Registration = Types.Registration
 
 -- Constants -----------------------------------------------------------
 
 local IS_SERVER = RunService:IsServer()
 
-local serverWriteTo = Server.writeTo
-local serverWriteToAll = Server.writeToAll
-local serverWriteToList = Server.writeToList
-local serverWriteToAllExcept = Server.writeToAllExcept
-local serverWriteToSet = Server.writeToSet
-local clientWrite = Client.write
-
 local DELTA_TARGETED = 1
 local DELTA_BROADCAST = 2
 
+local TS_LOOKUP = {
+    frame = Channel.TS_FRAME,
+    offset = Channel.TS_OFFSET,
+    full = Channel.TS_FULL,
+}
+
 -- Private -------------------------------------------------------------
 
 type PacketFields = {
-    _id: number,
-    _name: string,
-    _codec: Codec<any>,
+    _reg: Registration,
     _isUnreliable: boolean,
     _isDelta: boolean,
     _deltaMode: number,
     _signal: Signal.Signal,
 }
 
--- Server-only metatable. Single send() dispatches on target type.
+local function checkDeltaMode(self: any, mode: number): ()
+    if not self._isDelta then
+        return
+    end
+    local current = self._deltaMode
+    if current == 0 then
+        self._deltaMode = mode
+    elseif current ~= mode then
+        error(`[Lync] Delta packet cannot mix targeted and broadcast: "{self._reg.name}"`)
+    end
+end
+
+-- Server-only metatable
 local ServerImpl = {}
 ServerImpl.__index = ServerImpl
 
@@ -63,67 +74,68 @@ function ServerImpl.disconnectAll(self: Packet): ()
     self._signal:disconnectAll()
 end
 
-local function checkDeltaMode(self: Packet, mode: number): ()
-    if not self._isDelta then
-        return
-    end
-    local current = self._deltaMode
-    if current == 0 then
-        self._deltaMode = mode
-    elseif current ~= mode then
-        error(`[Lync] Delta packet cannot mix targeted and broadcast: "{self._name}"`)
-    end
-end
-
 function ServerImpl.send(self: Packet, data: any, target: any?): ()
     if target == nil then
         error("[Lync] Server packet:send requires a target")
     end
 
-    local id = self._id
-    local name = self._name
-    local codec = self._codec
+    local reg = self._reg
     local isUnreliable = self._isUnreliable
 
-    -- Single player
     if typeof(target) == "Instance" then
         checkDeltaMode(self, DELTA_TARGETED)
-        serverWriteTo(target :: Player, id, name, codec, data, isUnreliable)
+        Server.writeTo(target :: Player, reg, data, isUnreliable)
         return
     end
 
-    -- Must be a table from here
     local tag = target._tag
 
-    -- Lync.all sentinel
     if tag == "all" then
         checkDeltaMode(self, DELTA_BROADCAST)
-        serverWriteToAll(id, name, codec, data, isUnreliable)
+        Server.writeToAll(reg, data, isUnreliable)
         return
     end
 
-    -- Lync.except(player, ...) descriptor
     if tag == "except" then
         checkDeltaMode(self, DELTA_BROADCAST)
-        serverWriteToAllExcept(target._set, id, name, codec, data, isUnreliable)
+        Server.writeToAllExcept(target._set, reg, data, isUnreliable)
         return
     end
 
-    -- Group object
     if tag == "group" then
         checkDeltaMode(self, DELTA_BROADCAST)
-        serverWriteToSet(target:getSet(), id, name, codec, data, isUnreliable)
+        Server.writeToSet(target:getSet(), reg, data, isUnreliable)
         return
     end
 
-    -- Player list(array)
     checkDeltaMode(self, DELTA_TARGETED)
-    serverWriteToList(target :: { Player }, id, name, codec, data, isUnreliable)
+    Server.writeToList(target :: { Player }, reg, data, isUnreliable)
+end
+
+-- Stats: read directly from registration
+function ServerImpl.getBytesSent(self: Packet): number
+    return self._reg.bytesSent
+end
+
+function ServerImpl.getBytesReceived(self: Packet): number
+    return self._reg.bytesReceived
+end
+
+function ServerImpl.getFires(self: Packet): number
+    return self._reg.fires
+end
+
+function ServerImpl.getRecvFires(self: Packet): number
+    return self._reg.recvFires
+end
+
+function ServerImpl.getDrops(self: Packet): number
+    return self._reg.drops
 end
 
 table.freeze(ServerImpl)
 
--- Client-only metatable. Has send(), no target needed.
+-- Client-only metatable
 local ClientImpl = {}
 ClientImpl.__index = ClientImpl
 
@@ -144,9 +156,15 @@ function ClientImpl.disconnectAll(self: Packet): ()
 end
 
 function ClientImpl.send(self: Packet, data: any): ()
-    clientWrite(self._id, self._name, self._codec, data, self._isUnreliable)
+    Client.write(self._reg, data, self._isUnreliable)
 end
 
+ClientImpl.getBytesSent = ServerImpl.getBytesSent
+ClientImpl.getBytesReceived = ServerImpl.getBytesReceived
+ClientImpl.getFires = ServerImpl.getFires
+ClientImpl.getRecvFires = ServerImpl.getRecvFires
+ClientImpl.getDrops = ServerImpl.getDrops
+
 table.freeze(ClientImpl)
 
 -- Public --------------------------------------------------------------
@@ -167,6 +185,22 @@ function PacketModule.define(name: string, config: PacketConfig<any>): Packet
         error(`[Lync] Delta codec requires reliable delivery: "{name}"`)
     end
 
+    local timestampMode = if config.timestamp then TS_LOOKUP[config.timestamp] else nil
+    if config.timestamp and not timestampMode then
+        error(`[Lync] Invalid timestamp mode: "{config.timestamp}" on packet "{name}"`)
+    end
+
+    if timestampMode then
+        Channel.enableTimestamps()
+    end
+
+    local hasUnknown = (config.value :: any)._hasUnknown
+    if hasUnknown and not config.validate then
+        warn(
+            `[Lync] Packet "{name}" uses Lync.unknown: client data bypasses schema validation. Add a validate callback.`
+        )
+    end
+
     local signal = Signal.create()
 
     local reg = Registry.register(
@@ -176,15 +210,14 @@ function PacketModule.define(name: string, config: PacketConfig<any>): Packet
         signal,
         config.rateLimit,
         config.validate,
-        config.maxPayloadBytes
+        config.maxPayloadBytes,
+        timestampMode
     )
 
     local isDelta = (config.value :: InternalCodec<any>)._isDelta == true
 
     local fields: PacketFields = {
-        _id = reg.id,
-        _name = reg.name,
-        _codec = reg.codec,
+        _reg = reg,
         _isUnreliable = isUnreliable,
         _isDelta = isDelta,
         _deltaMode = 0,

package/src/api/Query.luau

@@ -28,6 +28,7 @@ type PendingQuery = {
     thread: thread?,
     callback: ((data: any) -> ())?,
     timeout: thread?,
+    source: Player?,
 }
 
 local _pending = {} :: { [number]: PendingQuery }
@@ -60,12 +61,17 @@ local function releaseCorrelation(): ()
     _activeCount -= 1
 end
 
-local function completeQuery(id: number, data: any): ()
+local function completeQuery(id: number, data: any, source: Player?): ()
     local entry = _pending[id]
     if not entry then
         return
     end
 
+    -- Reject responses from wrong player (prevents correlation spoofing)
+    if source ~= nil and entry.source ~= nil and source ~= entry.source then
+        return
+    end
+
     _pending[id] = nil
     releaseCorrelation()
 
@@ -110,7 +116,7 @@ local function requestMulti(self: Query, players: { Player }, data: any): { [Pla
     if count == 1 then
         local correlation = allocCorrelation()
         local thread = coroutine.running()
-        local entry: PendingQuery = { thread = thread, timeout = nil }
+        local entry: PendingQuery = { thread = thread, timeout = nil, source = players[1] }
         _pending[correlation] = entry
 
         Server.writeQuery(
@@ -154,6 +160,7 @@ local function requestMulti(self: Query, players: { Player }, data: any): { [Pla
                 end
             end,
             timeout = nil,
+            source = player,
         }
 
         _pending[correlation] = entry
@@ -196,12 +203,18 @@ function QueryImpl.listen(self: Query, callback: (...any) -> any): Connection
     if IS_SERVER then
         return self._reqReg.signal:connect(
             function(request: any, player: Player, correlation: number): ()
-                local ok, response = pcall(callback, request, player)
-                if not ok then
-                    warn(`[Lync] Query handler error on "{respName}": {response}`)
+                local results = table.pack(pcall(callback, request, player))
+                if not results[1] then
+                    warn(`[Lync] Query handler error on "{respName}": {results[2]}`)
+                    Server.writeQueryNil(player, respId, respName, correlation)
+                    return
                 end
 
-                if ok and response ~= nil then
+                local response = if results.n > 2
+                    then table.move(results, 2, results.n, 1, table.create(results.n - 1))
+                    else results[2]
+
+                if response ~= nil then
                     Server.writeQuery(player, respId, respName, correlation, respCodec, response)
                 else
                     Server.writeQueryNil(player, respId, respName, correlation)
@@ -211,12 +224,18 @@ function QueryImpl.listen(self: Query, callback: (...any) -> any): Connection
     else
         return self._reqReg.signal:connect(
             function(request: any, _player: Player?, correlation: number): ()
-                local ok, response = pcall(callback, request)
-                if not ok then
-                    warn(`[Lync] Query handler error on "{respName}": {response}`)
+                local results = table.pack(pcall(callback, request))
+                if not results[1] then
+                    warn(`[Lync] Query handler error on "{respName}": {results[2]}`)
+                    Client.writeQueryNil(respId, respName, correlation)
+                    return
                 end
 
-                if ok and response ~= nil then
+                local response = if results.n > 2
+                    then table.move(results, 2, results.n, 1, table.create(results.n - 1))
+                    else results[2]
+
+                if response ~= nil then
                     Client.writeQuery(respId, respName, correlation, respCodec, response)
                 else
                     Client.writeQueryNil(respId, respName, correlation)
@@ -251,7 +270,7 @@ function QueryImpl.requestFrom(self: Query, player: Player, data: any): any
 
     local correlation = allocCorrelation()
     local thread = coroutine.running()
-    local entry: PendingQuery = { thread = thread, timeout = nil }
+    local entry: PendingQuery = { thread = thread, timeout = nil, source = player }
     _pending[correlation] = entry
 
     Server.writeQuery(player, self._reqReg.id, self._name, correlation, self._reqReg.codec, data)
@@ -297,18 +316,20 @@ function QueryModule.define(name: string, config: QueryConfig<any, any>): Query
     local reqSignal = Signal.create()
     local respSignal = Signal.create()
 
+    local rateLimit = config.rateLimit or { maxPerSecond = 30 }
+
     local reqReg, respReg = Registry.registerQueryPair(
         name,
         config.request,
         config.response,
         reqSignal,
         respSignal,
-        config.rateLimit,
+        rateLimit,
         config.validate
     )
 
-    respSignal:connect(function(resp: any, correlation: number): ()
-        completeQuery(correlation, resp)
+    respSignal:connect(function(resp: any, source: Player?, correlation: number): ()
+        completeQuery(correlation, resp, source)
     end)
 
     return setmetatable({

package/src/api/Signal.luau

@@ -91,6 +91,10 @@ SignalImpl.__index = SignalImpl
 export type Signal = typeof(setmetatable({} :: SignalFields, SignalImpl))
 
 local function addEntry(self: Signal, callback: (...any) -> (), isOnce: boolean): Connection
+    if type(callback) ~= "function" then
+        error("[Lync] Expected function, got " .. type(callback))
+    end
+
     local count = self._count + 1
     self._count = count