@chrrxs/robloxstudio-mcp-inspector 3.1.3 → 3.1.5

package/studio-plugin/MCPInspectorPlugin.rbxmx

@@ -278,6 +278,326 @@ return {
         </Properties>
       </Item>
       <Item class="ModuleScript" referent="3">
+        <Properties>
+          <string name="Name">CaptureTransfer</string>
+          <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
+-- Private ClientBroker transport. Only metadata and <=1 MiB data chunks cross
+-- InvokeClient; callers still receive the original capture-studio response.
+local HttpService = game:GetService("HttpService")
+local READ_ENDPOINT = "/__mcp/capture-studio/read"
+local RELEASE_ENDPOINT = "/__mcp/capture-studio/release"
+local CHUNK_BYTES = 1024 * 1024
+local MAX_TRANSFER_BYTES = 64 * 1024 * 1024
+local MAX_TRANSFERS = 2
+local TRANSFER_TTL_SECONDS = 60
+local transfers = {}
+local function integer(value, min, max)
+	local _value = value
+	local _condition = type(_value) == "number"
+	if _condition then
+		_condition = value >= min and value <= max and value == math.floor(value)
+	end
+	return _condition
+end
+local function validId(value)
+	local _value = value
+	local _condition = type(_value) == "string"
+	if _condition then
+		_condition = #value > 0 and #value <= 64
+	end
+	return _condition
+end
+local function metadata(value)
+	local _value = value
+	if not (type(_value) == "table") then
+		return nil
+	end
+	local fields = value
+	if fields.success ~= true or (fields.encoding ~= "png" and fields.encoding ~= "rgba8") or fields.source ~= "StudioCaptureService" or not integer(fields.width, 1, 65536) or not integer(fields.height, 1, 65536) or not integer(fields.nativeWidth, 1, 65536) or not integer(fields.nativeHeight, 1, 65536) then
+		return nil
+	end
+	return {
+		success = true,
+		encoding = fields.encoding,
+		source = fields.source,
+		width = fields.width,
+		height = fields.height,
+		nativeWidth = fields.nativeWidth,
+		nativeHeight = fields.nativeHeight,
+	}
+end
+local function fail(message)
+	return {
+		success = false,
+		error = `Capture transfer: {message}`,
+	}
+end
+local function discard(id)
+	local _id = id
+	local transfer = transfers[_id]
+	if transfer == nil then
+		return nil
+	end
+	local _id_1 = id
+	transfers[_id_1] = nil
+	if transfer.expiryThread ~= nil then
+		task.cancel(transfer.expiryThread)
+	end
+end
+local function prune()
+	local now = os.clock()
+	for id, transfer in transfers do
+		if now >= transfer.expiresAt then
+			discard(id)
+		end
+	end
+end
+local function release(data)
+	if not validId(data.transferId) then
+		return fail("invalid transfer ID")
+	end
+	discard(data.transferId)
+	-- Idempotent release also negotiates chunk support before capture starts.
+	return {
+		success = true,
+		chunkBytes = CHUNK_BYTES,
+	}
+end
+local validSize
+local function begin(data, capture)
+	prune()
+	local id = data.transferId
+	-- An older server cannot consume chunk descriptors. Let it use legacy
+	-- capture rather than returning an unsafe inline image or a hard error.
+	if id == nil then
+		return {
+			unavailable = "Client capture requires bounded transfer support",
+		}
+	end
+	if not validId(id) then
+		return fail("invalid transfer ID")
+	end
+	if transfers[id] ~= nil then
+		return fail("duplicate transfer ID")
+	end
+	-- Reserve before capture yields: concurrent captures cannot over-admit or
+	-- evict each other's data. Retained strings are capped at 2 * 64 MiB.
+	-- ▼ ReadonlyMap.size ▼
+	local _size = 0
+	for _ in transfers do
+		_size += 1
+	end
+	-- ▲ ReadonlyMap.size ▲
+	if _size >= MAX_TRANSFERS then
+		return fail("two captures are already in flight; release or await them first")
+	end
+	local transfer = {
+		offset = 0,
+		expiresAt = os.clock() + TRANSFER_TTL_SECONDS,
+	}
+	transfers[id] = transfer
+	-- Capture only the ID, not the large payload, in the expiry closure.
+	transfer.expiryThread = task.delay(TRANSFER_TTL_SECONDS, function()
+		local current = transfers[id]
+		if current ~= nil and os.clock() >= current.expiresAt then
+			current.expiryThread = nil
+			discard(id)
+		end
+	end)
+	local ok, result = pcall(capture)
+	if not ok then
+		if transfers[id] == transfer then
+			discard(id)
+		end
+		return fail(`capture failed: {tostring(result)}`)
+	end
+	if transfers[id] ~= transfer or os.clock() >= transfer.expiresAt then
+		if transfers[id] == transfer then
+			discard(id)
+		end
+		return fail("capture expired before it completed")
+	end
+	local info = metadata(result)
+	if info == nil then
+		discard(id)
+		-- Unavailability must reach core unchanged to preserve legacy fallback.
+		if type(result) == "table" then
+			local fields = result
+			local _unavailable = fields.unavailable
+			if type(_unavailable) == "string" then
+				return {
+					unavailable = string.sub(fields.unavailable, 1, 4096),
+				}
+			end
+			local _error = fields.error
+			if type(_error) == "string" then
+				return fail(string.sub(fields.error, 1, 4096))
+			end
+		end
+		return fail("invalid capture response")
+	end
+	local fields = result
+	local pixels = fields.data
+	if not (type(pixels) == "string") or not validSize(#pixels, info) then
+		discard(id)
+		return fail("invalid or oversized capture data")
+	end
+	transfer.data = pixels
+	return {
+		transferId = id,
+		totalBytes = #pixels,
+		chunkBytes = CHUNK_BYTES,
+		metadata = info,
+	}
+end
+function validSize(size, info)
+	if not integer(size, 4, MAX_TRANSFER_BYTES) or size % 4 ~= 0 then
+		return false
+	end
+	return info.encoding ~= "rgba8" or size == math.ceil(info.width * info.height * 4 / 3) * 4
+end
+local function read(data)
+	prune()
+	local id = data.transferId
+	if not validId(id) then
+		return fail("invalid transfer ID")
+	end
+	local transfer = transfers[id]
+	if transfer == nil then
+		return fail("unknown or expired transfer")
+	end
+	local pixels = transfer.data
+	local offset = data.offset
+	local length = data.length
+	if pixels == nil or not integer(offset, 0, #pixels - 1) or not integer(length, 1, CHUNK_BYTES) or offset ~= transfer.offset or length ~= math.min(CHUNK_BYTES, #pixels - offset) then
+		discard(id)
+		return fail("invalid chunk offset or length")
+	end
+	local _arg0 = offset + 1
+	local _arg1 = offset + length
+	local chunk = string.sub(pixels, _arg0, _arg1)
+	transfer.offset += length
+	-- Last read releases immediately, even if the receiver disappears before
+	-- its explicit release. Explicit release is idempotent for error paths.
+	if transfer.offset == #pixels then
+		discard(id)
+	end
+	return {
+		transferId = id,
+		offset = offset,
+		data = chunk,
+	}
+end
+local function receive(invoke, data)
+	local id = HttpService:GenerateGUID(false)
+	local ok, result = pcall(function()
+		-- Older clients return inline data and may disconnect on a large capture.
+		-- Probe a harmless release of our fresh ID before requesting any pixels.
+		local probe = invoke(RELEASE_ENDPOINT, {
+			transferId = id,
+		})
+		if not (type(probe) == "table") then
+			return {
+				unavailable = "Client capture lacks bounded transfer support",
+			}
+		end
+		local capability = probe
+		if capability.success ~= true or capability.chunkBytes ~= CHUNK_BYTES then
+			return {
+				unavailable = "Client capture lacks bounded transfer support",
+			}
+		end
+		local response = invoke("/api/capture-studio", {
+			encoding = data.encoding,
+			transferId = id,
+		})
+		if not (type(response) == "table") then
+			error("invalid transfer response")
+		end
+		local fields = response
+		local _unavailable = fields.unavailable
+		if type(_unavailable) == "string" then
+			return {
+				unavailable = string.sub(fields.unavailable, 1, 4096),
+			}
+		end
+		local _error = fields.error
+		if type(_error) == "string" then
+			error(string.sub(fields.error, 1, 4096))
+		end
+		local info = metadata(fields.metadata)
+		if info == nil or fields.transferId ~= id or fields.chunkBytes ~= CHUNK_BYTES or not validSize(fields.totalBytes, info) then
+			error("invalid transfer metadata or size")
+		end
+		local size = fields.totalBytes
+		local chunks = {}
+		local offset = 0
+		while offset < size do
+			local length = math.min(CHUNK_BYTES, size - offset)
+			local response = invoke(READ_ENDPOINT, {
+				transferId = id,
+				offset = offset,
+				length = length,
+			})
+			if not (type(response) == "table") then
+				error("invalid chunk response")
+			end
+			local chunk = response
+			local _error_1 = chunk.error
+			if type(_error_1) == "string" then
+				error(string.sub(chunk.error, 1, 4096))
+			end
+			local _condition = chunk.transferId ~= id or chunk.offset ~= offset
+			if not _condition then
+				local _data = chunk.data
+				_condition = not (type(_data) == "string")
+				if not _condition then
+					_condition = #chunk.data ~= length
+				end
+			end
+			if _condition then
+				error("chunk ID, offset or length mismatch")
+			end
+			local _data = chunk.data
+			table.insert(chunks, _data)
+			offset += length
+		end
+		return {
+			success = true,
+			encoding = info.encoding,
+			source = info.source,
+			width = info.width,
+			height = info.height,
+			nativeWidth = info.nativeWidth,
+			nativeHeight = info.nativeHeight,
+			data = table.concat(chunks, ""),
+		}
+	end)
+	-- The final read already frees successful transfers. Cleanup is best-effort:
+	-- it must not mask an unavailable signal from an older client or a completed
+	-- image. Failed partial transfers also have the bounded expiry above.
+	pcall(function()
+		return invoke(RELEASE_ENDPOINT, {
+			transferId = id,
+		})
+	end)
+	if not ok then
+		return fail(tostring(result))
+	end
+	return result
+end
+return {
+	READ_ENDPOINT = READ_ENDPOINT,
+	RELEASE_ENDPOINT = RELEASE_ENDPOINT,
+	begin = begin,
+	read = read,
+	release = release,
+	receive = receive,
+}
+]]></string>
+        </Properties>
+      </Item>
+      <Item class="ModuleScript" referent="4">
         <Properties>
           <string name="Name">ClientBroker</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -287,10 +607,12 @@ local HttpService = _services.HttpService
 local Players = _services.Players
 local ReplicatedStorage = _services.ReplicatedStorage
 local RunService = _services.RunService
+local Workspace = _services.Workspace
 local RuntimeLogBuffer = TS.import(script, script.Parent, "RuntimeLogBuffer")
 local MemoryHandlers = TS.import(script, script.Parent, "handlers", "MemoryHandlers")
 local SceneAnalysisHandlers = TS.import(script, script.Parent, "handlers", "SceneAnalysisHandlers")
 local CaptureHandlers = TS.import(script, script.Parent, "handlers", "CaptureHandlers")
+local CaptureTransfer = TS.import(script, script.Parent, "CaptureTransfer")
 local InputHandlers = TS.import(script, script.Parent, "handlers", "InputHandlers")
 local MetadataHandlers = TS.import(script, script.Parent, "handlers", "MetadataHandlers")
 local EvalRuntimeHandlers = TS.import(script, script.Parent, "handlers", "EvalRuntimeHandlers")
@@ -312,6 +634,11 @@ local mcpUrl = DEFAULT_MCP_URL
 local BROKER_NAME = "__MCPClientBroker"
 local BROKER_OWNER_ATTRIBUTE = "__MCPBrokerOwner"
 local CLIENT_IDENTITY_KIND = "identity"
+-- A normal capture needs at most 15s sampling + 5s waiting for profiler data.
+-- Leave room for processing, then return a diagnostic before the outer 30s wait.
+local CLIENT_PROFILER_MAX_WAIT_SECONDS = 25
+local CLIENT_PROFILER_RESPONSE_RESERVE_SECONDS = 5
+local CLIENT_PROFILER_POLL_SECONDS = 0.05
 -- Endpoints the server-peer broker is allowed to forward to the client peer.
 -- Each requires the client peer's plugin VM (because the buffer / require
 -- cache / etc. lives there) so the server peer alone can't satisfy them.
