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

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;

package/out/middleware/createGuards.luau

@@ -0,0 +1,32 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Players = TS.import(script, TS.getModule(script, "@rbxts", "services")).Players
+--[[
+	*
+	 * 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`.
+	 
+]]
+local function createGuards(name, fixedParameters, restParameter, networkInfo, warnOnInvalid, signals)
+	return {
+		fixed = fixedParameters,
+		rest = restParameter,
+		reject = function(player, index, value)
+			if warnOnInvalid then
+				if player then
+					warn(`'{player}' sent invalid arguments for event '{name}' (arg #{index}):`, value)
+				else
+					warn(`Server sent invalid arguments for event '{name}' (arg #{index}):`, value)
+				end
+			end
+			signals:fire("onBadRequest", player or Players.LocalPlayer, {
+				networkInfo = networkInfo,
+				argIndex = index,
+				argValue = value,
+			})
+		end,
+	}
+end
+return {
+	createGuards = createGuards,
+}

package/out/middleware/processor.d.ts

@@ -0,0 +1,62 @@
+import { Serialization } from "@flamework-experimental/core";
+import { t } from "@rbxts/t";
+import { NetworkInfo } from "../types";
+import { MiddlewareFactory } from "./types";
+import { Signal } from "../util/signal";
+
+/** One step of the receive pipeline: `(player, ...args) -> result`. The player is `undefined` on a client. */
+export type Processor = (player: Player | undefined, ...args: unknown[]) => unknown;
+
+/** The generated argument checks, run ahead of all user middleware. */
+export interface Guards {
+	/** `fixed[i]` checks argument `i`. */
+	fixed: ReadonlyArray<t.check<unknown>>;
+
+	/** Checks every argument past the fixed ones, for a rest parameter. */
+	rest: t.check<unknown> | undefined;
+
+	/** Called with the first argument that failed, by its 0-based index. */
+	reject: (player: Player | undefined, index: number, value: unknown) => void;
+}
+
+/**
+ * Folds the guards and the middleware into one processor that runs them as plain calls in the
+ * calling thread and returns what the last link did, a Promise already followed (see `processor.luau`).
+ * @param rejected What the processor returns when a guard fails.
+ * @param cancelled What a Promise that was cancelled reads as.
+ */
+export function createProcessor(
+	middleware: ReadonlyArray<MiddlewareFactory<any, any>> | undefined,
+	networkInfo: NetworkInfo,
+	final: Processor,
+	guards: Guards | undefined,
+	rejected: unknown,
+	cancelled: unknown,
+): Processor;
+
+/**
+ * The handler for a remote's `OnServerEvent` (`withPlayer`) or `OnClientEvent`: decodes the payload
+ * when there is a decoder, reporting and dropping one it cannot read, and runs `process`.
+ */
+export function createReceiver(
+	decoder: Serialization.Decoder | undefined,
+	onMalformed: ((player: Player | undefined, message: string) => void) | undefined,
+	process: Processor,
+	withPlayer: boolean,
+): (...args: unknown[]) => void;
+
+/**
+ * Unpacks a serialized argument list, `(payload, blobs?)` as the remote carried it, under `pcall`:
+ * `true` and the list, or `false` and why it could not be read.
+ */
+export function decode(
+	decoder: Serialization.Decoder,
+	payload: unknown,
+	blobs: unknown,
+): LuaTuple<[ok: true, list: unknown[]] | [ok: false, message: string]>;
+
+/** The last step of an event's chain: fires `signal`, with the sender first when `withPlayer`. */
+export function deliverTo(signal: Signal, withPlayer: boolean): Processor;
+
+/** `callback` called without the player in front, which is how a client's callback is written. */
+export function withoutPlayer(callback: (...args: never[]) => unknown): Processor;

package/out/middleware/processor.luau

@@ -0,0 +1,214 @@
+--[[
+	The receive pipeline: what runs between a remote delivering a message (or `predict` standing in
+	for one) and the handler that receives it.
+
+	Plain calls in the thread that received the message: the payload is decoded, the generated guards
+	check the arguments, each middleware calls the next through `processNext`, and the last step
+	delivers (an event's signal, a function's callback). Nothing here makes a Promise or a thread. A
+	middleware may still yield, which holds up only the message it is processing, and one that
+	returns a Promise is waited for in place.
+
+	Plain Luau rather than TypeScript so that an argument list keeps its count: roblox-ts builds a
+	table from every `...args` and spreads it with `unpack`, which stops at `#list` and may lose the
+	values after a nil (see `util/trimArguments.ts`). Here the list travels as varargs, and is only cut
+	after its last value where it enters and where a middleware hands on a list of its own.
+]]
+
+local TS = _G[script]
+
+--- Stands in for a missing blob list when decoding: a sender whose type has blob slots always sends one.
+local NO_BLOBS = {}
+
+--[[
+	`callback(player, ...)`, with the argument list cut after its last value.
+
+	A list that ends in nil would reach a TypeScript `(...args)` as a table whose `#` can stop at any
+	earlier gap: `{1, nil, 3, nil}` may read as one value. One that ends in a value spreads whole. A
+	middleware that names its parameters, `(player, id, name) => processNext(player, id, name)`,
+	passes on a list ending in nil when `name` was not sent, which is why every link cuts it again.
+	Nothing is lost: an argument that was not passed reads as nil too.
+]]
+local function callTrimmed(callback: (...any) -> ...any, player: any, ...: any): any
+	local count = select("#", ...)
+	if count == 0 or select(count, ...) ~= nil then
+		return callback(player, ...)
+	end
+
+	repeat
+		count -= 1
+	until count == 0 or select(count, ...) ~= nil
+
+	return callback(player, table.unpack({ ... }, 1, count))
+end
+
+--[[
+	A link's result, with a Promise it returned followed in this thread: its value once resolved,
+	`cancelled` if it was cancelled, and its rejection raised.
+]]
+local function follow(value: any, cancelled: any): any
+	if type(value) ~= "table" then
+		return value
+	end
+
+	local Promise = TS.Promise
+	if not Promise.is(value) then
+		return value
+	end
+
+	local status, result = value:awaitStatus()
+	if status == Promise.Status.Resolved then
+		return result
+	elseif status == Promise.Status.Cancelled then
+		return cancelled
+	end
+
+	error(result, 0)
+end
+
+--[[
+	Folds the guards and the middleware into one function, `(player, ...args) -> result`, that runs
+	them in order in the calling thread and returns what the last one did.
+
+	`middleware` is a list of factories, the first the outermost; each is handed `processNext`, which
+	calls the next link and returns its result (a Promise the link returned already followed). A link
+	that does not call it drops the message there. `final` ends the chain.
+
+	`guards`, when given, check the arguments before any middleware runs: `fixed[i]` checks argument
+	`i`, `rest` every one past them. The first one that fails is reported through `reject` with its
+	0-based index, and the processor returns `rejected` without calling anything else.
+
+	`cancelled` is what a Promise that was cancelled reads as (`Networking.Skip` for a function).
+]]
+local function createProcessor(
+	middleware: { (processNext: any, networkInfo: any) -> any }?,
+	networkInfo: any,
+	final: (...any) -> ...any,
+	guards: any,
+	rejected: any,
+	cancelled: any
+)
+	local head = final
+	if middleware ~= nil then
+		for index = #middleware, 1, -1 do
+			local after = head
+			head = middleware[index](function(player, ...)
+				return follow(callTrimmed(after, player, ...), cancelled)
+			end, networkInfo)
+		end
+	end
+
+	if guards == nil then
+		return function(player, ...)
+			return follow(callTrimmed(head, player, ...), cancelled)
+		end
+	end
+
+	local fixed = guards.fixed
+	local rest = guards.rest
+	local reject = guards.reject
+	local fixedCount = #fixed
+
+	return function(player, ...)
+		-- Checked up to the last value: a trailing nil is an argument that was not passed.
+		local count = select("#", ...)
+		while count > 0 and select(count, ...) == nil do
+			count -= 1
+		end
+
+		for index = 1, math.max(fixedCount, count) do
+			local guard = fixed[index] or rest
+			if guard ~= nil then
+				local value = select(index, ...)
+				if not guard(value) then
+					reject(player, index - 1, value)
+					return rejected
+				end
+			end
+		end
+
+		return follow(callTrimmed(head, player, ...), cancelled)
+	end
+end
+
+--[[
+	Unpacks a serialized argument list, `(payload, blobs?)` as the remote carried it. Returns `true`
+	and the list, or `false` and why it could not be read. The decoder runs under `pcall`: a hostile
+	buffer raises instead of yielding garbage.
+]]
+local function decode(decoder: (buffer, { any }) -> { any }, payload: any, blobs: any): (boolean, any)
+	if type(payload) ~= "buffer" or (blobs ~= nil and type(blobs) ~= "table") then
+		return false, "payload is not a buffer with an optional blob list"
+	end
+
+	local ok, result = pcall(decoder, payload, blobs or NO_BLOBS)
+	if not ok then
+		return false, tostring(result)
+	end
+
+	return true, result
+end
+
+--[[
+	The handler to connect to a remote's `OnServerEvent` (`withPlayer`) or `OnClientEvent`: decodes
+	the payload when there is a `decoder`, reporting one it cannot read through `onMalformed` and
+	dropping it, and hands the arguments to `process`, in the thread the engine runs the handler on.
+]]
+local function createReceiver(
+	decoder: ((buffer, { any }) -> { any })?,
+	onMalformed: ((player: any, message: string) -> ())?,
+	process: (...any) -> ...any,
+	withPlayer: boolean
+)
+	local receive = process
+	if decoder ~= nil then
+		receive = function(player, payload, blobs)
+			local ok, result = decode(decoder, payload, blobs)
+			if not ok then
+				if onMalformed ~= nil then
+					onMalformed(player, result)
+				end
+				return
+			end
+
+			-- A decoded list has a slot per declared parameter, so an absent trailing optional leaves
+			-- it ending in nil: unpacked up to its last value.
+			return process(player, table.unpack(result, 1, table.maxn(result)))
+		end
+	end
+
+	if withPlayer then
+		return receive
+	end
+
+	return function(...)
+		return receive(nil, ...)
+	end
+end
+
+--- The last step of an event's chain: fires `signal`, with the sender first on the server.
+local function deliverTo(signal: any, withPlayer: boolean)
+	if withPlayer then
+		return function(player, ...)
+			signal:Fire(player, ...)
+		end
+	end
+
+	return function(_player, ...)
+		signal:Fire(...)
+	end
+end
+
+--- `callback` called without the player in front, which is how a client's callback is written.
+local function withoutPlayer(callback: (...any) -> ...any)
+	return function(_player, ...)
+		return callback(...)
+	end
+end
+
+return {
+	createProcessor = createProcessor,
+	createReceiver = createReceiver,
+	decode = decode,
+	deliverTo = deliverTo,
+	withoutPlayer = withoutPlayer,
+}

package/out/middleware/types.d.ts

@@ -1,15 +1,26 @@
-import { NetworkInfo } from "../types";
-import { Skip } from "./skip";
-
-export type MiddlewareProcessor<I extends readonly unknown[], O> = (player?: Player, ...args: I) => Promise<O>;
-export type Middleware<I extends readonly unknown[] = unknown[], O = void> = (
-	player?: Player,
-	...args: I
-) => O | Promise<O>;
-export type MiddlewareFactory<I extends readonly unknown[] = [], O = void> = (
-	processNext: MiddlewareProcessor<I, O>,
-	event: NetworkInfo,
-) => Middleware<I, O>;
-
-export type EventMiddleware<I extends readonly unknown[] = unknown[]> = MiddlewareFactory<I, void>;
-export type FunctionMiddleware<I extends readonly unknown[] = unknown[], O = void> = MiddlewareFactory<I, O | Skip>;
+import { NetworkInfo } from "../types";
+import { Skip } from "./skip";
+
+/**
+ * Calls the next link of the chain and returns its result: nothing for an event, the value (or
+ * `Networking.Skip`) for a function. A Promise the next link returned has already been waited for,
+ * in this thread.
+ */
+export type MiddlewareProcessor<I extends readonly unknown[], O> = (player?: Player, ...args: I) => O;
+
+/**
+ * One link of the chain. It may yield, which holds up only the message it is processing, and it may
+ * return a Promise, which is waited for before the link ahead of it continues.
+ */
+export type Middleware<I extends readonly unknown[] = unknown[], O = void> = (
+	player?: Player,
+	...args: I
+) => O | Promise<O>;
+
+export type MiddlewareFactory<I extends readonly unknown[] = [], O = void> = (
+	processNext: MiddlewareProcessor<I, O>,
+	event: NetworkInfo,
+) => Middleware<I, O>;
+
+export type EventMiddleware<I extends readonly unknown[] = unknown[]> = MiddlewareFactory<I, void>;
+export type FunctionMiddleware<I extends readonly unknown[] = unknown[], O = void> = MiddlewareFactory<I, O | Skip>;

package/out/util/createOnce.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a function that builds a value on its first call and returns that value from then on.
+ *
+ * `build` may yield: a client handler waits for the server's remotes to replicate. A thread that
+ * calls while a build is under way waits for it rather than starting a second one, which would wire
+ * a second handler to the same remotes. If the build throws, the thread that started it gets the
+ * error and the next waiting thread builds again.
+ *
+ * The build runs on a thread of its own, and the thread that started it waits like the others. A
+ * caller can be killed while it waits (`task.cancel`, a cancelled Promise, a test's timeout), and a
+ * killed thread never reaches a `finally`: a build killed with its caller would leave every thread
+ * queued behind it, and every later caller, waiting for good.
+ */
+export declare function createOnce<T extends defined>(): (build: () => T) => T;

package/out/util/createOnce.luau

@@ -0,0 +1,66 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * Returns a function that builds a value on its first call and returns that value from then on.
+	 *
+	 * `build` may yield: a client handler waits for the server's remotes to replicate. A thread that
+	 * calls while a build is under way waits for it rather than starting a second one, which would wire
+	 * a second handler to the same remotes. If the build throws, the thread that started it gets the
+	 * error and the next waiting thread builds again.
+	 *
+	 * The build runs on a thread of its own, and the thread that started it waits like the others. A
+	 * caller can be killed while it waits (`task.cancel`, a cancelled Promise, a test's timeout), and a
+	 * killed thread never reaches a `finally`: a build killed with its caller would leave every thread
+	 * queued behind it, and every later caller, waiting for good.
+	 
+]]
+local function createOnce()
+	local value
+	local waiting
+	return function(build)
+		while value == nil do
+			if waiting ~= nil then
+				local _waiting = waiting
+				local _arg0 = coroutine.running()
+				table.insert(_waiting, _arg0)
+				coroutine.yield()
+				continue
+			end
+			local threads = {}
+			waiting = threads
+			-- Set by the build's thread, so widened: the checks below must not narrow them to their start.
+			local finished = false
+			local failure = nil
+			task.spawn(function()
+				local ok, result = pcall(build)
+				if ok then
+					value = result
+				else
+					failure = {
+						reason = result,
+					}
+				end
+				finished = true
+				waiting = nil
+				for _, thread in threads do
+					-- A waiter killed meanwhile, the starter included, is not resumed.
+					if coroutine.status(thread) == "suspended" then
+						task.spawn(thread)
+					end
+				end
+			end)
+			if not finished then
+				local _arg0 = coroutine.running()
+				table.insert(threads, _arg0)
+				coroutine.yield()
+			end
+			if failure then
+				error(failure.reason, 0)
+			end
+		end
+		return value
+	end
+end
+return {
+	createOnce = createOnce,
+}

package/out/util/createSignalContainer.d.ts

@@ -1,5 +1,6 @@
+import { SignalConnection } from "./signal";
 export interface SignalContainer<T> {
     fire<K extends keyof T>(name: K, ...args: Parameters<T[K]>): void;
-    connect<K extends keyof T>(name: K, callback: T[K]): RBXScriptConnection;
+    connect<K extends keyof T>(name: K, callback: T[K]): SignalConnection;
 }
 export declare function createSignalContainer<T>(): SignalContainer<T>;

package/out/util/createSignalContainer.luau

@@ -1,6 +1,6 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
-local Signal = TS.import(script, TS.getModule(script, "@rbxts", "signal"))
+local createSignal = TS.import(script, script.Parent, "signal").createSignal
 local function createSignalContainer()
 	local signals = {}
 	return {
@@ -17,7 +17,7 @@ local function createSignalContainer()
 			local signal = signals[_name]
 			if not signal then
 				local _exp = name
-				signal = Signal.new()
+				signal = createSignal()
 				local _signal = signal
 				signals[_exp] = _signal
 			end

package/out/util/signal.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A handler's connection, public as `Networking.Connection`. Shaped like an `RBXScriptConnection`
+ * (`Connected`, `Disconnect`), plus `Destroy` for maids and janitors; it is a table, not an engine
+ * connection.
+ */
+export interface SignalConnection {
+	readonly Connected: boolean;
+	Disconnect(): void;
+	Destroy(): void;
+}
+
+/**
+ * Networking's own signal (see `signal.luau`): arguments are passed by reference, each handler runs
+ * on a recycled thread of its own, newest connection first.
+ */
+export interface Signal<T extends Callback = Callback> {
+	Connect(callback: T): SignalConnection;
+	Fire(...args: Parameters<T>): void;
+}
+
+export function createSignal<T extends Callback = Callback>(): Signal<T>;
+
+/**
+ * Runs `callback(...args)` at once on a recycled thread: a yield inside it does not hold up the
+ * caller, and an error is printed rather than raised to it.
+ */
+export function spawn<A extends unknown[]>(callback: (...args: A) => unknown, ...args: A): void;