@quenty/remoting 12.5.0 → 12.6.0

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [12.6.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/remoting@12.5.0...@quenty/remoting@12.6.0) (2024-09-12)
+
+
+### Features
+
+* Add new remoting .Server and .Client methods ([89862e8](https://github.com/Quenty/NevermoreEngine/commit/89862e852456ada3a1b1eefde682229c4ca033fa))
+* Declarative remoting realms allows for safer calls ([7264fd1](https://github.com/Quenty/NevermoreEngine/commit/7264fd1eb7b9d812a7383ec62db63ed90e78472a))
+
+
+
+
+
 # [12.5.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/remoting@12.4.0...@quenty/remoting@12.5.0) (2024-08-09)
 
 **Note:** Version bump only for package @quenty/remoting

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/remoting",
-  "version": "12.5.0",
+  "version": "12.6.0",
   "description": "Global remoting retrieval system for Roblox (RemoteFunctions/RemoteEvents)",
   "keywords": [
     "Roblox",
@@ -26,17 +26,18 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/brio": "^14.4.0",
-    "@quenty/instanceutils": "^13.4.0",
-    "@quenty/loader": "^10.3.0",
-    "@quenty/maid": "^3.2.0",
-    "@quenty/promise": "^10.3.0",
-    "@quenty/remotefunctionutils": "^10.3.0",
-    "@quenty/rx": "^13.4.0",
+    "@quenty/brio": "^14.5.0",
+    "@quenty/instanceutils": "^13.5.0",
+    "@quenty/loader": "^10.4.0",
+    "@quenty/maid": "^3.3.0",
+    "@quenty/promise": "^10.4.0",
+    "@quenty/promisemaid": "^5.4.0",
+    "@quenty/remotefunctionutils": "^10.4.0",
+    "@quenty/rx": "^13.5.0",
     "@quenty/table": "^3.5.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ba466bdbc05c42fb607cf5e228c16339201d21d7"
+  "gitHead": "fb172906f3ee725269ec1e5f4daf9dca227e729d"
 }

package/src/Shared/Interface/Remoting.lua

@@ -7,8 +7,8 @@
 
 local require = require(script.Parent.loader).load(script)
 
-local RunService = game:GetService("RunService")
 local Players = game:GetService("Players")
+local RunService = game:GetService("RunService")
 
 local Maid = require("Maid")
 local Promise = require("Promise")
@@ -16,6 +16,8 @@ local promiseChild = require("promiseChild")
 local PromiseUtils = require("PromiseUtils")
 local RemoteFunctionUtils = require("RemoteFunctionUtils")
 local RemotingMember = require("RemotingMember")
+local RemotingRealms = require("RemotingRealms")
+local RemotingRealmUtils = require("RemotingRealmUtils")
 local RxBrioUtils = require("RxBrioUtils")
 local RxInstanceUtils = require("RxInstanceUtils")
 
@@ -24,7 +26,8 @@ local RAW_MEMBERS = {
 	_maid = true;
 	_instance = true;
 	_remoteObjects = true;
-	_remoteFolder = true;
+	_container = true;
+	_defaultRemotingRealm = true;
 }
 
 local REMOTE_EVENT_SUFFIX = "Event"
@@ -34,16 +37,32 @@ local Remoting = {}
 Remoting.ClassName = "Remoting"
 Remoting.__index = Remoting
 
+Remoting.Realms = RemotingRealms
+
+Remoting.Server = {
+	new = function(instance, name)
+		return Remoting.new(instance, name, RemotingRealms.SERVER)
+	end;
+}
+
+Remoting.Client = {
+	new = function(instance, name)
+		return Remoting.new(instance, name, RemotingRealms.CLIENT)
+	end;
+}
+
 --[=[
 	Creates a new remoting instance
 
 	@param instance Instance
 	@param name string
+	@param remotingRealm RemotingRealm?
 	@return Remoting
 ]=]
-function Remoting.new(instance, name)
+function Remoting.new(instance, name, remotingRealm)
 	assert(typeof(instance) == "Instance", "Bad instance")
 	assert(type(name) == "string", "Bad name")
+	assert(RemotingRealmUtils.isRemotingRealm(remotingRealm) or remotingRealm == nil, "Bad remotingRealm")
 
 	local self = setmetatable({}, Remoting)
 
@@ -51,6 +70,8 @@ function Remoting.new(instance, name)
 
 	self._instance = assert(instance, "No instance")
 	self._name = assert(name, "No name")
+	self._remotingRealm = remotingRealm or RemotingRealmUtils.inferRemotingRealm()
+	self._useDummyObject = not RunService:IsRunning()
 
 	self._remoteFolderName = string.format("%sRemotes", self._name)
 	self._remoteObjects = {}
@@ -64,7 +85,7 @@ function Remoting:__index(index)
 	elseif RAW_MEMBERS[index] then
 		return rawget(self, index)
 	else
-		return RemotingMember.new(self, index)
+		return RemotingMember.new(self, index, self._remotingRealm)
 	end
 end
 
@@ -81,28 +102,47 @@ function Remoting:Connect(memberName, callback)
 
 	local connectMaid = Maid.new()
 
-	if RunService:IsServer() then
-		local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
-		connectMaid:GiveTask(remoteEvent.OnServerEvent:Connect(callback))
+	if self._remotingRealm == RemotingRealms.SERVER then
+		if self._useDummyObject then
+			self:DeclareEvent(memberName)
+
+			self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnClientEvent"))
+			local bindableEvent = self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnServerEvent"))
+			connectMaid:GiveTask(bindableEvent.Event:Connect(callback))
+		else
+			local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
+			connectMaid:GiveTask(remoteEvent.OnServerEvent:Connect(callback))
+		end
 
 		-- TODO: Cleanup if nothing else is expecting this
-	elseif RunService:IsClient() then
+	elseif self._remotingRealm == RemotingRealms.CLIENT then
 		connectMaid._warning = task.delay(5, function()
 			warn(string.format("[Remoting] - Failed to find RemoteEvent %q, event may never connect", self:_getDebugMemberName(memberName)))
 		end)
 
-		connectMaid:GiveTask(self:_observeRemoteEventBrio(memberName):Subscribe(function(brio)
-			if brio:IsDead() then
-				return
-			end
+		if self._useDummyObject then
+			connectMaid:GiveTask(self:_observeRemoteEventBrio(self:_getDummyMemberName(memberName, "OnClientEvent")):Subscribe(function(brio)
+				if brio:IsDead() then
+					return
+				end
+
+				connectMaid._warning = nil
 
-			connectMaid._warning = nil
+				local maid, remoteEvent = brio:ToMaidAndValue()
+				maid:GiveTask(remoteEvent.Event:Connect(callback))
+			end))
+		else
+			connectMaid:GiveTask(self:_observeRemoteEventBrio(memberName):Subscribe(function(brio)
+				if brio:IsDead() then
+					return
+				end
 
-			local remoteEvent = brio:GetValue()
-			local maid = brio:ToMaid()
+				connectMaid._warning = nil
 
-			maid:GiveTask(remoteEvent.OnClientEvent:Connect(callback))
-		end))
+				local maid, remoteEvent = brio:ToMaidAndValue()
+				maid:GiveTask(remoteEvent.OnClientEvent:Connect(callback))
+			end))
+		end
 	else
 		error("[Remoting.Connect] - Unknown RunService state")
 	end
@@ -128,28 +168,47 @@ function Remoting:Bind(memberName, callback)
 
 	local bindMaid = Maid.new()
 
-	if RunService:IsServer() then
-		local remoteFunction = self:_getOrCreateRemoteFunction(memberName)
-		remoteFunction.OnServerInvoke = self:_translateCallback(bindMaid, memberName, callback)
+	if self._remotingRealm == RemotingRealms.SERVER then
+		if self._useDummyObject then
+			self:DeclareMethod(memberName)
+
+			local bindableFunction = self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnServerInvoke"))
+			bindableFunction.OnInvoke = self:_translateCallback(bindMaid, memberName, callback)
+		else
+			local remoteFunction = self:_getOrCreateRemoteFunction(memberName)
+			remoteFunction.OnServerInvoke = self:_translateCallback(bindMaid, memberName, callback)
+		end
 
 		-- TODO: Cleanup if nothing else is expecting this
-	elseif RunService:IsClient() then
+	elseif self._remotingRealm == RemotingRealms.CLIENT then
 		bindMaid._warning = task.delay(5, function()
 			warn(string.format("[Remoting] - Failed to find RemoteEvent %q, event may never fire", self:_getDebugMemberName(memberName)))
 		end)
 
-		bindMaid:GiveTask(self:_observeRemoteFunctionBrio(memberName):Subscribe(function(brio)
-			if brio:IsDead() then
-				return
-			end
+		if self._useDummyObject then
+			bindMaid:GiveTask(self:_observeRemoteFunctionBrio(self:_getDummyMemberName(memberName, "OnClientInvoke")):Subscribe(function(brio)
+				if brio:IsDead() then
+					return
+				end
 
-			bindMaid._warning = nil
+				bindMaid._warning = nil
 
-			local remoteFunction = brio:GetValue()
-			local maid = brio:ToMaid()
+				local maid, remoteFunction = brio:ToMaidAndValue()
+				remoteFunction.OnInvoke = self:_translateCallback(maid, memberName, callback)
+			end))
+		else
+
+			bindMaid:GiveTask(self:_observeRemoteFunctionBrio(memberName):Subscribe(function(brio)
+				if brio:IsDead() then
+					return
+				end
 
-			remoteFunction.OnClientInvoke = self:_translateCallback(maid, memberName, callback)
-		end))
+				bindMaid._warning = nil
+
+				local maid, remoteFunction = brio:ToMaidAndValue()
+				remoteFunction.OnClientInvoke = self:_translateCallback(maid, memberName, callback)
+			end))
+		end
 
 		-- TODO: Warn if remote function doesn't exist
 	else
@@ -172,8 +231,13 @@ end
 function Remoting:DeclareEvent(memberName)
 	assert(type(memberName) == "string", "Bad memberName")
 
-	if RunService:IsServer() then
-		self:_getOrCreateRemoteEvent(memberName)
+	if self._remotingRealm == RemotingRealms.SERVER then
+		if self._useDummyObject then
+			self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnClientEvent"))
+			self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnServerEvent"))
+		else
+			self:_getOrCreateRemoteEvent(memberName)
+		end
 	end
 end
 
@@ -185,8 +249,13 @@ end
 function Remoting:DeclareMethod(memberName)
 	assert(type(memberName) == "string", "Bad memberName")
 
-	if RunService:IsServer() then
-		self:_getOrCreateRemoteFunction(memberName)
+	if self._remotingRealm == RemotingRealms.SERVER then
+		if self._useDummyObject then
+			self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnServerInvoke"))
+			self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnClientInvoke"))
+		else
+			self:_getOrCreateRemoteFunction(memberName)
+		end
 	end
 end
 
@@ -253,7 +322,13 @@ end
 function Remoting:FireClient(memberName, player, ...)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
-	assert(RunService:IsServer(), "FireClient must be called on server")
+	assert(self._remotingRealm == RemotingRealms.SERVER, "FireClient must be called on server")
+
+	if self._useDummyObject then
+		local bindableEvent = self:_getOrCreateRemoteEvent(memberName)
+		bindableEvent:Fire(...)
+		return
+	end
 
 	local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
 	remoteEvent:FireClient(player, ...)
@@ -272,10 +347,16 @@ end
 function Remoting:InvokeClient(memberName, player, ...)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
-	assert(RunService:IsServer(), "InvokeClient must be called on server")
+	assert(self._remotingRealm == RemotingRealms.SERVER, "InvokeClient must be called on server")
+
+	if self._useDummyObject then
+		local bindableFunction = self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnClientInvoke"))
+		bindableFunction:Invoke(...)
+		return
+	end
 
-	local remoteEvent = self:_getOrCreateRemoteFunction(memberName)
-	remoteEvent:InvokeClient(player, ...)
+	local remoteFunction = self:_getOrCreateRemoteFunction(memberName)
+	remoteFunction:InvokeClient(player, ...)
 end
 
 --[=[
@@ -289,7 +370,13 @@ end
 ]=]
 function Remoting:FireAllClients(memberName, ...)
 	assert(type(memberName) == "string", "Bad memberName")
-	assert(RunService:IsServer(), "FireAllClients must be called on server")
+	assert(self._remotingRealm == RemotingRealms.SERVER, "FireAllClients must be called on server")
+
+	if self._useDummyObject then
+		local bindableEvent = self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnClientEvent"))
+		bindableEvent:Fire(...)
+		return
+	end
 
 	local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
 	remoteEvent:FireAllClients(...)
@@ -307,7 +394,13 @@ end
 function Remoting:FireAllClientsExcept(memberName, excludePlayer, ...)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(typeof(excludePlayer) == "Instance" and excludePlayer:IsA("Player") or excludePlayer == nil, "Bad excludePlayer")
-	assert(RunService:IsServer(), "FireAllClientsExcept must be called on server")
+	assert(self._remotingRealm == RemotingRealms.SERVER, "FireAllClientsExcept must be called on server")
+
+	if self._useDummyObject then
+		local bindableEvent = self:_getOrCreateRemoteEvent(self:_getDummyMemberName(memberName, "OnClientEvent"))
+		bindableEvent:Fire(...)
+		return
+	end
 
 	local remoteEvent = self:_getOrCreateRemoteEvent(memberName)
 	for _, player in pairs(Players:GetPlayers()) do
@@ -326,7 +419,7 @@ end
 ]=]
 function Remoting:FireServer(memberName, ...)
 	assert(type(memberName) == "string", "Bad memberName")
-	assert(RunService:IsClient(), "FireServer must be called on server")
+	assert(self._remotingRealm == RemotingRealms.CLIENT, "FireServer must be called on client")
 
 	self:PromiseFireServer(memberName, ...)
 end
@@ -341,15 +434,23 @@ end
 ]=]
 function Remoting:PromiseFireServer(memberName, ...)
 	assert(type(memberName) == "string", "Bad memberName")
