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

package/README.md

@@ -27,6 +27,7 @@ bun install
 bun run build          # builds every package in dependency order
 bun run test           # build + transformer tests + runtime specs
 bun run lint
+bun run test:place     # the in-place suite in Roblox Studio (tests/place); needs Studio, Rojo and Lune
 ```
 
 ### Packages
@@ -64,3 +65,8 @@ Two suites, both run by `bun run test`:
 
 Specs live in [`packages/specs`](packages/specs) and are compiled by `rbxtsc` like any other
 Flamework consumer, so they exercise the transformer and the runtime together.
+
+A third suite runs against the real engine and is left out of `bun run test`: the
+[test place](tests/place/README.md), a small game linked to the packages' builds, whose
+`@flamework-experimental/testing` sections `bun run test:place` runs in Roblox Studio, both realms,
+under four Rojo projects (see [Testing in Roblox Studio](docs/testing/studio.md)).

package/flamework.build

@@ -1,6 +1,6 @@
 {
 	"version": 1,
-	"flameworkVersion": "2.0.0-alpha.1",
+	"flameworkVersion": "2.0.0-alpha.3",
 	"identifiers": {},
 	"idGenerationMode": "full",
 	"identifierPrefix": "$n"

package/out/event/createEvent.d.ts

@@ -1,6 +1,8 @@
 import { Serialization } from "@flamework-experimental/core";
-import { MiddlewareFactory, MiddlewareProcessor } from "../middleware/types";
+import { MiddlewareFactory } from "../middleware/types";
 import { NetworkInfo } from "../types";
+import { Guards } from "../middleware/processor";
+import { SignalConnection } from "../util/signal";
 export interface CreateEventOptions {
     /**
      * The namespace this event should be created in.
@@ -30,6 +32,11 @@ export interface CreateEventOptions {
      * A list of middleware that this event uses when it receives an event.
      */
     incomingMiddleware?: MiddlewareFactory<any[], void>[];
+    /**
+     * The generated argument checks, run on what arrives before any middleware. A message that fails
+     * them is dropped.
+     */
+    incomingGuards?: Guards;
     /**
      * Unpacks the argument list of incoming events. Absent when the project does not enable
      * serialization. Outgoing lists reach `fire*` already packed: the transformer generates the
@@ -46,14 +53,25 @@ export interface EventInterface {
     fireServer(...args: unknown[]): void;
     fireClient(player: Player, ...args: unknown[]): void;
     fireAllClients(...args: unknown[]): void;
-    connectServer(callback: (player: Player, ...args: unknown[]) => void): RBXScriptConnection;
-    connectClient(callback: (...args: unknown[]) => void): RBXScriptConnection;
-    invoke: MiddlewareProcessor<any[], void>;
+    connectServer(callback: (player: Player, ...args: unknown[]) => void): SignalConnection;
+    connectClient(callback: (...args: unknown[]) => void): SignalConnection;
+    /**
+     * Runs the receiving half as if the remote had delivered `args` (plain values, never a payload), on
+     * a recycled thread of its own, so that a middleware that yields does not hold up the caller.
+     */
+    predict(player: Player | undefined, ...args: unknown[]): void;
 }
 /**
  * The argument list a remote delivered: `args` as they are without a decoder, otherwise the buffer
  * and blob list unpacked. `undefined` when the payload was malformed, after reporting it through
  * `onMalformed`. Decoding runs under `pcall`: a hostile buffer raises instead of yielding garbage.
+ *
+ * Either way the list is trimmed after its last value, so that no hop after it loses the values
+ * that follow a nil (see `trimArguments`). A decoded list keeps one slot per declared parameter,
+ * so an absent trailing optional would otherwise end it in nil.
+ *
+ * An event's own messages are decoded in the receive pipeline (`processor.luau`); this is for a
+ * function's requests and responses, which carry a plain request id ahead of the payload.
  */
 export declare function decodeArguments(decoder: Serialization.Decoder | undefined, player: Player | undefined, args: unknown[], onMalformed?: (player: Player | undefined, message: string) => void): unknown[] | undefined;
 export declare function createEvent(options: CreateEventOptions): EventInterface;

package/out/event/createEvent.luau

@@ -2,77 +2,70 @@
 local TS = _G[script]
 local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
 local createRemoteInstance = TS.import(script, script.Parent, "createRemoteInstance").createRemoteInstance
-local createMiddlewareProcessor = TS.import(script, script.Parent.Parent, "middleware", "createMiddlewareProcessor").createMiddlewareProcessor
---* A sender whose type has blob slots always sends a table; one without never does. 
-local NO_BLOBS = {}
+local _processor = TS.import(script, script.Parent.Parent, "middleware", "processor")
+local createProcessor = _processor.createProcessor
+local createReceiver = _processor.createReceiver
+local decode = _processor.decode
+local deliverTo = _processor.deliverTo
+local _signal = TS.import(script, script.Parent.Parent, "util", "signal")
+local createSignal = _signal.createSignal
+local spawn = _signal.spawn
+local trimArguments = TS.import(script, script.Parent.Parent, "util", "trimArguments").trimArguments
 --[[
 	*
 	 * The argument list a remote delivered: `args` as they are without a decoder, otherwise the buffer
 	 * and blob list unpacked. `undefined` when the payload was malformed, after reporting it through
 	 * `onMalformed`. Decoding runs under `pcall`: a hostile buffer raises instead of yielding garbage.
+	 *
+	 * Either way the list is trimmed after its last value, so that no hop after it loses the values
+	 * that follow a nil (see `trimArguments`). A decoded list keeps one slot per declared parameter,
+	 * so an absent trailing optional would otherwise end it in nil.
+	 *
+	 * An event's own messages are decoded in the receive pipeline (`processor.luau`); this is for a
+	 * function's requests and responses, which carry a plain request id ahead of the payload.
 	 
 ]]
 local function decodeArguments(decoder, player, args, onMalformed)
 	if not decoder then
-		return args
+		return trimArguments(args)
 	end
-	local _binding = args
-	local payload = _binding[1]
-	local blobs = _binding[2]
-	if not (type(payload) == "buffer") or (blobs ~= nil and not (type(blobs) == "table")) then
-		local _result = onMalformed
-		if _result ~= nil then
-			_result(player, "payload is not a buffer with an optional blob list")
-		end
-		return nil
-	end
-	local ok, result = pcall(decoder, payload, (blobs or NO_BLOBS))
+	local ok, result = decode(decoder, args[1], args[2])
 	if not ok then
 		local _result = onMalformed
 		if _result ~= nil then
-			_result(player, tostring(result))
+			_result(player, result)
 		end
 		return nil
 	end
-	return result
+	return trimArguments(result)
 end
 local function createEvent(options)
 	local remote = createRemoteInstance(if options.reliability == "unreliable" then "UnreliableRemoteEvent" else "RemoteEvent", options.namespace, options.debugName, options.id)
-	local bindable
-	local invoke = createMiddlewareProcessor(options.incomingMiddleware, options.networkInfo, function(player, ...)
-		local args = { ... }
-		if RunService:IsServer() then
-			bindable:Fire(player, unpack(args))
-		else
-			bindable:Fire(unpack(args))
+	-- Which half this event is, fixed when it is made: the server's handlers are given the sender.
+	local isServer = RunService:IsServer()
+	-- Passes the arguments by reference. A BindableEvent would copy them, turning a decoded
+	-- `Map<Instance, ...>` into one keyed by strings and raising on a `Set<boolean>`.
+	local signal = createSignal()
+	-- Guards, then middleware, then the signal: plain calls in the thread that received the message.
+	local process = createProcessor(options.incomingMiddleware, options.networkInfo, deliverTo(signal, isServer), options.incomingGuards, nil, nil)
+	-- Nothing to deliver to until something connects (a `predict` may come first), so the remote is
+	-- only listened to from the first connection on.
+	local listening = false
+	local listen = function()
+		if listening then
+			return nil
 		end
-	end)
-	local receive = function(player, args)
-		local decoded = decodeArguments(options.incomingDecoder, player, args, options.onMalformed)
-		if decoded then
-			invoke(player, unpack(decoded))
-		end
-	end
-	local createConnection = function(callback)
-		if bindable then
-			return bindable.Event:Connect(callback)
-		end
-		bindable = Instance.new("BindableEvent")
+		listening = true
 		-- We defer to allow any other immediate connections to take place before unloading Roblox's queue.
 		task.defer(function()
-			if RunService:IsServer() then
-				remote.OnServerEvent:Connect(function(player, ...)
-					local args = { ... }
-					return receive(player, args)
-				end)
+			-- Runs in the thread the engine gives the handler, one per message.
+			local receive = createReceiver(options.incomingDecoder, options.onMalformed, process, isServer)
+			if isServer then
+				remote.OnServerEvent:Connect(receive)
 			else
-				remote.OnClientEvent:Connect(function(...)
-					local args = { ... }
-					return receive(nil, args)
-				end)
+				remote.OnClientEvent:Connect(receive)
 			end
 		end)
-		return bindable.Event:Connect(callback)
 	end
 	return {
 		fireEither = function(self, player, ...)
@@ -98,14 +91,19 @@ local function createEvent(options)
 		connectServer = function(self, callback)
 			local _arg0 = RunService:IsServer()
 			assert(_arg0)
-			return createConnection(callback)
+			listen()
+			return signal:Connect(callback)
 		end,
 		connectClient = function(self, callback)
 			local _arg0 = RunService:IsClient()
 			assert(_arg0)
-			return createConnection(callback)
+			listen()
+			return signal:Connect(callback)
+		end,
+		predict = function(self, player, ...)
+			local args = { ... }
+			spawn(process, player, unpack(args))
 		end,
-		invoke = invoke,
 	}
 end
 return {

package/out/events/createClientMethod.luau

@@ -1,9 +1,13 @@
 -- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local trimArguments = TS.import(script, script.Parent.Parent, "util", "trimArguments").trimArguments
 local function createClientMethod(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 = {
 		fire = function(self, ...)
 			local args = { ... }
-			sender:fireServer(unpack(args))
+			sender:fireServer(unpack(trimArguments(args)))
 		end,
 		_fire = function(self, ...)
 			local packed = { ... }
@@ -14,13 +18,13 @@ local function createClientMethod(receiver, sender)
 		end,
 		predict = function(self, ...)
 			local args = { ... }
-			return receiver.invoke(nil, unpack(args))
+			receiver:predict(nil, unpack(trimArguments(args)))
 		end,
 	}
 	setmetatable(method, {
 		__call = function(method, ...)
 			local args = { ... }
-			method:fire(unpack(args))
+			method:fire(unpack((trimArguments(args))))
 		end,
 	})
 	return method

package/out/events/createGenericHandler.luau

@@ -1,6 +1,6 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
-local createGuardMiddleware = TS.import(script, script.Parent.Parent, "middleware", "createGuardMiddleware").createGuardMiddleware
+local createGuards = TS.import(script, script.Parent.Parent, "middleware", "createGuards").createGuards
 local createEvent = TS.import(script, script.Parent.Parent, "event", "createEvent").createEvent
 local getNamespaceConfig = TS.import(script, script.Parent.Parent, "util", "getNamespaceConfig").getNamespaceConfig
 local Players = TS.import(script, TS.getModule(script, "@rbxts", "services")).Players
@@ -44,11 +44,13 @@ local function createGenericHandler(globalName, namespaceName, metadata, config,
 			name = effectiveName,
 			globalName = globalName,
 		}
+		-- The generated guards run ahead of all user middleware, so middleware never sees a payload that
+		-- failed them.
+		local incomingGuards
 		if not config.disableIncomingGuards and isIncoming then
 			local guards = metadata.incoming[name]
 			assert(guards)
-			local _arg0 = createGuardMiddleware(name, guards[1], guards[2], networkInfo, config.warnOnInvalidGuards, signals)
-			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)
@@ -70,6 +72,7 @@ local function createGenericHandler(globalName, namespaceName, metadata, config,
 				debugName = name,
 				networkInfo = networkInfo,
 				incomingMiddleware = incomingMiddleware,
+				incomingGuards = incomingGuards,
 			}
 			local _left = "incomingDecoder"
 			local _result

package/out/events/createNetworkingEvent.luau

@@ -5,6 +5,7 @@ local createClientMethod = TS.import(script, script.Parent, "createClientMethod"
 local createServerMethod = TS.import(script, script.Parent, "createServerMethod").createServerMethod
 local createSignalContainer = TS.import(script, script.Parent.Parent, "util", "createSignalContainer").createSignalContainer
 local createGenericHandler = TS.import(script, script.Parent, "createGenericHandler").createGenericHandler
+local createOnce = TS.import(script, script.Parent.Parent, "util", "createOnce").createOnce
 local function getDefaultConfiguration(config)
 	local _object = {}
 	local _left = "middleware"
@@ -30,7 +31,9 @@ end
 local function createNetworkingEvent(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
@@ -45,10 +48,9 @@ local function createNetworkingEvent(globalName)
 			if RunService:IsRunning() and not RunService:IsClient() then
 				return nil
 			end
-			if client == nil then
-				client = createGenericHandler(globalName, nil, meta, getDefaultConfiguration(config), signals, createClientMethod)
-			end
-			return client
+			return client(function()
+				return createGenericHandler(globalName, nil, meta, getDefaultConfiguration(config), signals, createClientMethod)
+			end)
 		end,
 		registerHandler = function(self, key, callback)
 			return signals:connect(key, callback)

package/out/events/createServerMethod.d.ts

@@ -8,6 +8,6 @@ export declare function createServerMethod(receiver: EventInterface, sender: Eve
     except: (players: Player | Player[], ...args: unknown[]) => void;
     broadcast: (...args: unknown[]) => void;
     readonly _flamework_receive?: unknown[] | undefined;
-    connect: (cb: (player: Player, ...args: unknown[]) => void) => RBXScriptConnection;
+    connect: (cb: (player: Player, ...args: unknown[]) => void) => import("../util/signal").SignalConnection;
     predict: (player: Player, ...args: unknown[]) => void;
 };

package/out/events/createServerMethod.luau

@@ -1,10 +1,14 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
 local Players = TS.import(script, TS.getModule(script, "@rbxts", "services")).Players
+local trimArguments = TS.import(script, script.Parent.Parent, "util", "trimArguments").trimArguments
 local function createServerMethod(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 = {
 		fire = function(self, players, ...)
 			local args = { ... }
+			args = trimArguments(args)
 			local _players = players
 			if typeof(_players) == "Instance" then
 				sender:fireClient(players, unpack(args))
@@ -16,10 +20,11 @@ local function createServerMethod(receiver, sender)
 		end,
 		broadcast = function(self, ...)
 			local args = { ... }
-			sender:fireAllClients(unpack(args))
+			sender:fireAllClients(unpack(trimArguments(args)))
 		end,
 		except = function(self, players, ...)
 			local args = { ... }
+			args = trimArguments(args)
 			local _players = players
 			if typeof(_players) == "Instance" then
 				players = { players }
@@ -47,13 +52,13 @@ local function createServerMethod(receiver, sender)
 		end,
 		predict = function(self, player, ...)
 			local args = { ... }
-			receiver.invoke(player, unpack(args))
+			receiver:predict(player, unpack(trimArguments(args)))
 		end,
 	}
 	setmetatable(method, {
 		__call = function(method, player, ...)
 			local args = { ... }
-			method:fire(player, unpack(args))
+			method:fire(player, unpack(trimArguments(args)))
 		end,
 	})
 	return method

package/out/events/types.d.ts

@@ -10,6 +10,7 @@ import {
 } from "../types";
 import { EventNetworkingEvents } from "../handlers";
 import { EventMiddleware } from "../middleware/types";
+import { SignalConnection } from "../util/signal";
 import { Modding } from "@flamework-experimental/core";
 
 /**
@@ -56,7 +57,7 @@ export interface RawServerReceiver<I extends unknown[]> {
 	 * Connect to this networking event.
 	 * @param callback The callback that will be fired
 	 */
-	connect(cb: (player: Player, ...args: I) => void): RBXScriptConnection;
+	connect(cb: (player: Player, ...args: I) => void): SignalConnection;
 
 	/**
 	 * Fires a server event using player as the sender.
@@ -91,7 +92,7 @@ export interface RawClientReceiver<I extends unknown[]> {
 	 * Connect to this networking event.
 	 * @param callback The callback that will be fired
 	 */
-	connect(cb: (...args: I) => void): RBXScriptConnection;
+	connect(cb: (...args: I) => void): SignalConnection;
 
 	/**
 	 * Fires a client event.
@@ -174,7 +175,7 @@ export interface GlobalEvent<S, C> {
 	registerHandler<K extends keyof EventNetworkingEvents>(
 		key: K,
 		callback: EventNetworkingEvents[K],
-	): RBXScriptConnection;
+	): SignalConnection;
 }
 
 export type EventNamespaces<T> = ExcludeMembers<T, Callback>;

package/out/function/createFunctionReceiver.d.ts

@@ -2,6 +2,7 @@ import { Serialization } from "@flamework-experimental/core";
 import { NetworkInfo } from "../types";
 import { NetworkingFunctionError } from "./errors";
 import { MiddlewareFactory } from "../middleware/types";
+import { Guards } from "../middleware/processor";
 export interface CreateFunctionReceiverOptions {
     /**
      * The namespace this event should be created in.
@@ -22,18 +23,18 @@ export interface CreateFunctionReceiverOptions {
      */
     networkInfo: NetworkInfo;
     /**
-     * This function will be called when we receive a response, and can be used to resolve or reject values.
+     * The middleware a request goes through before it reaches the callback.
      */
     incomingMiddleware?: MiddlewareFactory<any[], any>[];
     /**
-     * Unpacks the request's argument list. Absent when the project does not enable serialization.
+     * The generated argument checks, run on a request before any middleware. A request that fails
+     * them is rejected with `BadRequest`.
      */
-    argsDecoder?: Serialization.Decoder;
+    incomingGuards?: Guards;
     /**
-     * Unpacks the results a packed callback returns, so that `predict` resolves with the value itself.
-     * Absent when the project does not enable serialization.
+     * Unpacks the request's argument list. Absent when the project does not enable serialization.
      */
-    resultDecoder?: Serialization.Decoder;
+    argsDecoder?: Serialization.Decoder;
     /**
      * Called when a request cannot be decoded; the caller receives `BadRequest`.
      */
@@ -44,9 +45,9 @@ export interface RequestInfo {
     requests: Map<number, (value: unknown, rejection?: NetworkingFunctionError) => void>;
 }
 export interface FunctionReceiverInterface {
-    /** `packed`: the callback returns successful results as `[payload, blobs?]`, packed by the transformer. */
-    setServerCallback(callback: (player: Player, ...args: unknown[]) => unknown, packed?: boolean): void;
-    setClientCallback(callback: (...args: unknown[]) => unknown, packed?: boolean): void;
+    /** `pack`: turns a successful result into `[payload, blobs?]`, generated by the transformer. */
+    setServerCallback(callback: (player: Player, ...args: unknown[]) => unknown, pack?: (value: unknown) => unknown): void;
+    setClientCallback(callback: (...args: unknown[]) => unknown, pack?: (value: unknown) => unknown): void;
     invoke(player: Player | undefined, ...args: unknown[]): Promise<unknown>;
 }
 export declare function createFunctionReceiver(options: CreateFunctionReceiverOptions): FunctionReceiverInterface;

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;