@axpecter/lync 1.3.0

package/src/api/Signal.luau

@@ -0,0 +1,224 @@
+--!strict
+--!optimize 2
+-- O(1) disconnect listener system with thread reuse.
+
+local Types = require (script.Parent.Parent.Types)
+
+type Connection = Types.Connection
+
+-- Listener state: single numeric field for both connected and once checks.
+local STATE_DISCONNECTED = 0
+local STATE_CONNECTED = 1
+local STATE_ONCE = 2
+
+-- Private ----------------------------------------------------------------
+
+local _freeThread: thread? = nil
+
+local function passer (fn: (...any) -> (), ...: any): ()
+    local acquired = _freeThread
+    _freeThread = nil
+    fn (...)
+    _freeThread = acquired
+end
+
+local function yielder (): ()
+    while true do
+        passer (coroutine.yield ())
+    end
+end
+
+local function spawn (fn: (...any) -> (), ...: any): ()
+    if not _freeThread then
+        _freeThread = coroutine.create (yielder)
+        coroutine.resume (_freeThread :: thread)
+    end
+    task.spawn (_freeThread :: thread, fn, ...)
+end
+
+-- Entry doubles as the Connection handle , 1 alloc per listener instead of 2.
+local EntryImpl = {}
+EntryImpl.__index = EntryImpl
+
+function EntryImpl.disconnect (self: any): ()
+    if self._state == STATE_DISCONNECTED then
+        return
+    end
+
+    self._state = STATE_DISCONNECTED
+    self.connected = false
+
+    local entries = self._signal._entries
+    local count = self._signal._count
+    local index = self._index
+
+    if count == 0 or index > count then
+        return
+    end
+
+    if index < count then
+        local last = entries[count]
+        entries[index] = last
+        last._index = index
+    end
+
+    entries[count] = nil
+    self._signal._count = count - 1
+end
+
+local SignalImpl = {}
+SignalImpl.__index = SignalImpl
+
+local function addEntry (self: any, callback: (...any) -> (), isOnce: boolean): Connection
+    local count = self._count + 1
+    self._count = count
+
+    local entry = setmetatable ({
+        fn = callback,
+        _state = if isOnce then STATE_ONCE else STATE_CONNECTED,
+        connected = true,
+        _signal = self,
+        _index = count,
+    }, EntryImpl)
+
+    self._entries[count] = entry
+    return entry :: any
+end
+
+function SignalImpl.connect (self: any, callback: (...any) -> ()): Connection
+    return addEntry (self, callback, false)
+end
+
+function SignalImpl.once (self: any, callback: (...any) -> ()): Connection
+    return addEntry (self, callback, true)
+end
+
+function SignalImpl.wait (self: any): ...any
+    local thread = coroutine.running ()
+    local entry: any
+
+    entry = addEntry (self, function (...: any): ()
+        entry:disconnect ()
+        task.spawn (thread, ...)
+    end, true)
+
+    return coroutine.yield ()
+end
+
+-- Dispatches to all listeners via task.spawn (safe for yielding handlers).
+function SignalImpl.fire (self: any, ...: any): ()
+    local entries = self._entries
+    local count = self._count
+    if count == 0 then
+        return
+    end
+
+    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:disconnect ()
+        end
+        return
+    end
+
+    local snapshot = self._snapshot
+    table.move (entries, 1, count, 1, snapshot)
+
+    local tail = count + 1
+    if snapshot[tail] ~= nil then
+        snapshot[tail] = nil
+    end
+
+    for i = 1, count do
+        local entry = snapshot[i]
+        snapshot[i] = nil
+
+        local state = entry._state
+        if state == STATE_DISCONNECTED then
+            continue
+        end
+
+        spawn (entry.fn, ...)
+
+        if state == STATE_ONCE then
+            entry:disconnect ()
+        end
+    end
+end
+
+-- Synchronous dispatch. Only safe when all listeners are non-yielding.
+function SignalImpl.fireSync (self: any, ...: any): ()
+    local entries = self._entries
+    local count = self._count
+    if count == 0 then
+        return
+    end
+
+    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:disconnect ()
+        end
+        return
+    end
+
+    local snapshot = self._snapshot
+    table.move (entries, 1, count, 1, snapshot)
+
+    local tail = count + 1
+    if snapshot[tail] ~= nil then
+        snapshot[tail] = nil
+    end
+
+    for i = 1, count do
+        local entry = snapshot[i]
+        snapshot[i] = nil
+
+        local state = entry._state
+        if state == STATE_DISCONNECTED then
+            continue
+        end
+
+        entry.fn (...)
+
+        if state == STATE_ONCE then
+            entry:disconnect ()
+        end
+    end
+end
+
+function SignalImpl.disconnectAll (self: any): ()
+    local entries = self._entries
+
+    for i = 1, self._count do
+        entries[i]._state = STATE_DISCONNECTED
+        entries[i].connected = false
+        entries[i] = nil
+    end
+
+    self._count = 0
+end
+
+-- Public -----------------------------------------------------------------
+
+local Signal = {}
+
+function Signal.create (): any
+    return setmetatable ({ _entries = {}, _count = 0, _snapshot = {} }, SignalImpl)
+end
+
+return table.freeze (Signal)

