@flamework-experimental/networking 2.0.0-alpha.0

package/out/functions/createGenericHandler.luau

@@ -0,0 +1,140 @@
+-- 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 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)
+	local handler = {}
+	local _set = {}
+	for _, _v in metadata.incomingIds do
+		_set[_v] = true
+	end
+	local receiverNameSet = _set
+	local _set_1 = {}
+	for _, _v in metadata.outgoingIds do
+		_set_1[_v] = true
+	end
+	local senderNameSet = _set_1
+	local _set_2 = {}
+	local _array = {}
+	local _length = #_array
+	local _array_1 = metadata.incomingIds
+	local _Length = #_array_1
+	table.move(_array_1, 1, _Length, _length + 1, _array)
+	_length += _Length
+	local _array_2 = metadata.outgoingIds
+	table.move(_array_2, 1, #_array_2, _length + 1, _array)
+	for _, _v in _array do
+		_set_2[_v] = true
+	end
+	for name in _set_2 do
+		local configMiddleware = config.middleware[name]
+		local incomingMiddleware = if configMiddleware ~= nil then table.clone(configMiddleware) else {}
+		local isReceiver = receiverNameSet[name] ~= nil
+		local isSender = senderNameSet[name] ~= nil
+		local effectiveName = if namespaceName ~= nil then `{namespaceName}/{name}` else name
+		local networkInfo = {
+			eventType = "Function",
+			name = effectiveName,
+			globalName = globalName,
+		}
+		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)
+		end
+		-- A malformed serialized payload is reported like a failed guard, with no argument index.
+		local onMalformed = function(player, message)
+			if config.warnOnInvalidGuards then
+				local sender = if player ~= nil then `'{player}'` else "Server"
+				warn(`{sender} sent a malformed payload for function '{name}': {message}`)
+			end
+			signals:fire("onBadRequest", player or Players.LocalPlayer, {
+				networkInfo = networkInfo,
+				argIndex = -1,
+				argValue = message,
+			})
+		end
+		local _result
+		if isReceiver then
+			local _object = {
+				namespace = globalName,
+				debugName = name,
+				id = if isSender then `{receiverPrefix}{effectiveName}` else effectiveName,
+				networkInfo = networkInfo,
+				incomingMiddleware = incomingMiddleware,
+			}
+			local _left = "argsDecoder"
+			local _result_1 = metadata.incomingSerializers
+			if _result_1 ~= nil then
+				_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
+			_result = nil
+		end
+		local receiver = _result
+		local _result_1
+		if isSender then
+			local _object = {
+				namespace = globalName,
+				debugName = name,
+				id = if isReceiver then `{senderPrefix}{effectiveName}` else effectiveName,
+				networkInfo = networkInfo,
+			}
+			local _left = "resultDecoder"
+			local _result_2 = metadata.outgoingResults
+			if _result_2 ~= nil then
+				_result_2 = _result_2[name]
+			end
+			_object[_left] = _result_2
+			_object.onMalformed = function(player, message)
+				if config.warnOnInvalidGuards then
+					warn(`Received a malformed response for function '{name}': {message}`)
+				end
+				signals:fire("onBadResponse", player or Players.LocalPlayer, {
+					networkInfo = networkInfo,
+					value = message,
+				})
+			end
+			_object.responseMiddleware = if config.disableIncomingGuards then nil else function(player, value, resolve, reject)
+				local returnGuard = metadata.outgoing[name]
+				if returnGuard and not returnGuard(value) then
+					reject(NetworkingFunctionError.InvalidResult)
+					signals:fire("onBadResponse", player or Players.LocalPlayer, {
+						networkInfo = networkInfo,
+						value = value,
+					})
+				else
+					resolve(value)
+				end
+			end
+			_result_1 = createFunctionSender(_object)
+		else
+			_result_1 = nil
+		end
+		local sender = _result_1
+		handler[name] = createMethod(config, receiver, sender)
+	end
+	for _, namespaceId in metadata.namespaceIds do
+		local namespace = metadata.namespaces[namespaceId]
+		handler[namespaceId] = createGenericHandler(globalName, if namespaceName ~= nil then `{namespaceName}/{namespaceId}` else namespaceId, receiverPrefix, senderPrefix, namespace, getNamespaceConfig(config, namespaceId), signals, createMethod)
+	end
+	return handler
+end
+return {
+	createGenericHandler = createGenericHandler,
+}

package/out/functions/createNetworkingFunction.d.ts

