@axpecter/lync 1.3.1 → 1.4.1

package/src/codec/meta/Auto.luau

@@ -2,29 +2,32 @@
 --!native
 -- Auto (self-describing) codec. Writes a u8 type tag then the value.
 
-local Buffer = require (script.Parent.Parent.datatype.Buffer)
+local BoolCodec = require (script.Parent.Parent.primitive.Bool)
+local BufferCodec = require (script.Parent.Parent.datatype.Buffer)
 local CFrameCodec = require (script.Parent.Parent.datatype.CFrame)
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
-local BoolCodec = require (script.Parent.Parent.primitive.Bool)
-local Color = require (script.Parent.Parent.datatype.Color)
-local IntVector = require (script.Parent.Parent.datatype.IntVector)
-local Number = require (script.Parent.Parent.primitive.Number)
+local ColorCodec = require (script.Parent.Parent.datatype.Color)
+local IntVectorCodec = require (script.Parent.Parent.datatype.IntVector)
+local NumberCodec = require (script.Parent.Parent.primitive.Number)
 local NumberRangeCodec = require (script.Parent.Parent.datatype.NumberRange)
 local RayCodec = require (script.Parent.Parent.datatype.Ray)
 local RectCodec = require (script.Parent.Parent.datatype.Rect)
-local Region = require (script.Parent.Parent.datatype.Region)
-local Sequence = require (script.Parent.Parent.datatype.Sequence)
-local String = require (script.Parent.Parent.datatype.String)
+local RegionCodec = require (script.Parent.Parent.datatype.Region)
+local SequenceCodec = require (script.Parent.Parent.datatype.Sequence)
+local StringCodec = require (script.Parent.Parent.datatype.String)
 local Types = require (script.Parent.Parent.Parent.Types)
 local UDimCodec = require (script.Parent.Parent.datatype.UDim)
 local Varint = require (script.Parent.Parent.primitive.Varint)
-local Vector = require (script.Parent.Parent.datatype.Vector)
+local VectorCodec = require (script.Parent.Parent.datatype.Vector)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
+type InternalCodec<T> = Types.InternalCodec<T>
+
+local alloc = Channel.alloc
+local floor = math.floor
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local TAG_NIL = 0
 local TAG_BOOL = 1
@@ -54,128 +57,130 @@ local TAG_RAY = 24
 local TAG_NUMBERSEQUENCE = 25
 local TAG_COLORSEQUENCE = 26
 
-local floor = math.floor
-
 local READ_DISPATCH = table.freeze ({
     [TAG_BOOL] = BoolCodec.bool,
-    [TAG_U8] = Number.u8,
-    [TAG_U16] = Number.u16,
-    [TAG_U32] = Number.u32,
-    [TAG_I8] = Number.i8,
-    [TAG_I16] = Number.i16,
-    [TAG_I32] = Number.i32,
-    [TAG_F32] = Number.f32,
-    [TAG_F64] = Number.f64,
-    [TAG_STRING] = String.string,
-    [TAG_VEC2] = Vector.vec2,
-    [TAG_VEC3] = Vector.vec3,
-    [TAG_COLOR3] = Color.color3,
+    [TAG_U8] = NumberCodec.u8,
+    [TAG_U16] = NumberCodec.u16,
+    [TAG_U32] = NumberCodec.u32,
+    [TAG_I8] = NumberCodec.i8,
+    [TAG_I16] = NumberCodec.i16,
+    [TAG_I32] = NumberCodec.i32,
+    [TAG_F32] = NumberCodec.f32,
+    [TAG_F64] = NumberCodec.f64,
+    [TAG_STRING] = StringCodec.string,
+    [TAG_VEC2] = VectorCodec.vec2,
+    [TAG_VEC3] = VectorCodec.vec3,
+    [TAG_COLOR3] = ColorCodec.color3,
     [TAG_CFRAME] = CFrameCodec.cframe,
-    [TAG_BUFFER] = Buffer.buff,
+    [TAG_BUFFER] = BufferCodec.buff,
     [TAG_UDIM] = UDimCodec.udim,
     [TAG_UDIM2] = UDimCodec.udim2,
     [TAG_NUMBERRANGE] = NumberRangeCodec.numberRange,
     [TAG_RECT] = RectCodec.rect,
-    [TAG_VEC2INT16] = IntVector.vec2int16,
-    [TAG_VEC3INT16] = IntVector.vec3int16,
-    [TAG_REGION3] = Region.region3,
-    [TAG_REGION3INT16] = Region.region3int16,
+    [TAG_VEC2INT16] = IntVectorCodec.vec2int16,
+    [TAG_VEC3INT16] = IntVectorCodec.vec3int16,
+    [TAG_REGION3] = RegionCodec.region3,
+    [TAG_REGION3INT16] = RegionCodec.region3int16,
     [TAG_RAY] = RayCodec.ray,
-    [TAG_NUMBERSEQUENCE] = Sequence.numberSequence,
-    [TAG_COLORSEQUENCE] = Sequence.colorSequence,
+    [TAG_NUMBERSEQUENCE] = SequenceCodec.numberSequence,
+    [TAG_COLORSEQUENCE] = SequenceCodec.colorSequence,
 })
 
