@flamework-experimental/networking 2.0.0-alpha.0

package/out/events/types.d.ts

@@ -0,0 +1,220 @@
+import {
+	FunctionParameters,
+	IntrinsicTupleGuards,
+	IntrinsicNetworkDecoder,
+	IntrinsicObfuscate,
+	NetworkingObfuscationMarker,
+	NetworkRaw,
+	NetworkUnreliable,
+	ObfuscateNames,
+} from "../types";
+import { EventNetworkingEvents } from "../handlers";
+import { EventMiddleware } from "../middleware/types";
+import { Modding } from "@flamework-experimental/core";
+
+/**
+ * A sender declared `Networking.RawReliable` / `RawUnreliable`: its arguments 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[]> {
+	(player: Player | Player[], ...args: I): void;
+
+	/**
+	 * Sends this request to the specified player(s).
+	 * @param players The player(s) that will receive this event
+	 */
+	fire(players: Player | Player[], ...args: I): void;
+
+	/**
+	 * Sends this request to all players, excluding the specified player(s).
+	 * @param players The player(s) that will not receive this event
+	 */
+	except(players: Player | Player[], ...args: I): void;
+
+	/**
+	 * Sends this request to all connected players.
+	 */
+	broadcast(...args: I): void;
+}
+
+export interface ServerSender<I extends unknown[]> extends RawServerSender<I> {
+	/** @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. */
+	_fire(players: Player | Player[], payload?: buffer, blobs?: Array<defined>): void;
+
+	/** @hidden Sends an argument list the transformer already packed; nothing when the list carries nothing. */
+	_except(players: Player | Player[], payload?: buffer, blobs?: Array<defined>): void;
+
+	/** @hidden Sends an argument list the transformer already packed; nothing when the list carries nothing. */
+	_broadcast(payload?: buffer, blobs?: Array<defined>): void;
+}
+
+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;
+
+	/**
+	 * Fires a server event using player as the sender.
+	 */
+	predict(player: Player, ...args: I): void;
+}
+
+export interface ServerReceiver<I extends unknown[]> extends RawServerReceiver<I> {
+	/** @hidden Marks a receiver for the transformer. */
+	readonly _flamework_receive?: I;
+}
+
+export interface RawClientSender<I extends unknown[]> {
+	(...args: I): void;
+
+	/**
+	 * Sends this request to the server.
+	 */
+	fire(...args: I): void;
+}
+
+export interface ClientSender<I extends unknown[]> extends RawClientSender<I> {
+	/** @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. */
+	_fire(payload?: buffer, blobs?: Array<defined>): void;
+}
+
+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;
+
+	/**
+	 * Fires a client event.
+	 */
+	predict(...args: I): void;
+}
+
+export interface ClientReceiver<I extends unknown[]> extends RawClientReceiver<I> {
+	/** @hidden Marks a receiver for the transformer. */
+	readonly _flamework_receive?: I;
+}
+
+export type ServerHandler<E, R> = NetworkingObfuscationMarker & {
+	[k in keyof Events<E>]: E[k] extends NetworkRaw<unknown>
+		? RawServerSender<FunctionParameters<E[k]>>
+		: ServerSender<FunctionParameters<E[k]>>;
+} & {
+	[k in keyof Events<R>]: R[k] extends NetworkRaw<unknown>
+		? RawServerReceiver<FunctionParameters<R[k]>>
+		: ServerReceiver<FunctionParameters<R[k]>>;
+} & {
+	[k in keyof EventNamespaces<E>]: ServerHandler<E[k], k extends keyof R ? R[k] : {}>;
+} & {
+	[k in keyof EventNamespaces<R>]: ServerHandler<k extends keyof E ? E[k] : {}, R[k]>;
+};
+
+export type ClientHandler<E, R> = NetworkingObfuscationMarker & {
+	[k in keyof Events<E>]: E[k] extends NetworkRaw<unknown>
+		? RawClientSender<FunctionParameters<E[k]>>
+		: ClientSender<FunctionParameters<E[k]>>;
+} & {
+	[k in keyof Events<R>]: R[k] extends NetworkRaw<unknown>
+		? RawClientReceiver<FunctionParameters<R[k]>>
+		: ClientReceiver<FunctionParameters<R[k]>>;
+} & {
+	[k in keyof EventNamespaces<E>]: ClientHandler<E[k], k extends keyof R ? R[k] : {}>;
+} & {
+	[k in keyof EventNamespaces<R>]: ClientHandler<k extends keyof E ? E[k] : {}, R[k]>;
+};
+
+export interface EventCreateConfiguration<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 middleware for each event.
+	 */
+	middleware: EventMiddlewareList<T>;
+}
+
+export interface GlobalEvent<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<EventCreateConfiguration<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<EventCreateConfiguration<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 EventNetworkingEvents>(
+		key: K,
+		callback: EventNetworkingEvents[K],
+	): RBXScriptConnection;
+}
+
+export type EventNamespaces<T> = ExcludeMembers<T, Callback>;
+export type Events<T> = ExtractMembers<T, Callback>;
+
+export type NamespaceMetadata<R, S> = Modding.Emit<{
+	incomingIds: ObfuscateNames<keyof Events<R>>;
+	incoming: IntrinsicObfuscate<{ [k in keyof Events<R>]: IntrinsicTupleGuards<Parameters<Events<R>[k]>> }>;
+	incomingUnreliable: IntrinsicObfuscate<{
+		[k in keyof Events<R>]: R[k] extends NetworkUnreliable<unknown> ? true : undefined;
+	}>;
+
+	outgoingIds: ObfuscateNames<keyof Events<S>>;
+	outgoingUnreliable: IntrinsicObfuscate<{
+		[k in keyof Events<S>]: S[k] extends NetworkUnreliable<unknown> ? true : undefined;
+	}>;
+
+	/**
+	 * Decoders for each incoming event's argument list, present only with `networking.serialization`
+	 * on, and absent for raw events and for lists that carry nothing. Outgoing lists are packed
+	 * inline where they are fired; nothing here can encode.
+	 */
+	incomingSerializers: IntrinsicObfuscate<{
+		[k in keyof Events<R>]: R[k] extends NetworkRaw<unknown>
+			? undefined
+			: IntrinsicNetworkDecoder<Parameters<Events<R>[k]>>;
+	}>;
+
+	namespaceIds: ObfuscateNames<keyof EventNamespaces<R> | keyof EventNamespaces<S>>;
+	namespaces: IntrinsicObfuscate<
+		{
+			[k in keyof EventNamespaces<R>]: NamespaceMetadata<R[k], k extends keyof S ? S[k] : {}>;
+		} & {
+			[k in keyof EventNamespaces<S>]: NamespaceMetadata<k extends keyof R ? R[k] : {}, S[k]>;
+		}
+	>;
+}>;
+
+export type EventMiddlewareList<T> = {
+	readonly [k in keyof Events<T>]?: T[k] extends (...args: infer I) => void ? [...EventMiddleware<I>[]] : never;
+} & {
+	readonly [k in keyof EventNamespaces<T>]?: EventMiddlewareList<T[k]>;
+};