@@ -327,6 +654,8 @@ local CLIENT_BROKER_ALLOWED_ENDPOINTS = {
 	["/api/multiplayer-test-state"] = true,
 	["/api/multiplayer-test-leave-client"] = true,
 	["/api/capture-begin"] = true,
+	["/api/capture-studio"] = true,
+	["/api/capture-markers"] = true,
 	["/api/simulate-mouse-input"] = true,
 	["/api/simulate-keyboard-input"] = true,
 	["/api/focus-viewport"] = true,
@@ -514,6 +843,32 @@ local function setupClientBroker(attempt)
 			return BreakpointHandlers.breakpoints(payload.data or {})
 		end
 		if payload and payload.endpoint == "/api/capture-script-profiler" then
+			-- os.clock is VM-local. Only the engine-synchronized server clock can
+			-- reject an envelope that expired while travelling to this client.
+			local _remainingMs = payload.remainingMs
+			local _condition_1 = type(_remainingMs) == "number"
+			if _condition_1 then
+				_condition_1 = payload.remainingMs <= 0
+			end
+			local _condition_2 = _condition_1
+			if not _condition_2 then
+				local _expiresAtServerTime = payload.expiresAtServerTime
+				local _condition_3 = type(_expiresAtServerTime) == "number"
+				if _condition_3 then
+					_condition_3 = Workspace:GetServerTimeNow() >= payload.expiresAtServerTime
+				end
+				_condition_2 = _condition_3
+			end
+			if _condition_2 then
+				return {
+					success = false,
+					error = "client_broker_expired",
+					stage = "client_broker_pre_start",
+					requestId = payload.requestId,
+					executionOutcome = "not_executed",
+					message = "Client profiler request expired before capture started.",
+				}
+			end
 			return ScriptProfilerHandlers.captureScriptProfiler(payload.data or {})
 		end
 		if payload and payload.endpoint == "/api/capture-micro-profiler" then
@@ -528,6 +883,20 @@ local function setupClientBroker(attempt)
 		if payload and payload.endpoint == "/api/capture-begin" then
 			return CaptureHandlers.captureBegin()
 		end
+		if payload and payload.endpoint == "/api/capture-studio" then
+			return CaptureTransfer.begin(payload.data or {}, function()
+				return CaptureHandlers.captureStudio(payload.data or {})
+			end)
+		end
+		if payload and payload.endpoint == "/api/capture-markers" then
+			return CaptureHandlers.captureMarkers(payload.data or {})
+		end
+		if payload and payload.endpoint == CaptureTransfer.READ_ENDPOINT then
+			return CaptureTransfer.read(payload.data or {})
+		end
+		if payload and payload.endpoint == CaptureTransfer.RELEASE_ENDPOINT then
+			return CaptureTransfer.release(payload.data or {})
+		end
 		if payload and payload.endpoint == "/api/simulate-mouse-input" then
 			return InputHandlers.simulateMouseInput(payload.data or {})
 		end
@@ -800,7 +1169,112 @@ local function refreshAllProxyRegistrations()
 		task.spawn(registerProxyEntry, entry)
 	end
 end
-local function dispatchClientRequest(peerId, target, endpoint, data)
+local function invokeClientProfiler(entry, target, data, context)
+	local startedAt = os.clock()
+	local deadlineAt = math.min(context.deadlineAt - CLIENT_PROFILER_RESPONSE_RESERVE_SECONDS, startedAt + CLIENT_PROFILER_MAX_WAIT_SECONDS)
+	local failure = function(code, stage, outcome, detail)
+		context.executionOutcome = outcome
+		return {
+			success = false,
+			error = code,
+			stage = stage,
+			requestId = context.requestId,
+			peerId = entry.peerId,
+			target = target,
+			elapsedMs = math.floor(math.max(0, os.clock() - startedAt) * 1000),
+			executionOutcome = outcome,
+			message = if outcome == "unknown" then `{detail} Only the broker's local wait ended; remote execution may still be running. No retry was started.` else `{detail} Client profiler execution was not started.`,
+		}
+	end
+	if context.isCancelled() then
+		return failure("client_broker_cancelled", "client_broker_admission", "not_executed", "Request cancelled before client invocation.")
+	end
+	if startedAt >= deadlineAt then
+		return failure("client_broker_timeout", "client_broker_admission", "not_executed", "Insufficient request budget for client invocation and response delivery.")
+	end
+	local interrupted = function()
+		if context.isCancelled() then
+			return failure("client_broker_cancelled", "client_broker_wait", "unknown", "Request cancelled while awaiting the client profiler response.")
+		end
+		local _peerId = entry.peerId
+		local _condition = proxyByPeerId[_peerId] ~= entry
+		if not _condition then
+			local _player = entry.player
+			_condition = proxyByPlayer[_player] ~= entry
+			if not _condition then
+				_condition = entry.player.Parent == nil or entry.remote.Parent == nil or not RunService:IsRunning()
+			end
+		end
+		if _condition then
+			return failure("client_broker_disconnected", "client_broker_wait", "unknown", "Client proxy disconnected while awaiting the profiler response.")
+		end
+		if os.clock() >= deadlineAt then
+			return failure("client_broker_timeout", "client_broker_wait", "unknown", "Client profiler round-trip exceeded its response deadline.")
+		end
+		return nil
+	end
+	local remainingMs = math.max(0, math.floor((deadlineAt - os.clock()) * 1000))
+	local envelope = {
+		endpoint = "/api/capture-script-profiler",
+		data = data,
+		requestId = context.requestId,
+		remainingMs = remainingMs,
+		expiresAtServerTime = Workspace:GetServerTimeNow() + remainingMs / 1000,
+	}
+	local settled = false
+	local response
+	context.executionOutcome = "unknown"
+	local invocation = task.spawn(function()
+		local ok, result = pcall(function()
+			return entry.remote:InvokeClient(entry.player, envelope)
+		end)
+		-- Cancelling a suspended engine wait is best effort. A late return must
+		-- never replace the chosen outcome, even if task.cancel was unavailable.
+		if settled then
+			return nil
+		end
+		local interruption = interrupted()
+		if interruption ~= nil then
+			response = interruption
+		elseif not ok then
+			response = failure("client_broker_invoke_failed", "client_broker_wait", "unknown", `InvokeClient failed: {tostring(result)}`)
+		elseif result == nil then
+			response = failure("client_broker_nil_response", "client_broker_wait", "unknown", "Client profiler returned no response.")
+		else
+			response = result
+			-- Only this endpoint's broker pre-start refusal establishes that no
+			-- remote capture ran. Other responses retain normal handler outcome
+			-- classification; arbitrary payload fields cannot override transport.
+			context.executionOutcome = nil
+			if type(result) == "table" then
+				local reply = result
+				if reply.error == "client_broker_expired" and reply.stage == "client_broker_pre_start" then
+					context.executionOutcome = "not_executed"
+				end
+			end
+		end
+		settled = true
+	end)
+	while not settled do
+		local interruption = interrupted()
+		if interruption ~= nil then
+			response = interruption
+			settled = true
+			-- This only releases the local coroutine; it cannot stop the remote
+			-- OnClientInvoke callback or roll back an already-started capture.
+			pcall(function()
+				return task.cancel(invocation)
+			end)
+			break
+		end
+		task.wait(math.min(CLIENT_PROFILER_POLL_SECONDS, deadlineAt - os.clock()))
+	end
+	return response
+end
+local function dispatchClientRequest(peerId, target, endpoint, data, context)
+	if endpoint == "/api/capture-script-profiler" then
+		context.executionOutcome = "not_executed"
+	end
 	local _peerId = peerId
 	local entry = proxyByPeerId[_peerId]
 	local _condition = not entry
@@ -840,6 +1314,17 @@ local function dispatchClientRequest(peerId, target, endpoint, data)
 			error = `Client-proxy does not forward {endpoint}. Allowed: {table.concat(allowed, ", ")}.`,
 		}
 	end
+	if endpoint == "/api/capture-script-profiler" then
+		return invokeClientProfiler(entry, target, data, context)
+	end
+	if endpoint == "/api/capture-studio" then
+		return CaptureTransfer.receive(function(captureEndpoint, captureData)
+			return entry.remote:InvokeClient(entry.player, {
+				endpoint = captureEndpoint,
+				data = captureData,
+			})
+		end, data or {})
+	end
 	local envelope = {
 		endpoint = endpoint,
 		data = data,
@@ -920,7 +1405,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="4">
+      <Item class="ModuleScript" referent="5">
         <Properties>
           <string name="Name">Communication</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -988,8 +1473,10 @@ local routeMap = {
 	["/api/insert-asset"] = AssetHandlers.insertAsset,
 	["/api/preview-asset"] = AssetHandlers.previewAsset,
 	["/api/capture-screenshot"] = CaptureHandlers.captureScreenshot,
+	["/api/capture-studio"] = CaptureHandlers.captureStudio,
 	["/api/capture-begin"] = CaptureHandlers.captureBegin,
 	["/api/capture-read"] = CaptureHandlers.captureRead,
+	["/api/capture-markers"] = CaptureHandlers.captureMarkers,
 	["/api/simulate-mouse-input"] = InputHandlers.simulateMouseInput,
 	["/api/simulate-keyboard-input"] = InputHandlers.simulateKeyboardInput,
 	["/api/find-and-replace-in-scripts"] = ScriptHandlers.findAndReplaceInScripts,
@@ -1030,7 +1517,7 @@ local function getConnectionStatus()
 end
 local function dispatchSocketRequest(request, context)
 	if request.peerId ~= PluginSession.peerId then
-		return ClientBroker.dispatchClientRequest(request.peerId, request.target, request.endpoint, request.data)
+		return ClientBroker.dispatchClientRequest(request.peerId, request.target, request.endpoint, request.data, context)
 	end
 	local _condition = assignedRole
 	if _condition == nil then
@@ -1085,34 +1572,9 @@ local function handleTransportUpdate(update)
 	if not conn.isActive then
 		return nil
 	end
-	if update.state == "open" then
-		conn.lastHttpOk = true
-		conn.lastMcpOk = false
-		conn.consecutiveFailures = 0
-		conn.currentRetryDelay = 0.5
-		conn.mcpWaitStartTime = tick()
-	else
-		conn.lastHttpOk = false
-		conn.lastMcpOk = false
-		conn.consecutiveFailures = update.attempt
-		if update.retryDelay > 0 then
-			conn.currentRetryDelay = update.retryDelay
-		end
-		conn.mcpWaitStartTime = nil
-	end
+	State.applyTransportUpdate(update, tick())
 	UI.updateUIState()
 	UI.updateToolbarIcon()
-	if update.state == "waiting-duplicate" then
-		local ui = UI.getElements()
-		ui.statusLabel.Text = "Waiting for previous instance"
-		ui.statusLabel.TextColor3 = Color3.fromRGB(245, 158, 11)
-		local _condition = update.detail
-		if _condition == nil then
-			_condition = "The previous plugin instance is still active."
-		end
-		ui.detailStatusLabel.Text = _condition
-		ui.detailStatusLabel.TextColor3 = Color3.fromRGB(245, 158, 11)
-	end
 end
 local nameChangeConn
 local placeIdChangeConn
@@ -1163,6 +1625,7 @@ local function activatePlugin()
 	conn.lastHttpOk = false
 	conn.lastMcpOk = false
 	conn.mcpWaitStartTime = nil
+	State.clearTransportDiagnostics()
 	local normalizedUrl = ServerUrlSettings.normalizeServerUrl(ui.urlInput.Text)
 	conn.serverUrl = if normalizedUrl ~= "" then normalizedUrl else conn.serverUrl
 	if conn.serverUrl == "" then
@@ -1185,6 +1648,7 @@ local function activatePlugin()
 		onTransportUpdate = handleTransportUpdate,
 	})
 	if not conn.heartbeatConnection then