+local function extractDw (codec: any): any
+    return (codec :: InternalCodec<any>)._directWrite
+end
+
 local TYPE_DISPATCH = table.freeze ({
     boolean = { tag = TAG_BOOL, codec = BoolCodec.bool, size = 1, dw = nil },
-    string = { tag = TAG_STRING, codec = String.string, size = nil, dw = nil },
+    string = { tag = TAG_STRING, codec = StringCodec.string, size = nil, dw = nil },
+    buffer = { tag = TAG_BUFFER, codec = BufferCodec.buff, size = nil, dw = nil },
     Vector2 = {
         tag = TAG_VEC2,
-        codec = Vector.vec2,
+        codec = VectorCodec.vec2,
         size = 8,
-        dw = (Vector.vec2 :: any)._directWrite,
+        dw = extractDw (VectorCodec.vec2),
     },
     Vector3 = {
         tag = TAG_VEC3,
-        codec = Vector.vec3,
+        codec = VectorCodec.vec3,
         size = 12,
-        dw = (Vector.vec3 :: any)._directWrite,
+        dw = extractDw (VectorCodec.vec3),
     },
     Color3 = {
         tag = TAG_COLOR3,
-        codec = Color.color3,
+        codec = ColorCodec.color3,
         size = 3,
-        dw = (Color.color3 :: any)._directWrite,
+        dw = extractDw (ColorCodec.color3),
     },
     CFrame = {
         tag = TAG_CFRAME,
         codec = CFrameCodec.cframe,
         size = 24,
-        dw = (CFrameCodec.cframe :: any)._directWrite,
+        dw = extractDw (CFrameCodec.cframe),
     },
-    buffer = { tag = TAG_BUFFER, codec = Buffer.buff, size = nil, dw = nil },
     UDim = {
         tag = TAG_UDIM,
         codec = UDimCodec.udim,
         size = 8,
-        dw = (UDimCodec.udim :: any)._directWrite,
+        dw = extractDw (UDimCodec.udim),
     },
     UDim2 = {
         tag = TAG_UDIM2,
         codec = UDimCodec.udim2,
         size = 16,
-        dw = (UDimCodec.udim2 :: any)._directWrite,
+        dw = extractDw (UDimCodec.udim2),
     },
     NumberRange = {
         tag = TAG_NUMBERRANGE,
         codec = NumberRangeCodec.numberRange,
         size = 8,
-        dw = (NumberRangeCodec.numberRange :: any)._directWrite,
+        dw = extractDw (NumberRangeCodec.numberRange),
     },
     Rect = {
         tag = TAG_RECT,
         codec = RectCodec.rect,
         size = 16,
-        dw = (RectCodec.rect :: any)._directWrite,
+        dw = extractDw (RectCodec.rect),
     },
     Vector2int16 = {
         tag = TAG_VEC2INT16,
-        codec = IntVector.vec2int16,
+        codec = IntVectorCodec.vec2int16,
         size = 4,
-        dw = (IntVector.vec2int16 :: any)._directWrite,
+        dw = extractDw (IntVectorCodec.vec2int16),
     },
     Vector3int16 = {
         tag = TAG_VEC3INT16,
-        codec = IntVector.vec3int16,
+        codec = IntVectorCodec.vec3int16,
         size = 6,
-        dw = (IntVector.vec3int16 :: any)._directWrite,
+        dw = extractDw (IntVectorCodec.vec3int16),
     },
     Region3 = {
         tag = TAG_REGION3,
-        codec = Region.region3,
+        codec = RegionCodec.region3,
         size = 24,
-        dw = (Region.region3 :: any)._directWrite,
+        dw = extractDw (RegionCodec.region3),
     },
     Region3int16 = {
         tag = TAG_REGION3INT16,
-        codec = Region.region3int16,
+        codec = RegionCodec.region3int16,
         size = 12,
-        dw = (Region.region3int16 :: any)._directWrite,
+        dw = extractDw (RegionCodec.region3int16),
     },
     Ray = {
         tag = TAG_RAY,
         codec = RayCodec.ray,
         size = 24,
-        dw = (RayCodec.ray :: any)._directWrite,
+        dw = extractDw (RayCodec.ray),
     },
     NumberSequence = {
         tag = TAG_NUMBERSEQUENCE,
-        codec = Sequence.numberSequence,
+        codec = SequenceCodec.numberSequence,
         size = nil,
         dw = nil,
     },
     ColorSequence = {
         tag = TAG_COLORSEQUENCE,
-        codec = Sequence.colorSequence,
+        codec = SequenceCodec.colorSequence,
         size = nil,
         dw = nil,
     },
@@ -187,24 +192,24 @@ local NUM_DWRITES = {} :: { [number]: any }
 
 for _, pair in
     {
-        { TAG_U8, Number.u8, 1 },
-        { TAG_U16, Number.u16, 2 },
-        { TAG_U32, Number.u32, 4 },
-        { TAG_I8, Number.i8, 1 },
-        { TAG_I16, Number.i16, 2 },
-        { TAG_I32, Number.i32, 4 },
-        { TAG_F32, Number.f32, 4 },
-        { TAG_F64, Number.f64, 8 },
+        { TAG_U8, NumberCodec.u8, 1 },
+        { TAG_U16, NumberCodec.u16, 2 },
+        { TAG_U32, NumberCodec.u32, 4 },
+        { TAG_I8, NumberCodec.i8, 1 },
+        { TAG_I16, NumberCodec.i16, 2 },
+        { TAG_I32, NumberCodec.i32, 4 },
+        { TAG_F32, NumberCodec.f32, 4 },
+        { TAG_F64, NumberCodec.f64, 8 },
     }
 do
     NUM_SIZES[pair[1]] = pair[3]
-    NUM_DWRITES[pair[1]] = (pair[2] :: any)._directWrite
+    NUM_DWRITES[pair[1]] = (pair[2] :: InternalCodec<number>)._directWrite
 end
 
 table.freeze (NUM_SIZES)
 table.freeze (NUM_DWRITES)
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local _f32Temp = buffer.create (4)
 
@@ -246,7 +251,7 @@ local function selectNumberTag (value: number): number
     return TAG_F64
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local auto = table.freeze ({
     write = function (ch: ChannelState, value: any): ()
@@ -312,17 +317,17 @@ local auto = table.freeze ({
             error (`[Lync] Auto unsupported type: {valueType}`)
         end
 
-        local dw = entry.dw
-        local size = entry.size
-        if dw and size then
-            local totalSize = 1 + size
+        local entryDw = entry.dw
+        local entrySize = entry.size
+        if entryDw and entrySize then
+            local totalSize = 1 + entrySize
             local c = ch.cursor
             if c + totalSize > ch.size then
                 alloc (ch, totalSize)
             end
             local b = ch.buff
             buffer.writeu8 (b, c, entry.tag)
-            dw (b, c + 1, value)
+            entryDw (b, c + 1, value)
             ch.cursor = c + totalSize
         else
             local c = ch.cursor

package/src/codec/meta/Bitfield.luau

@@ -3,20 +3,21 @@
 -- Pack booleans, unsigned and signed integers at the bit level.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- Constants --------------------------------------------------------------
+local alloc = Channel.alloc
+
+-- Constants ----------------------------------------------------------
 
 local band = bit32.band
 local bor = bit32.bor
 local lshift = bit32.lshift
 local rshift = bit32.rshift
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 type FieldSpec = {
     type: "bool" | "uint" | "int",
@@ -36,7 +37,7 @@ local function selectIO (bytes: number): ((b: buffer, offset: number, v: number)
     return buffer.writeu32, buffer.readu32
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Bitfield = {}
 

package/src/codec/meta/Enum.luau

@@ -3,13 +3,14 @@
 -- String enum codec. Maps values to u8 indices at definition time.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- Public -----------------------------------------------------------------
+local alloc = Channel.alloc
+
+-- Public -------------------------------------------------------------
 
 local EnumCodec = {}
 
@@ -28,7 +29,7 @@ function EnumCodec.define (...: string): Codec<string>
 
     for i, value in values do
         if toIndex[value] ~= nil then
-            error (`[Lync] Duplicate enum value: \"{value}\"`)
+            error (`[Lync] Duplicate enum value: "{value}"`)
         end
         toIndex[value] = i - 1
         toValue[i] = value
@@ -42,7 +43,7 @@ function EnumCodec.define (...: string): Codec<string>
         _directWrite = function (b: buffer, offset: number, value: string): ()
             local idx = toIndex[value]
             if idx == nil then
-                error (`[Lync] Invalid enum value: \"{value}\"`)
+                error (`[Lync] Invalid enum value: "{value}"`)
             end
             buffer.writeu8 (b, offset, idx)
         end,
@@ -57,7 +58,7 @@ function EnumCodec.define (...: string): Codec<string>
         write = function (ch: ChannelState, value: string): ()
             local idx = toIndex[value]
             if idx == nil then
-                error (`[Lync] Invalid enum value: \"{value}\"`)
+                error (`[Lync] Invalid enum value: "{value}"`)
             end
             local c = ch.cursor
             if c + 1 > ch.size then

package/src/codec/meta/Quantized.luau

@@ -3,13 +3,14 @@
 -- Fixed-point compression. Maps float ranges to integer ranges.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
 type ChannelState = Types.ChannelState
 type Codec<T> = Types.Codec<T>
 
--- Constants --------------------------------------------------------------
+local alloc = Channel.alloc
+
+-- Constants ----------------------------------------------------------
 
 local clamp = math.clamp
 local round = math.round
@@ -19,7 +20,7 @@ local max = math.max
 
 local U32_MAX = 4294967295
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function selectIO (bytes: number): ((b: buffer, offset: number, v: number) -> (), (
     b: buffer,
@@ -44,7 +45,7 @@ local function selectWidth (maxInt: number): number
     return 4
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Quantized = {}
 

package/src/codec/meta/Unknown.luau

@@ -3,11 +3,15 @@
 -- Sidecar codec. Bypasses buffer serialization, uses Roblox remote refs.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
+local Types = require (script.Parent.Parent.Parent.Types)
+
+type ChannelState = Types.ChannelState
+
 local alloc = Channel.alloc
 
 return table.freeze ({
     unknown = table.freeze ({
-        write = function (ch: any, value: any): ()
+        write = function (ch: ChannelState, value: any): ()
             local refs = ch.refs
             local idx = #refs + 1
             if idx > 65535 then

package/src/codec/primitive/Float16.luau

@@ -3,12 +3,13 @@
 -- Half-precision float codec. 2 bytes, ±65504, ~3 decimal digits.
 
 local Channel = require (script.Parent.Parent.Parent.internal.Channel)
-local alloc = Channel.alloc
 local Types = require (script.Parent.Parent.Parent.Types)
 
+local alloc = Channel.alloc
+
 type ChannelState = Types.ChannelState
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local MAX_HALF = 65504
 local BIAS = 15
@@ -28,7 +29,7 @@ local ldexp = math.ldexp
 local round = math.round
 local huge = math.huge
 
--- Private ----------------------------------------------------------------
+-- Private ------------------------------------------------------------
 
 local function encode (value: number): number
     if value ~= value then
@@ -83,7 +84,7 @@ local function decode (packed: number): number
     return if band (packed, SIGN_BIT) ~= 0 then -result else result
 end
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Float16 = {}
 

package/src/codec/primitive/Varint.luau

@@ -9,7 +9,7 @@ type ChannelState = Types.ChannelState
 
 local alloc = Channel.alloc
 
--- Constants --------------------------------------------------------------
+-- Constants ----------------------------------------------------------
 
 local CONT = 0x80
 local MASK = 0x7F
@@ -21,7 +21,7 @@ local bor = bit32.bor
 local rshift = bit32.rshift
 local lshift = bit32.lshift
 
--- Public -----------------------------------------------------------------
+-- Public -------------------------------------------------------------
 
 local Varint = {}
 

package/src/index.d.ts

@@ -72,6 +72,46 @@ type InferBitfield<S extends Record<string, FieldSpec>> = Prettify<{
     [K in keyof S]: InferFieldSpec<S[K]>;
 }>;
 
+// -- Target descriptors ------------------------------------------------
+
+export interface AllTarget {
+    readonly _tag: "all";
+}
+
+export interface ExceptTarget {
+    readonly _tag: "except";
+    readonly _set: ReadonlyMap<Player, true>;
+}
+
+export interface GroupObject {
+    readonly _tag: "group";
+    add(this: GroupObject, player: Player): boolean;
+    remove(this: GroupObject, player: Player): boolean;
+    has(this: GroupObject, player: Player): boolean;
+    count(this: GroupObject): number;
+    forEach(this: GroupObject, fn: (player: Player) => void): void;
+    getSet(this: GroupObject): ReadonlyMap<Player, true>;
+    destroy(this: GroupObject): void;
+}
+
+export type Target = Player | AllTarget | ExceptTarget | GroupObject | Player[];
+
+// -- Scope -------------------------------------------------------------
+
+export interface Scope {
+    add(this: Scope, conn: Connection | RBXScriptConnection): void;
+    listen<T>(this: Scope, source: Packet<T>, callback: (data: T, sender: Player | undefined) => void): void;
+    once<T>(this: Scope, source: Packet<T>, callback: (data: T, sender: Player | undefined) => void): void;
+    listenAll(this: Scope, namespace: Namespace, callback: (name: string, data: unknown, sender: Player | undefined) => void): void;
+    destroy(this: Scope): void;
+}
+
+// -- DROP sentinel -----------------------------------------------------
+
+export interface DropSentinel {
+    readonly _tag: "drop";
+}
+
 // -- Packet ------------------------------------------------------------
 
 export interface PacketConfig<T> {
@@ -82,14 +122,8 @@ export interface PacketConfig<T> {
     maxPayloadBytes?: number;
 }
 
-// Server methods throw on client and vice versa.
 export interface Packet<T> {
-    sendTo(this: Packet<T>, data: T, player: Player): void;
-    sendToAll(this: Packet<T>, data: T): void;
-    sendToAllExcept(this: Packet<T>, data: T, except: Player): void;
-    sendToList(this: Packet<T>, data: T, players: Player[]): void;
-    sendToGroup(this: Packet<T>, data: T, groupName: string): void;
-    send(this: Packet<T>, data: T): void;
+    send(this: Packet<T>, data: T, target?: Target): void;
     listen(this: Packet<T>, callback: (data: T, sender: Player | undefined) => void): Connection;
     once(this: Packet<T>, callback: (data: T, sender: Player | undefined) => void): Connection;
     wait(this: Packet<T>): LuaTuple<[T, Player | undefined]>;
@@ -111,17 +145,18 @@ export interface Query<Req, Resp> {
         this: Query<Req, Resp>,
         callback: (request: Req, player: Player) => Resp | undefined,
     ): Connection;
-    invoke(this: Query<Req, Resp>, request: Req, player?: Player): Resp | undefined;
-    invokeAll(this: Query<Req, Resp>, request: Req): Map<Player, Resp | undefined>;
-    invokeList(
+    request(this: Query<Req, Resp>, data: Req): Resp | undefined;
+    requestFrom(this: Query<Req, Resp>, player: Player, data: Req): Resp | undefined;
+    requestAll(this: Query<Req, Resp>, data: Req): Map<Player, Resp | undefined>;
+    requestList(
         this: Query<Req, Resp>,
-        request: Req,
         players: Player[],
+        data: Req,
     ): Map<Player, Resp | undefined>;
-    invokeGroup(
+    requestGroup(
         this: Query<Req, Resp>,
-        request: Req,
-        groupName: string,
+        group: GroupObject,
+        data: Req,
     ): Map<Player, Resp | undefined>;
 }
 
@@ -143,6 +178,8 @@ type InferQueries<Q extends Record<string, QueryConfig<unknown, unknown>>> = {
 };
 
 export interface Namespace {
+    readonly packets: Record<string, Packet<unknown>>;
+    readonly queries: Record<string, Query<unknown, unknown>>;
     listenAll(
         this: Namespace,
         callback: (name: string, data: unknown, sender: Player | undefined) => void,
@@ -166,7 +203,6 @@ export interface Namespace {
 declare namespace Lync {
     // Lifecycle
     export const VERSION: string;
-    export const version: string;
     export function start(): void;
 
     // Definition
@@ -251,21 +287,24 @@ declare namespace Lync {
         callback: (player: Player, reason: string, packetName: string, data: unknown) => void,
     ): () => void;
     export function onSend(
-        handler: (data: unknown, name: string, player: Player | undefined) => unknown | undefined,
+        handler: (data: unknown, name: string, player: Player | undefined) => unknown | DropSentinel | undefined,
     ): () => void;
     export function onReceive(
-        handler: (data: unknown, name: string, player: Player | undefined) => unknown | undefined,
+        handler: (data: unknown, name: string, player: Player | undefined) => unknown | DropSentinel | undefined,
     ): () => void;
 
+    // Target descriptors
+    export const all: AllTarget;
+    export function except(...players: Player[]): ExceptTarget;
+
+    // Middleware sentinel
+    export const DROP: DropSentinel;
+
     // Groups
-    export function createGroup(name: string): void;
-    export function destroyGroup(name: string): void;
-    export function addToGroup(name: string, player: Player): boolean;
-    export function removeFromGroup(name: string, player: Player): boolean;
-    export function hasInGroup(name: string, player: Player): boolean;
-    export function getGroupSet(name: string): ReadonlyMap<Player, true>;
-    export function groupCount(name: string): number;
-    export function forEachInGroup(name: string, fn: (player: Player) => void): void;
+    export function createGroup(name: string): GroupObject;
+
+    // Scope
+    export function scope(): Scope;
 
     // Configuration
     export function setChannelMaxSize(bytes: number): void;
@@ -276,4 +315,4 @@ declare namespace Lync {
     export function queryPendingCount(): number;
 }
 
-export default Lync;
+export default Lync;