@chrrxs/robloxstudio-mcp 2.11.1 → 2.11.3

package/studio-plugin/MCPInspectorPlugin.rbxmx

@@ -11,10 +11,15 @@ local UI = TS.import(script, script, "modules", "UI")
 local Communication = TS.import(script, script, "modules", "Communication")
 local ClientBroker = TS.import(script, script, "modules", "ClientBroker")
 local RuntimeLogBuffer = TS.import(script, script, "modules", "RuntimeLogBuffer")
+local StopPlayMonitor = TS.import(script, script, "modules", "StopPlayMonitor")
 -- Attach the per-peer LogService.MessageOut listener as early as possible so
 -- boot-time prints from the user's place scripts are captured. Powers the
 -- get_runtime_logs MCP tool. Idempotent; safe to call before UI.init().
 RuntimeLogBuffer.install()
+-- Share the plugin reference with the stop-play signaling module so both the
+-- edit DM (write the flag) and the play-server DM (read+act on the flag) can
+-- access plugin:SetSetting/GetSetting.
+StopPlayMonitor.init(plugin)
 UI.init(plugin)
 local elements = UI.getElements()
 local ICON_DISCONNECTED = "rbxassetid://125921838360800"
@@ -65,6 +70,10 @@ task.delay(2, function()
 	end
 	if role == "server" then
 		ClientBroker.setupServerBroker()
+		-- The play-server DM is the only one where StudioTestService:EndTest is
+		-- legal, so the stop-play monitor lives here. Reads MCP_STOP_PLAY_SIGNAL
+		-- at 1Hz and calls EndTest when the edit DM sets it.
+		StopPlayMonitor.startMonitor()
 	elseif role == "client" then
 		ClientBroker.setupClientBroker()
 	end
@@ -94,12 +103,10 @@ local MemoryHandlers = TS.import(script, script.Parent, "handlers", "MemoryHandl
 -- in ReplicatedStorage; each player gets a proxy "client" registration on the
 -- MCP side, polled and dispatched by the server peer.
 --
--- The same server peer also registers an "edit" proxy that intercepts
--- /api/stop-playtest specifically - StudioTestService:EndTest only works from
--- the play server DM, so the real edit DM cannot satisfy stop requests on its
--- own. MCP returns the same pending request to multiple pollers until someone
--- /responds, so non-stop edit-targeted requests fall through to the actual
--- edit DM untouched.
+-- (Previously the server peer also registered an "edit-proxy" role to
+-- intercept /api/stop-playtest and call StudioTestService:EndTest. That hack
+-- is gone: stop now uses StopPlayMonitor with plugin:SetSetting cross-DM
+-- signaling, which works regardless of MCP server state.)
 local MCP_URL = "http://localhost:58741"
 local BROKER_NAME = "__MCPClientBroker"
 -- Endpoints the server-peer broker is allowed to forward to the client peer.
@@ -329,59 +336,10 @@ local function registerProxy(player, rf)
 	proxyByPlayer[_player_1] = _arg1
 	task.spawn(pollProxy, proxyId, player, rf)
 end
-local function startEditProxyLoop()
-	task.spawn(function()
-		local proxyId = HttpService:GenerateGUID(false)
-		local ok, res = postJson("/ready", {
-			instanceId = proxyId,
-			role = "edit-proxy",
-		})
-		if not ok or not res or not res.Success then
-			warn("[MCPFork] edit-proxy register failed")
-			return nil
-		end
-		while true do
-			local okPoll, pollRes = pcall(function()
-				return HttpService:RequestAsync({
-					Url = `{MCP_URL}/poll?instanceId={proxyId}`,
-					Method = "GET",
-					Headers = {
-						["Content-Type"] = "application/json",
-					},
-				})
-			end)
-			if okPoll and pollRes and (pollRes.Success or pollRes.StatusCode == 503) then
-				local okJson, body = pcall(function()
-					return HttpService:JSONDecode(pollRes.Body)
-				end)
-				if okJson and body then
-					-- Re-register if the server lost our edit-proxy registration.
-					if body.knownInstance == false then
-						reRegisterProxy(proxyId, "edit-proxy")
-					end
-					if body.request and body.request.endpoint == "/api/stop-playtest" and body.requestId ~= nil then
-						local sts = game:GetService("StudioTestService")
-						local endOk, endErr = pcall(function()
-							return sts:EndTest("stopped_by_mcp")
-						end)
-						local response = if endOk then {
-							success = true,
-							message = "Playtest stopped via edit-proxy/EndTest",
-						} else {
-							success = false,
-							error = `EndTest failed: {tostring(endErr)}`,
-						}
-						postJson("/response", {
-							requestId = body.requestId,
-							response = response,
-						})
-					end
-				end
-			end
-			task.wait(0.15)
-		end
-	end)
-end
+-- (Removed: startEditProxyLoop. The play-server DM no longer registers an
+-- "edit-proxy" peer with the MCP server. stop_playtest now uses a cross-DM
+-- plugin:SetSetting flag consumed by StopPlayMonitor in the play-server DM,
+-- which doesn't depend on MCP server state or peer registration at all.)
 local function setupServerBroker()
 	local rf = ReplicatedStorage:FindFirstChild(BROKER_NAME)
 	if not rf then
@@ -415,7 +373,6 @@ local function setupServerBroker()
 		end
 		table.clear(proxyByPlayer)
 	end)
-	startEditProxyLoop()
 end
 return {
 	MCP_URL = MCP_URL,
@@ -3298,56 +3255,52 @@ local function executeLuau(requestData)
 			error = "Code is required",
 		}
 	end
-	local output = {}
-	local oldPrint = print
-	local oldWarn = warn
-	local env = getfenv(0)
-	env.print = function(...)
-		local args = { ... }
-		local parts = {}
-		for _, a in args do
-			local _arg0 = tostring(a)
-			table.insert(parts, _arg0)
-		end
-		local _arg0 = table.concat(parts, "\t")
-		table.insert(output, _arg0)
-		oldPrint(unpack(args))
-	end
-	env.warn = function(...)
-		local args = { ... }
-		local parts = {}
-		for _, a in args do
-			local _arg0 = tostring(a)
-			table.insert(parts, _arg0)
-		end
-		local _arg0 = `[warn] {table.concat(parts, "\t")}`
-		table.insert(output, _arg0)
-		oldWarn(unpack(args))
-	end
-	-- Try loadstring first (preserves print/warn interception). When
-	-- ServerScriptService.LoadStringEnabled=false AND the plugin runs in a
-	-- peer where the engine respects that gate (notably the play-server DM
-	-- in some Studio configurations), loadstring either returns nil with a
-	-- "loadstring() is not available" message OR throws that same message
-	-- directly. Both paths must trigger the ModuleScript + require
-	-- fallback. The fallback can't intercept print/warn since the
-	-- ModuleScript runs in its own environment, so the output array stays
-	-- empty in that branch - the playtest log buffer already captures
-	-- prints separately via LogService.MessageOut.
+	-- Both execution paths (loadstring + ModuleScript-require fallback) run
+	-- the SAME wrapped source so they return a uniform { ok, value, output }
+	-- shape. Two problems the wrapper solves at once:
+	--
+	--   1. pcall(require, m) swallows the real error and returns Roblox's
+	--      generic "Requested module experienced an error while loading"
+	--      message. Wrapping user code in xpcall INSIDE the IIFE keeps the
+	--      ModuleScript itself returning successfully — the real error +
+	--      traceback live in the returned table.
+	--
+	--   2. The ModuleScript path runs in its own environment, so a plugin-
+	--      side getfenv print/warn override never reached user prints. A
+	--      lexical local print/warn inside the IIFE captures user prints
+	--      regardless of which path executes. We also call the real global
+	--      print/warn so messages still flow to Studio's output and
+	--      LogService.MessageOut (which powers get_runtime_logs).
+	--
+	-- Prints from required sub-modules don't reach this capture (they have
+	-- their own env) — those go through the runtime log buffer.
+	local wrapped = `return ((function()\
+\tlocal __mcp_output = \{\}\
+\tlocal __mcp_real_print = print\
+\tlocal __mcp_real_warn = warn\
+\tlocal print = function(...)\
+\t\t__mcp_real_print(...)\
+\t\tlocal args = \{...\}\
+\t\tlocal parts = table.create(#args)\
+\t\tfor i, a in ipairs(args) do parts[i] = tostring(a) end\
+\t\ttable.insert(__mcp_output, table.concat(parts, "\\t"))\
+\tend\
+\tlocal warn = function(...)\
+\t\t__mcp_real_warn(...)\
+\t\tlocal args = \{...\}\
+\t\tlocal parts = table.create(#args)\
+\t\tfor i, a in ipairs(args) do parts[i] = tostring(a) end\
+\t\ttable.insert(__mcp_output, "[warn] " .. table.concat(parts, "\\t"))\
+\tend\
+\tlocal function __mcp_run()\
+{code}\
+\tend\
+\tlocal ok, errOrValue = xpcall(__mcp_run, debug.traceback)\
+\treturn \{ ok = ok, value = errOrValue, output = __mcp_output \}\
+end)())`
 	local runViaModuleScript = function()
 		local m = Instance.new("ModuleScript")
 		m.Name = "__MCPExecLuauPayload"
-		-- Wrap user code in an IIFE so require() always gets exactly one
-		-- return value. Without this, code like `print("x")` errors with
-		-- "Module code did not return exactly one value" because top-level
-		-- ModuleScripts must return exactly one value.
-		--
-		-- The DOUBLE parens around the call are load-bearing: in Luau,
-		-- `return f()` propagates whatever multi-value tuple f returns,
-		-- including zero values. Outer parens adjust the call to exactly
-		-- one value (the first, or nil). So `return ((f)())` always
-		-- returns exactly one value, regardless of what f does.
-		local wrapped = `return ((function()\n{code}\nend)())`
 		local okSet, setErr = pcall(function()
 			m.Source = wrapped
 		end)
@@ -3371,7 +3324,7 @@ local function executeLuau(requestData)
 		return matchStart ~= nil
 	end
 	local success, result = pcall(function()
-		local fn, compileError = loadstring(code)
+		local fn, compileError = loadstring(wrapped)
 		if not fn then
 			if isLoadstringUnavailable(compileError) then
 				return runViaModuleScript()
@@ -3381,27 +3334,39 @@ local function executeLuau(requestData)
 		return fn()
 	end)
 	-- loadstring throws (not returns nil) in some plugin contexts when
-	-- LoadStringEnabled=false. Catch that here as a second-chance fallback.
+	-- LoadStringEnabled=false. Catch that as a second-chance fallback.
 	if not success and isLoadstringUnavailable(result) then
 		success, result = pcall(runViaModuleScript)
 	end
-	env.print = oldPrint
-	env.warn = oldWarn
-	if success then
-		return {
-			success = true,
-			returnValue = if result ~= nil then tostring(result) else nil,
-			output = output,
-			message = "Code executed successfully",
-		}
-	else
+	if not success then
+		-- Outer pcall failed - the wrapper itself didn't even run (e.g. compile
+		-- error in the user code, or ModuleScript setup error). 'result' is the
+		-- raw error string from pcall.
 		return {
 			success = false,
 			error = tostring(result),
-			output = output,
+			output = {},
 			message = "Code execution failed",
 		}
 	end