+		local lastDiagnosticUpdate = tick()
 		conn.heartbeatConnection = RunService.Heartbeat:Connect(function()
 			if initialRole == "server" and not RunService:IsRunning() then
 				ClientBroker.disconnectAllProxies()
@@ -1197,6 +1661,11 @@ local function activatePlugin()
 				PluginSession.invalidatePlaceName()
 				StudioWebSocket.refresh()
 			end
+			local now = tick()
+			if conn.nextRetryAt ~= nil and now - lastDiagnosticUpdate >= 0.25 then
+				lastDiagnosticUpdate = now
+				UI.updateUIState()
+			end
 		end)
 	end
 	if initialRole == "edit" then
@@ -1213,6 +1682,7 @@ function deactivatePlugin()
 	conn.lastHttpOk = false
 	conn.lastMcpOk = false
 	conn.mcpWaitStartTime = nil
+	State.clearTransportDiagnostics()
 	StudioWebSocket.stop()
 	disconnectIdentityWatchers()
 	if initialRole == "server" then
@@ -1276,7 +1746,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="5">
+      <Item class="ModuleScript" referent="6">
         <Properties>
           <string name="Name">CooperativeJobRunner</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -1351,7 +1821,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="6">
+      <Item class="ModuleScript" referent="7">
         <Properties>
           <string name="Name">EvalBridges</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -1472,9 +1942,9 @@ local function computeBridgeStamp()
 	for i = 1, #combined do
 		h = (h * 33 + (string.byte(combined, i))) % 2147483647
 	end
-	-- "3.1.3" is replaced with the package version at package time
+	-- "3.1.5" is replaced with the package version at package time
 	-- (scripts/build-plugin.mjs injectVersion), so a release bump also restamps.
-	return `{tostring(h)}-3.1.3`
+	return `{tostring(h)}-3.1.5`
 end
 local BRIDGE_STAMP = computeBridgeStamp()
 local function setSource(scriptInst, source)
@@ -1627,11 +2097,11 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="Folder" referent="7">
+      <Item class="Folder" referent="8">
         <Properties>
           <string name="Name">handlers</string>
         </Properties>
-        <Item class="ModuleScript" referent="8">
+        <Item class="ModuleScript" referent="9">
           <Properties>
             <string name="Name">AssetHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -2072,7 +2542,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="9">
+        <Item class="ModuleScript" referent="10">
           <Properties>
             <string name="Name">BreakpointHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -2579,7 +3049,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="10">
+        <Item class="ModuleScript" referent="11">
           <Properties>
             <string name="Name">CaptureHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -2587,11 +3057,35 @@ local TS = require(script.Parent.Parent.Parent.include.RuntimeLib)
 local RenderMonitor = TS.import(script, script.Parent.Parent, "RenderMonitor")
 local CaptureService = game:GetService("CaptureService")
 local AssetService = game:GetService("AssetService")
+local Workspace = game:GetService("Workspace")
+local CoreGui = game:GetService("CoreGui")
+local RunService = game:GetService("RunService")
 local MAX_TILE_SIZE = 1024
 local MAX_RAW_PIXEL_BYTES = 36 * 1024 * 1024
 local MAX_CREATED_IMAGE_DIM = 2048
 local BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 local PAD_BYTE = (string.byte("="))
+-- StudioCaptureService (Studio-only, PluginSecurity) is the fast path: it hands
+-- back the framebuffer directly, so it needs neither CaptureService's
+-- asynchronous callback nor an EditableImage round-trip — and it captures at
+-- ViewportSize, which is exactly the coordinate space simulate_mouse_input
+-- expects. It is gated behind Studio FFlags and is missing from @rbxts/types,
+-- hence the local structural declarations below.
+-- Studio exposes this API at runtime, but the installed @rbxts/types predates it.
+-- Unchecked cast, single reason: these enums exist in Studio but are missing
+-- from @rbxts/types, so the global Enum table has to be read dynamically.
+local ENUM_TABLE = Enum
+local STUDIO_CAPTURE_FORMATS = ENUM_TABLE.StudioCaptureScreenshotFormat
+local _FIT_TO_WINDOW = ENUM_TABLE.DeviceSimulatorScalingMode
+if _FIT_TO_WINDOW ~= nil then
+	_FIT_TO_WINDOW = _FIT_TO_WINDOW.FitToWindow
+end
+local FIT_TO_WINDOW = _FIT_TO_WINDOW
+-- Measured on a 1980x1032 viewport: RGBA8 completes in ~0.16s and PNG in ~1s.
+-- A capture that is still Pending well past that never completes (it happens
+-- while a playtest owns the renderer), so we stop waiting and let the caller
+-- fall back instead of stalling the tool call.
+local STUDIO_CAPTURE_TIMEOUT = 3
 local B64 = {}
 for i = 0, 63 do
 	B64[i + 1] = (string.byte(BASE64_CHARS, i + 1))
@@ -2701,7 +3195,11 @@ end
 -- pixels back is blocked, but capturing is not). The returned rbxtemp:// id is
 -- a process-scoped handle: it can be dereferenced from a DIFFERENT, more
 -- privileged DM (the edit DM) — see captureRead.
+local withViewportRead, captureScreenshotFrame
 local function doCaptureScreenshot()
+	return withViewportRead(captureScreenshotFrame)
+end
+function captureScreenshotFrame()
 	-- Fast-fail with a clear reason if the window isn't rendering — otherwise
 	-- CaptureScreenshot's callback never fires and we'd block for the full 10s.
 	local notRendering = RenderMonitor.notRenderingReason()
@@ -2737,8 +3235,12 @@ local function readContentToBase64(contentId)
 		return AssetService:CreateEditableImageAsync(Content.fromUri(contentId))
 	end)
 	if not editableOk then
+		-- Lead with Roblox's own message: the Game Settings toggle is only one of
+		-- the reasons this can fail (temporary-texture privilege and multiplayer
+		-- client handles are others), and telling someone who already enabled
+		-- it to enable it again is a dead end.
 		return {
-			error = `Failed to create EditableImage from screenshot. Enable EditableImage API: Game Settings > Security > 'Allow Mesh / Image APIs'. ({tostring(editableResult)})`,
+			error = `Failed to create EditableImage from screenshot: {tostring(editableResult)}. ` .. "If that mentions permissions, check Game Settings > Security > 'Allow Mesh / Image APIs'.",
 		}
 	end
 	local sourceImage = editableResult
@@ -2789,6 +3291,130 @@ local function readContentToBase64(contentId)
 		nativeHeight = nativeH,
 	}
 end
+local cachedStudioService
+local function getStudioCaptureService()
+	if cachedStudioService ~= nil then
+		return cachedStudioService
+	end
+	-- Unchecked cast, single reason: StudioCaptureService is absent from
+	-- @rbxts/types, so GetService cannot be called through the typed overload.
+	local dynamicGame = game
+	local ok, service = pcall(function()
+		return dynamicGame:GetService("StudioCaptureService")
+	end)
+	if not ok or service == nil then
+		return nil
+	end
+	cachedStudioService = service
+	return cachedStudioService
+end
+-- Captures through StudioCaptureService. Returns undefined when the service
+-- cannot capture right now (missing FFlag, permission not granted, or this
+-- DataModel is not the active one) so the caller can fall back to the
+-- CaptureService + EditableImage path.
+local captureStudioFrame
+local function doStudioCapture(wantPng)
+	return withViewportRead(function()
+		return captureStudioFrame(wantPng)
+	end)
+end
+function captureStudioFrame(wantPng)
+	if STUDIO_CAPTURE_FORMATS == nil then
+		return nil
+	end
+	local service = getStudioCaptureService()
+	if service == nil then
+		return nil
+	end
+	local canOk, can = pcall(function()
+		return service:CanCaptureScreenshot()
+	end)
+	if not canOk or can ~= true then
+		return nil
+	end
+	local camera = Workspace.CurrentCamera
+	if camera == nil then
+		return nil
+	end
+	local viewport = camera.ViewportSize
+	local nativeW = math.max(1, math.floor(viewport.X))
+	local nativeH = math.max(1, math.floor(viewport.Y))
+	local w = nativeW
+	local h = nativeH
+	-- Raw RGBA rides back base64-encoded, so an oversized viewport is
+	-- downscaled by the engine during the capture itself — no second pass.
+	if not wantPng and nativeW * nativeH * 4 > MAX_RAW_PIXEL_BYTES then
+		local scale = math.sqrt(MAX_RAW_PIXEL_BYTES / (nativeW * nativeH * 4))
+		w = math.max(1, math.floor(nativeW * scale))
+		h = math.max(1, math.floor(nativeH * scale))
+	end
+	-- CaptureSize is a framebuffer crop, not the logical viewport size. At
+	-- fractional display scaling it cuts off the right/bottom of the frame.
+	local options = {
+		OutputSize = Vector2.new(w, h),
+		ResampleMode = Enum.ResamplerMode.Default,
+		Format = if wantPng then STUDIO_CAPTURE_FORMATS.PNG else STUDIO_CAPTURE_FORMATS.RGBA8,
+	}
+	local captureOk, captureResult = pcall(function()
+		return service:CaptureScreenshot(options)
+	end)
+	if not captureOk then
+		return {
+			error = `StudioCaptureService:CaptureScreenshot failed: {tostring(captureResult)}`,
+		}
+	end
+	if captureResult == nil then
+		return nil
+	end
+	local capture = captureResult
+	local startTime = tick()
+	while capture.BufferStatus.Name == "Pending" or capture.BufferStatus.Name == "NotStarted" do
+		if tick() - startTime > STUDIO_CAPTURE_TIMEOUT then
+			return nil
+		end
+		task.wait(0.02)
+	end
+	if capture.BufferStatus.Name ~= "Ready" then
+		local errorsOk, errors = pcall(function()
+			return capture:GetErrors()
+		end)
+		local detail = if errorsOk then game:GetService("HttpService"):JSONEncode(errors) else "unavailable"
+		return {
+			error = `StudioCaptureService capture failed (status {capture.BufferStatus.Name}): {detail}`,
+		}
+	end
+	local bufferOk, captureBuffer = pcall(function()
+		return capture:GetBuffer()
+	end)
+	if not bufferOk then
+		return {
+			error = `StudioCaptureService:GetBuffer failed: {tostring(captureBuffer)}`,
+		}
+	end
+	local resolution = capture.Resolution
+	return {
+		success = true,
+		encoding = if wantPng then "png" else "rgba8",
+		source = "StudioCaptureService",
+		width = math.max(1, math.floor(resolution.X)),
+		height = math.max(1, math.floor(resolution.Y)),
+		nativeWidth = nativeW,
+		nativeHeight = nativeH,
+		data = encodeBase64(captureBuffer),
+	}
+end
+-- Studio-only capture endpoint. Reports `unavailable` (instead of an error) so
+-- the server can fall back to the legacy CaptureService path.
+local function captureStudio(requestData)
+	local wantPng = requestData.encoding == "png"
+	local result = doStudioCapture(wantPng)
+	if result == nil then
+		return {
+			unavailable = "StudioCaptureService cannot capture this DataModel right now",
+		}
+	end
+	return result
+end
 -- Edit-mode single shot: capture and read back in the same (edit) context.
 local function captureScreenshotData()
 	local cap = doCaptureScreenshot()