-	assert(RunService:IsClient(), "PromiseFireServer must be called on server")
+	assert(self._remotingRealm == RemotingRealms.CLIENT, "PromiseFireServer must be called on client")
 
 	local fireMaid = Maid.new()
 	local args = table.pack(...)
 
-	local promise = self:_promiseRemoteEvent(fireMaid, memberName)
-		:Then(function(remoteEvent)
-			remoteEvent:FireServer(table.unpack(args, 1, args.n))
-		end)
+	local promise
+	if self._useDummyObject then
+		promise = self:_promiseRemoteEvent(fireMaid, self:_getDummyMemberName(memberName, "OnServerEvent"))
+			:Then(function(bindableEvent)
+				bindableEvent:Fire(Players.LocalPlayer, table.unpack(args, 1, args.n))
+			end)
+	else
+		promise = self:_promiseRemoteEvent(fireMaid, memberName)
+			:Then(function(remoteEvent)
+				remoteEvent:FireServer(table.unpack(args, 1, args.n))
+			end)
+	end
 
 	promise:Finally(function()
 		self._maid[fireMaid] = nil
@@ -392,10 +493,18 @@ function Remoting:PromiseInvokeServer(memberName, ...)
 	local invokeMaid = Maid.new()
 	local args = table.pack(...)
 
-	local promise = self:_promiseRemoteFunction(invokeMaid, memberName)
-		:Then(function(remoteFunction)
-			return invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeServer(remoteFunction, table.unpack(args, 1, args.n)))
-		end)
+	local promise
+	if self._useDummyObject then
+		promise = self:_promiseRemoteFunction(invokeMaid, self:_getDummyMemberName(memberName, "OnServerInvoke"))
+			:Then(function(remoteFunction)
+				return invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeBindableFunction(remoteFunction, Players.LocalPlayer, table.unpack(args, 1, args.n)))
+			end)
+	else
+		promise = self:_promiseRemoteFunction(invokeMaid, memberName)
+			:Then(function(remoteFunction)
+				return invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeServer(remoteFunction, table.unpack(args, 1, args.n)))
+			end)
+	end
 
 	promise:Finally(function()
 		self._maid[invokeMaid] = nil
@@ -423,11 +532,17 @@ function Remoting:PromiseInvokeClient(memberName, player, ...)
 	assert(type(memberName) == "string", "Bad memberName")
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 
-	local remoteFunction = self:_getOrCreateRemoteFunction(memberName)
-
 	local invokeMaid = Maid.new()
 
-	local promise = invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeClient(remoteFunction, player, ...))
+	local promise
+	if self._useDummyObject then
+		local bindableFunction = self:_getOrCreateRemoteFunction(self:_getDummyMemberName(memberName, "OnClientInvoke"))
+		promise = invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeBindableFunction(bindableFunction, ...))
+	else
+		local remoteFunction = self:_getOrCreateRemoteFunction(memberName)
+		promise = invokeMaid:GivePromise(RemoteFunctionUtils.promiseInvokeClient(remoteFunction, player, ...))
+	end
+
 	promise:Finally(function()
 		self._maid[invokeMaid] = nil
 	end)
