@axpecter/lync 2.1.1 → 2.2.0

package/src/api/Signal.luau

@@ -1,20 +1,20 @@
 --!strict
 --!optimize 2
--- O(1) disconnect signal system with thread reuse.
+-- O(1) disconnect signal system with thread reuse and reentrancy-safe fire.
 
 local Types = require(script.Parent.Parent.Types)
 
--- Constants -----------------------------------------------------------
+-- Constants --------------------------------------------------------------
 
 local STATE_DISCONNECTED = 0
 local STATE_CONNECTED = 1
 local STATE_ONCE = 2
 
--- State ---------------------------------------------------------------
+-- State ------------------------------------------------------------------
 
 local _freeThread: thread? = nil
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local function passer(fn: (...any) -> (), ...): ()
     local thread = _freeThread
@@ -37,7 +37,6 @@ local function spawnCallback(fn: (...any) -> (), ...: any): ()
     task.spawn(_freeThread :: thread, fn, ...)
 end
 
--- Entry type
 type Entry = {
     fn: (...any) -> (),
     _state: number,
@@ -47,57 +46,49 @@ type Entry = {
     _index: number,
 }
 
--- EntryImpl metatable
 local EntryImpl = {}
 EntryImpl.__index = EntryImpl
 
-function EntryImpl.disconnect(self: Entry): ()
-    if self._state == STATE_DISCONNECTED then
+local function disconnectEntry(entry: Entry): ()
+    if entry._state == STATE_DISCONNECTED then
         return
     end
 
-    self._state = STATE_DISCONNECTED
-    self.connected = false
+    entry._state = STATE_DISCONNECTED
+    entry.connected = false
 
-    local entries = self._signalEntries
-    local countRef = self._signalCount
-    local idx = self._index
-    local last = countRef[1]
+    local entries = entry._signalEntries
+    local countRef = entry._signalCount
+    local idx, last = entry._index, countRef[1]
 
     if idx < last then
-        -- Swap-remove: move last entry to this slot
         local moved = entries[last]
         entries[idx] = moved
         moved._index = idx
     end
-
-    entries[last] = nil :: any
+    entries[last] = nil
     countRef[1] = last - 1
 end
 
+EntryImpl.disconnect = disconnectEntry
 table.freeze(EntryImpl)
 
--- Public --------------------------------------------------------------
-
-local SignalModule = {}
-
 type SignalFields = {
     _entries: { Entry },
     _count: { number },
-    _snapshot: { Entry },
 }
 
 local SignalImpl = {}
 SignalImpl.__index = SignalImpl
 
-function SignalImpl.connect(self: SignalFields, callback: (...any) -> ()): Types.Connection
+local function newEntry(self: SignalFields, callback: (...any) -> (), state: number): Entry
     local countRef = self._count
     local idx = countRef[1] + 1
     countRef[1] = idx
 
     local entry: Entry = setmetatable({
         fn = callback,
-        _state = STATE_CONNECTED,
+        _state = state,
         connected = true,
         _signalEntries = self._entries,
         _signalCount = countRef,
@@ -105,40 +96,28 @@ function SignalImpl.connect(self: SignalFields, callback: (...any) -> ()): Types
     }, EntryImpl) :: any
 
     self._entries[idx] = entry
-    return entry :: any
+    return entry
 end
 
-function SignalImpl.once(self: SignalFields, callback: (...any) -> ()): Types.Connection
-    local countRef = self._count
-    local idx = countRef[1] + 1
-    countRef[1] = idx
-
-    local entry: Entry = setmetatable({
-        fn = callback,
-        _state = STATE_ONCE,
-        connected = true,
-        _signalEntries = self._entries,
-        _signalCount = countRef,
-        _index = idx,
-    }, EntryImpl) :: any
+function SignalImpl.connect(self: SignalFields, callback: (...any) -> ()): Types.Connection
+    return newEntry(self, callback, STATE_CONNECTED) :: any
+end
 
-    self._entries[idx] = entry
-    return entry :: any
+function SignalImpl.once(self: SignalFields, callback: (...any) -> ()): Types.Connection
+    return newEntry(self, callback, STATE_ONCE) :: any
 end
 
 function SignalImpl.wait(self: SignalFields): ...any
     local running = coroutine.running()
     local conn: Types.Connection
-
     conn = SignalImpl.connect(self, function(...: any)
         conn:disconnect()
         task.spawn(running, ...)
     end)
-
     return coroutine.yield()
 end
 
-function SignalImpl.fire(self: SignalFields, ...: any): ()
+local function dispatch(self: SignalFields, sync: boolean, ...: any): ()
     local count = self._count[1]
     if count == 0 then
         return
@@ -146,78 +125,73 @@ function SignalImpl.fire(self: SignalFields, ...: any): ()
 
     local entries = self._entries
 
-    -- Single-listener fast path
     if count == 1 then
         local entry = entries[1]
-        if entry._state == STATE_ONCE then
-            EntryImpl.disconnect(entry)
-            spawnCallback(entry.fn, ...)
-        elseif entry._state == STATE_CONNECTED then
-            spawnCallback(entry.fn, ...)
+        local state = entry._state
+        if state == STATE_ONCE then
+            disconnectEntry(entry)
+            if sync then
+                entry.fn(...)
+            else
+                spawnCallback(entry.fn, ...)
+            end
+        elseif state == STATE_CONNECTED then
+            if sync then
+                entry.fn(...)
+            else
+                spawnCallback(entry.fn, ...)
+            end
         end
         return
     end
 
-    -- Multi-listener: snapshot to handle mid-fire disconnects
-    local snapshot = self._snapshot
+    local snapshot = table.create(count)
     table.move(entries, 1, count, 1, snapshot)
 
     for i = 1, count do
         local entry = snapshot[i]
-        snapshot[i] = nil :: any
-
-        if entry._state == STATE_ONCE then
-            EntryImpl.disconnect(entry)
-            spawnCallback(entry.fn, ...)
-        elseif entry._state == STATE_CONNECTED then
-            spawnCallback(entry.fn, ...)
+        local state = entry._state
+        if state == STATE_ONCE then
+            disconnectEntry(entry)
+            if sync then
+                entry.fn(...)
+            else
+                spawnCallback(entry.fn, ...)
+            end
+        elseif state == STATE_CONNECTED then
+            if sync then
+                entry.fn(...)
+            else
+                spawnCallback(entry.fn, ...)
+            end
         end
     end
 end
 
-function SignalImpl.fireSync(self: SignalFields, ...: any): ()
-    local count = self._count[1]
-    if count == 0 then
-        return
-    end
-
-    local entries = self._entries
-
-    if count == 1 then
-        local entry = entries[1]
-        if entry._state == STATE_ONCE then
-            EntryImpl.disconnect(entry)
-            entry.fn(...)
-        elseif entry._state == STATE_CONNECTED then
-            entry.fn(...)
-        end
-        return
-    end
+function SignalImpl.fire(self: SignalFields, ...: any): ()
+    dispatch(self, false, ...)
+end
 
-    local snapshot = self._snapshot
-    table.move(entries, 1, count, 1, snapshot)
+function SignalImpl.fireSync(self: SignalFields, ...: any): ()
+    dispatch(self, true, ...)
+end
 
-    for i = 1, count do
-        local entry = snapshot[i]
-        snapshot[i] = nil :: any
+function SignalImpl.count(self: SignalFields): number
+    return self._count[1]
+end
 
-        if entry._state == STATE_ONCE then
-            EntryImpl.disconnect(entry)
-            entry.fn(...)
-        elseif entry._state == STATE_CONNECTED then
-            entry.fn(...)
-        end
-    end
+function SignalImpl.hasListeners(self: SignalFields): boolean
+    return self._count[1] > 0
 end
 
 table.freeze(SignalImpl)
 
-function SignalModule.create(): any
-    return setmetatable({
-        _entries = {},
-        _count = { 0 },
-        _snapshot = {},
-    }, SignalImpl)
+-- Public -----------------------------------------------------------------
+
+local SignalModule = {}
+
+function SignalModule.create(): Types.SignalLike
+    return (setmetatable({ _entries = {}, _count = { 0 } }, SignalImpl) :: any) :: Types.SignalLike
 end
 
 return table.freeze(SignalModule)

package/src/codec/Base.luau

@@ -1,23 +1,33 @@
 --!strict
 --!optimize 2
--- Fixed-size codec factory with buffer allocation.
+-- Fixed-size codec factory and channel buffer-grow primitive.
 
 local Types = require(script.Parent.Parent.Types)
 
--- Constants -----------------------------------------------------------
+-- Constants --------------------------------------------------------------
 
 local DEFAULT_MAX = 262144
+local INITIAL_BUF = 1024
 
--- State ---------------------------------------------------------------
+-- State ------------------------------------------------------------------
 
 local _maxSize = DEFAULT_MAX
 
--- Private -------------------------------------------------------------
+-- Private ----------------------------------------------------------------
 
 local countlz = bit32.countlz
 local lshift = bit32.lshift
 
+--[[
+    Grow `ch.buff` so `ch.cursor + bytes` fits. New size is the next
+    power of two >= needed, capped by _maxSize. Caller MUST re-read
+    `ch.buff` after this returns: the buffer reference is replaced.
+]]
 local function alloc(ch: Types.ChannelState, bytes: number): ()
+    if bytes == 0 then
+        return
+    end
+
     local needed = ch.cursor + bytes
     if needed <= ch.size then
         return
@@ -25,11 +35,10 @@ local function alloc(ch: Types.ChannelState, bytes: number): ()
 
     if needed > _maxSize then
         local name = ch.currentPacket
-        error(
-            if name
-                then `[Lync] Channel: buffer overflow ({needed}B, max {_maxSize}B) in "{name}"`
-                else `[Lync] Channel: buffer overflow ({needed}B, max {_maxSize}B)`
-        )
+        if name then
+            error(`[Lync] Channel.alloc("{name}"): buffer overflow ({needed}B, max {_maxSize}B)`)
+        end
+        error(`[Lync] Channel.alloc: buffer overflow ({needed}B, max {_maxSize}B)`)
     end
 
     local newSize = lshift(1, 32 - countlz(needed - 1))
@@ -39,25 +48,31 @@ local function alloc(ch: Types.ChannelState, bytes: number): ()
     ch.size = newSize
 end
 
--- Public --------------------------------------------------------------
+-- Public -----------------------------------------------------------------
 
 local Base = {}
 
-function Base.alloc(ch: Types.ChannelState, bytes: number): ()
-    alloc(ch, bytes)
-end
+Base.INITIAL_BUF = INITIAL_BUF
+
+Base.alloc = alloc
 
 function Base.setMaxSize(bytes: number): ()
     _maxSize = bytes
 end
 
+--[[
+    Build a fixed-size codec. The codec exposes channel-level write/read
+    (which handles buffer growth and cursor bookkeeping) plus the raw
+    _directWrite / _directRead primitives composite codecs use in their
+    pre-sized fast paths.
+]]
 function Base.define<T>(
     size: number,
     directWrite: (b: buffer, offset: number, value: T) -> (),
     directRead: (b: buffer, offset: number) -> T,
     meta: { [string]: any }?
 ): Types.InternalCodec<T>
-    local codec: any = {
+    local codec: { [string]: any } = {
         _size = size,
         _directWrite = directWrite,
         _directRead = directRead,
@@ -82,21 +97,26 @@ function Base.define<T>(
         end
     end
 
-    return table.freeze(codec)
+    return table.freeze(codec) :: Types.InternalCodec<T>
 end
 
-function Base.zero(): Types.InternalCodec<nil>
+--[[
+    Constant codec: zero bytes wire, decode always returns `value`. Used
+    by quantizers when min == max so the wire emits nothing yet decode
+    still produces a type-faithful value.
+]]
+function Base.constant<T>(value: T): Types.InternalCodec<T>
     return table.freeze({
         _size = 0,
-        _directWrite = function(_b: buffer, _off: number, _v: nil): () end,
-        _directRead = function(_b: buffer, _off: number): nil
-            return nil
+        _directWrite = function(_b: buffer, _off: number, _v: T): () end,
+        _directRead = function(_b: buffer, _off: number): T
+            return value
         end,
-        write = function(_ch: Types.ChannelState, _v: nil): () end,
-        read = function(_src: buffer, _pos: number, _refs: { Instance }?): (nil, number)
-            return nil, 0
+        write = function(_ch: Types.ChannelState, _v: T): () end,
+        read = function(_src: buffer, _pos: number, _refs: { Instance }?): (T, number)
+            return value, 0
         end,
-    } :: any)
+    }) :: Types.InternalCodec<T>
 end
 
 return table.freeze(Base)