ye

Author: Axp3cter

bench/Run.server.luau

@@ -11,10 +11,10 @@ local LyncFolder = ReplicatedStorage:WaitForChild ("Lync")
 local Lync = require (LyncFolder)
 local Scenarios = require (LyncFolder:WaitForChild ("bench"):WaitForChild ("Scenarios"))
 
-Lync.setChannelMaxSize (1048576) -- 1 MB, needed for Blink entities bench (100x6B x 1000 fires)
+Lync.setChannelMaxSize (1048576) -- 1 MB, needed for Blink entities bench(100x6B x 1000 fires)
 Lync.start ()
 
--- Config -----------------------------------------------------------------
+-- Config --------------------------------------------------------------
 
 local FIRES_PER_FRAME = 1000
 local DURATION = 10
@@ -26,7 +26,7 @@ local sort = table.sort
 local max = math.max
 local min = math.min
 
--- Helpers ----------------------------------------------------------------
+-- Helpers -------------------------------------------------------------
 
 local function getPlayer (): Player
     local players = Players:GetPlayers ()
@@ -189,7 +189,7 @@ local function runBlinkTest (config: BlinkTestConfig): ()
     print (`      Sent={sent}  Samples={n}`)
 end
 
--- Main -------------------------------------------------------------------
+-- Main ----------------------------------------------------------------
 
 local player = getPlayer ()
 Scenarios.Ready:wait ()