package/out/function/createFunctionReceiver.d.ts

@@ -0,0 +1,52 @@
+import { Serialization } from "@flamework-experimental/core";
+import { NetworkInfo } from "../types";
+import { NetworkingFunctionError } from "./errors";
+import { MiddlewareFactory } from "../middleware/types";
+export interface CreateFunctionReceiverOptions {
+    /**
+     * The namespace this event should be created in.
+     */
+    namespace: string;
+    /**
+     * The name of the remote instance, not necessarily unique and used for debugging purposes.
+     */
+    debugName: string;
+    /**
+     * The remote's ID which must be unique.
+     */
+    id: string;
+    /**
+     * Information about the network, which includes some of the above.
+     *
+     * Passed to the middleware.
+     */
+    networkInfo: NetworkInfo;
+    /**
+     * This function will be called when we receive a response, and can be used to resolve or reject values.
+     */
+    incomingMiddleware?: MiddlewareFactory<any[], any>[];
+    /**
+     * Unpacks the request's argument list. Absent when the project does not enable serialization.
+     */
+    argsDecoder?: Serialization.Decoder;
+    /**
+     * Unpacks the results a packed callback returns, so that `predict` resolves with the value itself.
+     * Absent when the project does not enable serialization.
+     */
+    resultDecoder?: Serialization.Decoder;
+    /**
+     * Called when a request cannot be decoded; the caller receives `BadRequest`.
+     */
+    onMalformed?: (player: Player | undefined, message: string) => void;
+}
+export interface RequestInfo {
+    nextId: number;
+    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;
+    invoke(player: Player | undefined, ...args: unknown[]): Promise<unknown>;
+}
+export declare function createFunctionReceiver(options: CreateFunctionReceiverOptions): FunctionReceiverInterface;