package/src/codec/Base.luau

@@ -0,0 +1,49 @@
+--!strict
+--!native
+-- Fixed-size codec factory. Every fixed-size codec calls Base.define once.
+
+local Channel = require (script.Parent.Parent.internal.Channel)
+local alloc = Channel.alloc
+
+-- Public -----------------------------------------------------------------
+
+local Base = {}
+
+function Base.define <T>(
+    size: number,
+    directWrite: (b: buffer, offset: number, value: T) -> (),
+    directRead: (b: buffer, offset: number) -> T
+): any
+    return table.freeze ({
+        _size = size,
+        _directWrite = directWrite,
+        _directRead = directRead,
+        write = function (ch: any, value: T): ()
+            local c = ch.cursor
+            if c + size > ch.size then
+                alloc (ch, size)
+            end
+            directWrite (ch.buff, c, value)
+            ch.cursor = c + size
+        end,
+        read = function (src: buffer, pos: number, _refs: { Instance }?): (T, number)
+            return directRead (src, pos), size
+        end,
+    })
+end
+
+function Base.zero (): any
+    return table.freeze ({
+        _size = 0,
+        _directWrite = function (_b: buffer, _offset: number, _value: any): () end,
+        _directRead = function (_b: buffer, _offset: number): any
+            return nil
+        end,
+        write = function (_ch: any, _value: any): () end,
+        read = function (_src: buffer, _pos: number, _refs: { Instance }?): (any, number)
+            return nil, 0
+        end,
+    })
+end
+
+return table.freeze (Base)

package/src/codec/composite/Array.luau

