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

package/README.md

@@ -1,15 +1,17 @@
 # Flamework
 
-Flamework is an extensible framework for roblox-ts designed around portable, isolated and testable modules.
+Flamework is an extensible framework for roblox-ts. It is built around modules that are portable,
+isolated and easy to test.
 
 ## Documentation
 
-**[docs/](docs/README.md)** -- start there. A ten-part guide that builds up from a working entry
-point to plugins and project layout, plus reference material:
+Start with **[docs/](docs/README.md)**. It holds a twelve-part guide, which starts from a working
+entry point and builds up to plugins, project layout, scopes and testing. It also holds reference
+material:
 
 | | |
 |---|---|
-| [Guide](docs/README.md#guide) | Getting started, modules, providers, lifecycle events, components, networking, macros, plugins, project structure, migrating from v1. |
+| [Guide](docs/README.md#guide) | Getting started, modules, providers, lifecycle events, components, networking, macros, plugins, project structure, migrating from v1, scopes, testing in the place. |
 | [Internals](docs/reference/internals.md) | What the transformer does to your code and what the runtime does with the result. |
 | [Transformer plugins](docs/reference/transformer-plugins.md) | Adding macro types of your own. |
 
@@ -27,6 +29,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
@@ -36,31 +39,36 @@ bun run lint
 | `packages/core` | Modules, dependency injection, plugins and lifecycle events |
 | `packages/components` | CollectionService components, built on the core plugin system |
 | `packages/networking` | Remote events and functions |
-| `packages/testing` | In-place tests: sections, cleanup, a bindable and a remote to run them, a cloud entry; and `flamework-test`, the CLI that runs them in Roblox Studio on this machine or through Open Cloud (`cli/`) |
+| `packages/testing` | Tests that run inside a place: sections, cleanup, a bindable and a remote that run them, and a cloud entry point. Also `flamework-test` (`cli/`), the CLI that runs them in Roblox Studio on this machine or through Open Cloud |
 | `packages/transformer` | The roblox-ts transformer |
 | `packages/transformer-plugin` | Public API for writing transformer plugins |
-| `packages/specs` | Runtime specs, compiled by `rbxtsc` and executed under Lune |
+| `packages/specs` | Runtime specs, built by `rbxtsc` and run under Lune |
 
 ### Tests
 
-Two suites, both run by `bun run test`:
-
-- **Transformer tests** (`bun run test:unit`) compile a fixture project with the real `rbxtsc` and
-  assert on the emitted Luau — guard generation, identifiers, nested macros and the plugin system.
-- **Runtime specs** (`bun run test:runtime`) execute compiled `@flamework-experimental/core`, `components` and
-  `networking` under Lune using the harness in [`tests/runtime`](tests/runtime), which models
-  roblox-ts's `TS.import` tree over the filesystem and stubs the Roblox API surface Flamework
-  touches (Instances, attributes, CollectionService, RemoteEvents, Players, signals, `task`,
-  `Enum`, and a `Heartbeat` pump so `Promise.delay` -- and therefore request timeouts -- runs).
-  They cover dependency injection, modules, hooks and the per-frame lifecycle events, component
-  construction, dependencies and streaming, and both halves of networking: events, functions,
-  middleware and the generated guards.
-
-  They run twice, once as `Server` and once as `Client`, because realm-dependent code paths --
-  `@Provider`'s metadata, component streaming, and the client/server halves of networking -- differ
-  between them. Where a spec asserts something realm-specific, running it from both sides is what
-  proves the two agree: a function receives on `$name` and sends on `@name` from the server and the
-  mirror image from the client, so the pair of runs pins the wire format down from both ends.
-
-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.
+`bun run test` runs two suites:
+
+- **Transformer tests** (`bun run test:unit`) build a fixture project with the real `rbxtsc` and
+  check the Luau it emits: guard generation, identifiers, nested macros and the plugin system.
+- **Runtime specs** (`bun run test:runtime`) run the built `@flamework-experimental/core`,
+  `components` and `networking` packages under Lune. The harness in [`tests/runtime`](tests/runtime)
+  models roblox-ts's `TS.import` tree over the filesystem. It also stubs the parts of the Roblox API
+  that Flamework uses: Instances, attributes, CollectionService, RemoteEvents, Players, signals,
+  `task`, `Enum`, and a `Heartbeat` pump so that `Promise.delay` runs (and with it, request
+  timeouts). The specs cover dependency injection, modules, hooks and the per-frame lifecycle
+  events; component construction, dependencies and streaming; and both halves of networking:
+  events, functions, middleware and the generated guards.
+
+  The specs run twice, once as `Server` and once as `Client`, because some code paths depend on the
+  realm: `@Provider`'s metadata, component streaming, and the client and server halves of
+  networking. Running a realm-specific spec from both sides proves that the two sides agree. For
+  example, from the server a function receives on `$name` and sends on `@name`, and from the client
+  it does the reverse, so the two runs pin down the wire format from both ends.
+
+Specs live in [`packages/specs`](packages/specs). `rbxtsc` builds them like any other project that
+uses Flamework, so they test the transformer and the runtime together.
+
+A third suite runs against the real engine, and `bun run test` leaves it out. It lives in the
+[test place](tests/place/README.md), a small game linked to the packages' builds.
+`bun run test:place` runs its `@flamework-experimental/testing` sections in Roblox Studio, on 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.4",
 	"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;