package/out/function/createFunctionReceiver.luau

@@ -0,0 +1,118 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local _createEvent = TS.import(script, script.Parent.Parent, "event", "createEvent")
+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 getProcessResult
+local function createFunctionReceiver(options)
+	local event = createEvent({
+		namespace = options.namespace,
+		debugName = options.debugName,
+		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)
+	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.
+		     
+	]]
+	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)
+		else
+			event:fireEither(player, id, processResult, value)
+		end
+	end
+	local processRequest = function(player, id, ...)
+		local args = { ... }
+		if not callback 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)
+	end
+	if RunService:IsServer() then
+		event:connectServer(function(player, id, ...)
+			local args = { ... }
+			return processRequest(player, id, unpack(args))
+		end)
+	else
+		event:connectClient(function(id, ...)
+			local args = { ... }
+			return processRequest(nil, id, unpack(args))
+		end)
+	end
+	return {
+		setServerCallback = function(self, callback, packed)
+			if packed == nil then
+				packed = false
+			end
+			setCallback(callback, packed)
+		end,
+		setClientCallback = function(self, callback, packed)
+			if packed == nil then
+				packed = false
+			end
+			setCallback(callback, packed)
+		end,
+		invoke = function(self, player, ...)
+			local args = { ... }
+			if not callback then
+				return TS.Promise.reject(NetworkingFunctionError.Unprocessed)
+			end
+			return callback(player, unpack(args)):andThen(function(value)
+				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
+				end
+				local _binding = value
+				local payload = _binding[1]
+				local blobs = _binding[2]
+				return decoder(payload, blobs or {})[1]
+			end)
+		end,
+	}
+end
+function getProcessResult(value)
+	return if value == Skip then NetworkingFunctionError.Cancelled elseif value == SkipBadRequest then NetworkingFunctionError.BadRequest else true
+end
+return {
+	createFunctionReceiver = createFunctionReceiver,
+}

package/out/function/createFunctionSender.d.ts

@@ -0,0 +1,45 @@
+import { Serialization } from "@flamework-experimental/core";
+import { NetworkInfo } from "../types";
+import { NetworkingFunctionError } from "./errors";
+export interface CreateFunctionSenderOptions {
+    /**
+     * The namespace this event should be created in.
+     */
+    namespace: string;
+    /**
+     * The name of the remote instance, not necessarily unique and used for debugging purposes.
+     */
+    debugName: string;
+    /**
+     * The remote's ID which must be unique.
+     */
+    id: string;
+    /**
+     * Information about the network, which includes some of the above.
+     *
+     * Passed to the middleware.
+     */
+    networkInfo: NetworkInfo;
+    /**
+     * This function will be called when we receive a response, and can be used to resolve or reject values.
+     */
+    responseMiddleware?: (player: Player | undefined, value: unknown, resolve: (value: unknown) => void, reject: (value: unknown) => void) => void;
+    /**
+     * Unpacks a successful response's value, carried as a one-element list. Absent when the project
+     * does not enable serialization. Requests reach `invoke*` already packed by the transformer.
+     */
+    resultDecoder?: Serialization.Decoder;
+    /**
+     * Called when a response cannot be decoded; the request is rejected with `InvalidResult`.
+     */
+    onMalformed?: (player: Player | undefined, message: string) => void;
+}
+export interface RequestInfo {
+    nextId: number;
+    requests: Map<number, (value: unknown, rejection?: NetworkingFunctionError) => void>;
+}
+export interface FunctionSenderInterface {
+    invokeServer(...args: unknown[]): Promise<unknown>;
+    invokeClient(player: Player, ...args: unknown[]): Promise<unknown>;
+}
+export declare function createFunctionSender(options: CreateFunctionSenderOptions): FunctionSenderInterface;

