@axpecter/lync 1.5.2 → 2.1.0

package/src/api/Scope.luau

@@ -4,84 +4,73 @@
 
 local Types = require(script.Parent.Parent.Types)
 
-type Connection = Types.Connection
+-- Public --------------------------------------------------------------
 
--- Private -------------------------------------------------------------
+local Scope = {}
 
-type ScopeFields = {
-    _entries: { any }, -- Connection | RBXScriptConnection
-    _count: number,
+export type ScopeHandle = {
+    on: (self: ScopeHandle, source: any, fn: (...any) -> ()) -> Types.Connection,
+    once: (self: ScopeHandle, source: any, fn: (...any) -> ()) -> Types.Connection,
+    add: (self: ScopeHandle, connection: any) -> (),
+    destroy: (self: ScopeHandle) -> (),
 }
 
-local ScopeImpl = {}
-ScopeImpl.__index = ScopeImpl
-
-export type Scope = typeof(setmetatable({} :: ScopeFields, ScopeImpl))
-
-function ScopeImpl.add(self: Scope, conn: any): ()
-    if not conn then
-        return
-    end
-
-    local entries = self._entries
-    local count = self._count + 1
-    self._count = count
-    entries[count] = conn
-end
+local ScopeMeta = {}
+ScopeMeta.__index = ScopeMeta
 
-function ScopeImpl.listen(self: Scope, source: any, callback: (...any) -> ()): ()
-    local conn = source:listen(callback)
-    local entries = self._entries
-    local count = self._count + 1
-    self._count = count
-    entries[count] = conn
+function ScopeMeta.on(self: any, source: any, fn: (...any) -> ()): Types.Connection
+    local conn = source:on(fn)
+    local conns = self._connections
+    local idx = self._count + 1
+    self._count = idx
+    conns[idx] = conn
+    return conn
 end
 
-function ScopeImpl.once(self: Scope, source: any, callback: (...any) -> ()): ()
-    local conn = source:once(callback)
-    local entries = self._entries
-    local count = self._count + 1
-    self._count = count
-    entries[count] = conn
+function ScopeMeta.once(self: any, source: any, fn: (...any) -> ()): Types.Connection
+    local conn = source:once(fn)
+    local conns = self._connections
+    local idx = self._count + 1
+    self._count = idx
+    conns[idx] = conn
+    return conn
 end
 
-function ScopeImpl.listenAll(self: Scope, namespace: any, callback: (...any) -> ()): ()
-    local conn = namespace:listenAll(callback)
-    local entries = self._entries
-    local count = self._count + 1
-    self._count = count
-    entries[count] = conn
+function ScopeMeta.add(self: any, connection: any): ()
+    local idx = self._count + 1
+    self._count = idx
+    self._connections[idx] = connection
 end
 
-function ScopeImpl.destroy(self: Scope): ()
-    local entries = self._entries
+function ScopeMeta.destroy(self: any): ()
+    local conns = self._connections
     local count = self._count
 
     for i = 1, count do
-        local conn = entries[i]
-        entries[i] = nil
-
-        if typeof(conn) == "RBXScriptConnection" then
-            conn:Disconnect()
-        elseif conn.disconnect then
-            conn:disconnect()
+        local conn = conns[i]
+        conns[i] = nil :: any
+
+        --[[
+            Support both Lync Connection (conn:disconnect())
+            and RBXScriptConnection (conn:Disconnect()).
+        ]]
+        if typeof(conn) == "table" then
+            if conn.disconnect then
+                conn:disconnect()
+            end
+        elseif typeof(conn) == "RBXScriptConnection" then
+            (conn :: RBXScriptConnection):Disconnect()
         end
     end
 
     self._count = 0
 end
 
-table.freeze(ScopeImpl)
-
--- Public --------------------------------------------------------------
-
-local ScopeModule = {}
-
-function ScopeModule.create(): Scope
+function Scope.create(): ScopeHandle
     return setmetatable({
-        _entries = {},
+        _connections = {},
         _count = 0,
-    }, ScopeImpl)
+    }, ScopeMeta) :: any
 end
 
-return table.freeze(ScopeModule)
+return table.freeze(Scope)

package/src/api/Signal.luau

@@ -1,26 +1,26 @@
 --!strict
 --!optimize 2
--- O(1) disconnect listener system with thread reuse.
+-- O(1) disconnect signal system with thread reuse.
 
 local Types = require(script.Parent.Parent.Types)
 