@@ -440,21 +555,25 @@ function Remoting:PromiseInvokeClient(memberName, player, ...)
 	return promise
 end
 
-function Remoting:_ensureFolder()
-	assert(RunService:IsServer(), "Folder should only be created on server")
+function Remoting:GetContainerClass()
+	return "Configuration"
+end
+
+function Remoting:_ensureContainer()
+	assert(self._remotingRealm == RemotingRealms.SERVER, "Folder should only be created on server")
 
-	if self._remoteFolder then
-		return self._remoteFolder
+	if self._container then
+		return self._container
 	end
 
-	self._remoteFolder = Instance.new("Folder")
-	self._remoteFolder.Name = self._remoteFolderName
-	self._remoteFolder.Archivable = false
-	self._remoteFolder.Parent = self._instance
+	self._container = Instance.new(self:GetContainerClass())
+	self._container.Name = self._remoteFolderName
+	self._container.Archivable = false
+	self._container.Parent = self._instance
 
-	self._maid:GiveTask(self._remoteFolder)
+	self._maid:GiveTask(self._container)
 
-	return self._remoteFolder
+	return self._container
 end
 
 function Remoting:_observeRemoteFunctionBrio(memberName)
@@ -464,7 +583,11 @@ function Remoting:_observeRemoteFunctionBrio(memberName)
 
 	return self:_observeFolderBrio():Pipe({
 		RxBrioUtils.switchMapBrio(function(item)
-			return RxInstanceUtils.observeLastNamedChildBrio(item, "RemoteFunction", remoteFunctionName)
+			if self._useDummyObject then
+				return RxInstanceUtils.observeLastNamedChildBrio(item, "BindableFunction", remoteFunctionName)
+			else
+				return RxInstanceUtils.observeLastNamedChildBrio(item, "RemoteFunction", remoteFunctionName)
+			end
 		end)
 	})
 end