package/out/function/createFunctionSender.luau

@@ -0,0 +1,135 @@
+-- Compiled with roblox-ts v3.0.0
+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 _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 function createFunctionSender(options)
+	local event = createEvent({
+		namespace = options.namespace,
+		debugName = options.debugName,
+		id = options.id,
+		networkInfo = options.networkInfo,
+	})
+	local processResponse = function(player, requestInfo, id, processResult, ...)
+		local response = { ... }
+		if not t.number(id) then
+			return nil
+		end
+		local _requests = requestInfo.requests
+		local _id = id
+		local request = _requests[_id]
+		local _requests_1 = requestInfo.requests
+		local _id_1 = id
+		_requests_1[_id_1] = nil
+		if not request then
+			return nil
+		end
+		local rejection = getFunctionError(processResult)
+		if rejection ~= nil or not options.resultDecoder then
+			request(response[1], 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
+			request(nil, NetworkingFunctionError.InvalidResult)
+			return nil
+		end
+		request(decoded[1], nil)
+	end
+	-- We don't need to defer here because we only accept responses to our explicit invocations.
+	local requestInfoServer = {}
+	local requestInfoClient = createRequestInfo()
+	if RunService:IsServer() then
+		event:connectServer(function(player, id, processResult, ...)
+			local response = { ... }
+			local _player = player
+			local requestInfo = requestInfoServer[_player]
+			if not requestInfo then
+				return nil
+			end
+			processResponse(player, requestInfo, id, processResult, unpack(response))
+		end)
+		Players.PlayerRemoving:Connect(function(player)
+			local _player = player
+			local requestInfo = requestInfoServer[_player]
+			local _player_1 = player
+			requestInfoServer[_player_1] = nil
+			if requestInfo then
+				-- Cancel all existing requests from this player.
+				for _, request in requestInfo.requests do
+					request(nil, NetworkingFunctionError.Cancelled)
+				end
+			end
+		end)
+	else
+		event:connectClient(function(id, processResult, ...)
+			local response = { ... }
+			processResponse(nil, requestInfoClient, id, processResult, unpack(response))
+		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)
+				if rejection then
+					return reject(rejection)
+				end
+				if options.responseMiddleware then
+					options.responseMiddleware(player, value, resolve, reject)
+				else
+					resolve(value)
+				end
+			end
+			onCancel(function()
+				local _requests_1 = requestInfo.requests
+				local _id_1 = id
+				_requests_1[_id_1] = nil
+			end)
+		end)
+	end
+	return {
+		invokeServer = function(self, ...)
+			local args = { ... }
+			local _original = requestInfoClient.nextId
+			requestInfoClient.nextId += 1
+			local id = _original
+			event:fireServer(id, unpack(args))
+			return createInvocation(nil, id, requestInfoClient)
+		end,
+		invokeClient = function(self, player, ...)
+			local args = { ... }
+			local _player = player
+			local requestInfo = requestInfoServer[_player]
+			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)
+		end,
+	}
+end
+function createRequestInfo()
+	return {
+		nextId = 0,
+		requests = {},
+	}
+end
+return {
+	createFunctionSender = createFunctionSender,
+}

package/out/function/errors.d.ts