-type Connection = Types.Connection
-
 -- Constants -----------------------------------------------------------
 
 local STATE_DISCONNECTED = 0
 local STATE_CONNECTED = 1
 local STATE_ONCE = 2
 
--- Private -------------------------------------------------------------
+-- State ---------------------------------------------------------------
 
 local _freeThread: thread? = nil
 
-local function passer(fn: (...any) -> (), ...: any): ()
-    local acquired = _freeThread
+-- Private -------------------------------------------------------------
+
+local function passer(fn: (...any) -> (), ...): ()
+    local thread = _freeThread
     _freeThread = nil
     fn(...)
-    _freeThread = acquired
+    _freeThread = thread
 end
 
 local function yielder(): ()
@@ -29,7 +29,7 @@ local function yielder(): ()
     end
 end
 
-local function spawn(fn: (...any) -> (), ...: any): ()
+local function spawnCallback(fn: (...any) -> (), ...: any): ()
     if not _freeThread then
         _freeThread = coroutine.create(yielder)
         coroutine.resume(_freeThread :: thread)
@@ -37,29 +37,21 @@ local function spawn(fn: (...any) -> (), ...: any): ()
     task.spawn(_freeThread :: thread, fn, ...)
 end
 
--- Mutually recursive field types for Entry and Signal.
--- Entry._signal references the signal's fields; Signal._entries holds entries.
--- Luau resolves the cycle at type-check time.
-type EntryFields = {
+-- Entry type
+type Entry = {
     fn: (...any) -> (),
     _state: number,
     connected: boolean,
-    _signal: SignalFields,
+    _signalEntries: { Entry },
+    _signalCount: { number },
     _index: number,
 }
 
-type SignalFields = {
-    _entries: { EntryFields },
-    _count: number,
-    _snapshot: { EntryFields },
-}
-
+-- EntryImpl metatable
 local EntryImpl = {}
 EntryImpl.__index = EntryImpl
 
-type EntrySelf = typeof(setmetatable({} :: EntryFields, EntryImpl))
-
-function EntryImpl.disconnect(self: EntrySelf): ()
+function EntryImpl.disconnect(self: Entry): ()
     if self._state == STATE_DISCONNECTED then
         return
     end
@@ -67,136 +59,137 @@ function EntryImpl.disconnect(self: EntrySelf): ()
     self._state = STATE_DISCONNECTED
     self.connected = false
 
-    local entries = self._signal._entries
-    local count = self._signal._count
-    local index = self._index
+    local entries = self._signalEntries
+    local countRef = self._signalCount
+    local idx = self._index
+    local last = countRef[1]
 
-    if count == 0 or index > count then
-        return
-    end
-
-    if index < count then
-        local last = entries[count]
-        entries[index] = last
-        last._index = index
+    if idx < last then
+        -- Swap-remove: move last entry to this slot
+        local moved = entries[last]
+        entries[idx] = moved
+        moved._index = idx
     end
 
-    entries[count] = nil :: any
-    self._signal._count = count - 1
+    entries[last] = nil :: any
+    countRef[1] = last - 1
 end
 
-local SignalImpl = {}
-SignalImpl.__index = SignalImpl
+table.freeze(EntryImpl)
 
-export type Signal = typeof(setmetatable({} :: SignalFields, SignalImpl))
+-- Public --------------------------------------------------------------
 
-local function addEntry(self: Signal, callback: (...any) -> (), isOnce: boolean): Connection
-    if type(callback) ~= "function" then
-        error("[Lync] Expected function, got " .. type(callback))
-    end
+local SignalModule = {}
+
+type SignalFields = {
+    _entries: { Entry },
+    _count: { number },
+    _snapshot: { Entry },
+}
 
-    local count = self._count + 1
-    self._count = count
+local SignalImpl = {}
+SignalImpl.__index = SignalImpl
 
-    local entry = setmetatable({
+function SignalImpl.connect(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 = if isOnce then STATE_ONCE else STATE_CONNECTED,
+        _state = STATE_CONNECTED,
         connected = true,
-        _signal = self :: any,
-        _index = count,
-    }, EntryImpl)
+        _signalEntries = self._entries,
+        _signalCount = countRef,
+        _index = idx,
+    }, EntryImpl) :: any
 
-    self._entries[count] = entry :: any
+    self._entries[idx] = entry
     return entry :: any
 end
 