@@ -476,36 +599,39 @@ function Remoting:_observeRemoteEventBrio(memberName)
 
 	return self:_observeFolderBrio():Pipe({
 		RxBrioUtils.switchMapBrio(function(item)
-			return RxInstanceUtils.observeLastNamedChildBrio(item, "RemoteEvent", remoteFunctionName)
+			if self._useDummyObject then
+				return RxInstanceUtils.observeLastNamedChildBrio(item, "BindableEvent", remoteFunctionName)
+			else
+				return RxInstanceUtils.observeLastNamedChildBrio(item, "RemoteEvent", remoteFunctionName)
+			end
 		end)
 	})
 end
 
-function Remoting:_promiseFolder(maid)
+function Remoting:_promiseContainer(maid)
 	return maid:GivePromise(promiseChild(self._instance, self._remoteFolderName, 5))
 end
 
 function Remoting:_promiseRemoteEvent(maid, memberName)
 	local remoteEventName = self:_getMemberName(memberName, REMOTE_EVENT_SUFFIX)
-	return self:_promiseFolder(maid)
-		:Then(function(folder)
-			return maid:GivePromise(promiseChild(folder, remoteEventName, 5))
+	return self:_promiseContainer(maid)
+		:Then(function(container)
+			return maid:GivePromise(promiseChild(container, remoteEventName, 5))
 		end)
 end
 
 function Remoting:_promiseRemoteFunction(maid, memberName)
 	local remoteEventName = self:_getMemberName(memberName, REMOTE_FUNCTION_SUFFIX)
-	return self:_promiseFolder(maid)
-		:Then(function(folder)
-			return maid:GivePromise(promiseChild(folder, remoteEventName, 5))
+	return self:_promiseContainer(maid)
+		:Then(function(container)
+			return maid:GivePromise(promiseChild(container, remoteEventName, 5))
 		end)
 end
 
-
 function Remoting:_observeFolderBrio()
 	assert(self._instance, "Not initialized")
 
-	return RxInstanceUtils.observeLastNamedChildBrio(self._instance, "Folder", self._remoteFolderName)
+	return RxInstanceUtils.observeLastNamedChildBrio(self._instance, self:GetContainerClass(), self._remoteFolderName)
 end
 
 function Remoting:_getOrCreateRemoteFunction(memberName)
@@ -517,12 +643,18 @@ function Remoting:_getOrCreateRemoteFunction(memberName)
 		return self._remoteObjects[remoteFunctionName]
 	end
 
-	local folder = self:_ensureFolder()
+	local container = self:_ensureContainer()
+
+	local remoteFunction
+	if self._useDummyObject then
+		remoteFunction = Instance.new("BindableFunction")
+	else
+		remoteFunction = Instance.new("RemoteFunction")
+	end
 
-	local remoteFunction = Instance.new("RemoteFunction")
 	remoteFunction.Name = remoteFunctionName
 	remoteFunction.Archivable = false
-	remoteFunction.Parent = folder
+	remoteFunction.Parent = container
 
 	self._remoteObjects[remoteFunctionName] = remoteFunction
 	self._maid[remoteFunction] = remoteFunction
@@ -539,12 +671,18 @@ function Remoting:_getOrCreateRemoteEvent(memberName)
 		return self._remoteObjects[remoteEventName]
 	end
 
-	local folder = self:_ensureFolder()
+	local container = self:_ensureContainer()
+
+	local remoteEvent
+	if self._useDummyObject then
+		remoteEvent = Instance.new("BindableEvent")
+	else
+		remoteEvent = Instance.new("RemoteEvent")
+	end
 
-	local remoteEvent = Instance.new("RemoteEvent")
 	remoteEvent.Name = remoteEventName
 	remoteEvent.Archivable = false
-	remoteEvent.Parent = folder
+	remoteEvent.Parent = container
 
 	self._maid[remoteEvent] = remoteEvent
 	self._remoteObjects[remoteEventName] = remoteEvent
@@ -556,6 +694,12 @@ function Remoting:_getMemberName(memberName, objectType)
 	return memberName .. objectType
 end
 
+function Remoting:_getDummyMemberName(memberName, suffix)
+	assert(self._useDummyObject, "Not dummy mode")
+
+	return memberName .. "_" .. suffix .. "_"
+end
+
 function Remoting:_getDebugMemberName(memberName)
 	return string.format("%s.%s", self._name, memberName)
 end

package/src/Shared/Interface/RemotingMember.lua

@@ -5,7 +5,9 @@
 	@class RemotingMember
 ]=]
 