@@ -2814,16 +3440,382 @@ local function captureRead(requestData)
 	end
 	return readContentToBase64(contentId)
 end
+-- Viewport corner markers for the host-side window capture fallback.
+--
+-- Roblox's own capture APIs can be unavailable for the play viewport:
+-- StudioCaptureService reports CanCaptureScreenshot() == false in the play
+-- client (RequestScreenshotPermissionAsync raises "Feature not supported
+-- yet"), and CaptureService:CaptureScreenshot hands back a fully black frame
+-- there on some Studio builds (observed with the Vulkan renderer). When that
+-- happens the MCP server grabs the whole Studio window through the host OS
+-- instead and needs to know where the 3D viewport sits inside that window.
+-- Four small magenta squares pinned to the viewport corners give it an exact,
+-- DPI-independent answer; the server hides them again before the real capture.
+local MARKER_GUI_NAME = "__MCPCaptureMarkers"
+local MARKER_SIZE = 12
+local MARKER_COLOR = Color3.fromRGB(255, 0, 255)
+-- Safety net: the server always hides the markers itself, but if it dies
+-- mid-capture the viewport must not stay decorated.
+local MARKER_AUTO_HIDE_SECONDS = 15
+local MARKER_RENDER_FRAMES = 3
+local MARKER_RENDER_TIMEOUT = 2
+local CAPTURE_AUTO_FINISH_SECONDS = 60
+local VIEWPORT_ACQUIRE_TIMEOUT = 25
+local activeMarkerCapture
+local activeViewportReads = 0
+function withViewportRead(readFrame)
+	local start = os.clock()
+	while activeMarkerCapture ~= nil do
+		if os.clock() - start >= VIEWPORT_ACQUIRE_TIMEOUT then
+			return {
+				error = "Timed out waiting for the active host capture to restore the viewport; retry capture.",
+			}
+		end
+		task.wait(0.03)
+	end
+	-- No yield between observing the writer and acquiring this reader.
+	activeViewportReads += 1
+	local ok, result = pcall(readFrame)
+	activeViewportReads -= 1
+	if not ok then
+		return {
+			error = `Viewport capture failed: {tostring(result)}`,
+		}
+	end
+	return result
+end
+local function markerAccessError(action, captureId)
+	local capture = activeMarkerCapture
+	if captureId ~= nil then
+		local _captureId = captureId
+		local _condition = not (type(_captureId) == "string")
+		if not _condition then
+			_condition = captureId == ""
+		end
+		if _condition then
+			return "A non-empty captureId is required."
+		end
+		if capture == nil or capture.captureId ~= captureId or capture.expired then
+			return "The host capture token is stale or expired; discard this capture and prepare a new transaction."
+		end
+		if capture.busy then
+			return "The host capture is still preparing or restoring; retry after that operation completes."
+		end
+	elseif capture ~= nil and (action == "show" or action == "hide") then
+		return "An active host capture owns the viewport markers; supply its captureId."
+	end
+	return nil
+end
+local function viewportSize()
+	local camera = Workspace.CurrentCamera
+	if camera == nil then
+		return nil
+	end
+	local viewport = camera.ViewportSize
+	return {
+		viewportWidth = math.max(1, math.floor(viewport.X)),
+		viewportHeight = math.max(1, math.floor(viewport.Y)),
+	}
+end
+local function hideMarkers()
+	local existing = CoreGui:FindFirstChild(MARKER_GUI_NAME)
+	if existing ~= nil then
+		existing:Destroy()
+	end
+end
+-- Blocks until the markers have been composited into a few rendered frames
+-- (bounded, so a non-rendering window cannot hang the request).
+local function waitForRenderedFrames()
+	local frames = 0
+	local ok, connection = pcall(function()
+		return RunService.RenderStepped:Connect(function()
+			frames += 1
+		end)
+	end)
+	if not ok then
+		return 0
+	end
+	local start = os.clock()
+	while frames < MARKER_RENDER_FRAMES and os.clock() - start < MARKER_RENDER_TIMEOUT do
+		task.wait(0.03)
+	end
+	connection:Disconnect()
+	return frames
+end
+local function finishMarkerCapture(captureId)
+	local capture = activeMarkerCapture
+	-- A delayed retry or safety callback must never touch another capture's GUI.
+	if capture == nil or capture.captureId ~= captureId then
+		return {
+			success = true,
+			captureId = captureId,
+			stale = true,
+		}
+	end
+	if capture.busy then
+		return {
+			error = "Host capture is still preparing or restoring; retry finish with the same captureId.",
+			captureId = captureId,
+		}
+	end
+	capture.busy = true
+	local ok, failure = pcall(function()
+		hideMarkers()
+		local simulator = capture.simulator
+		local originalMode = capture.scalingMode
+		if capture.restorePending and simulator ~= nil and originalMode ~= nil then
+			-- Never switch devices or overwrite a mode the user changed mid-capture.
+			if simulator:GetDeviceAsync() == capture.deviceId and simulator:GetScalingModeAsync() == FIT_TO_WINDOW and simulator:GetDeviceAsync() == capture.deviceId then
+				simulator:SetScalingModeAsync(originalMode)
+				-- A minimized window may not render; the restored mode still releases
+				-- the transaction so the next capture can proceed when it is visible.
+				waitForRenderedFrames()
+			end
+			capture.restorePending = false
+		end
+	end)
+	capture.busy = false
+	if not ok then
+		return {
+			error = `Could not finish host capture or restore device scaling: {tostring(failure)} Retry finish with captureId {captureId}, or restore the simulator scaling mode manually.`,
+			captureId = captureId,
+		}
+	end
+	activeMarkerCapture = nil
+	return {
+		success = true,
+		captureId = captureId,
+	}
+end
+local function prepareMarkerCapture()
+	local start = os.clock()
+	while activeMarkerCapture ~= nil or activeViewportReads > 0 do
+		if os.clock() - start >= VIEWPORT_ACQUIRE_TIMEOUT then
+			return {
+				error = "Timed out waiting for another viewport capture to finish; retry host capture.",
+			}
+		end
+		task.wait(0.03)
+	end
+	local notRendering = RenderMonitor.notRenderingReason()
+	if notRendering ~= nil then
+		return {
+			error = notRendering,
+		}
+	end
+	local size = viewportSize()
+	if size == nil then
+		return {
+			error = "No CurrentCamera; cannot prepare host capture.",
+		}
+	end
+	local capture = {
+		captureId = game:GetService("HttpService"):GenerateGUID(false),
+		restorePending = false,
+		busy = true,
+		expired = false,
+	}
+	activeMarkerCapture = capture
+	task.delay(CAPTURE_AUTO_FINISH_SECONDS, function()
+		if activeMarkerCapture ~= capture then
+			return nil
+		end
+		capture.expired = true
+		-- A yielding prepare owns the state until it resumes and rolls back.
+		if capture.busy then
+			return nil
+		end
+		local result = finishMarkerCapture(capture.captureId)
+		if result.error ~= nil then
+			warn(result.error)
+		end
+	end)
+	local ok, failure = pcall(function()
+		-- Unchecked cast: the live simulator service is missing from this SDK's
+		-- GetService overloads; the structural return type describes only APIs used here.
+		local dynamicGame = game
+		local simulator = dynamicGame:GetService("StudioDeviceSimulatorService")
+		capture.simulator = simulator
+		capture.deviceId = simulator:GetDeviceAsync()
+		if capture.deviceId == "default" then
+			return nil
+		end
+		if FIT_TO_WINDOW == nil then
+			error("Studio does not expose DeviceSimulatorScalingMode.FitToWindow; update Studio before capturing a simulated viewport.")
+		end
+		local scalingMode = simulator:GetScalingModeAsync()
+		capture.scalingMode = scalingMode
+		if scalingMode == FIT_TO_WINDOW then
+			return nil
+		end
+		if simulator:GetScalingModeAsync() ~= scalingMode or simulator:GetDeviceAsync() ~= capture.deviceId then
+			error("The simulated device or scaling mode changed while preparing host capture; retry after the device settles.")
+		end
+		if capture.expired then
+			error("Host capture preparation expired.")
+		end
+		-- Set before the yielding setter: a setter failure can still have changed Studio.
+		capture.restorePending = true
+		simulator:SetScalingModeAsync(FIT_TO_WINDOW)
+		if waitForRenderedFrames() < MARKER_RENDER_FRAMES then
+			local _condition = RenderMonitor.notRenderingReason()
+			if _condition == nil then
+				_condition = "The fitted viewport did not render in time; restore the Studio window and retry."
+			end
+			error(_condition)
+		end
+		if simulator:GetDeviceAsync() ~= capture.deviceId or simulator:GetScalingModeAsync() ~= FIT_TO_WINDOW then
+			error("The simulated device or scaling mode changed while fitting the viewport; retry after the device settles.")
+		end
+	end)
+	capture.busy = false
+	if not ok or capture.expired then
+		local restored = finishMarkerCapture(capture.captureId)
+		local detail = if ok then "Host capture preparation expired." else tostring(failure)
+		return {
+			error = `Could not prepare host capture: {detail}{if restored.error ~= nil then ` {restored.error}` else ""}`,
+			captureId = capture.captureId,
+		}
+	end
+	-- Fitting can round 1200 logical pixels to 1199: keep the pre-fit dimensions
+	-- for the server's final image, while show/query report the actual fitted camera.
+	local _object = {
+		success = true,
+		captureId = capture.captureId,
+		viewportChanged = capture.restorePending,
+	}
+	for _k, _v in size do
+		_object[_k] = _v
+	end
+	return _object
+end
+local function showMarkers(captureId)
+	hideMarkers()
+	local size = viewportSize()
+	if size == nil then
+		return {
+			error = "No CurrentCamera; cannot place viewport markers.",
+		}
+	end
+	local gui = Instance.new("ScreenGui")
+	gui.Name = MARKER_GUI_NAME
+	gui.IgnoreGuiInset = true
+	gui.ScreenInsets = Enum.ScreenInsets.None
+	gui.DisplayOrder = 2147483647
+	gui.ResetOnSpawn = false
+	gui.ZIndexBehavior = Enum.ZIndexBehavior.Global
+	local corners = { { 0, 0 }, { 1, 0 }, { 0, 1 }, { 1, 1 } }
+	for _, _binding in corners do
+		local x = _binding[1]
+		local y = _binding[2]
+		local frame = Instance.new("Frame")
+		frame.Name = `Corner{x}{y}`
+		frame.AnchorPoint = Vector2.new(x, y)
+		frame.Position = UDim2.fromScale(x, y)
+		frame.Size = UDim2.fromOffset(MARKER_SIZE, MARKER_SIZE)
+		frame.BackgroundColor3 = MARKER_COLOR
+		frame.BackgroundTransparency = 0
+		frame.BorderSizePixel = 0
+		frame.ZIndex = 2147483647
+		frame.Parent = gui
+	end
+	gui.Parent = CoreGui
+	task.delay(MARKER_AUTO_HIDE_SECONDS, function()
+		if gui.Parent ~= nil then
+			gui:Destroy()
+		end
+	end)
+	local framesRendered = waitForRenderedFrames()
+	local accessError = markerAccessError("show", captureId)
+	if accessError ~= nil then
+		gui:Destroy()
+		return {
+			error = accessError,
+		}
+	end
+	local renderedSize = viewportSize()
+	if renderedSize == nil then
+		gui:Destroy()
+		return {
+			error = "No CurrentCamera after rendering viewport markers.",
+		}
+	end
+	local _object = {
+		success = true,
+	}
+	for _k, _v in renderedSize do
+		_object[_k] = _v
+	end
+	_object.markerSize = MARKER_SIZE
+	_object.framesRendered = framesRendered
+	return _object
+end
+-- prepare temporarily fits a simulated viewport; finish restores it after the
+-- clean host grab. hide only removes markers: restoring here would clip that grab.
+-- show/query report the current camera dimensions, not prepare's original size.
+local function captureMarkers(requestData)
+	local action = requestData.action
+	if action == "prepare" then
+		return prepareMarkerCapture()
+	end
+	if action == "finish" then
+		local captureId = requestData.captureId
+		if not (type(captureId) == "string") or captureId == "" then
+			return {
+				error = 'capture-markers action "finish" requires a non-empty captureId.',
+			}
+		end
+		return finishMarkerCapture(captureId)
+	end
+	if action == "show" or action == "hide" or action == "query" then
+		local accessError = markerAccessError(action, requestData.captureId)
+		if accessError ~= nil then
+			return {
+				error = accessError,
+			}
+		end
+	end
+	if action == "show" then
+		return showMarkers(requestData.captureId)
+	end
+	if action == "hide" then
+		hideMarkers()
+		return {
+			success = true,
+		}
+	end
+	if action == "query" then
+		local size = viewportSize()
+		if size == nil then
+			return {
+				error = "No CurrentCamera; cannot read viewport size.",
+			}
+		end
+		local _object = {
+			success = true,
+		}
+		for _k, _v in size do
+			_object[_k] = _v
+		end
+		_object.markerSize = MARKER_SIZE
+		return _object
+	end
+	return {
+		error = `capture-markers action must be "prepare", "finish", "show", "hide" or "query" (got {tostring(action)})`,
+	}
+end
 return {
 	captureScreenshotData = captureScreenshotData,
 	captureScreenshot = captureScreenshot,
+	captureStudio = captureStudio,
 	captureBegin = captureBegin,
 	captureRead = captureRead,
+	captureMarkers = captureMarkers,
 }
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="11">
+        <Item class="ModuleScript" referent="12">
           <Properties>
             <string name="Name">EvalRuntimeHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -2977,7 +3969,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="12">
+        <Item class="ModuleScript" referent="13">
           <Properties>
             <string name="Name">GenerateModelHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -3182,7 +4174,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="13">
+        <Item class="ModuleScript" referent="14">
           <Properties>
             <string name="Name">InputHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -3382,7 +4374,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="14">
+        <Item class="ModuleScript" referent="15">
           <Properties>
             <string name="Name">LogHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -3404,7 +4396,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="15">
+        <Item class="ModuleScript" referent="16">
           <Properties>
             <string name="Name">MemoryHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -3472,7 +4464,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="16">
+        <Item class="ModuleScript" referent="17">
           <Properties>
             <string name="Name">MetadataHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -3829,7 +4821,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="17">
+        <Item class="ModuleScript" referent="18">
           <Properties>
             <string name="Name">MicroProfilerHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -4402,6 +5394,16 @@ local function captureMicroProfiler(requestData)
 			backend = backend,
 		}
 	end
