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

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

package/out/functions/types.d.ts

@@ -12,6 +12,7 @@ import {
 } from "../types";
 import { FunctionNetworkingEvents } from "../handlers";
 import { FunctionMiddleware } from "../middleware/types";
+import { SignalConnection } from "../util/signal";
 import { Modding } from "@flamework-experimental/core";
 
 /**
@@ -68,8 +69,8 @@ export interface ServerReceiver<I extends unknown[], O, F = unknown> extends Raw
 	/** @hidden The declared function type; its return type is what the transformer packs. */
 	readonly _flamework_fn?: F;
 
-	/** @hidden Registers a callback whose successful results are already packed as `[payload, blobs?]`. */
-	_setCallback(callback: (player: Player, ...args: never[]) => unknown): void;
+	/** @hidden Registers a callback with `pack`, which turns a successful result into `[payload, blobs?]`. */
+	_setCallback(callback: (player: Player, ...args: never[]) => unknown, pack: (value: unknown) => unknown): void;
 }
 
 export interface RawClientSender<I extends unknown[], O> {
@@ -119,8 +120,8 @@ export interface ClientReceiver<I extends unknown[], O, F = unknown> extends Raw
 	/** @hidden The declared function type; its return type is what the transformer packs. */
 	readonly _flamework_fn?: F;
 
-	/** @hidden Registers a callback whose successful results are already packed as `[payload, blobs?]`. */
-	_setCallback(callback: (...args: never[]) => unknown): void;
+	/** @hidden Registers a callback with `pack`, which turns a successful result into `[payload, blobs?]`. */
+	_setCallback(callback: (...args: never[]) => unknown, pack: (value: unknown) => unknown): void;
 }
 
 export type ServerHandler<E, R> = NetworkingObfuscationMarker & {
@@ -199,7 +200,7 @@ export interface GlobalFunction<S, C> {
 	registerHandler<K extends keyof FunctionNetworkingEvents>(
 		key: K,
 		callback: FunctionNetworkingEvents[K],
-	): RBXScriptConnection;
+	): SignalConnection;
 }
 
 export interface FunctionConfiguration {
@@ -250,22 +251,19 @@ export type NamespaceMetadata<R, S> = Modding.Emit<{
 	incoming: IntrinsicObfuscate<{ [k in keyof Functions<R>]: IntrinsicTupleGuards<Parameters<R[k]>> }>;
 
 	outgoingIds: ObfuscateNames<keyof Functions<S>>;
-	outgoing: IntrinsicObfuscate<{ [k in keyof Functions<S>]: Modding.Target.Guard<ReturnType<S[k]>> }>;
+	// A response carries the resolved value: a `Promise<T>` result is checked as `T`.
+	outgoing: IntrinsicObfuscate<{ [k in keyof Functions<S>]: Modding.Target.Guard<Awaited<ReturnType<S[k]>>> }>;
 
 	/**
 	 * Decoders, present only with `networking.serialization` on and absent for raw functions: the
-	 * argument lists of requests this realm receives, the results its callbacks return (so `predict`
-	 * can unpack them) and the responses to requests it sends. Requests and results are packed inline
-	 * where they are produced.
+	 * argument lists of requests this realm receives and the responses to requests it sends. Requests
+	 * and results are packed inline where they are produced.
 	 */
 	incomingSerializers: IntrinsicObfuscate<{
 		[k in keyof Functions<R>]: R[k] extends NetworkRaw<unknown>
 			? undefined
 			: IntrinsicNetworkDecoder<Parameters<R[k]>>;
 	}>;
-	incomingResults: IntrinsicObfuscate<{
-		[k in keyof Functions<R>]: R[k] extends NetworkRaw<unknown> ? undefined : IntrinsicNetworkResultDecoder<R[k]>;
-	}>;
 	outgoingResults: IntrinsicObfuscate<{
 		[k in keyof Functions<S>]: S[k] extends NetworkRaw<unknown> ? undefined : IntrinsicNetworkResultDecoder<S[k]>;
 	}>;

package/out/handlers.d.ts

@@ -1,36 +1,35 @@
-import Signal from "@rbxts/signal";
-import { NetworkInfo } from "./types";
-
-interface BaseEvent {
-	/**
-	 * The event or function that was fired.
-	 */
-	networkInfo: NetworkInfo;
-}
-
-interface BadRequestData extends BaseEvent {
-	/**
-	 * The index of the argument that was incorrect, or -1 when a serialized payload could not be decoded.
-	 */
-	argIndex: number;
-
-	/**
-	 * The value of the argument that was incorrect, or the decoding error for a malformed payload.
-	 */
-	argValue: unknown;
-}
-
-interface BadResponseData extends BaseEvent {
-	/**
-	 * The index of the argument that was incorrect.
-	 */
-	value: unknown;
-}
-
-export interface EventNetworkingEvents {
-	onBadRequest: (player: Player, data: BadRequestData) => void;
-}
-
-export interface FunctionNetworkingEvents extends EventNetworkingEvents {
-	onBadResponse: (player: Player, data: BadResponseData) => void;
-}
+import { NetworkInfo } from "./types";
+
+interface BaseEvent {
+	/**
+	 * The event or function that was fired.
+	 */
+	networkInfo: NetworkInfo;
+}
+
+interface BadRequestData extends BaseEvent {
+	/**
+	 * The index of the argument that was incorrect, or -1 when a serialized payload could not be decoded.
+	 */
+	argIndex: number;
+
+	/**
+	 * The value of the argument that was incorrect, or the decoding error for a malformed payload.
+	 */
+	argValue: unknown;
+}
+
+interface BadResponseData extends BaseEvent {
+	/**
+	 * The index of the argument that was incorrect.
+	 */
+	value: unknown;
+}
+
+export interface EventNetworkingEvents {
+	onBadRequest: (player: Player, data: BadRequestData) => void;
+}
+
+export interface FunctionNetworkingEvents extends EventNetworkingEvents {
+	onBadResponse: (player: Player, data: BadResponseData) => void;
+}

package/out/index.d.ts

@@ -3,6 +3,7 @@ import { GlobalFunction } from "./functions/types";
 import { Skip as NetworkingSkip } from "./middleware/skip";
 import { NetworkingFunctionError } from "./function/errors";
 import { EventMiddleware as _EventMiddleware, FunctionMiddleware as _FunctionMiddleware } from "./middleware/types";
+import { SignalConnection as _SignalConnection } from "./util/signal";
 import { NetworkRaw, NetworkUnreliable } from "./types";
 import type { Modding } from "@flamework-experimental/core";
 export declare namespace Networking {
@@ -51,5 +52,10 @@ export declare namespace Networking {
      * A function that generates an event middleware.
      */
     type FunctionMiddleware<I extends readonly unknown[] = unknown[], O = void> = _FunctionMiddleware<I, O>;
+    /**
+     * What `connect` and `registerHandler` return: `Connected`, `Disconnect()`, and `Destroy()` for
+     * maids and janitors. It is networking's own, not an engine `RBXScriptConnection`.
+     */
+    type Connection = _SignalConnection;
 }
 export { NetworkingFunctionError };

package/out/init.luau

@@ -71,6 +71,12 @@ do
 		     * A function that generates an event middleware.
 		     
 	]]
+	--[[
+		*
+		     * What `connect` and `registerHandler` return: `Connected`, `Disconnect()`, and `Destroy()` for
+		     * maids and janitors. It is networking's own, not an engine `RBXScriptConnection`.
+		     
+	]]
 end
 return {
 	Networking = Networking,

package/out/middleware/createGuards.d.ts

@@ -0,0 +1,10 @@
+import { t } from "@rbxts/t";
+import { SignalContainer } from "../util/createSignalContainer";
+import { EventNetworkingEvents } from "../handlers";
+import { NetworkInfo } from "../types";
+import { Guards } from "./processor";
+/**
+ * The generated argument checks of one event or function, for the receive pipeline, which runs them
+ * ahead of all user middleware. A failure warns (with `warnOnInvalid`) and fires `onBadRequest`.
+ */
+export declare function createGuards(name: string, fixedParameters: t.check<unknown>[], restParameter: t.check<unknown> | undefined, networkInfo: NetworkInfo, warnOnInvalid: boolean, signals: SignalContainer<EventNetworkingEvents>): Guards;