@@ -0,0 +1,275 @@
+--!strict
+--!native
+-- array and deltaArray codecs.
+
+local Baseline = require (script.Parent.Parent.Parent.internal.Baseline)
+local Channel = require (script.Parent.Parent.Parent.internal.Channel)
+local alloc = Channel.alloc
+local Shared = require (script.Parent.Shared)
+local Types = require (script.Parent.Parent.Parent.Types)
+
+type ChannelState = Types.ChannelState
+type Codec<T> = Types.Codec<T>
+local Varint = require (script.Parent.Parent.primitive.Varint)
+
+local rangeEqual = Shared.rangeEqual
+local acquireScratch = Shared.acquireScratch
+local releaseScratch = Shared.releaseScratch
+
+local FLAG_DELTA = Shared.FLAG_DELTA
+local FLAG_FULL = Shared.FLAG_FULL
+local FLAG_UNCHANGED = Shared.FLAG_UNCHANGED
+
+-- Public -----------------------------------------------------------------
+
+local Array = {}
+
+function Array.deltaArray (element: Codec<any>, maxCount: number?): Codec<{ any }>
+    local deltaId = Shared.allocDeltaId ()
+
+    local writeElement = element.write
+    local readElement = element.read
+
+    local elemSize = (element :: any)._size :: number?
+    local elemDirect = (element :: any)._directWrite
+    local elemDRead = (element :: any)._directRead
+
+    return table.freeze ({
+        _isDelta = true,
+
+        write = function (ch: ChannelState, value: { any }): ()
+            local len = #value
+            local cache = ch.deltas[deltaId] :: { raw: buffer, bounds: { number }, len: number }?
+            local scratch = acquireScratch ()
+
+            local bounds = table.create (len + 1)
+            bounds[1] = 0
+
+            if elemDirect and elemSize then
+                local totalBytes = len * elemSize
+                alloc (scratch, totalBytes)
+                local b = scratch.buff
+                local c = 0
+                for i = 1, len do
+                    elemDirect (b, c, value[i])
+                    c += elemSize
+                    bounds[i + 1] = c
+                end
+                scratch.cursor = totalBytes
+            else
+                for i = 1, len do
+                    writeElement (scratch, value[i])
+                    bounds[i + 1] = scratch.cursor
+                end
+            end
+
+            local scratchTotal = scratch.cursor
+
+            if not cache or cache.len ~= len then
+                alloc (ch, 1)
+                buffer.writeu8 (ch.buff, ch.cursor, FLAG_FULL)
+                ch.cursor += 1
+                Varint.write (ch, len)
+
+                alloc (ch, scratchTotal)
+                buffer.copy (ch.buff, ch.cursor, scratch.buff, 0, scratchTotal)
+                ch.cursor += scratchTotal
+            else
+                local cacheRaw = cache.raw
+                local cacheBds = cache.bounds
+                local dirty = table.create (len)
+                local dirtyN = 0
+
+                for i = 1, len do
+                    local newOff = bounds[i]
+                    local newLen = bounds[i + 1] - newOff
+                    local oldOff = cacheBds[i]
+                    local oldLen = cacheBds[i + 1] - oldOff
+
+                    if
+                        newLen ~= oldLen
+                        or not rangeEqual (scratch.buff, newOff, cacheRaw, oldOff, newLen)
+                    then
+                        dirtyN += 1
+                        dirty[dirtyN] = i
+                    end
+                end
+
+                if dirtyN == 0 then
+                    alloc (ch, 1)
+                    buffer.writeu8 (ch.buff, ch.cursor, FLAG_UNCHANGED)
+                    ch.cursor += 1
+                    releaseScratch ()
+                    return
+                end
+
+                alloc (ch, 1)
+                buffer.writeu8 (ch.buff, ch.cursor, FLAG_DELTA)
+                ch.cursor += 1
+                Varint.write (ch, dirtyN)
+
+                for j = 1, dirtyN do
+                    local i = dirty[j]
+                    local newOff = bounds[i]
+                    local newLen = bounds[i + 1] - newOff
+
+                    Varint.write (ch, i - 1)
+                    alloc (ch, newLen)
+                    buffer.copy (ch.buff, ch.cursor, scratch.buff, newOff, newLen)
+                    ch.cursor += newLen
+                end
+            end
+
+            local rawBuf = buffer.create (scratchTotal)
+            buffer.copy (rawBuf, 0, scratch.buff, 0, scratchTotal)
+
+            table.freeze (bounds)
+            ch.deltas[deltaId] = { raw = rawBuf, bounds = bounds, len = len }
+            releaseScratch ()
+        end,
+
+        read = function (src: buffer, pos: number, refs: { Instance }?): ({ any }, number)
+            local flag = buffer.readu8 (src, pos)
+            local absPos = pos + 1
+
+            if flag == FLAG_UNCHANGED then
+                local cache = Baseline.getCache (deltaId)
+                return if cache then table.clone (cache) else {}, 1
+            end
+
+            if flag == FLAG_FULL then
+                local len, lenBytes = Varint.read (src, absPos)
+                absPos += lenBytes
+
+                if maxCount and len > maxCount then
+                    error (`[Lync] Array count {len} exceeds max {maxCount}`)
+                end
+
+                local result = table.create (len)
+
+                if elemDRead and elemSize then
+                    for i = 1, len do
+                        result[i] = elemDRead (src, absPos)
+                        absPos += elemSize
+                    end
+                else
+                    for i = 1, len do
+                        local val, n = readElement (src, absPos, refs)
+                        result[i] = val
+                        absPos += n
+                    end
+                end
+
+                Baseline.setCache (deltaId, result)
+                return result, absPos - pos
+            end
+
+            local cache = Baseline.getCache (deltaId) :: { any }?
+            local result = if cache then table.clone (cache) else {}
+
+            local dirtyN, dnBytes = Varint.read (src, absPos)
+            absPos += dnBytes
+
+            for _ = 1, dirtyN do
+                local idx, idxBytes = Varint.read (src, absPos)
+                absPos += idxBytes
+
+                if elemDRead and elemSize then
+                    result[idx + 1] = elemDRead (src, absPos)
+                    absPos += elemSize
+                else
+                    local val, n = readElement (src, absPos, refs)
+                    result[idx + 1] = val
+                    absPos += n
+                end
+            end
+
+            Baseline.setCache (deltaId, result)
+            return result, absPos - pos
+        end,
+    })
+end
+
+function Array.array (element: Codec<any>, maxCount: number?): Codec<{ any }>
+    local elementSize = (element :: any)._size :: number?
+    local directWrite = (element :: any)._directWrite
+    local directRead = (element :: any)._directRead
+
+    if elementSize and directWrite and directRead then
+        return table.freeze ({
+            write = function (ch: ChannelState, value: { any }): ()
+                local len = #value
+                Varint.write (ch, len)
+                if len == 0 then
+                    return
+                end
+
+                local totalBytes = len * elementSize
+                local c = ch.cursor
+                if c + totalBytes > ch.size then
+                    alloc (ch, totalBytes)
+                end
+
+                local b = ch.buff
+                for i = 1, len do
+                    directWrite (b, c, value[i])
+                    c += elementSize
+                end
+                ch.cursor = c
+            end,
+            read = function (src: buffer, pos: number, _refs: { Instance }?): ({ any }, number)
+                local len, lenBytes = Varint.read (src, pos)
+
+                if maxCount and len > maxCount then
+                    error (`[Lync] Array count {len} exceeds max {maxCount}`)
+                end
+
+                local result = table.create (len)
+                local c = pos + lenBytes
+
+                for i = 1, len do
+                    result[i] = directRead (src, c)
+                    c += elementSize
+                end
+
+                return result, c - pos
+            end,
+        })
+    end
+
+    local writeElement = element.write
+    local readElement = element.read
+
+    return table.freeze ({
+        write = function (ch: ChannelState, value: { any }): ()
+            local len = #value
+            Varint.write (ch, len)
+            if elementSize and len > 0 then
+                alloc (ch, len * elementSize)
+            end
+            for i = 1, len do
+                writeElement (ch, value[i])
+            end
+        end,
+        read = function (src: buffer, pos: number, refs: { Instance }?): ({ any }, number)
+            local len, lenBytes = Varint.read (src, pos)
+
+            if maxCount and len > maxCount then
+                error (`[Lync] Array count {len} exceeds max {maxCount}`)
+            end
+
+            local result = table.create (len)
+            local absPos = pos + lenBytes
+
+            for i = 1, len do
+                local value, n = readElement (src, absPos, refs)
+                result[i] = value
+                absPos += n
+            end
+
+            return result, absPos - pos
+        end,
+    })
+end
+
+return table.freeze (Array)