@flamework-experimental/networking 2.0.0-alpha.1 → 2.0.0-alpha.3

package/out/function/createFunctionReceiver.luau

@@ -5,10 +5,12 @@ local _createEvent = TS.import(script, script.Parent.Parent, "event", "createEve
 local createEvent = _createEvent.createEvent
 local decodeArguments = _createEvent.decodeArguments
 local NetworkingFunctionError = TS.import(script, script.Parent, "errors").NetworkingFunctionError
-local createMiddlewareProcessor = TS.import(script, script.Parent.Parent, "middleware", "createMiddlewareProcessor").createMiddlewareProcessor
 local _skip = TS.import(script, script.Parent.Parent, "middleware", "skip")
 local Skip = _skip.Skip
 local SkipBadRequest = _skip.SkipBadRequest
+local _processor = TS.import(script, script.Parent.Parent, "middleware", "processor")
+local createProcessor = _processor.createProcessor
+local withoutPlayer = _processor.withoutPlayer
 local getProcessResult
 local function createFunctionReceiver(options)
 	local event = createEvent({
@@ -17,57 +19,63 @@ local function createFunctionReceiver(options)
 		id = options.id,
 		networkInfo = options.networkInfo,
 	})
-	local callback
-	local packedResults = false
-	local setCallback = function(newCallback, packed)
-		packedResults = packed
-		callback = createMiddlewareProcessor(options.incomingMiddleware, options.networkInfo, function(player, ...)
-			local args = { ... }
-			if RunService:IsServer() then
-				return newCallback(player, unpack(args))
-			else
-				return newCallback(unpack(args))
-			end
-		end)
+	-- Which half this function is, fixed when it is made: the server's callback is given the sender.
+	local isServer = RunService:IsServer()
+	-- Guards, then middleware, then the callback: plain calls in the thread handling the request, a
+	-- Promise any of them returns waited for in place and a cancelled one read as `Networking.Skip`.
+	local process
+	local packResult
+	local setCallback = function(newCallback, pack)
+		packResult = pack
+		process = createProcessor(options.incomingMiddleware, options.networkInfo, if isServer then newCallback else withoutPlayer(newCallback), options.incomingGuards, SkipBadRequest, Skip)
 	end
 	--[[
 		*
-		     * A packed callback's successful value is `[payload, blobs?]`, or nothing at all when the result
-		     * type carries nothing (`void`); errors always go back as they are.
+		     * With serialization, a successful value leaves packed as `[payload, blobs?]`, or nothing at all
+		     * when the result type carries nothing (`void`); errors always go back as they are. It is packed
+		     * here, after the middleware, so a value a middleware returns is packed like the callback's own.
 		     
 	]]
 	local respond = function(player, id, processResult, value)
-		if processResult == true and packedResults and value ~= nil then
-			local _binding = value
-			local payload = _binding[1]
-			local blobs = _binding[2]
-			event:fireEither(player, id, processResult, payload, blobs)
+		if processResult == true and packResult then
+			local packed = packResult(value)
+			if packed ~= nil then
+				event:fireEither(player, id, processResult, packed[1], packed[2])
+			else
+				event:fireEither(player, id, processResult)
+			end
 		else
 			event:fireEither(player, id, processResult, value)
 		end
 	end
+	--* A request that raised -- in a guard, a middleware, the callback, its Promise or the packing -- is answered `false`. 
+	local fail = function(player, id, reason)
+		warn(`Failed to process request to '{options.debugName}'`)
+		warn(reason)
+		event:fireEither(player, id, false)
+	end
+	-- Runs on the thread the event's signal gives this handler, one per request.
 	local processRequest = function(player, id, ...)
 		local args = { ... }
-		if not callback then
+		local current = process
+		if not current then
 			return event:fireEither(player, id, NetworkingFunctionError.Unprocessed)
 		end
 		local decoded = decodeArguments(options.argsDecoder, player, args, options.onMalformed)
 		if not decoded then
 			return event:fireEither(player, id, NetworkingFunctionError.BadRequest)
 		end
-		callback(player, unpack(decoded)):andThen(function(value)
-			return respond(player, id, getProcessResult(value), value)
-		end):catch(function(reason)
-			warn(`Failed to process request to '{options.debugName}'`)
-			warn(reason)
-			event:fireEither(player, id, false)
-		end)
+		local ok, value = pcall(current, player, unpack(decoded))
+		if not ok then
+			return fail(player, id, value)
+		end
+		local sent, reason = pcall(respond, player, id, getProcessResult(value), value)
+		if not sent then
+			fail(player, id, reason)
+		end
 	end
-	if RunService:IsServer() then
-		event:connectServer(function(player, id, ...)
-			local args = { ... }
-			return processRequest(player, id, unpack(args))
-		end)
+	if isServer then
+		event:connectServer(processRequest)
 	else
 		event:connectClient(function(id, ...)
 			local args = { ... }
@@ -75,37 +83,27 @@ local function createFunctionReceiver(options)
 		end)
 	end
 	return {
-		setServerCallback = function(self, callback, packed)
-			if packed == nil then
-				packed = false
-			end
-			setCallback(callback, packed)
+		setServerCallback = function(self, callback, pack)
+			setCallback(callback, pack)
 		end,
-		setClientCallback = function(self, callback, packed)
-			if packed == nil then
-				packed = false
-			end
-			setCallback(callback, packed)
+		setClientCallback = function(self, callback, pack)
+			setCallback(callback, pack)
 		end,
 		invoke = function(self, player, ...)
 			local args = { ... }
-			if not callback then
+			local current = process
+			if not current then
 				return TS.Promise.reject(NetworkingFunctionError.Unprocessed)
 			end
-			return callback(player, unpack(args)):andThen(function(value)
+			-- The Promise `predict` returns is the only one: the chain runs in its executor's thread.
+			return TS.Promise.new(function(resolve, reject)
+				local value = current(player, unpack(args))
 				local processResult = getProcessResult(value)
 				if processResult ~= true then
-					return TS.Promise.reject(processResult)
-				end
-				-- A packed callback answered with bytes; a local caller wants the value.
-				local decoder = options.resultDecoder
-				if not packedResults or not decoder then
-					return value
+					reject(processResult)
+				else
+					resolve(value)
 				end
-				local _binding = value
-				local payload = _binding[1]
-				local blobs = _binding[2]
-				return decoder(payload, blobs or {})[1]
 			end)
 		end,
 	}

package/out/function/createFunctionSender.d.ts

@@ -39,7 +39,8 @@ export interface RequestInfo {
     requests: Map<number, (value: unknown, rejection?: NetworkingFunctionError) => void>;
 }
 export interface FunctionSenderInterface {
-    invokeServer(...args: unknown[]): Promise<unknown>;
-    invokeClient(player: Player, ...args: unknown[]): Promise<unknown>;
+    /** `timeout` in seconds; `math.huge` waits for good. */
+    invokeServer(timeout: number, ...args: unknown[]): Promise<unknown>;
+    invokeClient(player: Player, timeout: number, ...args: unknown[]): Promise<unknown>;
 }
 export declare function createFunctionSender(options: CreateFunctionSenderOptions): FunctionSenderInterface;

package/out/function/createFunctionSender.luau

@@ -3,14 +3,13 @@ local TS = _G[script]
 local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
 local Players = _services.Players
 local RunService = _services.RunService
-local _createEvent = TS.import(script, script.Parent.Parent, "event", "createEvent")
-local createEvent = _createEvent.createEvent
-local decodeArguments = _createEvent.decodeArguments
+local createEvent = TS.import(script, script.Parent.Parent, "event", "createEvent").createEvent
+local decode = TS.import(script, script.Parent.Parent, "middleware", "processor").decode
 local _errors = TS.import(script, script.Parent, "errors")
 local NetworkingFunctionError = _errors.NetworkingFunctionError
 local getFunctionError = _errors.getFunctionError
 local t = TS.import(script, TS.getModule(script, "@rbxts", "t").lib.ts).t
-local createRequestInfo
+local createRequestInfo, hasLeft
 local function createFunctionSender(options)
 	local event = createEvent({
 		namespace = options.namespace,
@@ -18,8 +17,8 @@ local function createFunctionSender(options)
 		id = options.id,
 		networkInfo = options.networkInfo,
 	})
-	local processResponse = function(player, requestInfo, id, processResult, ...)
-		local response = { ... }
+	--* A response is `(id, processResult, value)`, or `(id, true, payload, blobs?)` with a result decoder. 
+	local processResponse = function(player, requestInfo, id, processResult, value, blobs)
 		if not t.number(id) then
 			return nil
 		end
@@ -34,12 +33,16 @@ local function createFunctionSender(options)
 		end
 		local rejection = getFunctionError(processResult)
 		if rejection ~= nil or not options.resultDecoder then
-			request(response[1], rejection)
+			request(value, rejection)
 			return nil
 		end
 		-- A successful response carries the packed value: `(buffer, blobs?)`.
-		local decoded = decodeArguments(options.resultDecoder, player, response, options.onMalformed)
-		if not decoded then
+		local ok, decoded = decode(options.resultDecoder, value, blobs)
+		if not ok then
+			local _result = options.onMalformed
+			if _result ~= nil then
+				_result(player, decoded)
+			end
 			request(nil, NetworkingFunctionError.InvalidResult)
 			return nil
 		end
@@ -48,21 +51,27 @@ local function createFunctionSender(options)
 	-- We don't need to defer here because we only accept responses to our explicit invocations.
 	local requestInfoServer = {}
 	local requestInfoClient = createRequestInfo()
+	-- A player who has left never answers: `FireClient` drops the request without a word, and only a
+	-- finite timeout would ever settle it. Weak, so that remembering them does not keep them alive.
+	local departedPlayers = setmetatable({}, {
+		__mode = "k",
+	})
 	if RunService:IsServer() then
-		event:connectServer(function(player, id, processResult, ...)
-			local response = { ... }
+		event:connectServer(function(player, id, processResult, value, blobs)
 			local _player = player
 			local requestInfo = requestInfoServer[_player]
 			if not requestInfo then
 				return nil
 			end
-			processResponse(player, requestInfo, id, processResult, unpack(response))
+			processResponse(player, requestInfo, id, processResult, value, blobs)
 		end)
 		Players.PlayerRemoving:Connect(function(player)
 			local _player = player
-			local requestInfo = requestInfoServer[_player]
+			departedPlayers[_player] = true
 			local _player_1 = player
-			requestInfoServer[_player_1] = nil
+			local requestInfo = requestInfoServer[_player_1]
+			local _player_2 = player
+			requestInfoServer[_player_2] = nil
 			if requestInfo then
 				-- Cancel all existing requests from this player.
 				for _, request in requestInfo.requests do
@@ -71,16 +80,48 @@ local function createFunctionSender(options)
 			end
 		end)
 	else
-		event:connectClient(function(id, processResult, ...)
-			local response = { ... }
-			processResponse(nil, requestInfoClient, id, processResult, unpack(response))
+		event:connectClient(function(id, processResult, value, blobs)
+			processResponse(nil, requestInfoClient, id, processResult, value, blobs)
 		end)
 	end
-	local createInvocation = function(player, id, requestInfo)
-		return TS.Promise.new(function(resolve, reject, onCancel)
-			local _requests = requestInfo.requests
-			local _id = id
-			_requests[_id] = function(value, rejection)
+	--[[
+		*
+		     * The one Promise of a request, which its executor registers and sends; nothing else is made for
+		     * it. The timeout is a `task.delay`, cancelled when the answer arrives (none at all for
+		     * `math.huge`), and cancelling the Promise drops both the request and the timer.
+		     *
+		     * A send that raises (an argument the engine cannot carry) raises to the caller, as it did when
+		     * the request was sent ahead of its Promise, and leaves nothing pending.
+		     
+	]]
+	local createInvocation = function(player, requestInfo, timeout, send)
+		local _original = requestInfoClient.nextId
+		requestInfoClient.nextId += 1
+		local id = _original
+		local failed = false
+		local failure
+		local invocation = TS.Promise.new(function(resolve, reject, onCancel)
+			local timer
+			-- A player's entry lives only while requests to them are in flight, so a request that is
+			-- never answered holds the Player only until it times out or is cancelled.
+			local settle = function()
+				requestInfo.requests[id] = nil
+				local _condition = player and next(requestInfo.requests) == nil
+				if _condition then
+					local _player = player
+					_condition = requestInfoServer[_player] == requestInfo
+				end
+				if _condition then
+					local _player = player
+					requestInfoServer[_player] = nil
+				end
+				if timer ~= nil then
+					task.cancel(timer)
+					timer = nil
+				end
+			end
+			requestInfo.requests[id] = function(value, rejection)
+				settle()
 				if rejection then
 					return reject(rejection)
 				end
@@ -90,40 +131,77 @@ local function createFunctionSender(options)
 					resolve(value)
 				end
 			end
-			onCancel(function()
-				local _requests_1 = requestInfo.requests
-				local _id_1 = id
-				_requests_1[_id_1] = nil
-			end)
+			if timeout ~= math.huge then
+				timer = task.delay(timeout, function()
+					-- Running now: the timer is spent, and a thread cannot cancel itself.
+					timer = nil
+					settle()
+					reject(NetworkingFunctionError.Timeout)
+				end)
+			end
+			onCancel(settle)
+			local sent, reason = pcall(send, id)
+			if not sent then
+				settle()
+				failed = true
+				failure = reason
+			end
 		end)
+		if failed then
+			-- Never settled, so cancelling it is silent; the raise is the caller's.
+			invocation:cancel()
+			error(failure, 0)
+		end
+		return invocation
 	end
 	return {
-		invokeServer = function(self, ...)
+		invokeServer = function(self, timeout, ...)
 			local args = { ... }
-			local _original = requestInfoClient.nextId
-			requestInfoClient.nextId += 1
-			local id = _original
-			event:fireServer(id, unpack(args))
-			return createInvocation(nil, id, requestInfoClient)
+			return createInvocation(nil, requestInfoClient, timeout, function(id)
+				return event:fireServer(id, unpack(args))
+			end)
 		end,
-		invokeClient = function(self, player, ...)
+		invokeClient = function(self, player, timeout, ...)
 			local args = { ... }
 			local _player = player
-			local requestInfo = requestInfoServer[_player]
+			local _condition = departedPlayers[_player] ~= nil
+			if not _condition then
+				_condition = hasLeft(player)
+			end
+			if _condition then
+				return TS.Promise.reject(NetworkingFunctionError.Cancelled)
+			end
+			local _player_1 = player
+			local requestInfo = requestInfoServer[_player_1]
 			if not requestInfo then
 				local _exp = player
 				requestInfo = createRequestInfo()
 				local _requestInfo = requestInfo
 				requestInfoServer[_exp] = _requestInfo
 			end
-			local _original = requestInfoClient.nextId
-			requestInfoClient.nextId += 1
-			local id = _original
-			event:fireClient(player, id, unpack(args))
-			return createInvocation(player, id, requestInfo)
+			return createInvocation(player, requestInfo, timeout, function(id)
+				return event:fireClient(player, id, unpack(args))
+			end)
 		end,
 	}
 end
+--[[
+	*
+	 * A player who left before this sender existed, whom its `PlayerRemoving` never saw: a player in the
+	 * game is parented to `Players`. Inside `PlayerRemoving` the leaving player may still read as
+	 * parented (Immediate signals), which is what `departedPlayers` is for. A Player that never was
+	 * parented there (the Lune harness's) counts as present while `Players` lists it.
+	 
+]]
+function hasLeft(player)
+	local _condition = player.Parent ~= Players
+	if _condition then
+		local _exp = Players:GetPlayers()
+		local _player = player
+		_condition = not (table.find(_exp, _player) ~= nil)
+	end
+	return _condition
+end
 function createRequestInfo()
 	return {
 		nextId = 0,

package/out/functions/createClientMethod.d.ts

@@ -9,7 +9,7 @@ export declare function createClientMethod(config: FunctionCreateConfiguration<u
     invokeWithTimeout: (timeout: number, ...args: unknown[]) => Promise<unknown>;
     readonly _flamework_receive?: unknown[] | undefined;
     readonly _flamework_fn?: unknown;
-    _setCallback: (callback: (...args: never[]) => unknown) => void;
+    _setCallback: (callback: (...args: never[]) => unknown, pack: (value: unknown) => unknown) => void;
     setCallback: (callback: (...args: unknown[]) => unknown | Promise<unknown>) => void;
     predict: (...args: unknown[]) => Promise<unknown>;
 };

package/out/functions/createClientMethod.luau

@@ -1,18 +1,19 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
-local NetworkingFunctionError = TS.import(script, script.Parent.Parent, "function", "errors").NetworkingFunctionError
-local timeoutPromise = TS.import(script, script.Parent.Parent, "util", "timeoutPromise").timeoutPromise
+local trimArguments = TS.import(script, script.Parent.Parent, "util", "trimArguments").trimArguments
 local function createClientMethod(config, receiver, sender)
+	-- A method that takes an argument list trims it before spreading it, or an explicit trailing
+	-- `undefined` would lose the arguments after a gap (see `trimArguments`).
 	local method = {
 		invoke = function(self, ...)
 			local args = { ... }
-			return self:invokeWithTimeout(config.defaultTimeout, unpack(args))
+			return self:invokeWithTimeout(config.defaultTimeout, unpack(trimArguments(args)))
 		end,
 		invokeWithTimeout = function(self, timeout, ...)
 			local args = { ... }
 			local _sender = sender
 			assert(_sender, "This is not a sender remote.")
-			return TS.Promise.race({ timeoutPromise(timeout, NetworkingFunctionError.Timeout), sender:invokeServer(unpack(args)) })
+			return sender:invokeServer(timeout, unpack(trimArguments(args)))
 		end,
 		_invoke = function(self, ...)
 			local packed = { ... }
@@ -27,22 +28,22 @@ local function createClientMethod(config, receiver, sender)
 			assert(_receiver, "This is not a receiver remote.")
 			receiver:setClientCallback(callback)
 		end,
-		_setCallback = function(self, callback)
+		_setCallback = function(self, callback, pack)
 			local _receiver = receiver
 			assert(_receiver, "This is not a receiver remote.")
-			receiver:setClientCallback(callback, true)
+			receiver:setClientCallback(callback, pack)
 		end,
 		predict = function(self, ...)
 			local args = { ... }
 			local _receiver = receiver
 			assert(_receiver, "This is not a receiver remote.")
-			return receiver:invoke(nil, unpack(args))
+			return receiver:invoke(nil, unpack(trimArguments(args)))
 		end,
 	}
 	setmetatable(method, {
 		__call = function(method, ...)
 			local args = { ... }
-			return method:invoke(unpack(args))
+			return method:invoke(unpack(trimArguments(args)))
 		end,
 	})
 	return method

package/out/functions/createGenericHandler.luau

@@ -1,10 +1,9 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
 local NetworkingFunctionError = TS.import(script, script.Parent.Parent, "function", "errors").NetworkingFunctionError
-local SkipBadRequest = TS.import(script, script.Parent.Parent, "middleware", "skip").SkipBadRequest
 local createFunctionReceiver = TS.import(script, script.Parent.Parent, "function", "createFunctionReceiver").createFunctionReceiver
 local createFunctionSender = TS.import(script, script.Parent.Parent, "function", "createFunctionSender").createFunctionSender
-local createGuardMiddleware = TS.import(script, script.Parent.Parent, "middleware", "createGuardMiddleware").createGuardMiddleware
+local createGuards = TS.import(script, script.Parent.Parent, "middleware", "createGuards").createGuards
 local Players = TS.import(script, TS.getModule(script, "@rbxts", "services")).Players
 local getNamespaceConfig = TS.import(script, script.Parent.Parent, "util", "getNamespaceConfig").getNamespaceConfig
 local function createGenericHandler(globalName, namespaceName, receiverPrefix, senderPrefix, metadata, config, signals, createMethod)
@@ -42,11 +41,13 @@ local function createGenericHandler(globalName, namespaceName, receiverPrefix, s
 			name = effectiveName,
 			globalName = globalName,
 		}
+		-- The generated guards run ahead of all user middleware; a request that fails them is answered
+		-- `BadRequest`.
+		local incomingGuards
 		if not config.disableIncomingGuards and isReceiver then
 			local guards = metadata.incoming[name]
 			assert(guards)
-			local _arg0 = createGuardMiddleware(name, guards[1], guards[2], networkInfo, config.warnOnInvalidGuards, signals, SkipBadRequest)
-			table.insert(incomingMiddleware, 1, _arg0)
+			incomingGuards = createGuards(name, guards[1], guards[2], networkInfo, config.warnOnInvalidGuards, signals)
 		end
 		-- A malformed serialized payload is reported like a failed guard, with no argument index.
 		local onMalformed = function(player, message)
@@ -65,9 +66,10 @@ local function createGenericHandler(globalName, namespaceName, receiverPrefix, s
 			local _object = {
 				namespace = globalName,
 				debugName = name,
-				id = if isSender then `{receiverPrefix}{effectiveName}` else effectiveName,
+				id = `{receiverPrefix}{effectiveName}`,
 				networkInfo = networkInfo,
 				incomingMiddleware = incomingMiddleware,
+				incomingGuards = incomingGuards,
 			}
 			local _left = "argsDecoder"
 			local _result_1 = metadata.incomingSerializers
@@ -75,12 +77,6 @@ local function createGenericHandler(globalName, namespaceName, receiverPrefix, s
 				_result_1 = _result_1[name]
 			end
 			_object[_left] = _result_1
-			local _left_1 = "resultDecoder"
-			local _result_2 = metadata.incomingResults
-			if _result_2 ~= nil then
-				_result_2 = _result_2[name]
-			end
-			_object[_left_1] = _result_2
 			_object.onMalformed = onMalformed
 			_result = createFunctionReceiver(_object)
 		else
@@ -92,7 +88,7 @@ local function createGenericHandler(globalName, namespaceName, receiverPrefix, s
 			local _object = {
 				namespace = globalName,
 				debugName = name,
-				id = if isReceiver then `{senderPrefix}{effectiveName}` else effectiveName,
+				id = `{senderPrefix}{effectiveName}`,
 				networkInfo = networkInfo,
 			}
 			local _left = "resultDecoder"

package/out/functions/createNetworkingFunction.luau

@@ -5,6 +5,7 @@ local createSignalContainer = TS.import(script, script.Parent.Parent, "util", "c
 local createGenericHandler = TS.import(script, script.Parent, "createGenericHandler").createGenericHandler
 local createServerMethod = TS.import(script, script.Parent, "createServerMethod").createServerMethod
 local createClientMethod = TS.import(script, script.Parent, "createClientMethod").createClientMethod
+local createOnce = TS.import(script, script.Parent.Parent, "util", "createOnce").createOnce
 local SERVER_PREFIX = "$"
 local CLIENT_PREFIX = "@"
 local function getDefaultConfiguration(config)
@@ -38,7 +39,9 @@ end
 local function createNetworkingFunction(globalName)
 	local signals = createSignalContainer()
 	local server
-	local client
+	-- Built once: building it waits for the server's remotes, and a thread that asks meanwhile gets the
+	-- same handler rather than a second one wired to the same remotes.
+	local client = createOnce()
 	return {
 		createServer = function(self, config, meta)
 			if RunService:IsRunning() and not RunService:IsServer() then
@@ -53,10 +56,9 @@ local function createNetworkingFunction(globalName)
 			if RunService:IsRunning() and not RunService:IsClient() then
 				return nil
 			end
-			if client == nil then
-				client = createGenericHandler(globalName, nil, CLIENT_PREFIX, SERVER_PREFIX, meta, getDefaultConfiguration(config), signals, createClientMethod)
-			end
-			return client
+			return client(function()
+				return createGenericHandler(globalName, nil, CLIENT_PREFIX, SERVER_PREFIX, meta, getDefaultConfiguration(config), signals, createClientMethod)
+			end)
 		end,
 		registerHandler = function(self, key, callback)
 			return signals:connect(key, callback)

package/out/functions/createServerMethod.d.ts

@@ -9,7 +9,7 @@ export declare function createServerMethod(config: FunctionCreateConfiguration<u
     invokeWithTimeout: (player: Player, timeout: number, ...args: unknown[]) => Promise<unknown>;
     readonly _flamework_receive?: unknown[] | undefined;
     readonly _flamework_fn?: unknown;
-    _setCallback: (callback: (player: Player, ...args: never[]) => unknown) => void;
+    _setCallback: (callback: (player: Player, ...args: never[]) => unknown, pack: (value: unknown) => unknown) => void;
     setCallback: (callback: (player: Player, ...args: unknown[]) => unknown | Promise<unknown>) => void;
     predict: (player: Player, ...args: unknown[]) => Promise<unknown>;
 };

package/out/functions/createServerMethod.luau

@@ -1,18 +1,19 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
-local NetworkingFunctionError = TS.import(script, script.Parent.Parent, "function", "errors").NetworkingFunctionError
-local timeoutPromise = TS.import(script, script.Parent.Parent, "util", "timeoutPromise").timeoutPromise
+local trimArguments = TS.import(script, script.Parent.Parent, "util", "trimArguments").trimArguments
 local function createServerMethod(config, receiver, sender)
+	-- A method that takes an argument list trims it before spreading it, or an explicit trailing
+	-- `undefined` would lose the arguments after a gap (see `trimArguments`).
 	local method = {
 		invoke = function(self, player, ...)
 			local args = { ... }
-			return self:invokeWithTimeout(player, config.defaultTimeout, unpack(args))
+			return self:invokeWithTimeout(player, config.defaultTimeout, unpack(trimArguments(args)))
 		end,
 		invokeWithTimeout = function(self, player, timeout, ...)
 			local args = { ... }
 			local _sender = sender
 			assert(_sender, "This is not a sender remote.")
-			return TS.Promise.race({ timeoutPromise(timeout, NetworkingFunctionError.Timeout), sender:invokeClient(player, unpack(args)) })
+			return sender:invokeClient(player, timeout, unpack(trimArguments(args)))
 		end,
 		_invoke = function(self, player, ...)
 			local packed = { ... }
@@ -27,22 +28,22 @@ local function createServerMethod(config, receiver, sender)
 			assert(_receiver, "This is not a receiver remote.")
 			receiver:setServerCallback(callback)
 		end,
-		_setCallback = function(self, callback)
+		_setCallback = function(self, callback, pack)
 			local _receiver = receiver
 			assert(_receiver, "This is not a receiver remote.")
-			receiver:setServerCallback(callback, true)
+			receiver:setServerCallback(callback, pack)
 		end,
 		predict = function(self, player, ...)
 			local args = { ... }
 			local _receiver = receiver
 			assert(_receiver, "This is not a receiver remote.")
-			return receiver:invoke(player, unpack(args))
+			return receiver:invoke(player, unpack(trimArguments(args)))
 		end,
 	}
 	setmetatable(method, {
 		__call = function(method, player, ...)
 			local args = { ... }
-			return method:invoke(player, unpack(args))
+			return method:invoke(player, unpack(trimArguments(args)))
 		end,
 	})
 	return method