-function SignalImpl.connect(self: Signal, callback: (...any) -> ()): Connection
-    return addEntry(self, callback, false)
-end
+function SignalImpl.once(self: SignalFields, callback: (...any) -> ()): Types.Connection
+    local countRef = self._count
+    local idx = countRef[1] + 1
+    countRef[1] = idx
 
-function SignalImpl.once(self: Signal, callback: (...any) -> ()): Connection
-    return addEntry(self, callback, true)
+    local entry: Entry = setmetatable({
+        fn = callback,
+        _state = STATE_ONCE,
+        connected = true,
+        _signalEntries = self._entries,
+        _signalCount = countRef,
+        _index = idx,
+    }, EntryImpl) :: any
+
+    self._entries[idx] = entry
+    return entry :: any
 end
 
-function SignalImpl.wait(self: Signal): ...any
-    local thread = coroutine.running()
-    local entry: any
+function SignalImpl.wait(self: SignalFields): ...any
+    local running = coroutine.running()
+    local conn: Types.Connection
 
-    entry = addEntry(self, function(...: any): ()
-        entry:disconnect()
-        task.spawn(thread, ...)
-    end, true)
+    conn = SignalImpl.connect(self, function(...: any)
+        conn:disconnect()
+        task.spawn(running, ...)
+    end)
 
     return coroutine.yield()
 end
 
--- Dispatches to all listeners via task.spawn(safe for yielding handlers).
-function SignalImpl.fire(self: Signal, ...: any): ()
-    local entries = self._entries
-    local count = self._count
+function SignalImpl.fire(self: SignalFields, ...: any): ()
+    local count = self._count[1]
     if count == 0 then
         return
     end
 
+    local entries = self._entries
+
+    -- Single-listener fast path
     if count == 1 then
         local entry = entries[1]
-        local state = entry._state
-        if state == STATE_DISCONNECTED then
-            return
-        end
-
-        spawn(entry.fn, ...)
-
-        if state == STATE_ONCE then
-            (entry :: any):disconnect()
+        if entry._state == STATE_ONCE then
+            EntryImpl.disconnect(entry)
+            spawnCallback(entry.fn, ...)
+        elseif entry._state == STATE_CONNECTED then
+            spawnCallback(entry.fn, ...)
         end
         return
     end
 
+    -- Multi-listener: snapshot to handle mid-fire disconnects
     local snapshot = self._snapshot
     table.move(entries, 1, count, 1, snapshot)
 
-    local tail = count + 1
-    if snapshot[tail] ~= nil then
-        snapshot[tail] = nil :: any
-    end
-
     for i = 1, count do
         local entry = snapshot[i]
         snapshot[i] = nil :: any
 
-        local state = entry._state
-        if state == STATE_DISCONNECTED then
-            continue
-        end
-
-        spawn(entry.fn, ...)
-
-        if state == STATE_ONCE then
-            (entry :: any):disconnect()
+        if entry._state == STATE_ONCE then
+            EntryImpl.disconnect(entry)
+            spawnCallback(entry.fn, ...)
+        elseif entry._state == STATE_CONNECTED then
+            spawnCallback(entry.fn, ...)
         end
     end
 end
 
--- Synchronous dispatch. Only safe when all listeners are non-yielding.
-function SignalImpl.fireSync(self: Signal, ...: any): ()
-    local entries = self._entries
-    local count = self._count
+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]
-        local state = entry._state
-        if state == STATE_DISCONNECTED then
-            return
-        end
-
-        entry.fn(...)
-
-        if state == STATE_ONCE then
-            (entry :: any):disconnect()
+        if entry._state == STATE_ONCE then
+            EntryImpl.disconnect(entry)
+            entry.fn(...)
+        elseif entry._state == STATE_CONNECTED then
+            entry.fn(...)
         end
         return
     end
@@ -204,52 +197,26 @@ function SignalImpl.fireSync(self: Signal, ...: any): ()
     local snapshot = self._snapshot
     table.move(entries, 1, count, 1, snapshot)
 
-    local tail = count + 1
-    if snapshot[tail] ~= nil then
-        snapshot[tail] = nil :: any
-    end
-
     for i = 1, count do
         local entry = snapshot[i]
         snapshot[i] = nil :: any
 
-        local state = entry._state
-        if state == STATE_DISCONNECTED then
-            continue
-        end
-
-        entry.fn(...)
-
-        if state == STATE_ONCE then
-            (entry :: any):disconnect()
+        if entry._state == STATE_ONCE then
+            EntryImpl.disconnect(entry)
+            entry.fn(...)
+        elseif entry._state == STATE_CONNECTED then
+            entry.fn(...)
         end
     end
 end
 