-local RunService = game:GetService("RunService")
+local require = require(script.Parent.loader).load(script)
+
+local RemotingRealms = require("RemotingRealms")
 
 local RemotingMember = {}
 RemotingMember.ClassName = "RemotingMember"
@@ -16,13 +18,15 @@ RemotingMember.__index = RemotingMember
 
 	@param remoting Remoting
 	@param memberName string
+	@param remotingRealm RemotingRealms
 	@return RemotingMember
 ]=]
-function RemotingMember.new(remoting, memberName)
+function RemotingMember.new(remoting, memberName, remotingRealm)
 	local self = setmetatable({}, RemotingMember)
 
 	self._remoting = assert(remoting, "No remoting")
 	self._memberName = assert(memberName, "No memberName")
+	self._remotingRealm = assert(remotingRealm, "Bad remotingRealm")
 
 	return self
 end
@@ -80,7 +84,7 @@ end
 	@param ... any
 ]=]
 function RemotingMember:FireServer(...)
-	assert(RunService:IsClient(), "FireServer must be called on client")
+	assert(self._remotingRealm == RemotingRealms.CLIENT, "FireServer must be called on client")
 	self._remoting:FireServer(self._memberName, ...)
 end
 
@@ -91,7 +95,7 @@ end
 	@param ... any
 ]=]
 function RemotingMember:InvokeServer(...)