@@ -275,7 +275,7 @@ print (`\n\n  Blink-Compatible Bench  {FIRES_PER_FRAME}/frame  {DURATION}s per t
 print ("  Same data shapes as github.com/1Axen/blink/benchmark\n")
 
 runBlinkTest ({
-    name = "Entities (100x struct, 6x u8)",
+    name = "Entities(100x struct, 6x u8)",
     player = player,
     packet = Scenarios.BlinkEntities,
     data = Scenarios.BLINK_ENTITIES,
@@ -284,7 +284,7 @@ runBlinkTest ({
 print ("")
 
 runBlinkTest ({
-    name = "Booleans (1000x bool)",
+    name = "Booleans(1000x bool)",
     player = player,
     packet = Scenarios.BlinkBooleans,
     data = Scenarios.BLINK_BOOLEANS,

bench/Scenarios.luau

@@ -4,15 +4,15 @@
 
 local Lync = require (script.Parent.Parent)
 
--- Packets ----------------------------------------------------------------
+-- Packets -------------------------------------------------------------
 
 local Scenarios = {}
 
 Scenarios.Ready = Lync.definePacket ("BenchReady", {
     value = Lync.bool,
 })
 
--- Lync -------------------------------------------------------------------
+-- Lync ----------------------------------------------------------------
 
 Scenarios.Booleans = Lync.definePacket ("BenchBool", {
     value = Lync.bool,

src/Types.luau

@@ -1,6 +1,6 @@
 --!strict
 --!optimize 2
--- Shared type definitions.
+-- Shared type definitions for the Lync networking library.
 
 export type ChannelState = {
     buff: buffer,
@@ -10,7 +10,7 @@ export type ChannelState = {
     lastId: number,
     countPos: number,
     itemCount: number,
-    deltas: { [number]: any },
+    deltas: { [number]: any }, -- per-codec delta caches; shape varies by codec kind
     prevDump: buffer?,
 }
 
@@ -19,6 +19,17 @@ export type Codec<T> = {
     read: (src: buffer, pos: number, refs: { Instance }?) -> (T, number),
 }
 
+-- Extended codec exposing internal fast-path metadata used by composite codecs.
+export type InternalCodec<T> = {
+    write: (ch: ChannelState, value: T) -> (),
+    read: (src: buffer, pos: number, refs: { Instance }?) -> (T, number),
+    _size: number?,
+    _directWrite: ((b: buffer, offset: number, value: T) -> ())?,
+    _directRead: ((b: buffer, offset: number) -> T)?,
+    _isDelta: boolean?,
+    _isBool: boolean?,
+}
+
 export type RateLimitConfig = {
     maxPerSecond: number,
     burstAllowance: number?,

src/api/Group.luau

@@ -4,13 +4,13 @@
 
 local Players = game:GetService ("Players")
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _groups = {} :: { [string]: { [Player]: true } }
 local _counts = {} :: { [string]: number }
 local _playerGroups = {} :: { [Player]: { [string]: true } }
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function onPlayerRemoving (player: Player): ()
     local memberships = _playerGroups[player]
@@ -31,8 +31,6 @@ end
 
 Players.PlayerRemoving:Connect (onPlayerRemoving)
 
--- GroupImpl ---------------------------------------------------------------
-
 local GroupImpl = {}
 GroupImpl.__index = GroupImpl
 
@@ -139,7 +137,7 @@ end
 
 table.freeze (GroupImpl)
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Group = {}
 

src/api/Namespace.luau

@@ -11,16 +11,16 @@ type Connection = Types.Connection
 type PacketConfig<T> = Types.PacketConfig<T>
 type QueryConfig<R, S> = Types.QueryConfig<R, S>
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local MAX_NAMESPACES = 64
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 local _registered = {} :: { [string]: true }
 local _count = 0
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 type NamespaceConfig = {
     packets: { [string]: PacketConfig<any> }?,
@@ -47,8 +47,6 @@ local function scopedHandler (
     end
 end
 
--- Namespace --------------------------------------------------------------
-
 local NamespaceImpl = {}
 NamespaceImpl.__index = NamespaceImpl
 
@@ -173,7 +171,9 @@ function NamespaceImpl.queryNames (self: any): { string }
     return result
 end
 
--- Public -----------------------------------------------------------------
+table.freeze (NamespaceImpl)
+
+-- Public -------------------------------------------------------------
 
 local Namespace = {}
 

src/api/Packet.luau

@@ -11,9 +11,10 @@ local Signal = require (script.Parent.Signal)
 local Types = require (script.Parent.Parent.Types)
 
 type Connection = Types.Connection
+type InternalCodec<T> = Types.InternalCodec<T>
 type PacketConfig<T> = Types.PacketConfig<T>
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local IS_SERVER = RunService:IsServer ()
 
@@ -24,7 +25,10 @@ local serverWriteToAllExcept = Server.writeToAllExcept
 local serverWriteToSet = Server.writeToSet
 local clientWrite = Client.write
 
--- Private ----------------------------------------------------------------
+local DELTA_TARGETED = 1
+local DELTA_BROADCAST = 2
+
+-- Private ------------------------------------------------------------
 
 -- Shared methods (both contexts)
 local SharedImpl = {}
@@ -49,9 +53,6 @@ end
 local ServerImpl = setmetatable ({}, { __index = SharedImpl })
 ServerImpl.__index = ServerImpl
 
-local DELTA_TARGETED = 1
-local DELTA_BROADCAST = 2
-
 local function checkDeltaMode (self: any, mode: number): ()
     if not self._isDelta then
         return
@@ -122,7 +123,7 @@ end
 
 table.freeze (ClientImpl)
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Packet = {}
 
@@ -136,7 +137,7 @@ function Packet.define (name: string, config: PacketConfig<any>): any
 
     local isUnreliable = config.unreliable or false
 
-    if (config.value :: any)._isDelta and isUnreliable then
+    if (config.value :: InternalCodec<any>)._isDelta and isUnreliable then
         error (`[Lync] Delta codec requires reliable delivery: "{name}"`)
     end
 
@@ -152,7 +153,7 @@ function Packet.define (name: string, config: PacketConfig<any>): any
         config.maxPayloadBytes
     )
 
-    local isDelta = (config.value :: any)._isDelta == true
+    local isDelta = (config.value :: InternalCodec<any>)._isDelta == true
 
     return setmetatable ({
         _id = reg.id,

src/api/Query.luau

@@ -14,14 +14,14 @@ local Types = require (script.Parent.Parent.Types)
 type Connection = Types.Connection
 type QueryConfig<R, S> = Types.QueryConfig<R, S>
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local IS_SERVER = RunService:IsServer ()
 
 -- Wire ceiling: correlationId is u16 in Channel.writeQuery / Reader.process.
 local POOL_SIZE = 65536
 
--- State ------------------------------------------------------------------
+-- State --------------------------------------------------------------
 
 type PendingQuery = {
     thread: thread?,
@@ -33,7 +33,7 @@ local _pending = {} :: { [number]: PendingQuery }
 local _nextId = 0
 local _activeCount = 0
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function allocCorrelation (): number
     if _activeCount >= POOL_SIZE then
@@ -53,7 +53,9 @@ local function allocCorrelation (): number
     return id
 end
 
-local function freeCorrelation (): ()
+-- Decrements the active correlation counter. Does not free a specific slot;
+-- that is handled by nil-ing _pending[id] at the call site.
+local function releaseCorrelation (): ()
     _activeCount -= 1
 end
 
@@ -64,7 +66,7 @@ local function completeQuery (id: number, data: any): ()
     end
 
     _pending[id] = nil
-    freeCorrelation ()
+    releaseCorrelation ()
 
     if entry.timeout then
         task.cancel (entry.timeout)
@@ -158,7 +160,7 @@ local function requestMulti (self: any, players: { Player }, data: any): { [Play
             local entry = _pending[cid]
             if entry then
                 _pending[cid] = nil
-                freeCorrelation ()
+                releaseCorrelation ()
             end
         end
 
@@ -176,8 +178,6 @@ local function requestMulti (self: any, players: { Player }, data: any): { [Play
     return coroutine.yield ()
 end
 
--- Query ------------------------------------------------------------------
-
 local QueryImpl = {}
 QueryImpl.__index = QueryImpl
 
@@ -274,7 +274,9 @@ function QueryImpl.requestGroup (self: any, group: any, data: any): { [Player]:
     return requestMulti (self, players, data)
 end
 
--- Public -----------------------------------------------------------------
+table.freeze (QueryImpl)
+
+-- Public -------------------------------------------------------------
 
 local Query = {}
 

src/api/Scope.luau

@@ -2,7 +2,7 @@
 --!optimize 2
 -- Batched connection lifecycle management.
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local ScopeImpl = {}
 ScopeImpl.__index = ScopeImpl
@@ -62,7 +62,7 @@ end
 
 table.freeze (ScopeImpl)
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Scope = {}
 

src/api/Signal.luau

@@ -6,12 +6,13 @@ local Types = require (script.Parent.Parent.Types)
 
 type Connection = Types.Connection
 
--- Listener state: single numeric field for both connected and once checks.
+-- Constants ----------------------------------------------------------
+
 local STATE_DISCONNECTED = 0
 local STATE_CONNECTED = 1
 local STATE_ONCE = 2
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local _freeThread: thread? = nil
 
@@ -36,7 +37,9 @@ local function spawn (fn: (...any) -> (), ...: any): ()
     task.spawn (_freeThread :: thread, fn, ...)
 end
 
--- Entry doubles as the Connection handle , 1 alloc per listener instead of 2.
+-- Entry doubles as the Connection handle: 1 alloc per listener instead of 2.
+-- self: any — metatable typing via typeof(setmetatable) is not practical here
+-- because Entry and Signal reference each other circularly.
 local EntryImpl = {}
 EntryImpl.__index = EntryImpl
 
@@ -213,7 +216,10 @@ function SignalImpl.disconnectAll (self: any): ()
     self._count = 0
 end
 
--- Public -----------------------------------------------------------------
+table.freeze (EntryImpl)
+table.freeze (SignalImpl)
+
+-- Public -------------------------------------------------------------
 
 local Signal = {}