-function SignalImpl.disconnectAll(self: Signal): ()
-    local entries = self._entries
-
-    for i = 1, self._count do
-        entries[i]._state = STATE_DISCONNECTED
-        entries[i].connected = false
-        entries[i] = nil :: any
-    end
-
-    self._count = 0
-end
-
-table.freeze(EntryImpl)
 table.freeze(SignalImpl)
 
--- Public --------------------------------------------------------------
-
-local SignalModule = {}
-
-function SignalModule.create(): Signal
+function SignalModule.create(): any
     return setmetatable({
-        _entries = {} :: { EntryFields },
-        _count = 0,
-        _snapshot = {} :: { EntryFields },
+        _entries = {},
+        _count = { 0 },
+        _snapshot = {},
     }, SignalImpl)
 end
 

package/src/codec/Base.luau

@@ -1,53 +1,102 @@
 --!strict
---!native
--- Fixed-size codec factory. Every fixed-size codec calls Base.define once.
+--!optimize 2
+-- Fixed-size codec factory with buffer allocation.
 
-local Channel = require(script.Parent.Parent.internal.Channel)
 local Types = require(script.Parent.Parent.Types)
 
-type ChannelState = Types.ChannelState
+-- Constants -----------------------------------------------------------
 
-local alloc = Channel.alloc
+local DEFAULT_MAX = 262144
+
+-- State ---------------------------------------------------------------
+
+local _maxSize = DEFAULT_MAX
+
+-- Private -------------------------------------------------------------
+
+local countlz = bit32.countlz
+local lshift = bit32.lshift
+
+local function alloc(ch: Types.ChannelState, bytes: number): ()
+    local needed = ch.cursor + bytes
+    if needed <= ch.size then
+        return
+    end
+
+    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)`
+        )
+    end
+
+    local newSize = lshift(1, 32 - countlz(needed - 1))
+    local newBuff = buffer.create(newSize)
+    buffer.copy(newBuff, 0, ch.buff, 0, ch.cursor)
+    ch.buff = newBuff
+    ch.size = newSize
+end
 
 -- Public --------------------------------------------------------------
 
 local Base = {}
 
+function Base.alloc(ch: Types.ChannelState, bytes: number): ()
+    alloc(ch, bytes)
+end
+
+function Base.setMaxSize(bytes: number): ()
+    _maxSize = bytes
+end
+
 function Base.define<T>(
     size: number,
     directWrite: (b: buffer, offset: number, value: T) -> (),
-    directRead: (b: buffer, offset: number) -> T
-): any
-    return table.freeze({
+    directRead: (b: buffer, offset: number) -> T,
+    meta: { [string]: any }?
+): Types.InternalCodec<T>
+    local codec: any = {
         _size = size,
         _directWrite = directWrite,
         _directRead = directRead,
-        write = function(ch: ChannelState, value: T): ()
-            local c = ch.cursor
-            if c + size > ch.size then
+
+        write = function(ch: Types.ChannelState, value: T): ()
+            local cursor = ch.cursor
+            if cursor + size > ch.size then
                 alloc(ch, size)
             end
-            directWrite(ch.buff, c, value)
-            ch.cursor = c + size
+            directWrite(ch.buff, cursor, value)
+            ch.cursor = cursor + size
         end,
+
         read = function(src: buffer, pos: number, _refs: { Instance }?): (T, number)
             return directRead(src, pos), size
         end,
-    })
+    }
+
+    if meta then
+        for key, val in meta do
+            codec[key] = val
+        end
+    end
+
+    return table.freeze(codec)
 end
 
-function Base.zero(): any
+function Base.zero(): Types.InternalCodec<nil>
     return table.freeze({
         _size = 0,
-        _directWrite = function(_b: buffer, _offset: number, _value: any): () end,
-        _directRead = function(_b: buffer, _offset: number): any
+        _directWrite = function(_b: buffer, _off: number, _v: nil): () end,
+        _directRead = function(_b: buffer, _off: number): nil
             return nil
         end,
-        write = function(_ch: ChannelState, _value: any): () end,
-        read = function(_src: buffer, _pos: number, _refs: { Instance }?): (any, number)
+        write = function(_ch: Types.ChannelState, _v: nil): () end,
+        read = function(_src: buffer, _pos: number, _refs: { Instance }?): (nil, number)
             return nil, 0
         end,
-    })
+    } :: any)
 end
 
 return table.freeze(Base)