@@ -0,0 +1,2 @@
+import { GlobalFunction } from "./types";
+export declare function createNetworkingFunction<S, C>(globalName: string): GlobalFunction<S, C>;

package/out/functions/createNetworkingFunction.luau

@@ -0,0 +1,68 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local createSignalContainer = TS.import(script, script.Parent.Parent, "util", "createSignalContainer").createSignalContainer
+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 SERVER_PREFIX = "$"
+local CLIENT_PREFIX = "@"
+local function getDefaultConfiguration(config)
+	local _object = {}
+	local _left = "middleware"
+	local _condition = config.middleware
+	if _condition == nil then
+		_condition = {}
+	end
+	_object[_left] = _condition
+	local _left_1 = "defaultTimeout"
+	local _condition_1 = config.defaultTimeout
+	if _condition_1 == nil then
+		_condition_1 = (if RunService:IsClient() then 30 else 10)
+	end
+	_object[_left_1] = _condition_1
+	local _left_2 = "warnOnInvalidGuards"
+	local _condition_2 = config.warnOnInvalidGuards
+	if _condition_2 == nil then
+		_condition_2 = RunService:IsStudio()
+	end
+	_object[_left_2] = _condition_2
+	local _left_3 = "disableIncomingGuards"
+	local _condition_3 = config.disableIncomingGuards
+	if _condition_3 == nil then
+		_condition_3 = false
+	end
+	_object[_left_3] = _condition_3
+	return _object
+end
+local function createNetworkingFunction(globalName)
+	local signals = createSignalContainer()
+	local server
+	local client
+	return {
+		createServer = function(self, config, meta)
+			if RunService:IsRunning() and not RunService:IsServer() then
+				return nil
+			end
+			if server == nil then
+				server = createGenericHandler(globalName, nil, SERVER_PREFIX, CLIENT_PREFIX, meta, getDefaultConfiguration(config), signals, createServerMethod)
+			end
+			return server
+		end,
+		createClient = function(self, config, meta)
+			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
+		end,
+		registerHandler = function(self, key, callback)
+			return signals:connect(key, callback)
+		end,
+	}
+end
+return {
+	createNetworkingFunction = createNetworkingFunction,
+}

package/out/functions/createServerMethod.d.ts

@@ -0,0 +1,15 @@
+import { FunctionReceiverInterface } from "../function/createFunctionReceiver";
+import { FunctionSenderInterface } from "../function/createFunctionSender";
+import { FunctionCreateConfiguration } from "./types";
+export declare function createServerMethod(config: FunctionCreateConfiguration<unknown>, receiver?: FunctionReceiverInterface, sender?: FunctionSenderInterface): {
+    readonly _flamework_send?: unknown[] | undefined;
+    _invoke: (player: Player, payload?: buffer, blobs?: Array<defined>) => Promise<unknown>;
+    _invokeWithTimeout: (player: Player, timeout: number, payload?: buffer, blobs?: Array<defined>) => Promise<unknown>;
+    invoke: (player: Player, ...args: unknown[]) => Promise<unknown>;
+    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: unknown[]) => unknown | Promise<unknown>) => void;
+    predict: (player: Player, ...args: unknown[]) => Promise<unknown>;
+};

package/out/functions/createServerMethod.luau

@@ -0,0 +1,52 @@
+-- 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 function createServerMethod(config, receiver, sender)
+	local method = {
+		invoke = function(self, player, ...)
+			local args = { ... }
+			return self:invokeWithTimeout(player, config.defaultTimeout, unpack(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)) })
+		end,
+		_invoke = function(self, player, ...)
+			local packed = { ... }
+			return self:invokeWithTimeout(player, config.defaultTimeout, unpack(packed))
+		end,
+		_invokeWithTimeout = function(self, player, timeout, ...)
+			local packed = { ... }
+			return self:invokeWithTimeout(player, timeout, unpack(packed))
+		end,
+		setCallback = function(self, callback)
+			local _receiver = receiver
+			assert(_receiver, "This is not a receiver remote.")
+			receiver:setServerCallback(callback)
+		end,
+		_setCallback = function(self, callback)
+			local _receiver = receiver
+			assert(_receiver, "This is not a receiver remote.")
+			receiver:setServerCallback(callback, true)
+		end,
+		predict = function(self, player, ...)
+			local args = { ... }
+			local _receiver = receiver
+			assert(_receiver, "This is not a receiver remote.")
+			return receiver:invoke(player, unpack(args))
+		end,
+	}
+	setmetatable(method, {
+		__call = function(method, player, ...)
+			local args = { ... }
+			return method:invoke(player, unpack(args))
+		end,
+	})
+	return method
+end
+return {
+	createServerMethod = createServerMethod,
+}