@@ -0,0 +1,10 @@
+import { t as t } from "@rbxts/t";
+export declare const isNetworkingFunctionError: t.check<NetworkingFunctionError>;
+export declare enum NetworkingFunctionError {
+    Timeout = "Timeout",
+    Cancelled = "Cancelled",
+    BadRequest = "BadRequest",
+    Unprocessed = "Unprocessed",
+    InvalidResult = "InvalidResult"
+}
+export declare function getFunctionError(value: unknown): NetworkingFunctionError | undefined;

package/out/function/errors.luau

@@ -0,0 +1,25 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local t = TS.import(script, TS.getModule(script, "@rbxts", "t").lib.ts).t
+local Flamework = TS.import(script, TS.getModule(script, "@flamework-experimental", "core").out).Flamework
+local isNetworkingFunctionError = Flamework.createGuard(t.literalList({ "Timeout", "Cancelled", "BadRequest", "Unprocessed", "InvalidResult" }))
+local NetworkingFunctionError = {
+	Timeout = "Timeout",
+	Cancelled = "Cancelled",
+	BadRequest = "BadRequest",
+	Unprocessed = "Unprocessed",
+	InvalidResult = "InvalidResult",
+}
+local function getFunctionError(value)
+	local _value = value
+	if type(_value) == "boolean" then
+		return if value == false then NetworkingFunctionError.Unprocessed else nil
+	elseif isNetworkingFunctionError(value) then
+		return value
+	end
+end
+return {
+	getFunctionError = getFunctionError,
+	isNetworkingFunctionError = isNetworkingFunctionError,
+	NetworkingFunctionError = NetworkingFunctionError,
+}

package/out/functions/createClientMethod.d.ts

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

package/out/functions/createClientMethod.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 createClientMethod(config, receiver, sender)
+	local method = {
+		invoke = function(self, ...)
+			local args = { ... }
+			return self:invokeWithTimeout(config.defaultTimeout, unpack(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)) })
+		end,
+		_invoke = function(self, ...)
+			local packed = { ... }
+			return self:invokeWithTimeout(config.defaultTimeout, unpack(packed))
+		end,
+		_invokeWithTimeout = function(self, timeout, ...)
+			local packed = { ... }
+			return self:invokeWithTimeout(timeout, unpack(packed))
+		end,
+		setCallback = function(self, callback)
+			local _receiver = receiver
+			assert(_receiver, "This is not a receiver remote.")
+			receiver:setClientCallback(callback)
+		end,
+		_setCallback = function(self, callback)
+			local _receiver = receiver
+			assert(_receiver, "This is not a receiver remote.")
+			receiver:setClientCallback(callback, true)
+		end,
+		predict = function(self, ...)
+			local args = { ... }
+			local _receiver = receiver
+			assert(_receiver, "This is not a receiver remote.")
+			return receiver:invoke(nil, unpack(args))
+		end,
+	}
+	setmetatable(method, {
+		__call = function(method, ...)
+			local args = { ... }
+			return method:invoke(unpack(args))
+		end,
+	})
+	return method
+end
+return {
+	createClientMethod = createClientMethod,
+}

package/out/functions/createGenericHandler.d.ts

@@ -0,0 +1,7 @@
+import { FunctionNetworkingEvents } from "../handlers";
+import { ClientHandler, FunctionCreateConfiguration, NamespaceMetadata, ServerHandler } from "./types";
+import { SignalContainer } from "../util/createSignalContainer";
+import { FunctionReceiverInterface } from "../function/createFunctionReceiver";
+import { FunctionSenderInterface } from "../function/createFunctionSender";
+export type MethodCreator = (config: FunctionCreateConfiguration<unknown>, receiver?: FunctionReceiverInterface, sender?: FunctionSenderInterface) => unknown;
+export declare function createGenericHandler<T extends ClientHandler<S, R> | ServerHandler<S, R>, S, R>(globalName: string, namespaceName: string | undefined, receiverPrefix: string, senderPrefix: string, metadata: NamespaceMetadata<R, S>, config: FunctionCreateConfiguration<R>, signals: SignalContainer<FunctionNetworkingEvents>, createMethod: MethodCreator): T;