-	assert(RunService:IsClient(), "InvokeServer must be called on client")
+	assert(self._remotingRealm == RemotingRealms.CLIENT, "InvokeServer must be called on client")
 
 	return self._remoting:InvokeServer(self._memberName, ...)
 end
@@ -103,7 +107,7 @@ end
 	@param ... any
 ]=]
 function RemotingMember:PromiseInvokeServer(...)
-	assert(RunService:IsClient(), "PromiseInvokeServer must be called on client")
+	assert(self._remotingRealm == RemotingRealms.CLIENT, "PromiseInvokeServer must be called on client")
 
 	return self._remoting:PromiseInvokeServer(self._memberName, ...)
 end
@@ -116,7 +120,7 @@ end
 	@return Promise
 ]=]
 function RemotingMember:PromiseFireServer(...)
-	assert(RunService:IsClient(), "PromiseInvokeServer must be called on client")
+	assert(self._remotingRealm == RemotingRealms.CLIENT, "PromiseInvokeServer must be called on client")
 
 	return self._remoting:PromiseFireServer(self._memberName, ...)
 end
@@ -134,7 +138,7 @@ end
 ]=]
 function RemotingMember:PromiseInvokeClient(player, ...)
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
-	assert(RunService:IsServer(), "PromiseInvokeClient must be called on client")
+	assert(self._remotingRealm == RemotingRealms.SERVER, "PromiseInvokeClient must be called on client")
 
 	return self._remoting:PromiseInvokeClient(self._memberName, player, ...)
 end