package/out/functions/types.d.ts

@@ -0,0 +1,289 @@
+import { NetworkingFunctionError } from "../function/errors";
+import {
+	FunctionParameters,
+	FunctionReturn,
+	IntrinsicTupleGuards,
+	IntrinsicNetworkDecoder,
+	IntrinsicNetworkResultDecoder,
+	IntrinsicObfuscate,
+	NetworkingObfuscationMarker,
+	NetworkRaw,
+	ObfuscateNames,
+} from "../types";
+import { FunctionNetworkingEvents } from "../handlers";
+import { FunctionMiddleware } from "../middleware/types";
+import { Modding } from "@flamework-experimental/core";
+
+/**
+ * A sender declared `Networking.Raw`: its arguments and the result travel as they are. Without the
+ * hidden marker below, no call site packs them and the peer runs no decoder.
+ */
+export interface RawServerSender<I extends unknown[], O> {
+	(player: Player, ...args: I): Promise<O>;
+
+	/**
+	 * Sends this request to the specified player.
+	 * @param player The player that will receive this event
+	 */
+	invoke(player: Player, ...args: I): Promise<O>;
+
+	/**
+	 * Sends this request to the specified player, specifying a timeout.
+	 * @param player The player that will receive this event
+	 * @param timeout The maximum time to wait before timing out
+	 */
+	invokeWithTimeout(player: Player, timeout: number, ...args: I): Promise<O>;
+}
+
+export interface ServerSender<I extends unknown[], O> extends RawServerSender<I, O> {
+	/** @hidden Marks a sender for the transformer, which packs its arguments at each call site. */
+	readonly _flamework_send?: I;
+
+	/** @hidden Sends an argument list the transformer already packed; nothing when the list carries nothing. */
+	_invoke(player: Player, payload?: buffer, blobs?: Array<defined>): Promise<O>;
+
+	/** @hidden Sends an argument list the transformer already packed; nothing when the list carries nothing. */
+	_invokeWithTimeout(player: Player, timeout: number, payload?: buffer, blobs?: Array<defined>): Promise<O>;
+}
+
+export interface RawServerReceiver<I extends unknown[], O> {
+	/**
+	 * Connect to a networking event.
+	 * @param event The event to connect to
+	 * @param callback The callback that will be invoked
+	 * @param guards A list of guards that will only be used on this connection
+	 */
+	setCallback(callback: (player: Player, ...args: I) => O | Promise<O>): void;
+
+	/**
+	 * Invokes a server function using player as the sender.
+	 */
+	predict(player: Player, ...args: I): Promise<O>;
+}
+
+export interface ServerReceiver<I extends unknown[], O, F = unknown> extends RawServerReceiver<I, O> {
+	/** @hidden Marks a receiver for the transformer, which packs the callback's result at the call site. */
+	readonly _flamework_receive?: I;
+
+	/** @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;
+}
+
+export interface RawClientSender<I extends unknown[], O> {
+	(...args: I): Promise<O>;
+
+	/**
+	 * Sends this request to the server.
+	 */
+	invoke(...args: I): Promise<O>;
+
+	/**
+	 * Sends this request to the server, specifying a timeout.
+	 * @param timeout The maximum time to wait before timing out
+	 */
+	invokeWithTimeout(timeout: number, ...args: I): Promise<O>;
+}
+
+export interface ClientSender<I extends unknown[], O> extends RawClientSender<I, O> {
+	/** @hidden Marks a sender for the transformer, which packs its arguments at each call site. */
+	readonly _flamework_send?: I;
+
+	/** @hidden Sends an argument list the transformer already packed; nothing when the list carries nothing. */
+	_invoke(payload?: buffer, blobs?: Array<defined>): Promise<O>;
+
+	/** @hidden Sends an argument list the transformer already packed; nothing when the list carries nothing. */
+	_invokeWithTimeout(timeout: number, payload?: buffer, blobs?: Array<defined>): Promise<O>;
+}
+
+export interface RawClientReceiver<I extends unknown[], O> {
+	/**
+	 * Connect to a networking function.
+	 * @param event The function to connect to
+	 * @param callback The callback that will be invoked
+	 */
+	setCallback(callback: (...args: I) => O | Promise<O>): void;
+
+	/**
+	 * Invokes a client function.
+	 */
+	predict(...args: I): Promise<O>;
+}
+
+export interface ClientReceiver<I extends unknown[], O, F = unknown> extends RawClientReceiver<I, O> {
+	/** @hidden Marks a receiver for the transformer, which packs the callback's result at the call site. */
+	readonly _flamework_receive?: I;
+
+	/** @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;
+}
+
+export type ServerHandler<E, R> = NetworkingObfuscationMarker & {
+	[k in keyof Functions<E>]: E[k] extends NetworkRaw<unknown>
+		? RawServerSender<FunctionParameters<E[k]>, FunctionReturn<E[k]>>
+		: ServerSender<FunctionParameters<E[k]>, FunctionReturn<E[k]>>;
+} & {
+	[k in keyof Functions<R>]: R[k] extends NetworkRaw<unknown>
+		? RawServerReceiver<FunctionParameters<R[k]>, FunctionReturn<R[k]>>
+		: ServerReceiver<FunctionParameters<R[k]>, FunctionReturn<R[k]>, R[k]>;
+} & {
+	[k in keyof FunctionNamespaces<E>]: ServerHandler<E[k], k extends keyof R ? R[k] : {}>;
+} & {
+	[k in keyof FunctionNamespaces<R>]: ServerHandler<k extends keyof E ? E[k] : {}, R[k]>;
+};
+
+export type ClientHandler<E, R> = NetworkingObfuscationMarker & {
+	[k in keyof Functions<E>]: E[k] extends NetworkRaw<unknown>
+		? RawClientSender<FunctionParameters<E[k]>, FunctionReturn<E[k]>>
+		: ClientSender<FunctionParameters<E[k]>, FunctionReturn<E[k]>>;
+} & {
+	[k in keyof Functions<R>]: R[k] extends NetworkRaw<unknown>
+		? RawClientReceiver<FunctionParameters<R[k]>, FunctionReturn<R[k]>>
+		: ClientReceiver<FunctionParameters<R[k]>, FunctionReturn<R[k]>, R[k]>;
+} & {
+	[k in keyof FunctionNamespaces<E>]: ClientHandler<E[k], k extends keyof R ? R[k] : {}>;
+} & {
+	[k in keyof FunctionNamespaces<R>]: ClientHandler<k extends keyof E ? E[k] : {}, R[k]>;
+};
+
+export interface FunctionCreateConfiguration<T> {
+	/**
+	 * Disables input validation, allowing any value to pass.
+	 * Defaults to `false`
+	 */
+	disableIncomingGuards: boolean;
+
+	/**
+	 * Emit a warning whenever a guard fails.
+	 * Defaults to `RunService.IsStudio()`
+	 */
+	warnOnInvalidGuards: boolean;
+
+	/**
+	 * The default timeout for outgoing requests.
+	 * Defaults to `10`
+	 */
+	defaultTimeout: number;
+
+	/**
+	 * The middleware for each event.
+	 */
+	middleware: FunctionMiddlewareList<T>;
+}
+
+export interface GlobalFunction<S, C> {
+	/**
+	 * This is the server implementation of the network and does not exist on the client.
+	 *
+	 * @metadata macro {@link config intrinsic-const} {@link config intrinsic-middleware}
+	 */
+	createServer(config: Partial<FunctionCreateConfiguration<S>>, meta?: NamespaceMetadata<S, C>): ServerHandler<C, S>;
+
+	/**
+	 * This is the client implementation of the network and does not exist on the server.
+	 *
+	 * @metadata macro {@link config intrinsic-const} {@link config intrinsic-middleware}
+	 */
+	createClient(config: Partial<FunctionCreateConfiguration<C>>, meta?: NamespaceMetadata<C, S>): ClientHandler<S, C>;
+
+	/**
+	 * Registers a networking event handler.
+	 * @param key The name of the event
+	 * @param callback The handler you wish to attach
+	 */
+	registerHandler<K extends keyof FunctionNetworkingEvents>(
+		key: K,
+		callback: FunctionNetworkingEvents[K],
+	): RBXScriptConnection;
+}
+
+export interface FunctionConfiguration {
+	/**
+	 * Disables input validation and return validation on the server, allowing any value to pass.
+	 * Defaults to `false`
+	 */
+	disableServerGuards: boolean;
+
+	/**
+	 * Disables input validation and return validation on the client, allowing any value to pass.
+	 * Defaults to `false`
+	 */
+	disableClientGuards: boolean;
+
+	/**
+	 * The default timeout for requests from the server to the client.
+	 * Defaults to `10`
+	 */
+	defaultServerTimeout: number;
+
+	/**
+	 * The default timeout for requests from the client to the server.
+	 * Defaults to `30`
+	 */
+	defaultClientTimeout: number;
+
+	/**
+	 * Emit a warning whenever a guard fails.
+	 * Defaults to `RunService.IsStudio()`
+	 */
+	warnOnInvalidGuards: boolean;
+}
+
+export interface RequestInfo {
+	nextId: number;
+	requests: Map<number, (value: unknown, rejection?: NetworkingFunctionError) => void>;
+}
+
+export type FunctionNamespaces<T> = ExcludeMembers<T, Callback>;
+export type Functions<T> = ExtractMembers<T, Callback>;
+
+/**
+ * We must generate the return type of events separately as Flamework no longer includes all type guards on both server and client.
+ */
+export type NamespaceMetadata<R, S> = Modding.Emit<{
+	incomingIds: ObfuscateNames<keyof Functions<R>>;
+	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]>> }>;
+
+	/**
+	 * 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.
+	 */
+	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]>;
+	}>;
+
+	namespaceIds: ObfuscateNames<keyof FunctionNamespaces<R> | keyof FunctionNamespaces<S>>;
+	namespaces: IntrinsicObfuscate<
+		{
+			[k in keyof FunctionNamespaces<R>]: NamespaceMetadata<R[k], k extends keyof S ? S[k] : {}>;
+		} & {
+			[k in keyof FunctionNamespaces<S>]: NamespaceMetadata<k extends keyof R ? R[k] : {}, S[k]>;
+		}
+	>;
+}>;
+
+export type FunctionMiddlewareList<T> = {
+	readonly [k in keyof Functions<T>]?: T[k] extends (...args: infer I) => infer O
+		? [...FunctionMiddleware<I, O>[]]
+		: never;
+} & {
+	readonly [k in keyof FunctionNamespaces<T>]?: FunctionMiddlewareList<T[k]>;
+};

