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

package/README.md

@@ -5,15 +5,20 @@ isolated and easy to test.
 
 ## Documentation
 
-Start with **[docs/](docs/README.md)**. It holds a twelve-part guide, which starts from a working
+Start with **[docs/](https://github.com/Velover/ExperimentalFlameworkV2/blob/HEAD/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, 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. |
+| [Guide](https://github.com/Velover/ExperimentalFlameworkV2/blob/HEAD/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](https://github.com/Velover/ExperimentalFlameworkV2/blob/HEAD/docs/reference/internals.md) | What the transformer does to your code and what the runtime does with the result. |
+| [Transformer plugins](https://github.com/Velover/ExperimentalFlameworkV2/blob/HEAD/docs/reference/transformer-plugins.md) | Adding macro types of your own. |
+
+The guide also ships inside the core package, for the version you installed:
+`node_modules/@flamework-experimental/core/docs/README.md` is its index, and the pages are in
+`node_modules/@flamework-experimental/core/docs/guide/`. Instructions for a coding assistant can
+point there, so that it reads the docs for your version.
 
 The Flamework website documents v1, most of which no longer applies:
 
@@ -51,7 +56,7 @@ bun run test:place     # the in-place suite in Roblox Studio (tests/place); need
 - **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)
+  `components` and `networking` packages under Lune. The harness in [`tests/runtime`](https://github.com/Velover/ExperimentalFlameworkV2/tree/HEAD/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
@@ -65,10 +70,10 @@ bun run test:place     # the in-place suite in Roblox Studio (tests/place); need
   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
+Specs live in [`packages/specs`](https://github.com/Velover/ExperimentalFlameworkV2/tree/HEAD/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.
+[test place](https://github.com/Velover/ExperimentalFlameworkV2/blob/HEAD/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)).
+realms, under four Rojo projects (see [Testing in Roblox Studio](https://github.com/Velover/ExperimentalFlameworkV2/blob/HEAD/docs/testing/studio.md)).

package/flamework.build

@@ -1,6 +1,6 @@
 {
 	"version": 1,
-	"flameworkVersion": "2.0.0-alpha.4",
+	"flameworkVersion": "2.0.0-alpha.5",
 	"identifiers": {},
 	"idGenerationMode": "full",
 	"identifierPrefix": "$n"

package/out/events/createGenericHandler.luau

@@ -50,7 +50,7 @@ local function createGenericHandler(globalName, namespaceName, metadata, config,
 		if not config.disableIncomingGuards and isIncoming then
 			local guards = metadata.incoming[name]
 			assert(guards)
-			incomingGuards = createGuards(name, guards[1], guards[2], networkInfo, config.warnOnInvalidGuards, signals)
+			incomingGuards = createGuards(name, guards[1], guards[2], guards[3], networkInfo, config.warnOnInvalidGuards, signals)
 		end
 		-- A malformed serialized payload is reported like a failed guard, with no argument index.
 		local onMalformed = function(player, message)

package/out/events/createServerMethod.d.ts

@@ -1,9 +1,11 @@
 import { EventInterface } from "../event/createEvent";
 export declare function createServerMethod(receiver: EventInterface, sender: EventInterface): {
     readonly _flamework_send?: unknown[] | undefined;
+    readonly _flamework_fn?: unknown;
     _fire: (players: Player | Player[], payload?: buffer, blobs?: Array<defined>) => void;
     _except: (players: Player | Player[], payload?: buffer, blobs?: Array<defined>) => void;
     _broadcast: (payload?: buffer, blobs?: Array<defined>) => void;
+    readonly _flamework_packing?: "plain" | undefined;
     fire: (players: Player | Player[], ...args: unknown[]) => void;
     except: (players: Player | Player[], ...args: unknown[]) => void;
     broadcast: (...args: unknown[]) => void;

package/out/events/types.d.ts

@@ -2,10 +2,11 @@ import {
 	FunctionParameters,
 	IntrinsicTupleGuards,
 	IntrinsicNetworkDecoder,
+	IntrinsicNetworkUnreliable,
 	IntrinsicObfuscate,
+	IsRawMember,
 	NetworkingObfuscationMarker,
-	NetworkRaw,
-	NetworkUnreliable,
+	NetworkPacking,
 	ObfuscateNames,
 } from "../types";
 import { EventNetworkingEvents } from "../handlers";
@@ -17,9 +18,12 @@ 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[]> {
+export interface RawServerSender<I extends unknown[], M = "raw"> {
 	(player: Player | Player[], ...args: I): void;
 
+	/** @hidden How the member is packed (see `NetworkPacking`), which keeps differently packed members apart in a union. */
+	readonly _flamework_packing?: M;
+
 	/**
 	 * Sends this request to the specified player(s).
 	 * @param players The player(s) that will receive this event
@@ -38,10 +42,13 @@ export interface RawServerSender<I extends unknown[]> {
 	broadcast(...args: I): void;
 }
 
-export interface ServerSender<I extends unknown[]> extends RawServerSender<I> {
+export interface ServerSender<I extends unknown[], F = unknown, M = NetworkPacking<F>> extends RawServerSender<I, M> {
 	/** @hidden Marks a sender for the transformer, which packs its arguments at each call site. */
 	readonly _flamework_send?: I;
 
+	/** @hidden The declared member, whose markers (`Serialized`) say whether its call sites pack. */
+	readonly _flamework_fn?: F;
+
 	/** @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;
 
@@ -70,19 +77,25 @@ export interface ServerReceiver<I extends unknown[]> extends RawServerReceiver<I
 	readonly _flamework_receive?: I;
 }
 
-export interface RawClientSender<I extends unknown[]> {
+export interface RawClientSender<I extends unknown[], M = "raw"> {
 	(...args: I): void;
 
+	/** @hidden How the member is packed (see `NetworkPacking`), which keeps differently packed members apart in a union. */
+	readonly _flamework_packing?: M;
+
 	/**
 	 * Sends this request to the server.
 	 */
 	fire(...args: I): void;
 }
 
-export interface ClientSender<I extends unknown[]> extends RawClientSender<I> {
+export interface ClientSender<I extends unknown[], F = unknown, M = NetworkPacking<F>> extends RawClientSender<I, M> {
 	/** @hidden Marks a sender for the transformer, which packs its arguments at each call site. */
 	readonly _flamework_send?: I;
 
+	/** @hidden The declared member, whose markers (`Serialized`) say whether its call sites pack. */
+	readonly _flamework_fn?: F;
+
 	/** @hidden Sends an argument list the transformer already packed; nothing when the list carries nothing. */
 	_fire(payload?: buffer, blobs?: Array<defined>): void;
 }
@@ -106,11 +119,11 @@ export interface ClientReceiver<I extends unknown[]> extends RawClientReceiver<I
 }
 
 export type ServerHandler<E, R> = NetworkingObfuscationMarker & {
-	[k in keyof Events<E>]: E[k] extends NetworkRaw<unknown>
+	[k in keyof Events<E>]: IsRawMember<E[k]> extends true
 		? RawServerSender<FunctionParameters<E[k]>>
-		: ServerSender<FunctionParameters<E[k]>>;
+		: ServerSender<FunctionParameters<E[k]>, E[k]>;
 } & {
-	[k in keyof Events<R>]: R[k] extends NetworkRaw<unknown>
+	[k in keyof Events<R>]: IsRawMember<R[k]> extends true
 		? RawServerReceiver<FunctionParameters<R[k]>>
 		: ServerReceiver<FunctionParameters<R[k]>>;
 } & {
@@ -120,11 +133,11 @@ export type ServerHandler<E, R> = NetworkingObfuscationMarker & {
 };
 
 export type ClientHandler<E, R> = NetworkingObfuscationMarker & {
-	[k in keyof Events<E>]: E[k] extends NetworkRaw<unknown>
+	[k in keyof Events<E>]: IsRawMember<E[k]> extends true
 		? RawClientSender<FunctionParameters<E[k]>>
-		: ClientSender<FunctionParameters<E[k]>>;
+		: ClientSender<FunctionParameters<E[k]>, E[k]>;
 } & {
-	[k in keyof Events<R>]: R[k] extends NetworkRaw<unknown>
+	[k in keyof Events<R>]: IsRawMember<R[k]> extends true
 		? RawClientReceiver<FunctionParameters<R[k]>>
 		: ClientReceiver<FunctionParameters<R[k]>>;
 } & {
@@ -185,23 +198,22 @@ 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;
+		[k in keyof Events<R>]: IntrinsicNetworkUnreliable<R[k], k>;
 	}>;
 
 	outgoingIds: ObfuscateNames<keyof Events<S>>;
 	outgoingUnreliable: IntrinsicObfuscate<{
-		[k in keyof Events<S>]: S[k] extends NetworkUnreliable<unknown> ? true : undefined;
+		[k in keyof Events<S>]: IntrinsicNetworkUnreliable<S[k], k>;
 	}>;
 
 	/**
-	 * 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.
+	 * Decoders for each incoming event's argument list, present for the events that are packed (all of
+	 * them with `networking.serialization` on, else the serialized ones) 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]>>;
+		[k in keyof Events<R>]: IntrinsicNetworkDecoder<Parameters<Events<R>[k]>, R[k], k>;
 	}>;
 
 	namespaceIds: ObfuscateNames<keyof EventNamespaces<R> | keyof EventNamespaces<S>>;

package/out/functions/createClientMethod.d.ts

@@ -3,12 +3,13 @@ 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;
+    readonly _flamework_fn?: unknown;
     _invoke: (payload?: buffer, blobs?: Array<defined>) => Promise<unknown>;
     _invokeWithTimeout: (timeout: number, payload?: buffer, blobs?: Array<defined>) => Promise<unknown>;
+    readonly _flamework_packing?: "plain" | undefined;
     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, pack: (value: unknown) => unknown) => void;
     setCallback: (callback: (...args: unknown[]) => unknown | Promise<unknown>) => void;
     predict: (...args: unknown[]) => Promise<unknown>;

package/out/functions/createGenericHandler.luau

@@ -47,7 +47,7 @@ local function createGenericHandler(globalName, namespaceName, receiverPrefix, s
 		if not config.disableIncomingGuards and isReceiver then
 			local guards = metadata.incoming[name]
 			assert(guards)
-			incomingGuards = createGuards(name, guards[1], guards[2], networkInfo, config.warnOnInvalidGuards, signals)
+			incomingGuards = createGuards(name, guards[1], guards[2], guards[3], networkInfo, config.warnOnInvalidGuards, signals)
 		end
 		-- A malformed serialized payload is reported like a failed guard, with no argument index.
 		local onMalformed = function(player, message)

package/out/functions/createServerMethod.d.ts

@@ -3,12 +3,13 @@ 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;
+    readonly _flamework_fn?: unknown;
     _invoke: (player: Player, payload?: buffer, blobs?: Array<defined>) => Promise<unknown>;
     _invokeWithTimeout: (player: Player, timeout: number, payload?: buffer, blobs?: Array<defined>) => Promise<unknown>;
+    readonly _flamework_packing?: "plain" | undefined;
     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, pack: (value: unknown) => unknown) => void;
     setCallback: (callback: (player: Player, ...args: unknown[]) => unknown | Promise<unknown>) => void;
     predict: (player: Player, ...args: unknown[]) => Promise<unknown>;

package/out/functions/types.d.ts

@@ -6,8 +6,9 @@ import {
 	IntrinsicNetworkDecoder,
 	IntrinsicNetworkResultDecoder,
 	IntrinsicObfuscate,
+	IsRawMember,
 	NetworkingObfuscationMarker,
-	NetworkRaw,
+	NetworkPacking,
 	ObfuscateNames,
 } from "../types";
 import { FunctionNetworkingEvents } from "../handlers";
@@ -19,9 +20,12 @@ 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> {
+export interface RawServerSender<I extends unknown[], O, M = "raw"> {
 	(player: Player, ...args: I): Promise<O>;
 
+	/** @hidden How the member is packed (see `NetworkPacking`), which keeps differently packed members apart in a union. */
+	readonly _flamework_packing?: M;
+
 	/**
 	 * Sends this request to the specified player.
 	 * @param player The player that will receive this event
@@ -36,10 +40,17 @@ export interface RawServerSender<I extends unknown[], O> {
 	invokeWithTimeout(player: Player, timeout: number, ...args: I): Promise<O>;
 }
 
-export interface ServerSender<I extends unknown[], O> extends RawServerSender<I, O> {
+export interface ServerSender<I extends unknown[], O, F = unknown, M = NetworkPacking<F>> extends RawServerSender<
+	I,
+	O,
+	M
+> {
 	/** @hidden Marks a sender for the transformer, which packs its arguments at each call site. */
 	readonly _flamework_send?: I;
 
+	/** @hidden The declared function type, whose markers (`Serialized`) say whether its call sites pack. */
+	readonly _flamework_fn?: F;
+
 	/** @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>;
 
@@ -47,7 +58,10 @@ export interface ServerSender<I extends unknown[], O> extends RawServerSender<I,
 	_invokeWithTimeout(player: Player, timeout: number, payload?: buffer, blobs?: Array<defined>): Promise<O>;
 }
 
-export interface RawServerReceiver<I extends unknown[], O> {
+export interface RawServerReceiver<I extends unknown[], O, M = "raw"> {
+	/** @hidden How the member is packed (see `NetworkPacking`), which keeps differently packed members apart in a union. */
+	readonly _flamework_packing?: M;
+
 	/**
 	 * Connect to a networking event.
 	 * @param event The event to connect to
@@ -62,20 +76,27 @@ export interface RawServerReceiver<I extends unknown[], O> {
 	predict(player: Player, ...args: I): Promise<O>;
 }
 
-export interface ServerReceiver<I extends unknown[], O, F = unknown> extends RawServerReceiver<I, O> {
+export interface ServerReceiver<I extends unknown[], O, F = unknown, M = NetworkPacking<F>> extends RawServerReceiver<
+	I,
+	O,
+	M
+> {
 	/** @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. */
+	/** @hidden The declared function type: its return type is what the transformer packs, its markers say how. */
 	readonly _flamework_fn?: F;
 
 	/** @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> {
+export interface RawClientSender<I extends unknown[], O, M = "raw"> {
 	(...args: I): Promise<O>;
 
+	/** @hidden How the member is packed (see `NetworkPacking`), which keeps differently packed members apart in a union. */
+	readonly _flamework_packing?: M;
+
 	/**
 	 * Sends this request to the server.
 	 */
@@ -88,10 +109,17 @@ export interface RawClientSender<I extends unknown[], O> {
 	invokeWithTimeout(timeout: number, ...args: I): Promise<O>;
 }
 
-export interface ClientSender<I extends unknown[], O> extends RawClientSender<I, O> {
+export interface ClientSender<I extends unknown[], O, F = unknown, M = NetworkPacking<F>> extends RawClientSender<
+	I,
+	O,
+	M
+> {
 	/** @hidden Marks a sender for the transformer, which packs its arguments at each call site. */
 	readonly _flamework_send?: I;
 
+	/** @hidden The declared function type, whose markers (`Serialized`) say whether its call sites pack. */
+	readonly _flamework_fn?: F;
+
 	/** @hidden Sends an argument list the transformer already packed; nothing when the list carries nothing. */
 	_invoke(payload?: buffer, blobs?: Array<defined>): Promise<O>;
 
@@ -99,7 +127,10 @@ export interface ClientSender<I extends unknown[], O> extends RawClientSender<I,
 	_invokeWithTimeout(timeout: number, payload?: buffer, blobs?: Array<defined>): Promise<O>;
 }
 
-export interface RawClientReceiver<I extends unknown[], O> {
+export interface RawClientReceiver<I extends unknown[], O, M = "raw"> {
+	/** @hidden How the member is packed (see `NetworkPacking`), which keeps differently packed members apart in a union. */
+	readonly _flamework_packing?: M;
+
 	/**
 	 * Connect to a networking function.
 	 * @param event The function to connect to
@@ -113,11 +144,15 @@ export interface RawClientReceiver<I extends unknown[], O> {
 	predict(...args: I): Promise<O>;
 }
 
-export interface ClientReceiver<I extends unknown[], O, F = unknown> extends RawClientReceiver<I, O> {
+export interface ClientReceiver<I extends unknown[], O, F = unknown, M = NetworkPacking<F>> extends RawClientReceiver<
+	I,
+	O,
+	M
+> {
 	/** @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. */
+	/** @hidden The declared function type: its return type is what the transformer packs, its markers say how. */
 	readonly _flamework_fn?: F;
 
 	/** @hidden Registers a callback with `pack`, which turns a successful result into `[payload, blobs?]`. */
@@ -125,11 +160,11 @@ export interface ClientReceiver<I extends unknown[], O, F = unknown> extends Raw
 }
 
 export type ServerHandler<E, R> = NetworkingObfuscationMarker & {
-	[k in keyof Functions<E>]: E[k] extends NetworkRaw<unknown>
+	[k in keyof Functions<E>]: IsRawMember<E[k]> extends true
 		? RawServerSender<FunctionParameters<E[k]>, FunctionReturn<E[k]>>
-		: ServerSender<FunctionParameters<E[k]>, FunctionReturn<E[k]>>;
+		: ServerSender<FunctionParameters<E[k]>, FunctionReturn<E[k]>, E[k]>;
 } & {
-	[k in keyof Functions<R>]: R[k] extends NetworkRaw<unknown>
+	[k in keyof Functions<R>]: IsRawMember<R[k]> extends true
 		? RawServerReceiver<FunctionParameters<R[k]>, FunctionReturn<R[k]>>
 		: ServerReceiver<FunctionParameters<R[k]>, FunctionReturn<R[k]>, R[k]>;
 } & {
@@ -139,11 +174,11 @@ export type ServerHandler<E, R> = NetworkingObfuscationMarker & {
 };
 
 export type ClientHandler<E, R> = NetworkingObfuscationMarker & {
-	[k in keyof Functions<E>]: E[k] extends NetworkRaw<unknown>
+	[k in keyof Functions<E>]: IsRawMember<E[k]> extends true
 		? RawClientSender<FunctionParameters<E[k]>, FunctionReturn<E[k]>>
-		: ClientSender<FunctionParameters<E[k]>, FunctionReturn<E[k]>>;
+		: ClientSender<FunctionParameters<E[k]>, FunctionReturn<E[k]>, E[k]>;
 } & {
-	[k in keyof Functions<R>]: R[k] extends NetworkRaw<unknown>
+	[k in keyof Functions<R>]: IsRawMember<R[k]> extends true
 		? RawClientReceiver<FunctionParameters<R[k]>, FunctionReturn<R[k]>>
 		: ClientReceiver<FunctionParameters<R[k]>, FunctionReturn<R[k]>, R[k]>;
 } & {
@@ -255,17 +290,16 @@ export type NamespaceMetadata<R, S> = Modding.Emit<{
 	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 and the responses to requests it sends. Requests
-	 * and results are packed inline where they are produced.
+	 * Decoders for the functions that are packed (all of them with `networking.serialization` on, else
+	 * the serialized ones), absent for raw functions: the 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]>>;
+		[k in keyof Functions<R>]: IntrinsicNetworkDecoder<Parameters<R[k]>, R[k], k>;
 	}>;
 	outgoingResults: IntrinsicObfuscate<{
-		[k in keyof Functions<S>]: S[k] extends NetworkRaw<unknown> ? undefined : IntrinsicNetworkResultDecoder<S[k]>;
+		[k in keyof Functions<S>]: IntrinsicNetworkResultDecoder<S[k], k>;
 	}>;
 
 	namespaceIds: ObfuscateNames<keyof FunctionNamespaces<R> | keyof FunctionNamespaces<S>>;

package/out/index.d.ts

@@ -4,7 +4,7 @@ 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 { NetworkInfo as _NetworkInfo, NetworkRaw, NetworkSerialized, NetworkUnreliable } from "./types";
 import type { Modding } from "@flamework-experimental/core";
 export declare namespace Networking {
     /**
@@ -44,6 +44,27 @@ export declare namespace Networking {
      * A function whose requests and results bypass serialization; see {@link RawReliable}.
      */
     type Raw<T> = NetworkRaw<T>;
+    /**
+     * Packs this event's arguments into a buffer even when `networking.serialization` is off, exactly
+     * as the switch would. With the switch on, it changes nothing.
+     *
+     * `Unreliable<Serialized<T>>` and `Serialized<Unreliable<T>>` are the same as `SerializedUnreliable<T>`.
+     * It cannot be combined with `Raw`.
+     */
+    type SerializedReliable<T> = NetworkSerialized<T>;
+    /**
+     * An unreliable event whose arguments are packed into a buffer; see {@link SerializedReliable}.
+     */
+    type SerializedUnreliable<T> = NetworkUnreliable<NetworkSerialized<T>>;
+    /**
+     * A function whose requests and results are packed into a buffer; see {@link SerializedReliable}.
+     */
+    type Serialized<T> = NetworkSerialized<T>;
+    /**
+     * What a middleware factory receives as its second argument: the event or function's `name`,
+     * `globalName` and `eventType`.
+     */
+    type NetworkInfo = _NetworkInfo;
     /**
      * A function that generates an event middleware.
      */

package/out/init.luau

@@ -60,6 +60,31 @@ do
 		*
 		     * A function whose requests and results bypass serialization; see {@link RawReliable}.
 		     
+	]]
+	--[[
+		*
+		     * Packs this event's arguments into a buffer even when `networking.serialization` is off, exactly
+		     * as the switch would. With the switch on, it changes nothing.
+		     *
+		     * `Unreliable<Serialized<T>>` and `Serialized<Unreliable<T>>` are the same as `SerializedUnreliable<T>`.
+		     * It cannot be combined with `Raw`.
+		     
+	]]
+	--[[
+		*
+		     * An unreliable event whose arguments are packed into a buffer; see {@link SerializedReliable}.
+		     
+	]]
+	--[[
+		*
+		     * A function whose requests and results are packed into a buffer; see {@link SerializedReliable}.
+		     
+	]]
+	--[[
+		*
+		     * What a middleware factory receives as its second argument: the event or function's `name`,
+		     * `globalName` and `eventType`.
+		     
 	]]
 	--[[
 		*

package/out/middleware/createGuards.d.ts

@@ -7,4 +7,4 @@ 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;
+export declare function createGuards(name: string, fixedParameters: t.check<unknown>[], restParameter: t.check<unknown> | undefined, parametersAfterRest: t.check<unknown>[] | undefined, networkInfo: NetworkInfo, warnOnInvalid: boolean, signals: SignalContainer<EventNetworkingEvents>): Guards;

package/out/middleware/createGuards.luau

@@ -7,10 +7,11 @@ local Players = TS.import(script, TS.getModule(script, "@rbxts", "services")).Pl
 	 * ahead of all user middleware. A failure warns (with `warnOnInvalid`) and fires `onBadRequest`.
 	 
 ]]
-local function createGuards(name, fixedParameters, restParameter, networkInfo, warnOnInvalid, signals)
+local function createGuards(name, fixedParameters, restParameter, parametersAfterRest, networkInfo, warnOnInvalid, signals)
 	return {
 		fixed = fixedParameters,
 		rest = restParameter,
+		after = parametersAfterRest,
 		reject = function(player, index, value)
 			if warnOnInvalid then
 				if player then

package/out/middleware/processor.d.ts

@@ -15,6 +15,9 @@ export interface Guards {
 	/** Checks every argument past the fixed ones, for a rest parameter. */
 	rest: t.check<unknown> | undefined;
 
+	/** With a rest parameter, `after[i]` checks the argument `i` places after the rest (`(...args: [...B[], C])`). */
+	after?: ReadonlyArray<t.check<unknown>>;
+
 	/** Called with the first argument that failed, by its 0-based index. */
 	reject: (player: Player | undefined, index: number, value: unknown) => void;
 }

package/out/middleware/processor.luau

@@ -74,8 +74,9 @@ end
 	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.
+	`i`, `rest` every one past them, and `after` (for a rest parameter with parameters after it) the
+	last ones. 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).
 ]]
@@ -105,9 +106,43 @@ local function createProcessor(
 
 	local fixed = guards.fixed
 	local rest = guards.rest
+	local after = guards.after
 	local reject = guards.reject
 	local fixedCount = #fixed
 
+	if after ~= nil and #after > 0 then
+		local afterCount = #after
+
+		-- `(...args: [A, ...B[], C])`: A first, C last, and every argument between them a B.
+		return function(player, ...)
+			local count = select("#", ...)
+			while count > 0 and select(count, ...) == nil do
+				count -= 1
+			end
+
+			local total = math.max(fixedCount + afterCount, count)
+			local restEnd = total - afterCount
+			for index = 1, total do
+				local guard
+				if index <= fixedCount then
+					guard = fixed[index]
+				elseif index > restEnd then
+					guard = after[index - restEnd]
+				else
+					guard = rest
+				end
+
+				local value = select(index, ...)
+				if guard ~= nil and not guard(value) then
+					reject(player, index - 1, value)
+					return rejected
+				end
+			end
+
+			return follow(callTrimmed(head, player, ...), cancelled)
+		end
+	end
+
 	return function(player, ...)
 		-- Checked up to the last value: a trailing nil is an argument that was not passed.
 		local count = select("#", ...)

package/out/types.d.ts

@@ -26,6 +26,31 @@ export type NetworkUnreliable<T> = T & { _flamework_unreliable: never };
  */
 export type NetworkRaw<T> = T & { _flamework_raw: never };
 
+/**
+ * Marks an event or function whose values are packed into a buffer whether or not the project turns
+ * `networking.serialization` on: the call sites encode and the metadata decodes, exactly as the switch
+ * would have them do.
+ */
+export type NetworkSerialized<T> = T & { _flamework_serialized: never };
+
+/**
+ * A member declared raw and nothing else. One that is also serialized gets the marked handler
+ * instead, so that the transformer sees it where it is used and reports the conflict.
+ */
+export type IsRawMember<T> =
+	T extends NetworkRaw<unknown> ? (T extends NetworkSerialized<unknown> ? false : true) : false;
+
+/**
+ * How the member `F` is packed. Each sender and function receiver takes it as a type argument of its
+ * own and carries it as the hidden `_flamework_packing`, so members that are packed differently have
+ * unrelated handler types. (Worked out from `F` inside the interface, it would be compared through
+ * `F`, which a `Serialized` member's type extends.) A union of them, from a conditional or a helper
+ * that returns one of several members, then keeps every one of them rather than reducing to the one
+ * the others extend, and the transformer refuses a call that cannot pack for all of them.
+ */
+export type NetworkPacking<F> =
+	IsRawMember<F> extends true ? "raw" : F extends NetworkSerialized<unknown> ? "serialized" : "plain";
+
 export interface NetworkingObfuscationMarker {
 	/**
 	 * An internal marker type used to signify to Flamework to obfuscate access expressions.
@@ -53,26 +78,42 @@ export type IntrinsicObfuscateArray<T, V = T> = Modding.Intrinsic<"shuffle-array
 export type IntrinsicTupleGuards<T> = Modding.Intrinsic<"tuple-guards", [T], GuardType>;
 
 /**
- * Decode code for the argument list `T`, generated only when the project's flamework.config.json
- * enables `networking.serialization`; `undefined` otherwise, which passes values through as they
- * are. The matching encoding is generated inline at every call site, so no encoder exists at runtime.
+ * Decode code for the argument list `T` of the member `F`, generated when the member is packed: with
+ * the project's `networking.serialization` on (unless `F` is raw), or when `F` is serialized.
+ * `undefined` otherwise, which passes values through as they are. `K` is the member's name, for the
+ * transformer's messages. The matching encoding is generated inline at every call site, so no encoder
+ * exists at runtime.
  * @hidden Intrinsic feature not intended for users
  */
-export type IntrinsicNetworkDecoder<T extends Array<unknown>> = Modding.Intrinsic<
+export type IntrinsicNetworkDecoder<T extends Array<unknown>, F = unknown, K = unknown> = Modding.Intrinsic<
 	"network-decoder",
-	[T],
+	[T, F, K],
 	Serialization.Decoder<T> | undefined
 >;
 
 /**
  * Decode code for the result of the function type `F`, carried as a one-element list. Takes the
- * function type rather than its return type so that the return type as declared is known.
+ * function type rather than its return type so that the return type as declared is known, and so
+ * that its markers are; see {@link IntrinsicNetworkDecoder} for `K`.
  * @hidden Intrinsic feature not intended for users
  */
-export type IntrinsicNetworkResultDecoder<F> = Modding.Intrinsic<
+export type IntrinsicNetworkResultDecoder<F, K = unknown> = Modding.Intrinsic<
 	"network-result-decoder",
-	[F],
+	[F, K],
 	Serialization.Decoder | undefined
 >;
 
-type GuardType = [t.check<unknown>[], t.check<unknown> | undefined];
+/**
+ * `true` for a member declared unreliable, `undefined` otherwise. An intrinsic rather than a
+ * conditional type so that every member of an event network, in both directions, passes through the
+ * transformer's check of its markers wherever a handler is created.
+ * @hidden Intrinsic feature not intended for users
+ */
+export type IntrinsicNetworkUnreliable<F, K = unknown> = Modding.Intrinsic<
+	"network-unreliable",
+	[F, K],
+	true | undefined
+>;
+
+/** The guards of the arguments before a rest parameter, of the rest, and of any after it (`[A, ...B[], C]`). */
+type GuardType = [t.check<unknown>[], t.check<unknown> | undefined, t.check<unknown>[]?];

package/package.json

@@ -1,8 +1,17 @@
 {
   "name": "@flamework-experimental/networking",
-  "version": "2.0.0-alpha.3",
+  "version": "2.0.0-alpha.4",
   "main": "out/init.luau",
   "types": "out/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Velover/ExperimentalFlameworkV2.git",
+    "directory": "packages/networking"
+  },
+  "homepage": "https://github.com/Velover/ExperimentalFlameworkV2#readme",
+  "bugs": {
+    "url": "https://github.com/Velover/ExperimentalFlameworkV2/issues"
+  },
   "scripts": {
     "build": "rbxtsc",
     "watch": "rbxtsc -w"