@@ -151,7 +155,7 @@ end
 ]=]
 function RemotingMember:InvokeClient(player, ...)
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
-	assert(RunService:IsServer(), "InvokeClient must be called on client")
+	assert(self._remotingRealm == RemotingRealms.SERVER, "InvokeClient must be called on client")
 
 	return self._remoting:InvokeClient(self._memberName, player, ...)
 end
@@ -165,7 +169,7 @@ end
 	@param ... any
 ]=]
 function RemotingMember:FireAllClients(...)
-	assert(RunService:IsServer(), "FireAllClients must be called on client")
+	assert(self._remotingRealm == RemotingRealms.SERVER, "FireAllClients must be called on client")
 
 	self._remoting:FireAllClients(self._memberName, ...)
 end
@@ -180,12 +184,11 @@ end
 ]=]
 function RemotingMember:FireAllClientsExcept(excludePlayer, ...)
 	assert(typeof(excludePlayer) == "Instance" and excludePlayer:IsA("Player") or excludePlayer == nil, "Bad excludePlayer")
-	assert(RunService:IsServer(), "FireAllClientsExcept must be called on server")
+	assert(self._remotingRealm == RemotingRealms.SERVER, "FireAllClientsExcept must be called on server")
 
 	self._remoting:FireAllClientsExcept(self._memberName, excludePlayer, ...)
 end
 
-
 --[=[
 	Fires the client with the data
 
@@ -196,7 +199,7 @@ end
 	@param ... any
 ]=]
 function RemotingMember:FireClient(player, ...)
-	assert(RunService:IsServer(), "FireClient must be called on client")
+	assert(self._remotingRealm == RemotingRealms.SERVER, "FireClient must be called on client")
 	assert(typeof(player) == "Instance" and player:IsA("Player"), "Bad player")
 
 	self._remoting:FireClient(self._memberName, player, ...)

package/src/Shared/Realm/RemotingRealmUtils.lua

@@ -0,0 +1,27 @@
+--[=[
+	@class RemotingRealmUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local RunService = game:GetService("RunService")
+
+local RemotingRealms = require("RemotingRealms")
+
+local RemotingRealmUtils = {}
+
+function RemotingRealmUtils.isRemotingRealm(realm)
+	return realm == RemotingRealms.SERVER or realm == RemotingRealms.CLIENT
+end
+
+function RemotingRealmUtils.inferRemotingRealm()
+	if RunService:IsServer() then
+		return RemotingRealms.SERVER
+	elseif RunService:IsClient() then
+		return RemotingRealms.CLIENT
+	else
+		error("[RemotingRealmUtils.inferRemotingRealm] - Unknown RunService state")
+	end
+end
+
+return RemotingRealmUtils

package/src/Shared/Realm/RemotingRealms.lua

@@ -0,0 +1,12 @@
+--[=[
+	@class RemotingRealms
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Table = require("Table")
+
+return Table.readonly({
+	SERVER = "server";
+	CLIENT = "client";
+})