+	-- Wrapper executed - unpack { ok, value, output }.
+	local r = result
+	local capturedOutput = r.output
+	local output = if capturedOutput ~= nil then capturedOutput else ({})
+	if r.ok == true then
+		return {
+			success = true,
+			returnValue = if r.value ~= nil then tostring(r.value) else nil,
+			output = output,
+			message = "Code executed successfully",
+		}
+	end
+	return {
+		success = false,
+		error = if r.value ~= nil then tostring(r.value) else "(unknown error)",
+		output = output,
+		message = "Code execution failed",
+	}
 end
 local function undo(_requestData)
 	local success, result = pcall(function()
@@ -5686,13 +5651,18 @@ local TS = require(script.Parent.Parent.Parent.include.RuntimeLib)
 local _services = TS.import(script, script.Parent.Parent.Parent, "node_modules", "@rbxts", "services")
 local HttpService = _services.HttpService
 local LogService = _services.LogService
+local RunService = _services.RunService
 local _EvalBridges = TS.import(script, script.Parent.Parent, "EvalBridges")
 local installBridges = _EvalBridges.installBridges
 local cleanupBridges = _EvalBridges.cleanupBridges
+local StopPlayMonitor = TS.import(script, script.Parent.Parent, "StopPlayMonitor")
 local StudioTestService = game:GetService("StudioTestService")
 local ServerScriptService = game:GetService("ServerScriptService")
 local ScriptEditorService = game:GetService("ScriptEditorService")
-local STOP_SIGNAL = "__MCP_STOP__"
+-- NAV_SIGNAL flows from the edit DM to the play-server DM via the injected
+-- __MCP_CommandListener Script + LogService.MessageOut. Stop signaling moved
+-- off this path entirely (see StopPlayMonitor) because cross-DM MessageOut
+-- reflection from edit -> play-server does not work in practice.
 local NAV_SIGNAL = "__MCP_NAV__"
 local NAV_RESULT = "__MCP_NAV_RESULT__"
 local testRunning = false
@@ -5704,16 +5674,13 @@ local stopListenerScript
 local navResultCallback
 local function buildCommandListenerSource()
 	return `local LogService = game:GetService("LogService")\
-local StudioTestService = game:GetService("StudioTestService")\
 local PathfindingService = game:GetService("PathfindingService")\
 local Players = game:GetService("Players")\
 local HttpService = game:GetService("HttpService")\
 local NAV_SIG = "{NAV_SIGNAL}"\
 local NAV_RES = "{NAV_RESULT}"\
 LogService.MessageOut:Connect(function(msg)\
-	if msg == "{STOP_SIGNAL}" then\
-		pcall(function() StudioTestService:EndTest("stopped_by_mcp") end)\
-	elseif string.sub(msg, 1, #NAV_SIG + 1) == NAV_SIG .. ":" then\
+	if string.sub(msg, 1, #NAV_SIG + 1) == NAV_SIG .. ":" then\
 		local json = string.sub(msg, #NAV_SIG + 2)\
 		task.spawn(function()\
 			local ok, d = pcall(function() return HttpService:JSONDecode(json) end)\
@@ -5801,6 +5768,19 @@ local function startPlaytest(requestData)
 			error = 'mode must be "play" or "run"',
 		}
 	end
+	-- Self-heal: if testRunning is stuck true but Studio reports no active
+	-- playtest, the previous start_playtest's task.spawn was orphaned
+	-- (plugin reload mid-test, Studio entered some inconsistent state, etc).
+	-- Reset it so subsequent starts don't hit a false "already running".
+	if testRunning and not RunService:IsRunning() then
+		testRunning = false
+		if logConnection then
+			logConnection:Disconnect()
+			logConnection = nil
+		end
+		cleanupStopListener()
+		cleanupBridges()
+	end
 	if testRunning then
 		return {
 			error = "A test is already running",
@@ -5812,9 +5792,6 @@ local function startPlaytest(requestData)
 	testError = nil
 	cleanupStopListener()
 	logConnection = LogService.MessageOut:Connect(function(message, messageType)
-		if message == STOP_SIGNAL then
-			return nil
-		end
 		local _message = message
 		local _arg1 = #NAV_SIGNAL
 		if string.sub(_message, 1, _arg1) == NAV_SIGNAL then
@@ -5876,25 +5853,60 @@ local function startPlaytest(requestData)
 		cleanupStopListener()
 		cleanupBridges()
 	end)
-	local msg = if numPlayers ~= nil then `Playtest started in {mode} mode with {numPlayers} player(s)` else `Playtest started in {mode} mode`
+	local msg = if numPlayers ~= nil then `Playtest started in {mode} mode with {numPlayers} player(s).` else `Playtest started in {mode} mode.`
 	local response = {
 		success = true,
 		message = msg,
-		evalBridges = if bridgeInstall.installed then "installed" else `failed: {bridgeInstall.error}`,
 	}
+	-- Only mention eval bridges when they failed — when they're fine, the
+	-- detail is noise. eval_server_runtime / eval_client_runtime will surface
+	-- their own clear errors if the caller tries to use them after a failed
+	-- install.
+	if not bridgeInstall.installed then
+		response.evalBridgesError = bridgeInstall.error
+	end
 	return response
 end
 local function stopPlaytest(_requestData)
-	-- Server-side routing (tools/index.ts:stopPlaytest) sends /api/stop-playtest
-	-- to the role="edit-proxy" instance whenever one is registered. This handler
-	-- is only reached when there's no edit-proxy - i.e. no active playtest, or
-	-- the play DMs haven't completed plugin auto-activation yet. Calling
-	-- StudioTestService:EndTest from the edit DM is illegal ("can only be
-	-- called from the server DataModel of a running Studio play session"), so
-	-- don't try - return a clean "no active playtest" response instead.
+	-- Signal the play-server DM's StopPlayMonitor via plugin:SetSetting (a
+	-- cross-DM persistent store). The monitor polls at 1Hz, sees the flag,
+	-- calls StudioTestService:EndTest, then resets the flag. We wait up to
+	-- 2.5s for the reset to confirm a play DM actually consumed the request,
+	-- which avoids returning success when nothing is running.
+	if not StopPlayMonitor.requestStop() then
+		return {
+			error = "Plugin not ready. Try again in a moment.",
+		}
+	end
+	if not StopPlayMonitor.waitForConsumption() then
+		-- Clean up the pending flag so a future playtest's monitor doesn't fire
+		-- EndTest on its own startup against a stale signal.
+		StopPlayMonitor.clearPending()
+		return {
+			error = "No active playtest to stop.",
+		}
+	end
+	-- Flag was consumed (EndTest called). ExecutePlayModeAsync in our
+	-- startPlaytest task.spawn is still unwinding though — testRunning stays
+	-- true until that yield completes and the post-block runs. Wait so
+	-- back-to-back stop -> start sequences don't race against the prior
+	-- teardown and get "A test is already running". 10s covers play-DM
+	-- teardown on heavier places; if it still hasn't cleared we return
+	-- anyway so users aren't stuck — but note that in the response so the
+	-- caller knows a subsequent start may need a moment.
+	local deadline = tick() + 10
+	while testRunning and tick() < deadline do
+		task.wait(0.1)
+	end
+	if testRunning then
+		return {
+			success = true,
+			message = "Playtest stop signal sent; teardown still in progress.",
+		}
+	end
 	return {
-		error = "No active playtest to stop (edit-proxy not registered).",
-		hint = "If a playtest is running, the play-server DM may not have completed plugin auto-activation yet. " .. "Wait a moment and retry, or call execute_luau target=server with StudioTestService:EndTest as a manual fallback.",
+		success = true,
+		message = "Playtest stopped.",
 	}
 end
 local function getPlaytestOutput(_requestData)
@@ -6203,7 +6215,7 @@ return {
         <Properties>
           <string name="Name">State</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
-local CURRENT_VERSION = "2.11.1"
+local CURRENT_VERSION = "2.11.3"
 local MAX_CONNECTIONS = 5
 local BASE_PORT = 58741
 local activeTabIndex = 0
@@ -6296,6 +6308,113 @@ return {
         </Properties>
       </Item>
       <Item class="ModuleScript" referent="22">
+        <Properties>
+          <string name="Name">StopPlayMonitor</string>
+          <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
+-- Cross-DM stop_playtest signaling via plugin:SetSetting.
+--
+-- `plugin:SetSetting` / `plugin:GetSetting` is a per-plugin persistent store
+-- that's shared across every DataModel the plugin runs in (edit, play-server,
+-- play-clients). We use it as a one-bit flag for "please call EndTest in the
+-- play-server DM":
+--
+--   * The edit DM's stopPlaytest handler writes the flag (requestStop).
+--   * A monitor loop running inside the play-server DM polls the flag at 1Hz
+--     and calls StudioTestService:EndTest when it flips true, then resets it.
+--   * The edit DM then waits up to ~2.5s for the flag to be reset, which
+--     tells us a play-server actually consumed the request (no false-positive
+--     success when nothing was running).
+--
+-- Why this is simpler than the previous edit-proxy registration:
+--   * Doesn't depend on the MCP server tracking peer roles at all.
+--   * Survives MCP server restarts: monitor loop is local to the play-server
+--     plugin lifetime, not to any HTTP/registration state.
+--   * No need for cross-DM LogService.MessageOut reflection (which we verified
+--     does not work edit -> play-server anyway).
+--
+-- Pattern mirrors the official Roblox Studio MCP
+-- (Roblox/studio-rust-mcp-server, plugin/src/Utils/GameStopUtil.luau).
+local StudioTestService = game:GetService("StudioTestService")
+local SETTING_KEY = "MCP_STOP_PLAY_SIGNAL"
+local POLL_INTERVAL_SEC = 1
+local WAIT_FOR_CONSUMPTION_TIMEOUT_SEC = 2.5
+local WAIT_POLL_SEC = 0.1
+local pluginRef
+local function init(p)
+	pluginRef = p
+end
+local function startMonitor()
+	if not pluginRef then
+		warn("[MCP] StopPlayMonitor.startMonitor called before init; skipping")
+		return nil
+	end
+	-- Clear any stale value left from a prior session. If a real stop request
+	-- is in-flight when this runs, the requesting edit DM will set it again
+	-- within its 2.5s wait window.
+	pcall(function()
+		return pluginRef:SetSetting(SETTING_KEY, false)
+	end)
+	task.spawn(function()
+		while true do
+			local okGet, val = pcall(function()
+				return pluginRef:GetSetting(SETTING_KEY)
+			end)
+			if okGet and val == true then
+				pcall(function()
+					return pluginRef:SetSetting(SETTING_KEY, false)
+				end)
+				pcall(function()
+					return StudioTestService:EndTest("stopped_by_mcp")
+				end)
+			end
+			task.wait(POLL_INTERVAL_SEC)
+		end
+	end)
+end
+local function requestStop()
+	if not pluginRef then
+		return false
+	end
+	local ok = pcall(function()
+		return pluginRef:SetSetting(SETTING_KEY, true)
+	end)
+	return ok
+end
+local function waitForConsumption()
+	if not pluginRef then
+		return false
+	end
+	local start = tick()
+	while tick() - start < WAIT_FOR_CONSUMPTION_TIMEOUT_SEC do
+		local okGet, val = pcall(function()
+			return pluginRef:GetSetting(SETTING_KEY)
+		end)
+		if okGet and val ~= true then
+			return true
+		end
+		task.wait(WAIT_POLL_SEC)
+	end
+	return false
+end
+local function clearPending()
+	if not pluginRef then
+		return nil
+	end
+	pcall(function()
+		return pluginRef:SetSetting(SETTING_KEY, false)
+	end)
+end
+return {
+	init = init,
+	startMonitor = startMonitor,
+	requestStop = requestStop,
+	waitForConsumption = waitForConsumption,
+	clearPending = clearPending,
+}
+]]></string>
+        </Properties>
+      </Item>
+      <Item class="ModuleScript" referent="23">
         <Properties>
           <string name="Name">UI</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -7046,7 +7165,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="23">
+      <Item class="ModuleScript" referent="24">
         <Properties>
           <string name="Name">Utils</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -7576,11 +7695,11 @@ return {
         </Properties>
       </Item>
     </Item>
-    <Item class="Folder" referent="27">
+    <Item class="Folder" referent="28">
       <Properties>
         <string name="Name">include</string>
       </Properties>
-      <Item class="ModuleScript" referent="24">
+      <Item class="ModuleScript" referent="25">
         <Properties>
           <string name="Name">Promise</string>
           <string name="Source"><![CDATA[--[[
@@ -9654,7 +9773,7 @@ return Promise
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="25">
+      <Item class="ModuleScript" referent="26">
         <Properties>
           <string name="Name">RuntimeLib</string>
           <string name="Source"><![CDATA[local Promise = require(script.Parent.Promise)
@@ -9921,15 +10040,15 @@ return TS
         </Properties>
       </Item>
     </Item>
-    <Item class="Folder" referent="28">
+    <Item class="Folder" referent="29">
       <Properties>
         <string name="Name">node_modules</string>
       </Properties>
-      <Item class="Folder" referent="29">
+      <Item class="Folder" referent="30">
         <Properties>
           <string name="Name">@rbxts</string>
         </Properties>
-      <Item class="ModuleScript" referent="26">
+      <Item class="ModuleScript" referent="27">
         <Properties>
           <string name="Name">services</string>
           <string name="Source"><![CDATA[return setmetatable({}, {