package/out/handlers.d.ts

@@ -0,0 +1,36 @@
+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;
+}

package/out/index.d.ts

@@ -0,0 +1,55 @@
+import { GlobalEvent } from "./events/types";
+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 { NetworkRaw, NetworkUnreliable } from "./types";
+import type { Modding } from "@flamework-experimental/core";
+export declare namespace Networking {
+    /**
+     * Creates a new event based off the supplied types.
+     * @param serverMiddleware Middleware for server events
+     * @param clientMiddleware Middleware for client events
+     * @metadata macro
+     */
+    function createEvent<S, C>(name?: Modding.Caller.Uuid): GlobalEvent<S, C>;
+    /**
+     * Creates a new function event based off the supplied types.
+     * @param serverMiddleware Middleware for server events
+     * @param clientMiddleware Middleware for client events
+     * @metadata macro
+     */
+    function createFunction<S, C>(name?: Modding.Caller.Uuid): GlobalFunction<S, C>;
+    /**
+     * Stops networking function middleware.
+     */
+    const Skip: NetworkingSkip;
+    /**
+     * Specifies that this event is unreliable.
+     *
+     * This will only work on remote events.
+     */
+    type Unreliable<T> = NetworkUnreliable<T>;
+    /**
+     * Sends this event's arguments as they are, bypassing `networking.serialization` for this event
+     * alone. The generated guards still run on what arrives.
+     */
+    type RawReliable<T> = NetworkRaw<T>;
+    /**
+     * An unreliable event whose arguments bypass serialization; see {@link RawReliable}.
+     */
+    type RawUnreliable<T> = NetworkUnreliable<NetworkRaw<T>>;
+    /**
+     * A function whose requests and results bypass serialization; see {@link RawReliable}.
+     */
+    type Raw<T> = NetworkRaw<T>;
+    /**
+     * A function that generates an event middleware.
+     */
+    type EventMiddleware<I extends readonly unknown[] = unknown[]> = _EventMiddleware<I>;
+    /**
+     * A function that generates an event middleware.
+     */
+    type FunctionMiddleware<I extends readonly unknown[] = unknown[], O = void> = _FunctionMiddleware<I, O>;
+}
+export { NetworkingFunctionError };