+	local frameLimitOk, frameLimitResult = safeCall(function()
+		return LibMP.Control:SetFrameLimit(math.min(frameWindow, 256))
+	end)
+	if not frameLimitOk then
+		return {
+			error = "micro_profiler_frame_limit_failed",
+			message = tostring(frameLimitResult),
+			backend = backend,
+		}
+	end
 	local profilerOk, profilerResult = safeCall(function()
 		return LibMP.Control:EnableProfiler(true)
 	end)
@@ -4423,6 +5425,11 @@ local function captureMicroProfiler(requestData)
 		}
 	end
 	task.wait(durationMs / 1000)
+	-- Active reads synchronize the engine's data; paused reads can return an
+	-- empty or stale cache. Export first, then pause, including on export failure.
+	local bufferOk, snapshotOrErr = safeCall(function()
+		return LibMP.Control:CaptureToBufferSync()
+	end)
 	local captureStopOk, captureStopResult = safeCall(function()
 		return LibMP.Control:EnableCapture(false)
 	end)
@@ -4433,9 +5440,6 @@ local function captureMicroProfiler(requestData)
 			backend = backend,
 		}
 	end
-	local bufferOk, snapshotOrErr = safeCall(function()
-		return LibMP.Control:CaptureToBufferSync()
-	end)
 	if not bufferOk then
 		return {
 			error = "micro_profiler_snapshot_failed",
@@ -5582,7 +6586,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="18">
+        <Item class="ModuleScript" referent="19">
           <Properties>
             <string name="Name">PropertyHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -5667,6 +6671,7 @@ local function setProperties(requestData)
 	-- execute_luau edits as well, even when every assignment in this call failed.
 	finishRecording(recordingId, true)
 	return {
+		success = failureCount == 0,
 		instancePath = instancePath,
 		summary = {
 			total = successCount + failureCount,
@@ -5682,7 +6687,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="19">
+        <Item class="ModuleScript" referent="20">
           <Properties>
             <string name="Name">QueryHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -6337,7 +7342,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="20">
+        <Item class="ModuleScript" referent="21">
           <Properties>
             <string name="Name">SceneAnalysisHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -6586,7 +7591,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="21">
+        <Item class="ModuleScript" referent="22">
           <Properties>
             <string name="Name">ScriptHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -7258,7 +8263,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="22">
+        <Item class="ModuleScript" referent="23">
           <Properties>
             <string name="Name">ScriptProfilerHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -7721,7 +8726,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="23">
+        <Item class="ModuleScript" referent="24">
           <Properties>
             <string name="Name">SerializationHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -7907,7 +8912,7 @@ return {
 ]]></string>
           </Properties>
         </Item>
-        <Item class="ModuleScript" referent="24">
+        <Item class="ModuleScript" referent="25">
           <Properties>
             <string name="Name">TestHandlers</string>
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -8034,6 +9039,7 @@ local function stopPlaytest(_requestData)
 	-- Signal the play-server DM's StopPlayMonitor via plugin:SetSetting.
 	-- The monitor acknowledges with the matching request id only after its
 	-- StudioTestService:EndTest call returns from pcall.
+	local hadActivePlaytest = testRunning or not StudioTestService.EditModeActive
 	local stopRequest = StopPlayMonitor.requestStop()
 	if not stopRequest.ok or stopRequest.requestId == nil then
 		return {
@@ -8056,6 +9062,15 @@ local function stopPlaytest(_requestData)
 		-- Either way clean up the pending request so a future playtest's monitor
 		-- doesn't fire EndTest on startup against a stale signal.
 		StopPlayMonitor.clearPending(stopRequest.requestId)
+		-- Settings acknowledgement can be lost as the server VM exits. Reconcile
+		-- only a playtest observed at entry, and only after both native teardown
+		-- and the tracked execution have finished. Never mask an EndTest error.
+		if not consumption.consumed and hadActivePlaytest and not testRunning and StudioTestService.EditModeActive then
+			return {
+				success = true,
+				message = "Playtest stopped.",
+			}
+		end
 		if testRunning then
 			return {
 				error = "Playtest stop signal failed or was not acknowledged. " .. "The playtest may have ended anyway; check get_connected_instances.",
@@ -8298,7 +9313,7 @@ return {
           </Properties>
         </Item>
       </Item>
-      <Item class="ModuleScript" referent="25">
+      <Item class="ModuleScript" referent="26">
         <Properties>
           <string name="Name">HttpDiagnostics</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -8379,7 +9394,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="26">
+      <Item class="ModuleScript" referent="27">
         <Properties>
           <string name="Name">LuauExec</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -8813,7 +9828,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="27">
+      <Item class="ModuleScript" referent="28">
         <Properties>
           <string name="Name">PeerRole</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -8834,7 +9849,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="28">
+      <Item class="ModuleScript" referent="29">
         <Properties>
           <string name="Name">PluginSession</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -9023,7 +10038,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="29">
+      <Item class="ModuleScript" referent="30">
         <Properties>
           <string name="Name">Recording</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -9053,7 +10068,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="30">
+      <Item class="ModuleScript" referent="31">
         <Properties>
           <string name="Name">RenderMonitor</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -9121,7 +10136,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="31">
+      <Item class="ModuleScript" referent="32">
         <Properties>
           <string name="Name">RuntimeLogBuffer</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -9357,7 +10372,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="32">
+      <Item class="ModuleScript" referent="33">
         <Properties>
           <string name="Name">ScriptSearch</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -9684,7 +10699,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="33">
+      <Item class="ModuleScript" referent="34">
         <Properties>
           <string name="Name">ServerUrlSettings</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -9823,13 +10838,14 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="34">
+      <Item class="ModuleScript" referent="35">
         <Properties>
           <string name="Name">State</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
-local CURRENT_VERSION = "3.1.3"
+local CURRENT_VERSION = "3.1.5"
 local PLUGIN_VARIANT = "inspector"
 local BASE_PORT = 58741
+local SENSITIVE_DIAGNOSTIC_TERMS = { "token", "authorization", "bearer", "password", "cookie", "secret" }
 local function createConnection(port)
 	return {
 		port = port,
@@ -9848,16 +10864,123 @@ local connection = createConnection(BASE_PORT)
 local function getActiveConnection()
 	return connection
 end
+local function clearTransportDiagnostics()
+	connection.transportState = nil
+	connection.transportAttempt = nil
+	connection.transportDetail = nil
+	connection.lastTransportFailure = nil
+	connection.nextRetryAt = nil
+end
+local function sanitizeTransportDetail(detail)
+	-- Transport emits credential-free stage descriptions; also defend the UI
+	-- against accidental raw errors, URLs, markup, and multiline responses.
+	local lower = string.lower(detail)
+	for _, sensitive in SENSITIVE_DIAGNOSTIC_TERMS do
+		if (string.find(lower, sensitive, 1, true)) ~= nil then
+			return "Connection failed (sensitive details hidden)."
+		end
+	end
+	local plain = string.gsub(detail, "%w+://%S+", "[address hidden]")
+	plain = string.gsub(plain, "%c", " ")
+	plain = string.gsub(plain, "<[^>]*>", "")
+	plain = string.gsub(plain, "%s+", " ")
+	return if #plain > 180 then `{string.sub(plain, 1, 177)}...` else plain
+end
+local function applyTransportUpdate(update, now)
+	if not connection.isActive then
+		return nil
+	end
+	if update.state == "open" then
+		clearTransportDiagnostics()
+		connection.lastHttpOk = true
+		connection.lastMcpOk = false
+		connection.consecutiveFailures = 0
+		connection.currentRetryDelay = 0.5
+		connection.mcpWaitStartTime = now
+		return nil
+	end
+	connection.lastHttpOk = false
+	connection.lastMcpOk = false
+	connection.consecutiveFailures = update.attempt
+	connection.mcpWaitStartTime = nil
+	local previousState = connection.transportState
+	connection.transportState = update.state
+	connection.transportAttempt = update.attempt
+	if update.detail ~= nil then
+		connection.transportDetail = sanitizeTransportDetail(update.detail)
+	elseif update.state ~= "connecting" or previousState ~= "connecting" then
+		connection.transportDetail = nil
+	end
+	if update.state == "retrying" or update.state == "waiting-duplicate" then
+		local _condition = connection.transportDetail
+		if _condition == nil then
+			_condition = "Connection attempt failed."
+		end
+		connection.lastTransportFailure = _condition
+		connection.currentRetryDelay = update.retryDelay
+		connection.nextRetryAt = now + update.retryDelay
+	else
+		connection.nextRetryAt = nil
+	end
+end
+local function getTransportDiagnostics(now)
+	if not connection.isActive then
+		return {
+			status = "Disconnected",
+			detail = "",
+		}
+	end
+	if connection.lastHttpOk then
+		return if connection.lastMcpOk then {
+			status = "Connected",
+			detail = "Listener: connected  MCP client: connected",
+		} else {
+			status = "Waiting for MCP client",
+			detail = "Listener: connected  MCP client: not connected",
+		}
+	end
+	local _condition = connection.transportAttempt
+	if _condition == nil then
+		_condition = 0
+	end
+	local attempt = _condition + 1
+	local failure = connection.lastTransportFailure
+	if connection.nextRetryAt ~= nil then
+		local remaining = math.max(0, math.ceil((connection.nextRetryAt - now) * 10) / 10)
+		local _object = {
+			status = if connection.transportState == "waiting-duplicate" then "Waiting for previous instance" else "Listener disconnected",
+		}
+		local _left = "detail"
+		local _condition_1 = failure
+		if _condition_1 == nil then
+			_condition_1 = "Connection attempt failed."
+		end
+		_object[_left] = `Retry attempt {attempt} in {remaining}s\n{_condition_1}`
+		return _object
+	end
+	local _condition_1 = connection.transportDetail
+	if _condition_1 == nil then
+		_condition_1 = "Starting listener connection"
+	end
+	local stage = _condition_1
+	return {
+		status = `Connecting (attempt {attempt})`,
+		detail = if failure ~= nil then `{stage}\nLast failure: {failure}` else stage,
+	}
+end
 return {
 	CURRENT_VERSION = CURRENT_VERSION,
 	PLUGIN_VARIANT = PLUGIN_VARIANT,
 	BASE_PORT = BASE_PORT,
 	getActiveConnection = getActiveConnection,
+	clearTransportDiagnostics = clearTransportDiagnostics,
+	applyTransportUpdate = applyTransportUpdate,
+	getTransportDiagnostics = getTransportDiagnostics,
 }
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="35">
+      <Item class="ModuleScript" referent="36">
         <Properties>
           <string name="Name">StopPlayMonitor</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -9871,6 +10994,10 @@ local RunService = _services.RunService
 local PluginSession = TS.import(script, script.Parent, "PluginSession")
 local StudioTestService = game:GetService("StudioTestService")
 local SETTING_KEY_PREFIX = "MCP_STOP_PLAY_"
+local RESULT_KEY_SUFFIX = "_RESULT"
+-- Capture before registration yields. Requests from an earlier runtime must
+-- never stop a newly created play session, even if clearing settings was lost.
+local moduleLoadedAt = tick()
 -- Keep this conservative. plugin:GetSetting is backed by Studio's plugin
 -- settings store, and this monitor runs during every play session, including
 -- manually-started Play. The official reference implementation polls at 1s.
@@ -9883,9 +11010,14 @@ local POLL_INTERVAL_SEC = 1
 local WAIT_FOR_CONSUMPTION_TIMEOUT_SEC = 8.0
 local WAIT_POLL_SEC = 0.1
 local REQUEST_TTL_SEC = 12.0
+-- Plugin settings can silently lose writes when other Studio windows use the
+-- same plugin. Redeliver the same request, without extending its deadline/TTL.
+local RETRY_INTERVAL_SEC = 1
 local pluginRef
 local endTestIssued = false
 local transportLifecycle
+local pendingRequest
+local lastResult
 local function init(p)
 	pluginRef = p
 end
@@ -9948,14 +11080,21 @@ local function writePayload(key, payload)
 	return writeSetting(key, encoded)
 end
 local function writeResult(key, request, ok, errText)
-	writePayload(key, {
+	local payload = {
 		kind = "result",
 		id = request.id,
 		requestedAt = request.requestedAt,
 		consumedAt = tick(),
 		ok = ok,
 		error = errText,
-	})
+	}
+	-- Cache before publishing: a lost acknowledgement must not issue EndTest a
+	-- second time or turn a successful duplicate into an "already issued" error.
+	lastResult = {
+		key = key,
+		payload = payload,
+	}
+	writePayload(key .. RESULT_KEY_SUFFIX, payload)
 end
 local function handleStopRequest(key, request)
 	local _condition = request.kind ~= "request"
@@ -9972,10 +11111,14 @@ local function handleStopRequest(key, request)
 		return nil
 	end
 	local age = tick() - request.requestedAt
-	if age < -5 or age > REQUEST_TTL_SEC then
+	if request.requestedAt < moduleLoadedAt or age < -5 or age > REQUEST_TTL_SEC then
 		writeSetting(key, false)
 		return nil
 	end
+	if lastResult ~= nil and lastResult.key == key and lastResult.payload.id == request.id then
+		writePayload(key .. RESULT_KEY_SUFFIX, lastResult.payload)
+		return nil
+	end
 	if endTestIssued then
 		writeResult(key, request, false, "StudioTestService:EndTest was already issued for this play session, but the runtime DataModel is still alive.")
 		return nil
@@ -10036,6 +11179,11 @@ local function requestStop()
 		requestedAt = tick(),
 	}
 	local ok = writePayload(settingKey(), payload)
+	pendingRequest = if ok then {
+		key = settingKey(),
+		payload = payload,
+		lastPublishedAt = tick(),
+	} else nil
 	return {
 		ok = ok,
 		requestId = if ok then requestId else nil,
@@ -10050,8 +11198,12 @@ local function waitForConsumption(requestId)
 		}
 	end
 	local start = tick()
+	local pending = pendingRequest
+	local key = if pending ~= nil and pending.payload.id == requestId then pending.key else settingKey()
 	while tick() - start < WAIT_FOR_CONSUMPTION_TIMEOUT_SEC do
-		local payload = decodePayload(readSetting(settingKey()))
+		-- Separate slots prevent a retry from overwriting a durable acknowledgement
+		-- during a transient nil read after the server VM has already exited.
+		local payload = decodePayload(readSetting(key .. RESULT_KEY_SUFFIX))
 		if payload and payload.kind == "result" and payload.id == requestId then
 			return {
 				ok = payload.ok == true,
@@ -10059,6 +11211,19 @@ local function waitForConsumption(requestId)
 				error = payload.error,
 			}
 		end
+		local _condition = pending ~= nil and pendingRequest == pending and pending.payload.id == requestId and tick() - pending.lastPublishedAt >= RETRY_INTERVAL_SEC
+		if _condition then
+			local _exp = tick()
+			local _condition_1 = pending.payload.requestedAt
+			if _condition_1 == nil then
+				_condition_1 = 0
+			end
+			_condition = _exp - _condition_1 < REQUEST_TTL_SEC
+		end
+		if _condition then
+			writePayload(key, pending.payload)
+			pending.lastPublishedAt = tick()
+		end
 		task.wait(WAIT_POLL_SEC)
 	end
 	return {
@@ -10071,6 +11236,17 @@ local function clearPending(requestId)
 	if not pluginRef then
 		return nil
 	end
+	local _condition = requestId == nil
+	if not _condition then
+		local _result = pendingRequest
+		if _result ~= nil then
+			_result = _result.payload.id
+		end
+		_condition = _result == requestId
+	end
+	if _condition then
+		pendingRequest = nil
+	end
 	local myKey = settingKey()
 	if requestId ~= nil then
 		local payload = decodePayload(readSetting(myKey))
@@ -10090,7 +11266,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="36">
+      <Item class="ModuleScript" referent="37">
         <Properties>
           <string name="Name">StudioWebSocket</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -10102,6 +11278,7 @@ local PROTOCOL_VERSION = 1
 local INITIAL_RETRY_DELAY_SECONDS = 0.5
 local MAX_RETRY_DELAY_SECONDS = 5
 local SOCKET_SILENCE_TIMEOUT_SECONDS = 20
+local CONNECTION_STAGE_TIMEOUT_SECONDS = 20
 local RESPONSE_RETENTION_SECONDS = 5 * 60
 local RESPONSE_ACK_TIMEOUT_SECONDS = 120
 local MAX_TERMINAL_RESPONSES = 32768
@@ -10122,7 +11299,11 @@ local socketOpen = false
 local socketConnections = {}
 local lastValidEventAt = 0
 local cachedReady
-local readyRefreshPending = false
+local connectionWork
+local refreshWork
+local refreshRequested = false
+local reconnectTimer
+local silenceTimer
 local pendingResponseBytes = 0
 local inFlightRequestBytes = 0
 local pendingRejectionCount = 0
@@ -10669,7 +11850,7 @@ local function dispatchRequest(request, requestBytes)
 		local dispatchOk, response = pcall(function()
 			return dispatchOptions.dispatchRequest(request, context)
 		end)
-		local executionOutcome = if dispatchOk then handlerOutcome(response) else "error"
+		local executionOutcome = context.executionOutcome or (if dispatchOk then handlerOutcome(response) else "error")
 		-- Report handler return before JSON encoding or result retention can fail.
 		completeProgress(request.requestId, inFlight.progress, executionOutcome)
 		local body = if dispatchOk then encodeResponse(request.requestId, response, executionOutcome) else encodeError(request.requestId, `Plugin request execution failed: {string.sub(tostring(response), 1, 512)}`, executionOutcome)
@@ -10693,6 +11874,90 @@ local function reportTransport(update)
 		end)
 	end
 end
+local function ownsWork(work)
+	return active and generation == work.generation and options == work.options and (connectionWork == work or refreshWork == work)
+end
+local function cancelThread(worker)
+	-- Cancellation is best-effort for native yielding calls. Identity checks
+	-- remain necessary when an operation returns after its owner was retired.
+	if worker ~= nil and worker ~= coroutine.running() then
+		pcall(function()
+			return task.cancel(worker)
+		end)
+	end
+end
+local function finishWork(work)
+	if connectionWork == work then
+		connectionWork = nil
+	end
+	if refreshWork == work then
+		refreshWork = nil
+	end
+	cancelThread(work.deadline)
+	cancelThread(work.worker)
+	work.deadline = nil
+	work.worker = nil
+end
+local function cancelTransportWork()
+	if connectionWork ~= nil then
+		finishWork(connectionWork)
+	end
+	if refreshWork ~= nil then
+		refreshRequested = true
+		finishWork(refreshWork)
+	end
+	cancelThread(reconnectTimer)
+	cancelThread(silenceTimer)
+	reconnectTimer = nil
+	silenceTimer = nil
+end
+local function runWork(work, callback, failed)
+	local finished = false
+	local worker = task.spawn(function()
+		if not ownsWork(work) then
+			return nil
+		end
+		work.worker = coroutine.running()
+		local ok, workError = pcall(callback)
+		work.worker = nil
+		finished = true
+		if not ok and ownsWork(work) then
+			-- Native upgrade errors can echo credential-bearing request data.
+			local detail = if work.stage == "WebSocket upgrade" then "WebSocket upgrade failed" else `{work.stage} failed: {tostring(workError)}`
+			failed(detail)
+		end
+	end)
+	if not finished and ownsWork(work) then
+		work.worker = worker
+	end
+end
+local flushRefresh
+local function beginStage(work, stage)
+	cancelThread(work.deadline)
+	work.stage = stage
+	work.deadline = task.delay(CONNECTION_STAGE_TIMEOUT_SECONDS, function()
+		if not ownsWork(work) then
+			return nil
+		end
+		work.deadline = nil
+		local detail = `{stage} timed out after {CONNECTION_STAGE_TIMEOUT_SECONDS} seconds`
+		if connectionWork == work then
+			scheduleReconnect(work.generation, detail)
+		else
+			finishWork(work)
+			warn(`[robloxstudio-mcp] {detail}`)
+			flushRefresh()
+		end
+	end)
+	if connectionWork == work then
+		reportTransport({
+			state = "connecting",
+			attempt = reconnectAttempt,
+			retryDelay = 0,
+			detail = `{stage} (timeout {CONNECTION_STAGE_TIMEOUT_SECONDS} seconds)`,
+		})
+	end
+end
 local connect
 function scheduleReconnect(expectedGeneration, detail, duplicate)
 	if duplicate == nil then
@@ -10701,7 +11966,14 @@ function scheduleReconnect(expectedGeneration, detail, duplicate)
 	if not active or generation ~= expectedGeneration then
 		return nil
 	end
+	-- A healthy registration gets one socket-only revalidation, preserving
+	-- recovery under HTTP quota. Any failure before Opened exhausts that path.
+	if not socketOpen then
+		cachedReady = nil
+	end
 	generation += 1
+	local nextGeneration = generation
+	cancelTransportWork()
 	closeCurrentSocket()
 	reconnectAttempt += 1
 	local delay = if duplicate then 1 else retryDelay(reconnectAttempt)
@@ -10711,8 +11983,11 @@ function scheduleReconnect(expectedGeneration, detail, duplicate)
 		retryDelay = delay,
 		detail = detail,
 	})
-	local nextGeneration = generation
-	task.delay(delay, function()
+	if not active or generation ~= nextGeneration then
+		return nil
+	end
+	reconnectTimer = task.delay(delay, function()
+		reconnectTimer = nil
 		if active and generation == nextGeneration then
 			connect(nextGeneration)
 		end
@@ -10720,10 +11995,11 @@ function scheduleReconnect(expectedGeneration, detail, duplicate)
 end
 local function watchForSilence(expectedGeneration, expectedClient)
 	local elapsed = tick() - lastValidEventAt
-	task.delay(math.max(SOCKET_SILENCE_TIMEOUT_SECONDS - elapsed, 0.1), function()
+	silenceTimer = task.delay(math.max(SOCKET_SILENCE_TIMEOUT_SECONDS - elapsed, 0.1), function()
 		if not active or generation ~= expectedGeneration or socketClient ~= expectedClient then
 			return nil
 		end
+		silenceTimer = nil
 		local silentFor = tick() - lastValidEventAt
 		if silentFor >= SOCKET_SILENCE_TIMEOUT_SECONDS then
 			scheduleReconnect(expectedGeneration, `WebSocket silent for {math.floor(silentFor)} seconds`)
@@ -10790,13 +12066,18 @@ local function parseReadyResponse(body)
 		transportToken = value.transportToken,
 	}
 end
-local function registerReady(currentOptions, expectedGeneration, reconnectOnFailure)
+local function registerReady(work, reconnectOnFailure)
+	if not ownsWork(work) then
+		return nil
+	end
+	local currentOptions = work.options
+	local expectedGeneration = work.generation
 	local instanceId = PluginSession.getInstanceId()
 	local multiplayerGroupId = PluginSession.getMultiplayerGroupId()
 	local transportRole = PluginSession.getRole()
 	local readyUrl = `{currentOptions.serverUrl}/ready`
 	local readyPayload = PluginSession.createReadyPayload(PluginSession.peerId, transportRole, instanceId, multiplayerGroupId)
-	if not active or generation ~= expectedGeneration or options ~= currentOptions then
+	if not ownsWork(work) then
 		return nil
 	end
 	local readyOk, readyResult = pcall(function()
@@ -10809,7 +12090,7 @@ local function registerReady(currentOptions, expectedGeneration, reconnectOnFail
 			Body = HttpService:JSONEncode(readyPayload),
 		})
 	end)
-	if not active or generation ~= expectedGeneration or options ~= currentOptions then
+	if not ownsWork(work) then
 		return nil
 	end
 	local readyLogKey = `{currentOptions.serverUrl}|{PluginSession.peerId}`
@@ -10839,7 +12120,7 @@ local function registerReady(currentOptions, expectedGeneration, reconnectOnFail
 	invokeCallback("WebSocket ready", function()
 		return currentOptions.onReady(readyData)
 	end)
-	return readyData
+	return if ownsWork(work) then readyData else nil
 end
 local function credentialsRejected(statusCode)
 	return statusCode == 401 or statusCode == 403 or statusCode == 404
@@ -10849,14 +12130,28 @@ function connect(expectedGeneration)
 	if not active or generation ~= expectedGeneration or currentOptions == nil then
 		return nil
 	end
-	reportTransport({
-		state = "connecting",
-		attempt = reconnectAttempt,
-		retryDelay = 0,
-	})
-	task.spawn(function()
-		local readyData = cachedReady or registerReady(currentOptions, expectedGeneration, true)
-		if readyData == nil or not active or generation ~= expectedGeneration or options ~= currentOptions then
+	if refreshWork ~= nil then
+		finishWork(refreshWork)
+	end
+	local work = {
+		generation = expectedGeneration,
+		options = currentOptions,
+		stage = "",
+	}
+	connectionWork = work
+	beginStage(work, if cachedReady == nil then "/ready registration" else "WebSocket upgrade")
+	if not ownsWork(work) then
+		return nil
+	end
+	runWork(work, function()
+		local readyData = cachedReady or registerReady(work, true)
+		if readyData == nil or not ownsWork(work) then
+			return nil
+		end
+		if work.stage ~= "WebSocket upgrade" then
+			beginStage(work, "WebSocket upgrade")
+		end
+		if not ownsWork(work) then
 			return nil
 		end
 		local socketBaseUrl = string.gsub(currentOptions.serverUrl, "^http", "ws")
@@ -10869,28 +12164,32 @@ function connect(expectedGeneration)
 			})
 		end)
 		if not createOk then
-			scheduleReconnect(expectedGeneration, `Failed to create WebSocket: {tostring(createdClient)}`)
+			scheduleReconnect(expectedGeneration, "Failed to create WebSocket")
 			return nil
 		end
-		if not active or generation ~= expectedGeneration or options ~= currentOptions then
+		if not ownsWork(work) then
 			pcall(function()
 				return createdClient:Close()
 			end)
 			return nil
 		end
 		socketClient = createdClient
-		socketConnections = { createdClient.Opened:Connect(function(statusCode, _headers)
+		-- Attach incrementally so a failed subscription cannot leak earlier ones.
+		local _socketConnections = socketConnections
+		local _arg0 = createdClient.Opened:Connect(function(statusCode, _headers)
 			if not active or generation ~= expectedGeneration or socketClient ~= createdClient then
 				return nil
 			end
+			if socketOpen then
+				return nil
+			end
 			if statusCode ~= 101 and (statusCode < 200 or statusCode >= 300) then
-				if credentialsRejected(statusCode) then
-					cachedReady = nil
-				end
+				cachedReady = nil
 				scheduleReconnect(expectedGeneration, `WebSocket opened with HTTP {statusCode}`)
 				return nil
 			end
 			socketOpen = true
+			finishWork(work)
 			lastValidEventAt = tick()
 			reconnectAttempt = 0
 			reportTransport({
@@ -10898,8 +12197,18 @@ function connect(expectedGeneration)
 				attempt = 0,
 				retryDelay = 0,
 			})
+			if not active or generation ~= expectedGeneration or socketClient ~= createdClient then
+				return nil
+			end
+			watchForSilence(expectedGeneration, createdClient)
 			resumePendingResponses()
-		end), createdClient.MessageReceived:Connect(function(message)
+			if active and generation == expectedGeneration and socketClient == createdClient then
+				flushRefresh()
+			end
+		end)
+		table.insert(_socketConnections, _arg0)
+		local _socketConnections_1 = socketConnections
+		local _arg0_1 = createdClient.MessageReceived:Connect(function(message)
 			if not active or generation ~= expectedGeneration or socketClient ~= createdClient then
 				return nil
 			end
@@ -10937,27 +12246,41 @@ function connect(expectedGeneration)
 				invokeCallback("WebSocket status", function()
 					return currentOptions.onStatus(event)
 				end)
+				if not active or generation ~= expectedGeneration or socketClient ~= createdClient then
+					return nil
+				end
 				if not event.knownPeer then
 					cachedReady = nil
 					scheduleReconnect(expectedGeneration, "WebSocket session is no longer registered")
 				end
 			end
-		end), createdClient.Error:Connect(function(statusCode, message)
+		end)
+		table.insert(_socketConnections_1, _arg0_1)
+		local _socketConnections_2 = socketConnections
+		local _arg0_2 = createdClient.Error:Connect(function(statusCode, _message)
 			if not active or generation ~= expectedGeneration or socketClient ~= createdClient then
 				return nil
 			end
-			if credentialsRejected(statusCode) then
+			if not socketOpen or credentialsRejected(statusCode) then
 				cachedReady = nil
 			end
-			scheduleReconnect(expectedGeneration, `WebSocket error {statusCode}: {message}`)
-		end), createdClient.Closed:Connect(function()
+			-- Native error messages may echo request credentials.
+			scheduleReconnect(expectedGeneration, `WebSocket error {statusCode}`)
+		end)
+		table.insert(_socketConnections_2, _arg0_2)
+		local _socketConnections_3 = socketConnections
+		local _arg0_3 = createdClient.Closed:Connect(function()
 			if not active or generation ~= expectedGeneration or socketClient ~= createdClient then
 				return nil
 			end
+			if not socketOpen then
+				cachedReady = nil
+			end
 			scheduleReconnect(expectedGeneration, "WebSocket closed")
-		end) }
-		lastValidEventAt = tick()
-		watchForSilence(expectedGeneration, createdClient)
+		end)
+		table.insert(_socketConnections_3, _arg0_3)
+	end, function(detail)
+		return scheduleReconnect(expectedGeneration, detail)
 	end)
 end
 local stop
@@ -10972,20 +12295,42 @@ local function start(newOptions)
 	generation += 1
 	connect(generation)
 end
-local function refresh()
+function flushRefresh()
 	local currentOptions = options
-	if not active or currentOptions == nil or readyRefreshPending then
+	if not refreshRequested or not active or currentOptions == nil or refreshWork ~= nil or connectionWork ~= nil or not socketOpen then
 		return nil
 	end
-	-- Metadata changes must not close a healthy socket or make its reconnect
-	-- depend on RequestAsync quota. Proxy registration remains independent.
-	readyRefreshPending = true
-	local expectedGeneration = generation
-	task.spawn(function()
-		registerReady(currentOptions, expectedGeneration, false)
-		readyRefreshPending = false
+	refreshRequested = false
+	-- Only explicit metadata changes are queued. Failure alone never schedules
+	-- more HTTP requests or replaces a healthy transport.
+	local work = {
+		generation = generation,
+		options = currentOptions,
+		stage = "",
+	}
+	refreshWork = work
+	beginStage(work, "/ready metadata refresh")
+	runWork(work, function()
+		-- Consume at worker entry so changes coalesce even before task.spawn runs.
+		refreshRequested = false
+		registerReady(work, false)
+		if ownsWork(work) then
+			finishWork(work)
+			flushRefresh()
+		end
+	end, function(detail)
+		finishWork(work)
+		warn(`[robloxstudio-mcp] {detail}`)
+		flushRefresh()
 	end)
 end
+local function refresh()
+	if not active or options == nil then
+		return nil
+	end
+	refreshRequested = true
+	flushRefresh()
+end
 -- EndTest may tear down this VM without an Unloading callback. Release the
 -- native socket before yielding to unregister; a failed EndTest can resume.
 local function suspendForShutdown()
@@ -10996,6 +12341,8 @@ local function suspendForShutdown()
 	active = false
 	shutdownSuspended = true
 	generation += 1
+	cancelTransportWork()
+	refreshRequested = false
 	reconnectAttempt = 0
 	closeCurrentSocket()
 	cachedReady = nil
@@ -11019,6 +12366,8 @@ function stop()
 	active = false
 	shutdownSuspended = false
 	generation += 1
+	cancelTransportWork()
+	refreshRequested = false
 	for _, inFlight in inFlightRequests do
 		inFlight.cancelled = true
 	end
@@ -11041,7 +12390,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="37">
+      <Item class="ModuleScript" referent="38">
         <Properties>
           <string name="Name">TopologyId</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -11086,7 +12435,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="38">
+      <Item class="ModuleScript" referent="39">
         <Properties>
           <string name="Name">UI</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -11349,12 +12698,13 @@ local function init(pluginRef)
 		end
 	end)
 	local statusRow = Instance.new("Frame")
-	statusRow.Size = UDim2.new(1, 0, 0, 14)
+	statusRow.Size = UDim2.new(1, 0, 0, 0)
+	statusRow.AutomaticSize = Enum.AutomaticSize.Y
 	statusRow.BackgroundTransparency = 1
 	statusRow.LayoutOrder = 2
 	statusRow.Parent = card
 	local statusLabel = Instance.new("TextLabel")
-	statusLabel.Size = UDim2.new(1, 0, 1, 0)
+	statusLabel.Size = UDim2.new(1, 0, 0, 18)
 	statusLabel.BackgroundTransparency = 1
 	statusLabel.Text = "Disconnected"
 	statusLabel.TextColor3 = C.red
@@ -11362,17 +12712,20 @@ local function init(pluginRef)
 	statusLabel.Font = Enum.Font.GothamBold
 	statusLabel.TextXAlignment = Enum.TextXAlignment.Left
 	statusLabel.TextWrapped = true
+	statusLabel.RichText = false
 	statusLabel.Parent = statusRow
 	local detailStatusLabel = Instance.new("TextLabel")
-	detailStatusLabel.Size = UDim2.new(0.5, 0, 1, 0)
-	detailStatusLabel.Position = UDim2.new(0.5, 0, 0, 0)
+	detailStatusLabel.Size = UDim2.new(1, 0, 0, 0)
+	detailStatusLabel.Position = UDim2.new(0, 0, 0, 18)
+	detailStatusLabel.AutomaticSize = Enum.AutomaticSize.Y
 	detailStatusLabel.BackgroundTransparency = 1
 	detailStatusLabel.Text = "HTTP: X  MCP: X"
 	detailStatusLabel.TextColor3 = C.muted
 	detailStatusLabel.TextSize = 9
 	detailStatusLabel.Font = Enum.Font.GothamMedium
-	detailStatusLabel.TextXAlignment = Enum.TextXAlignment.Right
+	detailStatusLabel.TextXAlignment = Enum.TextXAlignment.Left
 	detailStatusLabel.TextWrapped = true
+	detailStatusLabel.RichText = false
 	detailStatusLabel.Parent = statusRow
 	local stepsFrame = Instance.new("Frame")
 	stepsFrame.Size = UDim2.new(1, 0, 0, 0)
@@ -11509,13 +12862,14 @@ local function updateUIState()
 		return nil
 	end
 	local el = elements
+	local diagnostics = State.getTransportDiagnostics(tick())
 	if not conn.isActive then
-		el.statusLabel.Text = "Disconnected"
+		el.statusLabel.Text = diagnostics.status
 		el.statusLabel.TextColor3 = C.muted
 		el.statusIndicator.BackgroundColor3 = C.red
 		el.statusPulse.BackgroundColor3 = C.red
 		el.statusText.Text = "OFFLINE"
-		el.detailStatusLabel.Text = ""
+		el.detailStatusLabel.Text = diagnostics.detail
 		el.detailStatusLabel.TextColor3 = C.muted
 		stopPulseAnimation()
 		el.step1Dot.BackgroundColor3 = C.gray
@@ -11538,12 +12892,12 @@ local function updateUIState()
 	el.urlInput.TextEditable = false
 	el.urlInput.BackgroundColor3 = C.card
 	if conn.lastHttpOk and conn.lastMcpOk then
-		el.statusLabel.Text = "Connected"
+		el.statusLabel.Text = diagnostics.status
 		el.statusLabel.TextColor3 = Color3.fromRGB(34, 197, 94)
 		el.statusIndicator.BackgroundColor3 = Color3.fromRGB(34, 197, 94)
 		el.statusPulse.BackgroundColor3 = Color3.fromRGB(34, 197, 94)
 		el.statusText.Text = "ONLINE"
-		el.detailStatusLabel.Text = "HTTP: OK  MCP: OK"
+		el.detailStatusLabel.Text = diagnostics.detail
 		el.detailStatusLabel.TextColor3 = Color3.fromRGB(34, 197, 94)
 		el.step1Dot.BackgroundColor3 = Color3.fromRGB(34, 197, 94)
 		el.step1Label.Text = "HTTP server (OK)"
@@ -11554,12 +12908,12 @@ local function updateUIState()
 		el.troubleshootLabel.Visible = false
 		stopPulseAnimation()
 	elseif conn.lastHttpOk and not conn.lastMcpOk then
-		el.statusLabel.Text = "Waiting for MCP server"
+		el.statusLabel.Text = diagnostics.status
 		el.statusLabel.TextColor3 = Color3.fromRGB(245, 158, 11)
 		el.statusIndicator.BackgroundColor3 = Color3.fromRGB(245, 158, 11)
 		el.statusPulse.BackgroundColor3 = Color3.fromRGB(245, 158, 11)
 		el.statusText.Text = "WAITING"
-		el.detailStatusLabel.Text = "HTTP: OK  MCP: ..."
+		el.detailStatusLabel.Text = diagnostics.detail
 		el.detailStatusLabel.TextColor3 = Color3.fromRGB(245, 158, 11)
 		el.step1Dot.BackgroundColor3 = Color3.fromRGB(34, 197, 94)
 		el.step1Label.Text = "HTTP server (OK)"
@@ -11570,53 +12924,21 @@ local function updateUIState()
 		local elapsed = if conn.mcpWaitStartTime ~= nil then tick() - conn.mcpWaitStartTime else 0
 		el.troubleshootLabel.Visible = elapsed > 8
 		startPulseAnimation()
-	elseif conn.consecutiveFailures >= conn.maxFailuresBeforeError then
-		el.statusLabel.Text = "Server unavailable"
-		el.statusLabel.TextColor3 = Color3.fromRGB(239, 68, 68)
-		el.statusIndicator.BackgroundColor3 = Color3.fromRGB(239, 68, 68)
-		el.statusPulse.BackgroundColor3 = Color3.fromRGB(239, 68, 68)
-		el.statusText.Text = "ERROR"
-		el.detailStatusLabel.Text = "HTTP: X  MCP: X"
-		el.detailStatusLabel.TextColor3 = Color3.fromRGB(239, 68, 68)
-		el.step1Dot.BackgroundColor3 = Color3.fromRGB(239, 68, 68)
-		el.step1Label.Text = "HTTP server (error)"
-		el.step2Dot.BackgroundColor3 = Color3.fromRGB(239, 68, 68)
-		el.step2Label.Text = "MCP bridge (error)"
-		el.step3Dot.BackgroundColor3 = Color3.fromRGB(239, 68, 68)
-		el.step3Label.Text = "Commands (error)"
-		el.troubleshootLabel.Visible = false
-		stopPulseAnimation()
-	elseif conn.consecutiveFailures > 5 then
-		local waitTime = math.ceil(conn.currentRetryDelay)
-		el.statusLabel.Text = `Retrying ({waitTime}s)`
-		el.statusLabel.TextColor3 = Color3.fromRGB(245, 158, 11)
-		el.statusIndicator.BackgroundColor3 = Color3.fromRGB(245, 158, 11)
-		el.statusPulse.BackgroundColor3 = Color3.fromRGB(245, 158, 11)
-		el.statusText.Text = "RETRY"
-		el.detailStatusLabel.Text = "HTTP: ...  MCP: ..."
-		el.detailStatusLabel.TextColor3 = Color3.fromRGB(245, 158, 11)
-		el.step1Dot.BackgroundColor3 = Color3.fromRGB(245, 158, 11)
-		el.step1Label.Text = "HTTP server (retrying...)"
-		el.step2Dot.BackgroundColor3 = Color3.fromRGB(245, 158, 11)
-		el.step2Label.Text = "MCP bridge (retrying...)"
-		el.step3Dot.BackgroundColor3 = Color3.fromRGB(245, 158, 11)
-		el.step3Label.Text = "Commands (retrying...)"
-		el.troubleshootLabel.Visible = false
-		startPulseAnimation()
 	else
-		el.statusLabel.Text = if conn.consecutiveFailures > 1 then `Connecting (attempt {conn.consecutiveFailures})` else "Connecting..."
+		local retrying = conn.nextRetryAt ~= nil
+		el.statusLabel.Text = diagnostics.status
 		el.statusLabel.TextColor3 = C.yellow
 		el.statusIndicator.BackgroundColor3 = C.yellow
 		el.statusPulse.BackgroundColor3 = C.yellow
-		el.statusText.Text = "CONNECTING"
-		el.detailStatusLabel.Text = if conn.consecutiveFailures == 0 then "..." else "HTTP: ...  MCP: ..."
-		el.detailStatusLabel.TextColor3 = C.muted
+		el.statusText.Text = if retrying then "RETRY" else "CONNECTING"
+		el.detailStatusLabel.Text = diagnostics.detail
+		el.detailStatusLabel.TextColor3 = C.yellow
 		el.step1Dot.BackgroundColor3 = C.yellow
-		el.step1Label.Text = "HTTP server (connecting...)"
-		el.step2Dot.BackgroundColor3 = C.yellow
-		el.step2Label.Text = "MCP bridge (connecting...)"
-		el.step3Dot.BackgroundColor3 = C.yellow
-		el.step3Label.Text = "Commands (connecting...)"
+		el.step1Label.Text = if retrying then "Listener (disconnected)" else "Listener (connecting...)"
+		el.step2Dot.BackgroundColor3 = C.gray
+		el.step2Label.Text = "MCP client (waiting for listener)"
+		el.step3Dot.BackgroundColor3 = C.gray
+		el.step3Label.Text = "Commands (waiting for listener)"
 		el.troubleshootLabel.Visible = false
 		startPulseAnimation()
 	end
@@ -11638,7 +12960,7 @@ return {
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="39">
+      <Item class="ModuleScript" referent="40">
         <Properties>
           <string name="Name">Utils</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
@@ -12479,11 +13801,11 @@ return {
         </Properties>
       </Item>
     </Item>
-    <Item class="Folder" referent="44">
+    <Item class="Folder" referent="45">
       <Properties>
         <string name="Name">include</string>
       </Properties>
-      <Item class="ModuleScript" referent="40">
+      <Item class="ModuleScript" referent="41">
         <Properties>
           <string name="Name">LibMP</string>
           <string name="Source"><![CDATA[-- =============================================================================
@@ -168867,7 +170189,7 @@ return LibMP
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="41">
+      <Item class="ModuleScript" referent="42">
         <Properties>
           <string name="Name">Promise</string>
           <string name="Source"><![CDATA[--[[
@@ -170941,7 +172263,7 @@ return Promise
 ]]></string>
         </Properties>
       </Item>
-      <Item class="ModuleScript" referent="42">
+      <Item class="ModuleScript" referent="43">
         <Properties>
           <string name="Name">RuntimeLib</string>
           <string name="Source"><![CDATA[local Promise = require(script.Parent.Promise)
@@ -171208,15 +172530,15 @@ return TS
         </Properties>
       </Item>
     </Item>
-    <Item class="Folder" referent="45">
+    <Item class="Folder" referent="46">
       <Properties>
         <string name="Name">node_modules</string>
       </Properties>
-      <Item class="Folder" referent="46">
+      <Item class="Folder" referent="47">
         <Properties>
           <string name="Name">@rbxts</string>
         </Properties>
-      <Item class="ModuleScript" referent="43">
+      <Item class="ModuleScript" referent="44">
         <Properties>
           <string name="Name">services</string>
           <string name="Source"><![CDATA[return setmetatable({}, {