@chrrxs/robloxstudio-mcp-inspector 3.1.3 → 3.1.5

package/dist/index.js

@@ -1945,6 +1945,15 @@ import { toNodeHandler } from "@modelcontextprotocol/node";
 
 // ../core/dist/bridge-service.js
 import { createHash, randomUUID } from "crypto";
+var MultiplayerGroupInUseError = class extends Error {
+  groupId;
+  code = "multiplayer_group_in_use";
+  constructor(groupId) {
+    super(`Multiplayer Group "${groupId}" still has connected runtime peers and cannot be removed.`);
+    this.groupId = groupId;
+    this.name = "MultiplayerGroupInUseError";
+  }
+};
 function isExecutionOutcome(value) {
   return value === "success" || value === "error" || value === "not_executed" || value === "unknown";
 }
@@ -2233,6 +2242,11 @@ var BridgeService = class {
     const group = this.multiplayerGroupsById.get(groupId);
     if (!group)
       return void 0;
+    for (const peer of this.peersById.values()) {
+      if (peer.multiplayerGroupId === groupId && isRuntimeRole(peer.role)) {
+        throw new MultiplayerGroupInUseError(groupId);
+      }
+    }
     this.multiplayerGroupsById.delete(groupId);
     for (const peer of this.peersById.values()) {
       if (peer.multiplayerGroupId === groupId)
@@ -2855,7 +2869,7 @@ var BridgeService = class {
       operation.status.executionStartedAt = now;
     else {
       operation.status.executionOutcome = outcome ?? "unknown";
-      if (outcome !== "not_executed")
+      if (outcome === "success" || outcome === "error")
         operation.status.executionCompletedAt = now;
     }
     operation.updatedAt = now;
@@ -2871,7 +2885,7 @@ var BridgeService = class {
         requestId,
         targetPeerId: operation.status.targetPeerId,
         ...observations(operation.status),
-        executionCompletedAt: executionOutcome === "not_executed" ? void 0 : operation.status.executionCompletedAt ?? Date.now(),
+        executionCompletedAt: executionOutcome === "success" || executionOutcome === "error" ? operation.status.executionCompletedAt ?? Date.now() : void 0,
         stage: "response_delivery",
         outcome: executionOutcome === "not_executed" ? "not_executed" : "unknown",
         executionOutcome
@@ -2899,13 +2913,15 @@ var BridgeService = class {
     operation.status.state = "settled";
     const localRejection = error instanceof RequestFailure && error.details.transportStage === "server_send";
     const responseOutcome = handlerOutcome(response);
-    const completedOutcome = !hasError && responseOutcome === "error" ? "error" : executionOutcome ?? (localRejection ? "not_executed" : hasError ? operation.status.executionOutcome === "success" ? "success" : "error" : responseOutcome);
+    const completedOutcome = executionOutcome === "unknown" || executionOutcome === "not_executed" ? executionOutcome : !hasError && responseOutcome === "error" ? "error" : executionOutcome ?? (localRejection ? "not_executed" : hasError ? operation.status.executionOutcome === "success" ? "success" : "error" : responseOutcome);
     operation.status.executionOutcome = completedOutcome;
-    operation.status.outcome = hasError || completedOutcome === "error" || completedOutcome === "not_executed" ? "error" : "success";
+    operation.status.outcome = hasError || responseOutcome === "error" || completedOutcome === "error" || completedOutcome === "not_executed" ? "error" : "success";
     if (!localRejection) {
       operation.status.stage = "response_delivery";
-      if (completedOutcome !== "not_executed")
+      if (completedOutcome === "success" || completedOutcome === "error")
         operation.status.executionCompletedAt ??= now;
+      else
+        delete operation.status.executionCompletedAt;
     }
     operation.status.settledAt = now;
     operation.updatedAt = now;
@@ -3308,6 +3324,10 @@ execute_luau runs through the Studio plugin. eval_server_runtime and eval_client
 
 Read output with get_runtime_logs. Reuse nextCursor as cursor for one Instance, or nextCursorByInstance as cursor_by_instance for a Multiplayer Group, instead of requesting the full process streams again.
 
+- Each Peer VM retains approximately 64 KiB of message text, rather than a fixed message count. Reads do not consume or clear the buffer; incoming messages evict old entries.
+- totalDropped sums lifetime eviction counts from successfully read Peers. It counts messages evicted, not messages missed by this caller, and may decrease when Peers fail, disconnect, or reload.
+- For successfully read Peers, nextCursor advances past all captured entries, including those omitted by filter or tail. It is a continuation watermark, not pagination through omitted results; continuing from it will not return those entries.
+
 ## Simulation and input
 
 - Inspect current settings with get_simulation_state before changing them.
@@ -3936,6 +3956,40 @@ var StudioLaunchPreDispatchError = class extends Error {
     };
   }
 };
+var StudioCloseVerificationError = class extends Error {
+  observation;
+  constructor(message, observation) {
+    super(message);
+    this.observation = observation;
+  }
+};
+async function beforeCloseDeadline(operation, deadline, processId) {
+  const { promise, reject } = Promise.withResolvers();
+  const timeoutError = () => new StudioCloseVerificationError(`Timed out verifying Studio process ${processId} termination; process state is unknown.`, { status: "unknown", observedAt: Date.now(), error: "Close operation deadline exceeded." });
+  if (Date.now() >= deadline)
+    throw timeoutError();
+  const timer = setTimeout(() => reject(timeoutError()), deadline - Date.now());
+  try {
+    return await Promise.race([operation(), promise]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function observePosixProcess(processId) {
+  try {
+    process.kill(processId, 0);
+    return { status: "running", observedAt: Date.now() };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+      return { status: "not_running", observedAt: Date.now(), reason: "missing" };
+    }
+    return {
+      status: "unknown",
+      observedAt: Date.now(),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 function run(command, args, options = {}) {
   return execFileSync2(command, args, {
     encoding: "utf8",
@@ -3957,9 +4011,10 @@ async function runAsync(command, args, options = {}) {
 function isWsl() {
   return getStudioPlatformCapabilities().isWsl;
 }
-async function powershellAsync(script) {
+async function powershellAsync(script, timeoutMs = 15e3) {
   return runAsync("powershell.exe", ["-NoProfile", "-Command", script], {
-    cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd()
+    cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd(),
+    timeout: timeoutMs
   });
 }
 function windowsLocalAppData() {
@@ -4094,8 +4149,15 @@ function quoteWindowsCommandLineArg(value) {
   }
   return `${quoted}${"\\".repeat(backslashes * 2)}"`;
 }
-function buildWindowsStudioStartScriptFromConvertedExe(windowsExe, args, processEnvironment, windowsWorkingDirectory) {
+function parseStudioTestWorkerJobName(name) {
+  if (name !== void 0 && !/^Local\\RsmcpStudioWorker-[a-f0-9]{32}$/u.test(name)) {
+    throw new Error("Invalid Studio test worker job name.");
+  }
+  return name;
+}
+function buildWindowsStudioStartScriptFromConvertedExe(windowsExe, args, processEnvironment, windowsWorkingDirectory, testWorkerJobName = process.env.RSMCP_STUDIO_TEST_WORKER_JOB) {
   const environmentPatch = parseStudioProcessEnvironmentPatch(processEnvironment);
+  parseStudioTestWorkerJobName(testWorkerJobName);
   const commandLine = [windowsExe, ...args].map(quoteWindowsCommandLineArg).join(" ");
   return [
     "$ErrorActionPreference = 'Stop'",
@@ -4208,6 +4270,15 @@ public sealed class McpSuspendedStudio : IDisposable
     [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
     private static extern IntPtr CreateJobObjectW(IntPtr jobAttributes, string name);
 
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern IntPtr OpenJobObjectW(uint access, bool inheritHandle, string name);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool GetHandleInformation(IntPtr handle, out uint flags);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool QueryInformationJobObject(IntPtr job, int informationClass, IntPtr information, uint informationLength, out uint returned);
+
     [DllImport("kernel32.dll", SetLastError = true)]
     private static extern bool SetInformationJobObject(
         IntPtr job,
@@ -4295,20 +4366,60 @@ public sealed class McpSuspendedStudio : IDisposable
             throw new InvalidOperationException("Unexpected Studio process wait result: " + wait);
     }
 
-    public static McpSuspendedStudio Start(string application, string commandLine, string currentDirectory)
+    private static Win32Exception TestWorkerError(string operation)
+    {
+        int error = Marshal.GetLastWin32Error();
+        return new Win32Exception(error, operation + " (Win32 " + error + "): " + new Win32Exception(error).Message);
+    }
+
+    private static IntPtr OpenTestWorkerJob(string name)
+    {
+        if (name == null) return IntPtr.Zero;
+        if (!System.Text.RegularExpressions.Regex.IsMatch(name, @"\\ALocal\\\\RsmcpStudioWorker-[a-f0-9]{32}\\z"))
+            throw new ArgumentException("Invalid Studio test worker job name");
+        IntPtr handle = OpenJobObjectW(5, false, name);
+        if (handle == IntPtr.Zero)
+            throw TestWorkerError("Open test worker job failed");
+        try
+        {
+            uint flags;
+            if (!GetHandleInformation(handle, out flags))
+                throw TestWorkerError("Get test worker job handle flags failed");
+            if ((flags & 1) != 0)
+                throw new InvalidOperationException("Test worker job handle must not be inherited");
+            int length = Marshal.SizeOf(typeof(ExtendedLimitInformation));
+            IntPtr buffer = Marshal.AllocHGlobal(length);
+            try
+            {
+                uint returned;
+                if (!QueryInformationJobObject(handle, JOB_OBJECT_EXTENDED_LIMIT_INFORMATION, buffer, (uint)length, out returned))
+                    throw TestWorkerError("Query test worker job limits failed");
+                var information = (ExtendedLimitInformation)Marshal.PtrToStructure(buffer, typeof(ExtendedLimitInformation));
+                if (returned != length || information.BasicLimitInformation.LimitFlags != JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE)
+                    throw new InvalidOperationException("Test worker job must retain kill-on-close without breakaway");
+            }
+            finally { Marshal.FreeHGlobal(buffer); }
+            return handle;
+        }
+        catch { CloseHandle(handle); throw; }
+    }
+
+    public static McpSuspendedStudio Start(string application, string commandLine, string currentDirectory, string testWorkerJobName)
     {
         if (String.IsNullOrEmpty(currentDirectory))
             currentDirectory = null;
         IntPtr jobHandle = CreateJobObjectW(IntPtr.Zero, null);
         if (jobHandle == IntPtr.Zero)
             throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateJobObjectW failed");
+        IntPtr workerJob = IntPtr.Zero;
         try
         {
             ConfigureKillOnClose(jobHandle, true);
+            workerJob = OpenTestWorkerJob(testWorkerJobName);
             var startup = new StartupInfo();
             startup.cb = Marshal.SizeOf(startup);
             ProcessInformation created;
-            uint flags = CREATE_SUSPENDED | CREATE_BREAKAWAY_FROM_JOB;
+            uint flags = CREATE_SUSPENDED | (workerJob == IntPtr.Zero ? CREATE_BREAKAWAY_FROM_JOB : 0);
             bool started = CreateProcessW(application, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, false, flags, IntPtr.Zero, currentDirectory, ref startup, out created);
             if (!started && Marshal.GetLastWin32Error() == 5)
                 started = CreateProcessW(application, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, false, CREATE_SUSPENDED, IntPtr.Zero, currentDirectory, ref startup, out created);
@@ -4316,6 +4427,10 @@ public sealed class McpSuspendedStudio : IDisposable
                 throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateProcessW failed");
             try
             {
+                // Worker lifetime encloses the private launch-authorization job.
+                // COMPLETE may release authorization, never test-worker ownership.
+                if (workerJob != IntPtr.Zero && !AssignProcessToJobObject(workerJob, created.hProcess))
+                    throw TestWorkerError("Assign Studio to test worker job failed");
                 if (!AssignProcessToJobObject(jobHandle, created.hProcess))
                     throw new Win32Exception(Marshal.GetLastWin32Error(), "AssignProcessToJobObject failed");
                 return new McpSuspendedStudio(created, jobHandle);
@@ -4339,6 +4454,10 @@ public sealed class McpSuspendedStudio : IDisposable
             CloseHandle(jobHandle);
             throw;
         }
+        finally
+        {
+            if (workerJob != IntPtr.Zero) CloseHandle(workerJob);
+        }
     }
 
     public void Resume()
@@ -4388,7 +4507,7 @@ public sealed class McpSuspendedStudio : IDisposable
     }
 }
 '@`,
-    `$launch = [McpSuspendedStudio]::Start(${powershellStringLiteral(windowsExe)}, ${powershellStringLiteral(commandLine)}, ${windowsWorkingDirectory === void 0 ? "$null" : powershellStringLiteral(windowsWorkingDirectory)})`,
+    `$launch = [McpSuspendedStudio]::Start(${powershellStringLiteral(windowsExe)}, ${powershellStringLiteral(commandLine)}, ${windowsWorkingDirectory === void 0 ? "$null" : powershellStringLiteral(windowsWorkingDirectory)}, ${testWorkerJobName === void 0 ? "$null" : powershellStringLiteral(testWorkerJobName)})`,
     "try {",
     "[Console]::Out.WriteLine((ConvertTo-Json @{ pid = $launch.ProcessId; started = [string]$launch.StartedAtFileTime } -Compress)); [Console]::Out.Flush()",
     "$accepted = $false",
@@ -4427,13 +4546,14 @@ function buildWindowsStudioStopScript(processId, startedAt) {
     "} finally { if ($null -ne $studio) { $studio.Dispose() } }"
   ].join("; ");
 }
-async function stopWindowsStudio(processId, startedAt) {
-  await powershellAsync(buildWindowsStudioStopScript(processId, startedAt));
+async function stopWindowsStudio(processId, startedAt, timeoutMs = 15e3) {
+  await powershellAsync(buildWindowsStudioStopScript(processId, startedAt), timeoutMs);
 }
 async function spawnWindowsStudio(exe, args, processEnvironment, studioWorkingDirectory) {
   const windowsExe = await toStudioLaunchArgAsync(exe);
   const windowsWorkingDirectory = studioWorkingDirectory ? await toStudioLaunchArgAsync(studioWorkingDirectory) : void 0;
-  const script = buildWindowsStudioStartScriptFromConvertedExe(windowsExe, args, processEnvironment, windowsWorkingDirectory);
+  const testWorkerJobName = process.env.RSMCP_STUDIO_TEST_WORKER_JOB;
+  const script = buildWindowsStudioStartScriptFromConvertedExe(windowsExe, args, processEnvironment, windowsWorkingDirectory, testWorkerJobName);
   const launcher = spawn("powershell.exe", ["-NoProfile", "-Command", script], {
     cwd: isWsl() && existsSync2("/mnt/c/Windows") ? "/mnt/c/Windows" : process.cwd(),
     stdio: ["pipe", "pipe", "pipe"],
@@ -4740,6 +4860,24 @@ function prepareStudioLaunchOptions(options) {
     localPlaceFile: createBaseplatePlaceFile()
   };
 }
+function resolveStudioExeFromVersions(root) {
+  if (!existsSync2(root)) {
+    throw new Error(`Roblox Studio Versions folder not found: ${root}. Set ROBLOX_STUDIO_EXE.`);
+  }
+  const candidates = readdirSync(root).filter((name) => name.startsWith("version-")).map((name) => path2.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync2(candidate)).sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
+  if (candidates.length === 0) {
+    throw new Error(`RobloxStudioBeta.exe not found under ${root}. Set ROBLOX_STUDIO_EXE.`);
+  }
+  const exe = candidates[0];
+  const installationDir = path2.dirname(exe);
+  const hasIncompleteDownload = readdirSync(installationDir).some((name) => /\.crdownload$/i.test(name));
+  const settings = statSync(path2.join(installationDir, "AppSettings.xml"), { throwIfNoEntry: false });
+  if (hasIncompleteDownload || !settings?.isFile() || settings.size === 0) {
+    const reason = hasIncompleteDownload ? "an unfinished .crdownload download is present" : "AppSettings.xml is missing, empty, or not a regular file";
+    throw new Error(`Roblox Studio installation/update is incomplete at ${installationDir}: ${reason}. Complete the installation/update or reinstall Roblox Studio under the owning Windows account before launching.`);
+  }
+  return exe;
+}
 function resolveStudioExe() {
   if (process.env.ROBLOX_STUDIO_EXE)
     return process.env.ROBLOX_STUDIO_EXE;
@@ -4751,14 +4889,7 @@ function resolveStudioExe() {
   }
   const localAppData = windowsLocalAppData();
   const root = localAppData ? path2.join(toWslPath(localAppData), "Roblox", "Versions") : path2.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
-  if (!existsSync2(root)) {
-    throw new Error(`Roblox Studio Versions folder not found: ${root}. Set ROBLOX_STUDIO_EXE.`);
-  }
-  const candidates = readdirSync(root).filter((name) => name.startsWith("version-")).map((name) => path2.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync2(candidate)).sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
-  if (candidates.length === 0) {
-    throw new Error(`RobloxStudioBeta.exe not found under ${root}. Set ROBLOX_STUDIO_EXE.`);
-  }
-  return candidates[0];
+  return resolveStudioExeFromVersions(root);
 }
 async function resolveStudioExeAsync() {
   if (process.env.ROBLOX_STUDIO_EXE)
@@ -4771,14 +4902,7 @@ async function resolveStudioExeAsync() {
   }
   const localAppData = await windowsLocalAppDataAsync();
   const root = localAppData ? path2.join(await toWslPathAsync(localAppData), "Roblox", "Versions") : path2.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
-  if (!existsSync2(root)) {
-    throw new Error(`Roblox Studio Versions folder not found: ${root}. Set ROBLOX_STUDIO_EXE.`);
-  }
-  const candidates = readdirSync(root).filter((name) => name.startsWith("version-")).map((name) => path2.join(root, name, "RobloxStudioBeta.exe")).filter((candidate) => existsSync2(candidate)).sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
-  if (candidates.length === 0) {
-    throw new Error(`RobloxStudioBeta.exe not found under ${root}. Set ROBLOX_STUDIO_EXE.`);
-  }
-  return candidates[0];
+  return resolveStudioExeFromVersions(root);
 }
 var WINDOWS_STUDIO_PROCESS_QUERY = [
   "$ErrorActionPreference = 'Stop'",
@@ -4795,13 +4919,13 @@ function parseWindowsStudioProcesses(output) {
   }
   return processes;
 }
-async function observeStudioProcesses() {
+async function observeStudioProcesses(timeoutMs = 15e3) {
   const observedAt = Date.now();
   try {
     if (process.platform === "darwin") {
       let out2 = "";
       try {
-        out2 = await runAsync("pgrep", ["-fl", "RobloxStudio"]);
+        out2 = await runAsync("pgrep", ["-fl", "RobloxStudio"], { timeout: timeoutMs });
       } catch (error) {
         const code = error.code;
         if (Number(code) === 1)
@@ -4817,7 +4941,7 @@ async function observeStudioProcesses() {
     if (process.platform !== "win32" && !isWsl()) {
       return { status: "ok", observedAt, processes: [] };
     }
-    const out = await powershellAsync(WINDOWS_STUDIO_PROCESS_QUERY);
+    const out = await powershellAsync(WINDOWS_STUDIO_PROCESS_QUERY, timeoutMs);
     return { status: "ok", observedAt, processes: parseWindowsStudioProcesses(out) };
   } catch (error) {
     return {
@@ -4901,6 +5025,7 @@ var StudioInstanceManager = class {
   confirmedExitGraceMs;
   snapshotCacheMs;
   launchCompletionTimeoutMs;
+  closeTimeoutMs;
   coordinatorTimer;
   coordinatorRefresh;
   cachedSnapshot;
@@ -4915,6 +5040,7 @@ var StudioInstanceManager = class {
     this.confirmedExitGraceMs = options.confirmedExitGraceMs ?? 5e3;
     this.snapshotCacheMs = options.snapshotCacheMs ?? 0;
     this.launchCompletionTimeoutMs = options.launchCompletionTimeoutMs ?? LAUNCH_COMPLETION_TIMEOUT_MS;
+    this.closeTimeoutMs = options.closeTimeoutMs ?? 1e4;
   }
   getLifecycleCapabilities() {
     const platform = this.platformCapabilities ?? getStudioPlatformCapabilities();
@@ -5312,58 +5438,57 @@ var StudioInstanceManager = class {
         instanceId: record.instanceId
       };
     }
+    const deadline = Date.now() + this.closeTimeoutMs;
     const processId = record.nativeProcessId ?? record.spawnPid;
     if (!processId) {
       throw new Error(`Cannot close ${record.instanceId ?? "Studio launch"} because its process id was not detected.`);
     }
     const control = record.recordId ? this.launchControls.get(record.recordId) : void 0;
-    if (record.processAuthorizationState !== "released" && control) {
-      await control.abort();
-      const closedAt2 = Date.now();
-      record.closedAt = closedAt2;
-      record.exitedAt = closedAt2;
-      if (record.state !== "failed")
-        record.state = "exited";
-      record.processObservationStatus = "not_running";
-      record.lastProcessObservationAt = closedAt2;
-      record.lastSuccessfulProcessObservationAt = closedAt2;
-      record.lastProcessObservationError = void 0;
-      this.cleanupManagedRecord(record);
-      this.markClosedInMemory(record);
-      await this.persist(record);
-      return {
-        status: "closed",
-        launchId: record.recordId,
-        instanceId: record.instanceId
-      };
-    }
-    const snapshot = await this.getProcessSnapshot(true);
-    const observation = this.observeRecord(record, snapshot);
-    if (observation.status === "unknown") {
-      await this.applyProcessObservation(record, observation);
-      throw new Error(`Cannot verify the managed Studio process because process observation failed: ${observation.error}`);
-    }
-    if (observation.status === "not_running") {
-      await this.markProcessExited(record, void 0, observation.reason === "identity_mismatch" ? "Studio process identity changed; the retained PID was not reused." : record.failureReason);
-      await this.registry.logEvent({
-        event: "registry_close_already_stopped",
-        recordId: record.recordId,
-        instanceId: record.instanceId,
-        source: record.source,
-        reason: observation.reason === "identity_mismatch" ? "identity_mismatch" : "pid_not_running",
-        action: "marked_closed_and_cleaned_baseplate"
-      });
-      return {
-        status: "already_closed",
-        launchId: record.recordId,
-        instanceId: record.instanceId
-      };
+    const abort = record.processAuthorizationState !== "released" && control ? () => control.abort() : void 0;
+    if (!abort) {
+      let snapshot;
+      try {
+        snapshot = await beforeCloseDeadline(() => this.readProcessSnapshot(deadline - Date.now()), deadline, processId);
+      } catch (error) {
+        if (error instanceof StudioCloseVerificationError) {
+          await this.applyProcessObservation(record, error.observation);
+        }
+        throw error;
+      }
+      const observation = this.observeRecord(record, snapshot);
+      if (observation.status === "unknown") {
+        await this.applyProcessObservation(record, observation);
+        throw new Error(`Cannot verify the managed Studio process because process observation failed: ${observation.error}`);
+      }
+      if (observation.status === "not_running") {
+        await this.markProcessExited(record, void 0, observation.reason === "identity_mismatch" ? "Studio process identity changed; the retained PID was not reused." : record.failureReason);
+        await this.registry.logEvent({
+          event: "registry_close_already_stopped",
+          recordId: record.recordId,
+          instanceId: record.instanceId,
+          source: record.source,
+          reason: observation.reason === "identity_mismatch" ? "identity_mismatch" : "pid_not_running",
+          action: "marked_closed_and_cleaned_baseplate"
+        });
+        return {
+          status: "already_closed",
+          launchId: record.recordId,
+          instanceId: record.instanceId
+        };
+      }
     }
     try {
-      await this.closeProcess(processId, record.nativeProcessStartedAt);
+      await this.closeProcess(processId, record.nativeProcessStartedAt, abort, deadline);
     } catch (error) {
-      const retry = await this.getProcessSnapshot(true);
+      if (error instanceof StudioCloseVerificationError) {
+        await this.applyProcessObservation(record, error.observation);
+        throw error;
+      }
+      if (abort)
+        throw error;
+      const retry = await beforeCloseDeadline(() => this.readProcessSnapshot(deadline - Date.now()), deadline, processId);
       const retryObservation = this.observeRecord(record, retry);
+      await this.applyProcessObservation(record, retryObservation);
       if (retryObservation.status === "running" || retryObservation.status === "unknown")
         throw error;
       await this.registry.logEvent({
@@ -5400,7 +5525,8 @@ var StudioInstanceManager = class {
     };
   }
   async closeConnectedInstance(instance) {
-    const snapshot = await this.getProcessSnapshot(true);
+    const deadline = Date.now() + this.closeTimeoutMs;
+    const snapshot = await beforeCloseDeadline(() => this.readProcessSnapshot(deadline - Date.now()), deadline, 0);
     if (snapshot.status === "error") {
       throw new Error(`Could not enumerate Studio processes: ${snapshot.error}`);
     }
@@ -5408,26 +5534,64 @@ var StudioInstanceManager = class {
     if (!process2) {
       throw new Error(`Could not find a Studio process for connected instance "${instance.instanceId}".`);
     }
-    await this.closeProcess(process2.Id, process2.StartTimeUtcFileTime);
+    await this.closeProcess(process2.Id, process2.StartTimeUtcFileTime, void 0, deadline);
   }
-  async closeProcess(processId, startedAt) {
-    if (this.processAdapter.stopProcess) {
-      await this.processAdapter.stopProcess(processId, startedAt);
-      return;
-    }
-    if (process.platform === "win32" || isWsl()) {
-      if (startedAt === void 0) {
-        throw new Error("Cannot stop a Windows Studio process without its creation-time identity.");
+  async closeProcess(processId, startedAt, stop, deadline = Date.now() + this.closeTimeoutMs) {
+    this.cachedSnapshot = void 0;
+    await beforeCloseDeadline(async () => {
+      if (stop) {
+        await stop();
+      } else if (this.processAdapter.stopProcess) {
+        await this.processAdapter.stopProcess(processId, startedAt);
+      } else if (process.platform === "win32" || isWsl()) {
+        if (startedAt === void 0) {
+          throw new Error("Cannot stop a Windows Studio process without its creation-time identity.");
+        }
+        await stopWindowsStudio(processId, startedAt, Math.max(1, deadline - Date.now()));
+      } else {
+        try {
+          process.kill(processId, "SIGTERM");
+        } catch (error) {
+          if (!(error instanceof Error) || !("code" in error) || error.code !== "ESRCH")
+            throw error;
+        }
       }
-      await stopWindowsStudio(processId, startedAt);
-    } else {
-      try {
-        process.kill(processId, "SIGTERM");
-      } catch (error) {
-        if (error.code !== "ESRCH")
-          throw error;
+    }, deadline, processId);
+    while (true) {
+      const observation = await beforeCloseDeadline(() => this.observeClosingProcess(processId, startedAt, deadline), deadline, processId);
+      if (observation.status === "not_running")
+        return;
+      if (observation.status === "unknown") {
+        throw new StudioCloseVerificationError(`Could not verify Studio process ${processId} termination: ${observation.error}`, observation);
+      }
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        throw new StudioCloseVerificationError(`Timed out closing Studio process ${processId}: the process is still running. Close can be retried.`, observation);
+      }
+      await delay2(Math.min(100, remaining));
+      if (Date.now() >= deadline) {
+        throw new StudioCloseVerificationError(`Timed out closing Studio process ${processId}: the process is still running. Close can be retried.`, observation);
+      }
+    }
+  }
+  async observeClosingProcess(processId, startedAt, deadline) {
+    if (process.platform === "darwin" && !this.processAdapter.observeStudioProcesses && !this.processAdapter.listStudioProcesses) {
+      return observePosixProcess(processId);
+    }
+    const snapshot = await this.readProcessSnapshot(Math.max(1, deadline - Date.now()));
+    if (snapshot.status === "error") {
+      return { status: "unknown", observedAt: snapshot.observedAt, error: snapshot.error };
+    }
+    const target = snapshot.processes.find((candidate) => candidate.Id === processId);
+    if (!target)
+      return { status: "not_running", observedAt: snapshot.observedAt, reason: "missing" };
+    if (startedAt !== void 0 && target.StartTimeUtcFileTime !== startedAt) {
+      if (target.StartTimeUtcFileTime === void 0) {
+        return { status: "unknown", observedAt: snapshot.observedAt, error: "Process creation-time identity is unavailable." };
       }
+      return { status: "not_running", observedAt: snapshot.observedAt, reason: "identity_mismatch" };
     }
+    return { status: "running", observedAt: snapshot.observedAt };
   }
   findProcessForConnectedInstance(instance, processes) {
     if (processes.length === 0)
@@ -5457,24 +5621,7 @@ var StudioInstanceManager = class {
       return this.snapshotInFlight;
     this.snapshotInFlight = (async () => {
       try {
-        let snapshot;
-        if (this.processAdapter.observeStudioProcesses) {
-          snapshot = await this.processAdapter.observeStudioProcesses();
-        } else if (this.processAdapter.listStudioProcesses) {
-          const observedAt = Date.now();
-          const processes = await this.processAdapter.listStudioProcesses();
-          snapshot = { status: "ok", observedAt, processes };
-        } else {
-          snapshot = await observeStudioProcesses();
-        }
-        this.cachedSnapshot = snapshot;
-        return snapshot;
-      } catch (error) {
-        const snapshot = {
-          status: "error",
-          observedAt: Date.now(),
-          error: error instanceof Error ? error.message : String(error)
-        };
+        const snapshot = await this.readProcessSnapshot();
         this.cachedSnapshot = snapshot;
         return snapshot;
       } finally {
@@ -5483,6 +5630,25 @@ var StudioInstanceManager = class {
     })();
     return this.snapshotInFlight;
   }
+  async readProcessSnapshot(timeoutMs = 15e3) {
+    try {
+      if (this.processAdapter.observeStudioProcesses) {
+        return await this.processAdapter.observeStudioProcesses();
+      }
+      if (this.processAdapter.listStudioProcesses) {
+        const observedAt = Date.now();
+        const processes = await this.processAdapter.listStudioProcesses();
+        return { status: "ok", observedAt, processes };
+      }
+      return await observeStudioProcesses(Math.max(1, timeoutMs));
+    } catch (error) {
+      return {
+        status: "error",
+        observedAt: Date.now(),
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
   async getCurrentBootId() {
     return this.processAdapter.currentBootId ? await this.processAdapter.currentBootId() : currentBootIdAsync();
   }
@@ -5548,8 +5714,16 @@ var StudioInstanceManager = class {
     if (!processId)
       return { status: "running", observedAt: snapshot.observedAt };
     const studioProcess = snapshot.processes.find((candidate) => candidate.Id === processId);
-    if (!studioProcess)
+    if (!studioProcess) {
+      if (process.platform === "darwin" && !this.processAdapter.observeStudioProcesses && !this.processAdapter.listStudioProcesses) {
+        const observation = observePosixProcess(processId);
+        return observation.status === "running" ? { status: "unknown", observedAt: observation.observedAt, error: `Studio PID ${processId} is still alive but missing from process enumeration.` } : observation;
+      }
       return { status: "not_running", observedAt: snapshot.observedAt, reason: "missing" };
+    }
+    if (record.nativeProcessStartedAt !== void 0 && studioProcess.StartTimeUtcFileTime === void 0) {
+      return { status: "unknown", observedAt: snapshot.observedAt, error: "Process creation-time identity is unavailable." };
+    }
     return this.verifyProcessForRecord(record, studioProcess) ? { status: "running", observedAt: snapshot.observedAt } : { status: "not_running", observedAt: snapshot.observedAt, reason: "identity_mismatch" };
   }
   verifyProcessForRecord(record, studioProcess) {
@@ -5838,20 +6012,20 @@ var StudioInstanceManager = class {
 };
 
 // ../core/dist/mcp-runtime.js
-var INTERNAL_RESULT_KEYS = /* @__PURE__ */ new Set([
-  "bundleModifiedAt",
-  "bundlePath",
-  "bundleSha256",
-  "connectedAt",
-  "debug",
-  "diagnostics",
-  "internal",
-  "lastActivity",
-  "transportPeerId",
-  "pluginVariant",
-  "pluginVersion",
-  "serverVersion"
-]);
+var INTERNAL_ENVELOPE_KEYS = {
+  bundleModifiedAt: true,
+  bundlePath: true,
+  bundleSha256: true,
+  connectedAt: true,
+  debug: true,
+  diagnostics: true,
+  internal: true,
+  lastActivity: true,
+  transportPeerId: true,
+  pluginVariant: true,
+  pluginVersion: true,
+  serverVersion: true
+};
 var TEXT_RESULT_TOOLS = /* @__PURE__ */ new Set(["get_roblox_docs"]);
 var SIDE_EFFECTING_READ_TOOLS = /* @__PURE__ */ new Set([
   "capture_micro_profiler",
@@ -5900,18 +6074,15 @@ function compactPublicValue(value) {
     return value.map(compactPublicValue);
   if (!value || typeof value !== "object")
     return value;
-  const compact = {};
-  for (const [key, child] of Object.entries(value)) {
-    if (child === void 0 || INTERNAL_RESULT_KEYS.has(key))
-      continue;
-    compact[key] = compactPublicValue(child);
-  }
-  return compact;
+  return Object.fromEntries(Object.entries(value).filter(([, child]) => child !== void 0).map(([key, child]) => [key, compactPublicValue(child)]));
+}
+function compactPublicEnvelope(value) {
+  return Object.fromEntries(Object.entries(value).filter(([key, child]) => child !== void 0 && !Object.hasOwn(INTERNAL_ENVELOPE_KEYS, key)).map(([key, child]) => [key, compactPublicValue(child)]));
 }
 function asStructuredObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return void 0;
-  return compactPublicValue(value);
+  return compactPublicEnvelope(value);
 }
 function parseJsonObject(text) {
   try {
@@ -5936,6 +6107,7 @@ function normalizeToolResult(raw, era) {
       ...result.isError ? { isError: true } : {}
     };
   }
+  const isError = result.isError || structured.success === false || typeof structured.error === "string" && structured.error.length > 0;
   const content = era === "modern" ? originalContent.filter((_, index) => index !== jsonTextIndex) : [
     { type: "text", text: JSON.stringify(structured) },
     ...originalContent.filter((_, index) => index !== jsonTextIndex)
@@ -5943,7 +6115,7 @@ function normalizeToolResult(raw, era) {
   return {
     content,
     structuredContent: structured,
-    ...result.isError ? { isError: true } : {}
+    ...isError ? { isError: true } : {}
   };
 }
 function publicRoutingError(error) {
@@ -5966,8 +6138,11 @@ function publicRoutingError(error) {
   };
 }
 function publicToolErrorBody(name, error) {
+  if (error instanceof MultiplayerGroupInUseError) {
+    return { error: error.code, message: error.message, multiplayer_group_id: error.groupId };
+  }
   if (error instanceof StudioLaunchPreDispatchError) {
-    return compactPublicValue(error.toResponseBody());
+    return compactPublicEnvelope(error.toResponseBody());
   }
   if (error instanceof RoutingFailure)
     return publicRoutingError(error);
@@ -6441,6 +6616,47 @@ var WebSocketStudioTransport = class {
 };
 
 // ../core/dist/http-server.js
+var TOOL_PROXY_ENDPOINTS = {
+  get_place_info: ["/api/place-info"],
+  search_objects: ["/api/search-objects"],
+  get_instance_properties: ["/api/instance-properties"],
+  get_project_structure: ["/api/project-structure"],
+  set_properties: ["/api/set-properties"],
+  get_script_source: ["/api/get-script-source"],
+  set_script_source: ["/api/set-script-source"],
+  edit_script_lines: ["/api/edit-script-lines"],
+  insert_script_lines: ["/api/insert-script-lines"],
+  delete_script_lines: ["/api/delete-script-lines"],
+  get_attributes: ["/api/get-attributes"],
+  selection: ["/api/get-selection", "/api/set-selection", "/api/focus-viewport"],
+  execute_luau: ["/api/execute-luau"],
+  eval_server_runtime: ["/api/eval-runtime"],
+  eval_client_runtime: ["/api/eval-runtime"],
+  grep_scripts: ["/api/grep-scripts"],
+  solo_playtest: ["/api/start-playtest", "/api/stop-playtest", "/api/multiplayer-test-state"],
+  multiplayer_playtest: [
+    "/api/multiplayer-test-start",
+    "/api/multiplayer-test-add-players",
+    "/api/multiplayer-test-leave-client",
+    "/api/multiplayer-test-end",
+    "/api/multiplayer-test-state"
+  ],
+  get_runtime_logs: ["/api/get-runtime-logs"],
+  capture_script_profiler: ["/api/capture-script-profiler"],
+  capture_micro_profiler: ["/api/capture-micro-profiler"],
+  breakpoints: ["/api/breakpoints"],
+  insert_asset: ["/api/insert-asset"],
+  generate_model: ["/api/generate-model"],
+  preview_asset: ["/api/preview-asset"],
+  capture_screenshot: ["/api/capture-studio", "/api/capture-screenshot", "/api/capture-begin", "/api/capture-read", "/api/capture-markers"],
+  simulate_mouse_input: ["/api/simulate-mouse-input"],
+  simulate_keyboard_input: ["/api/simulate-keyboard-input"],
+  get_memory_breakdown: ["/api/get-memory-breakdown"],
+  get_scene_analysis: ["/api/get-scene-analysis"],
+  export_rbxm: ["/api/export-rbxm"],
+  import_rbxm: ["/api/import-rbxm"],
+  find_and_replace_in_scripts: ["/api/find-and-replace-in-scripts"]
+};
 function toPassivePeer(peer) {
   return {
     instanceId: peer.instanceId,
@@ -6627,6 +6843,7 @@ ${body}`);
 }
 function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   const app = express();
+  const allowedProxyEndpoints = allowedTools ? new Set(Object.entries(TOOL_PROXY_ENDPOINTS).filter(([toolName]) => allowedTools.has(toolName)).flatMap(([, endpoints]) => endpoints)) : void 0;
   const studioLifecycleCallable = !allowedTools || allowedTools.has("manage_instance");
   const studioLifecycleCapabilities = studioLifecycleCallable ? tools.getStudioLifecycleCapabilities() : void 0;
   let mcpServerActive = false;
@@ -6773,8 +6990,8 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   });
   const authToken = security?.authToken;
   const authRequired = (requestPath) => {
-    const path6 = requestPath.toLowerCase().replace(/\/+$/, "");
-    return path6 === "/mcp" || path6.startsWith("/mcp/") || path6 === "/proxy" || path6 === "/topology" || path6 === "/request-status" || path6 === "/unregister-instance-id" || path6 === "/create-multiplayer-group" || path6 === "/remove-multiplayer-group";
+    const path7 = requestPath.toLowerCase().replace(/\/+$/, "");
+    return path7 === "/mcp" || path7.startsWith("/mcp/") || path7 === "/proxy" || path7 === "/topology" || path7 === "/request-status" || path7 === "/unregister-instance-id" || path7 === "/create-multiplayer-group" || path7 === "/remove-multiplayer-group";
   };
   app.use((req, res, next) => {
     if (!authToken || !authRequired(req.path)) {
@@ -7034,14 +7251,27 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     const group = await bridge.createMultiplayerGroupEverywhere(groupId, controllerInstanceId);
     res.json({ success: true, group });
   });
-  app.post("/remove-multiplayer-group", async (req, res) => {
+  app.post("/remove-multiplayer-group", async (req, res, next) => {
     const { groupId } = req.body;
     if (typeof groupId !== "string" || groupId.length === 0) {
       res.status(400).json({ error: "groupId is required" });
       return;
     }
-    const removed = await bridge.removeMultiplayerGroupEverywhere(groupId);
-    res.json({ success: true, removed });
+    try {
+      const removed = await bridge.removeMultiplayerGroupEverywhere(groupId);
+      res.json({ success: true, removed });
+    } catch (error) {
+      if (error instanceof MultiplayerGroupInUseError) {
+        res.status(409).json({
+          success: false,
+          error: error.code,
+          message: error.message,
+          groupId: error.groupId
+        });
+        return;
+      }
+      next(error);
+    }
   });
   app.get("/status", (req, res) => {
     const peers = bridge.getPublicPeers().map(toPassivePeer);
@@ -7088,6 +7318,10 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       res.status(400).json({ error: "endpoint and targetPeerId are required" });
       return;
     }
+    if (allowedProxyEndpoints && !allowedProxyEndpoints.has(endpoint)) {
+      res.status(403).json({ error: "forbidden_endpoint" });
+      return;
+    }
     if (timeoutMs !== void 0 && (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 3e5)) {
       res.status(400).json({ error: "timeoutMs must be an integer between 1 and 300000" });
       return;
@@ -7750,12 +7984,10 @@ var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 var MAX_EDITABLE_IMAGE_DIMENSION = 1024;
 var MAX_PNG_DIMENSION = 16 * 1024;
 var MAX_PNG_PIXELS = 8 * 1024 * 1024;
+var MAX_SCREENSHOT_PNG_PIXELS = 32 * 1024 * 1024;
 var MAX_PNG_INPUT_BYTES = 32 * 1024 * 1024;
 var MAX_PNG_BASE64_CHARACTERS = 4 * Math.ceil(MAX_PNG_INPUT_BYTES / 3);
-var MAX_PNG_CHUNK_BYTES = 32 * 1024 * 1024;
-var MAX_PNG_COMPRESSED_BYTES = 32 * 1024 * 1024;
 var MAX_PNG_CHUNKS = 65536;
-var MAX_PNG_INFLATED_BYTES = MAX_PNG_PIXELS * 4 + MAX_PNG_DIMENSION;
 function paethPredictor(a, b, c) {
   const p = a + b - c;
   const pa = Math.abs(p - a);
@@ -7778,12 +8010,12 @@ function bytesPerPixel(colorType) {
     return 2;
   throw new Error(`Unsupported PNG color type ${colorType}. Supported color types: 0, 2, 4, 6.`);
 }
-function validatePngInputSize(byteLength) {
+function validatePngInputSize(byteLength, maxInputBytes = MAX_PNG_INPUT_BYTES) {
   if (!Number.isSafeInteger(byteLength) || byteLength < 0) {
     throw new Error(`Invalid PNG input length ${byteLength}.`);
   }
-  if (byteLength > MAX_PNG_INPUT_BYTES) {
-    throw new Error(`PNG input length ${byteLength} exceeds the ${MAX_PNG_INPUT_BYTES}-byte limit.`);
+  if (byteLength > maxInputBytes) {
+    throw new Error(`PNG input length ${byteLength} exceeds the ${maxInputBytes}-byte limit.`);
   }
 }
 function getBase64DecodedLength(encoded) {
@@ -7845,7 +8077,7 @@ function readPngFileWithinLimit(resolved, imagePath) {
     fs2.closeSync(descriptor);
   }
 }
-function validateSourceDimensions(width, height) {
+function validateSourceDimensions(width, height, maxPixels) {
   if (width <= 0 || height <= 0) {
     throw new Error("PNG IHDR dimensions must be positive.");
   }
@@ -7853,78 +8085,65 @@ function validateSourceDimensions(width, height) {
     throw new Error(`PNG dimensions ${width}x${height} exceed the ${MAX_PNG_DIMENSION}-pixel dimension limit.`);
   }
   const pixelCount = width * height;
-  if (!Number.isSafeInteger(pixelCount) || pixelCount > MAX_PNG_PIXELS) {
-    throw new Error(`PNG pixel count ${pixelCount} exceeds the ${MAX_PNG_PIXELS}-pixel limit.`);
+  if (!Number.isSafeInteger(pixelCount) || pixelCount > maxPixels) {
+    throw new Error(`PNG pixel count ${pixelCount} exceeds the ${maxPixels}-pixel limit.`);
   }
 }
-function getExpectedScanlineLength(width, height, bpp) {
+function getExpectedScanlineLength(width, height, bpp, maxPixels) {
+  const maxInflatedBytes = maxPixels * 4 + MAX_PNG_DIMENSION;
   const stride = width * bpp;
   const expected = height * (stride + 1);
-  if (!Number.isSafeInteger(stride) || !Number.isSafeInteger(expected) || expected > MAX_PNG_INFLATED_BYTES) {
-    throw new Error(`PNG scanline data length ${expected} exceeds the ${MAX_PNG_INFLATED_BYTES}-byte limit.`);
+  if (!Number.isSafeInteger(stride) || !Number.isSafeInteger(expected) || expected > maxInflatedBytes) {
+    throw new Error(`PNG scanline data length ${expected} exceeds the ${maxInflatedBytes}-byte limit.`);
   }
   return expected;
 }
-function convertScanlinesToRgba(raw, width, height, colorType, bpp, expectedLength) {
-  const stride = width * bpp;
-  if (raw.length !== expectedLength) {
-    if (raw.length > expectedLength) {
-      throw new Error(`Inflated PNG data exceeds the expected scanline length of ${expectedLength} bytes.`);
-    }
-    throw new Error(`PNG data ended early. Expected ${expectedLength} bytes after inflate, got ${raw.length}.`);
-  }
-  const unfiltered = Buffer.alloc(width * height * bpp);
-  let srcOffset = 0;
-  for (let y = 0; y < height; y++) {
-    const filter = raw[srcOffset++];
-    const rowOffset = y * stride;
-    const prevRowOffset = (y - 1) * stride;
-    for (let x = 0; x < stride; x++) {
-      const value = raw[srcOffset++];
-      const left = x >= bpp ? unfiltered[rowOffset + x - bpp] : 0;
-      const up = y > 0 ? unfiltered[prevRowOffset + x] : 0;
-      const upLeft = y > 0 && x >= bpp ? unfiltered[prevRowOffset + x - bpp] : 0;
-      let decoded;
-      if (filter === 0) {
-        decoded = value;
-      } else if (filter === 1) {
-        decoded = value + left;
-      } else if (filter === 2) {
-        decoded = value + up;
-      } else if (filter === 3) {
-        decoded = value + Math.floor((left + up) / 2);
-      } else if (filter === 4) {
-        decoded = value + paethPredictor(left, up, upLeft);
-      } else {
-        throw new Error(`Unsupported PNG filter type ${filter}.`);
-      }
-      unfiltered[rowOffset + x] = decoded & 255;
+function unfilterPngRow(raw, rowOffset, stride, bpp) {
+  const filter = raw[rowOffset - 1];
+  if (filter === 0)
+    return;
+  const prevRowOffset = rowOffset - stride - 1;
+  for (let x = 0; x < stride; x++) {
+    const left = x >= bpp ? raw[rowOffset + x - bpp] : 0;
+    const up = prevRowOffset > 0 ? raw[prevRowOffset + x] : 0;
+    const upLeft = prevRowOffset > 0 && x >= bpp ? raw[prevRowOffset + x - bpp] : 0;
+    let predictor;
+    if (filter === 1) {
+      predictor = left;
+    } else if (filter === 2) {
+      predictor = up;
+    } else if (filter === 3) {
+      predictor = Math.floor((left + up) / 2);
+    } else {
+      predictor = paethPredictor(left, up, upLeft);
     }
+    raw[rowOffset + x] = raw[rowOffset + x] + predictor & 255;
   }
-  if (colorType === 6)
-    return unfiltered;
+}
+function convertScanlinesToRgba({ raw, width, height, colorType, bpp }) {
+  const stride = width * bpp;
   const rgba = Buffer.alloc(width * height * 4);
-  let si = 0;
   let di = 0;
-  for (let i = 0; i < width * height; i++) {
-    if (colorType === 2) {
-      rgba[di++] = unfiltered[si++];
-      rgba[di++] = unfiltered[si++];
-      rgba[di++] = unfiltered[si++];
-      rgba[di++] = 255;
-    } else if (colorType === 0) {
-      const gray = unfiltered[si++];
-      rgba[di++] = gray;
-      rgba[di++] = gray;
-      rgba[di++] = gray;
-      rgba[di++] = 255;
-    } else {
-      const gray = unfiltered[si++];
-      const alpha = unfiltered[si++];
-      rgba[di++] = gray;
-      rgba[di++] = gray;
-      rgba[di++] = gray;
-      rgba[di++] = alpha;
+  for (let rowOffset = 1; rowOffset < raw.length; rowOffset += stride + 1) {
+    unfilterPngRow(raw, rowOffset, stride, bpp);
+    if (colorType === 6) {
+      raw.copy(rgba, di, rowOffset, rowOffset + stride);
+      di += stride;
+      continue;
+    }
+    for (let si = rowOffset; si < rowOffset + stride; si += bpp) {
+      if (colorType === 2) {
+        rgba[di++] = raw[si];
+        rgba[di++] = raw[si + 1];
+        rgba[di++] = raw[si + 2];
+        rgba[di++] = 255;
+      } else {
+        const gray = raw[si];
+        rgba[di++] = gray;
+        rgba[di++] = gray;
+        rgba[di++] = gray;
+        rgba[di++] = colorType === 4 ? raw[si + 1] : 255;
+      }
     }
   }
   return rgba;
@@ -7951,8 +8170,9 @@ function resizeRgbaNearest(image) {
   }
   return { width, height, rgba };
 }
-function decodePngToRgba(data) {
-  validatePngInputSize(data.length);
+function inflatePng(data, maxPixels) {
+  const maxInputBytes = maxPixels * 4;
+  validatePngInputSize(data.length, maxInputBytes);
   if (data.length < PNG_SIGNATURE.length || !data.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)) {
     throw new Error("Unsupported image format. generate_model currently supports PNG images.");
   }
@@ -7973,8 +8193,8 @@ function decodePngToRgba(data) {
     }
     const length = data.readUInt32BE(offset);
     const type = data.toString("ascii", offset + 4, offset + 8);
-    if (length > MAX_PNG_CHUNK_BYTES) {
-      throw new Error(`PNG chunk ${type} length ${length} exceeds the ${MAX_PNG_CHUNK_BYTES}-byte chunk limit.`);
+    if (length > maxInputBytes) {
+      throw new Error(`PNG chunk ${type} length ${length} exceeds the ${maxInputBytes}-byte chunk limit.`);
     }
     if (++chunkCount > MAX_PNG_CHUNKS) {
       throw new Error(`PNG contains more than the ${MAX_PNG_CHUNKS}-chunk limit.`);
@@ -8010,12 +8230,12 @@ function decodePngToRgba(data) {
       if (interlace !== 0)
         throw new Error("Interlaced PNG images are not supported.");
       bpp = bytesPerPixel(colorType);
-      validateSourceDimensions(width, height);
-      expectedScanlineLength = getExpectedScanlineLength(width, height, bpp);
+      validateSourceDimensions(width, height, maxPixels);
+      expectedScanlineLength = getExpectedScanlineLength(width, height, bpp, maxPixels);
       sawIhdr = true;
     } else if (type === "IDAT") {
-      if (length > MAX_PNG_COMPRESSED_BYTES - idatLength) {
-        throw new Error(`PNG image data exceeds the ${MAX_PNG_COMPRESSED_BYTES}-byte compressed-data limit.`);
+      if (length > maxInputBytes - idatLength) {
+        throw new Error(`PNG image data exceeds the ${maxInputBytes}-byte compressed-data limit.`);
       }
       idatLength += length;
       idatChunks.push(chunk);
@@ -8043,8 +8263,43 @@ function decodePngToRgba(data) {
     const detail = error instanceof Error ? error.message : String(error);
     throw new Error(`Invalid PNG compressed data: ${detail}`);
   }
-  const rgba = convertScanlinesToRgba(raw, width, height, colorType, bpp, expectedScanlineLength);
-  return resizeRgbaNearest({ width, height, rgba });
+  if (raw.length !== expectedScanlineLength) {
+    throw new Error(`PNG data ended early. Expected ${expectedScanlineLength} bytes after inflate, got ${raw.length}.`);
+  }
+  const rowLength = width * bpp + 1;
+  for (let rowOffset = 0; rowOffset < raw.length; rowOffset += rowLength) {
+    if (raw[rowOffset] > 4) {
+      throw new Error(`Unsupported PNG filter type ${raw[rowOffset]}.`);
+    }
+  }
+  return { width, height, colorType, bpp, raw };
+}
+function isUniformPng(data) {
+  const { raw, width, colorType, bpp } = inflatePng(data, MAX_SCREENSHOT_PNG_PIXELS);
+  const stride = width * bpp;
+  unfilterPngRow(raw, 1, stride, bpp);
+  const red = raw[1];
+  const grayscale = colorType === 0 || colorType === 4;
+  const green = grayscale ? red : raw[2];
+  const blue = grayscale ? red : raw[3];
+  for (let rowOffset = 1; rowOffset < raw.length; rowOffset += stride + 1) {
+    if (rowOffset !== 1)
+      unfilterPngRow(raw, rowOffset, stride, bpp);
+    for (let offset = rowOffset; offset < rowOffset + stride; offset += bpp) {
+      if (raw[offset] !== red || !grayscale && (raw[offset + 1] !== green || raw[offset + 2] !== blue)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function decodePngToRgba(data) {
+  const png = inflatePng(data, MAX_PNG_PIXELS);
+  return resizeRgbaNearest({
+    width: png.width,
+    height: png.height,
+    rgba: convertScanlinesToRgba(png)
+  });
 }
 function decodePngBase64ToRgba(encoded) {
   const expectedLength = getBase64DecodedLength(encoded);
@@ -10028,9 +10283,308 @@ function rgbaToPng(rgba, width, height) {
   ]);
 }
 
-// ../core/dist/tools/index.js
+// ../core/dist/host-capture.js
+import { spawn as spawn2 } from "child_process";
 import * as fs3 from "fs";
+import * as os3 from "os";
 import * as path5 from "path";
+var HOST_CAPTURE_TIMEOUT_MS = 2e4;
+var MARKER_MIN_RB = 200;
+var MARKER_MAX_G = 60;
+var MARKER_SCALE_TOLERANCE = 0.03;
+function isHostCaptureDisabled(env = process.env) {
+  const value = (env.ROBLOX_STUDIO_HOST_CAPTURE ?? "").trim().toLowerCase();
+  return value === "0" || value === "false" || value === "off";
+}
+function isHostCaptureSupported(platform = process.platform) {
+  return platform === "win32";
+}
+function hostCaptureUnsupportedReason(platform = process.platform) {
+  return `host window capture is only implemented on Windows (this is ${platform})`;
+}
+function isUniformFrame(rgba, width, height) {
+  const pixels = width * height;
+  if (pixels <= 0 || rgba.length < pixels * 4)
+    return false;
+  const r = rgba[0];
+  const g = rgba[1];
+  const b = rgba[2];
+  for (let i = 0; i < pixels; i++) {
+    const o = i * 4;
+    if (rgba[o] !== r || rgba[o + 1] !== g || rgba[o + 2] !== b)
+      return false;
+  }
+  return true;
+}
+function isMarkerPixel(rgba, offset) {
+  return rgba[offset] >= MARKER_MIN_RB && rgba[offset + 1] <= MARKER_MAX_G && rgba[offset + 2] >= MARKER_MIN_RB;
+}
+function findViewportRect(rgba, width, height, hint) {
+  let minX = width;
+  let minY = height;
+  let maxX = -1;
+  let maxY = -1;
+  for (let y = 0; y < height; y++) {
+    const row = y * width * 4;
+    for (let x = 0; x < width; x++) {
+      if (!isMarkerPixel(rgba, row + x * 4))
+        continue;
+      if (x < minX)
+        minX = x;
+      if (x > maxX)
+        maxX = x;
+      if (y < minY)
+        minY = y;
+      if (y > maxY)
+        maxY = y;
+    }
+  }
+  if (maxX < 0) {
+    return { error: "no viewport markers were visible in the Studio window capture" };
+  }
+  const rect = { x: minX, y: minY, width: maxX - minX + 1, height: maxY - minY + 1 };
+  const inset = Math.max(1, Math.floor(hint.markerSize / 4));
+  const corners = [
+    [minX + inset, minY + inset],
+    [maxX - inset, minY + inset],
+    [minX + inset, maxY - inset],
+    [maxX - inset, maxY - inset]
+  ];
+  for (const [x, y] of corners) {
+    if (!isMarkerPixel(rgba, (y * width + x) * 4)) {
+      return { error: `viewport markers were found but do not form a rectangle (box ${rect.width}x${rect.height} at ${rect.x},${rect.y})` };
+    }
+  }
+  const scaleX = rect.width / hint.viewportWidth;
+  const scaleY = rect.height / hint.viewportHeight;
+  if (Math.abs(scaleX - scaleY) > MARKER_SCALE_TOLERANCE * Math.max(scaleX, scaleY)) {
+    return {
+      error: `viewport marker box ${rect.width}x${rect.height} does not match the reported ${hint.viewportWidth}x${hint.viewportHeight} viewport aspect`
+    };
+  }
+  return { rect };
+}
+function cropToViewport(rgba, width, height, rect, targetWidth, targetHeight) {
+  const x0 = Math.max(0, Math.min(width - 1, rect.x));
+  const y0 = Math.max(0, Math.min(height - 1, rect.y));
+  const srcW = Math.max(1, Math.min(rect.width, width - x0));
+  const srcH = Math.max(1, Math.min(rect.height, height - y0));
+  const exact = srcW === targetWidth && srcH === targetHeight;
+  const outW = targetWidth;
+  const outH = targetHeight;
+  const out = Buffer.alloc(outW * outH * 4);
+  if (exact) {
+    for (let y = 0; y < outH; y++) {
+      rgba.copy(out, y * outW * 4, ((y0 + y) * width + x0) * 4, ((y0 + y) * width + x0 + outW) * 4);
+    }
+    return { width: outW, height: outH, rgba: out };
+  }
+  const sx = srcW / outW;
+  const sy = srcH / outH;
+  for (let y = 0; y < outH; y++) {
+    const fy = Math.min(srcH - 1, (y + 0.5) * sy - 0.5);
+    const iy = Math.max(0, Math.floor(fy));
+    const ny = Math.min(srcH - 1, iy + 1);
+    const wy = Math.max(0, fy - iy);
+    for (let x = 0; x < outW; x++) {
+      const fx = Math.min(srcW - 1, (x + 0.5) * sx - 0.5);
+      const ix = Math.max(0, Math.floor(fx));
+      const nx = Math.min(srcW - 1, ix + 1);
+      const wx = Math.max(0, fx - ix);
+      const o00 = ((y0 + iy) * width + x0 + ix) * 4;
+      const o10 = ((y0 + iy) * width + x0 + nx) * 4;
+      const o01 = ((y0 + ny) * width + x0 + ix) * 4;
+      const o11 = ((y0 + ny) * width + x0 + nx) * 4;
+      const dst = (y * outW + x) * 4;
+      for (let c = 0; c < 4; c++) {
+        const top = rgba[o00 + c] * (1 - wx) + rgba[o10 + c] * wx;
+        const bottom = rgba[o01 + c] * (1 - wx) + rgba[o11 + c] * wx;
+        out[dst + c] = Math.round(top * (1 - wy) + bottom * wy);
+      }
+    }
+  }
+  return { width: outW, height: outH, rgba: out };
+}
+var WINDOWS_CAPTURE_SCRIPT = String.raw`
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+Add-Type -AssemblyName System.Drawing
+Add-Type -TypeDefinition @"
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+public static class McpStudioCapture {
+  [DllImport("user32.dll")] static extern bool EnumWindows(EnumWindowsProc cb, IntPtr lParam);
+  [DllImport("user32.dll")] static extern bool IsWindowVisible(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern bool IsIconic(IntPtr hWnd);
+  [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint pid);
+  [DllImport("user32.dll", CharSet = CharSet.Unicode)] static extern int GetWindowTextW(IntPtr hWnd, StringBuilder text, int count);
+  [DllImport("user32.dll", CharSet = CharSet.Unicode)] static extern int GetWindowTextLengthW(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern bool GetClientRect(IntPtr hWnd, out RECT rect);
+  [DllImport("user32.dll")] public static extern bool PrintWindow(IntPtr hWnd, IntPtr hdc, uint flags);
+  delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+  [StructLayout(LayoutKind.Sequential)] public struct RECT { public int Left, Top, Right, Bottom; }
+  public class Candidate { public IntPtr Handle; public uint Pid; public string Title; }
+  public static List<Candidate> Find(string processName) {
+    var found = new List<Candidate>();
+    EnumWindows((hWnd, lParam) => {
+      if (!IsWindowVisible(hWnd)) return true;
+      int length = GetWindowTextLengthW(hWnd);
+      if (length <= 0) return true;
+      var sb = new StringBuilder(length + 1);
+      GetWindowTextW(hWnd, sb, sb.Capacity);
+      string title = sb.ToString();
+      if (!title.EndsWith("Roblox Studio", StringComparison.Ordinal)) return true;
+      uint pid;
+      GetWindowThreadProcessId(hWnd, out pid);
+      try {
+        var proc = System.Diagnostics.Process.GetProcessById((int)pid);
+        if (!string.Equals(proc.ProcessName, processName, StringComparison.OrdinalIgnoreCase)) return true;
+      } catch { return true; }
+      found.Add(new Candidate { Handle = hWnd, Pid = pid, Title = title });
+      return true;
+    }, IntPtr.Zero);
+    return found;
+  }
+}
+"@
+function Emit($obj) { Write-Output ($obj | ConvertTo-Json -Compress) }
+$hint = $env:MCP_CAPTURE_TITLE_HINT
+$outFile = $env:MCP_CAPTURE_OUT
+$candidates = [McpStudioCapture]::Find('RobloxStudioBeta')
+if ($candidates.Count -eq 0) { Emit @{ ok = $false; error = 'no visible Roblox Studio window was found' }; exit 0 }
+$pick = $null
+if ($hint) { $pick = $candidates | Where-Object { $_.Title.StartsWith($hint) } | Select-Object -First 1 }
+if ($pick -eq $null -and $candidates.Count -eq 1) { $pick = $candidates[0] }
+if ($pick -eq $null) {
+  $titles = ($candidates | ForEach-Object { $_.Title }) -join ' | '
+  Emit @{ ok = $false; error = "could not pick a Studio window for '$hint' among: $titles" }; exit 0
+}
+if ([McpStudioCapture]::IsIconic($pick.Handle)) {
+  Emit @{ ok = $false; error = "the Studio window '$($pick.Title)' is minimized; restore it (it may stay behind other windows)" }; exit 0
+}
+$rect = New-Object McpStudioCapture+RECT
+[void][McpStudioCapture]::GetClientRect($pick.Handle, [ref]$rect)
+$w = $rect.Right - $rect.Left; $h = $rect.Bottom - $rect.Top
+if ($w -le 0 -or $h -le 0) { Emit @{ ok = $false; error = "the Studio window client area is empty ($w x $h)" }; exit 0 }
+$bmp = New-Object System.Drawing.Bitmap $w, $h, ([System.Drawing.Imaging.PixelFormat]::Format32bppArgb)
+$g = [System.Drawing.Graphics]::FromImage($bmp)
+$hdc = $g.GetHdc()
+# PW_CLIENTONLY (1) | PW_RENDERFULLCONTENT (2): DWM-composited client area, occluded windows included.
+$printed = [McpStudioCapture]::PrintWindow($pick.Handle, $hdc, 3)
+$g.ReleaseHdc($hdc); $g.Dispose()
+if (-not $printed) { $bmp.Dispose(); Emit @{ ok = $false; error = 'PrintWindow failed for the Studio window' }; exit 0 }
+$bounds = New-Object System.Drawing.Rectangle 0, 0, $w, $h
+$data = $bmp.LockBits($bounds, [System.Drawing.Imaging.ImageLockMode]::ReadOnly, [System.Drawing.Imaging.PixelFormat]::Format32bppArgb)
+$bytes = New-Object byte[] ($data.Stride * $h)
+[System.Runtime.InteropServices.Marshal]::Copy($data.Scan0, $bytes, 0, $bytes.Length)
+$stride = $data.Stride
+$bmp.UnlockBits($data); $bmp.Dispose()
+[System.IO.File]::WriteAllBytes($outFile, $bytes)
+Emit @{ ok = $true; width = $w; height = $h; stride = $stride; title = $pick.Title }
+`;
+function powershellPath() {
+  const systemRoot = process.env.SystemRoot ?? process.env.windir;
+  if (systemRoot) {
+    const candidate = path5.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    if (fs3.existsSync(candidate))
+      return candidate;
+  }
+  return "powershell.exe";
+}
+function runWindowsCapture(titleHint, outFile) {
+  return new Promise((resolve5, reject) => {
+    const encoded = Buffer.from(WINDOWS_CAPTURE_SCRIPT, "utf16le").toString("base64");
+    const child = spawn2(powershellPath(), ["-NoProfile", "-NonInteractive", "-NoLogo", "-ExecutionPolicy", "Bypass", "-EncodedCommand", encoded], {
+      env: { ...process.env, MCP_CAPTURE_TITLE_HINT: titleHint ?? "", MCP_CAPTURE_OUT: outFile },
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      child.kill();
+      reject(new Error(`host window capture timed out after ${HOST_CAPTURE_TIMEOUT_MS}ms`));
+    }, HOST_CAPTURE_TIMEOUT_MS);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error(`could not start PowerShell for host window capture: ${error.message}`));
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+      const last = lines[lines.length - 1];
+      if (last && last.startsWith("{")) {
+        try {
+          resolve5(JSON.parse(last));
+          return;
+        } catch {
+        }
+      }
+      const detail = (stderr.trim() || stdout.trim()).slice(0, 600);
+      reject(new Error(`host window capture helper exited with code ${code}${detail ? `: ${detail}` : ""}`));
+    });
+  });
+}
+async function captureStudioWindow(titleHint) {
+  if (isHostCaptureDisabled()) {
+    return { ok: false, error: "host window capture is disabled by ROBLOX_STUDIO_HOST_CAPTURE" };
+  }
+  if (!isHostCaptureSupported()) {
+    return { ok: false, error: hostCaptureUnsupportedReason() };
+  }
+  const outFile = path5.join(os3.tmpdir(), `robloxstudio-mcp-capture-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.bgra`);
+  try {
+    const report = await runWindowsCapture(titleHint, outFile);
+    if (!report.ok || !report.width || !report.height || !report.stride) {
+      return { ok: false, error: report.error ?? "host window capture returned no image" };
+    }
+    const raw = fs3.readFileSync(outFile);
+    const { width, height, stride } = report;
+    const rgba = Buffer.alloc(width * height * 4);
+    for (let y = 0; y < height; y++) {
+      const src = y * stride;
+      const dst = y * width * 4;
+      for (let x = 0; x < width; x++) {
+        const s = src + x * 4;
+        const d = dst + x * 4;
+        rgba[d] = raw[s + 2];
+        rgba[d + 1] = raw[s + 1];
+        rgba[d + 2] = raw[s];
+        rgba[d + 3] = 255;
+      }
+    }
+    return { ok: true, capture: { width, height, rgba, title: report.title ?? "" } };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  } finally {
+    fs3.rmSync(outFile, { force: true });
+  }
+}
+
+// ../core/dist/tools/index.js
+import * as fs4 from "fs";
+import * as path6 from "path";
+var HOST_VIEWPORT_RECT_TTL_MS = 6e4;
 var MAX_INLINE_IMAGE_BYTES = 6e6;
 var MAX_MATRIX_IMAGE_BYTES = 8e6;
 var DEFAULT_ASSET_AUDIO_PREVIEWS = 3;
@@ -10209,9 +10763,9 @@ function compactSoundReference(sound) {
     name: stringField(sound, "name"),
     className: stringField(sound, "className")
   };
-  const path6 = stringField(sound, "path");
-  if (path6)
-    compact.path = path6;
+  const path7 = stringField(sound, "path");
+  if (path7)
+    compact.path = path7;
   const assetId = robloxAssetIdFromContentId(sound.assetId ?? sound.soundId ?? sound.asset);
   if (assetId !== void 0)
     compact.assetId = assetId;
@@ -10274,8 +10828,8 @@ function loadMicroProfilerBaseline(source, sourcePath) {
     if (typeof sourcePath !== "string" || sourcePath === "") {
       throw new Error("baseline_path must be a non-empty string when provided");
     }
-    const resolved = path5.resolve(sourcePath);
-    const parsed = JSON.parse(fs3.readFileSync(resolved, "utf8"));
+    const resolved = path6.resolve(sourcePath);
+    const parsed = JSON.parse(fs4.readFileSync(resolved, "utf8"));
     const record = asRecord(parsed);
     if (!record)
       throw new Error(`baseline_path did not contain a JSON object: ${resolved}`);
@@ -10777,6 +11331,9 @@ var RobloxStudioTools = class {
   cookieClient;
   instanceManager;
   managedConnectionAssociations = Promise.resolve();
+  hostWindowCapture = captureStudioWindow;
+  hostViewportRects = /* @__PURE__ */ new Map();
+  viewportCaptureQueues = /* @__PURE__ */ new Map();
   constructor(bridge) {
     this.client = new StudioHttpClient(bridge);
     this.bridge = bridge;
@@ -10886,7 +11443,10 @@ var RobloxStudioTools = class {
   _requestPeer(endpoint, data, targetPeerId, timeoutMs, signal, operationId) {
     return this.client.request(endpoint, data, targetPeerId, timeoutMs, signal, operationId);
   }
-  _request(endpoint, data, instanceId, role, timeoutMs, signal) {
+  async _request(endpoint, data, instanceId, role, timeoutMs, signal) {
+    const refresh = this.bridge.refreshTopologyForRouting(signal);
+    if (refresh)
+      await refresh;
     const peer = this._peerForRoleInScope(instanceId, role);
     if (!peer) {
       throw new RoutingFailure({
@@ -10899,6 +11459,9 @@ var RobloxStudioTools = class {
   }
   // Resolve an optional Studio process plus role to one exact Peer and dispatch.
   async _callSingle(endpoint, data, target, instance_id, timeoutMs, signal, operationId) {
+    const refresh = this.bridge.refreshTopologyForRouting(signal);
+    if (refresh)
+      await refresh;
     const resolved = this.bridge.resolveTarget({ instance_id, target });
     if (!resolved.ok)
       throw new RoutingFailure(resolved.error);
@@ -10930,6 +11493,7 @@ var RobloxStudioTools = class {
       clientRole: client?.role
     };
   }
+  // Resolve synchronously after the caller has refreshed and captured its topology.
   _resolveInstanceIdOnly(instance_id) {
     if (instance_id !== void 0) {
       const resolvedInstanceId = this.bridge.resolveConnectedInstanceId(instance_id);
@@ -11143,6 +11707,9 @@ var RobloxStudioTools = class {
   async _waitForRuntimeRoles(instanceId, opts, timeoutSec = 30) {
     const deadline = Date.now() + timeoutSec * 1e3;
     while (Date.now() < deadline) {
+      const refresh = this.bridge.refreshTopologyForRouting();
+      if (refresh)
+        await refresh;
       const roles = this._rolesForScope(instanceId);
       const clientRoles = this._clientRolesForScope(instanceId);
       const hasServer = !opts.server || roles.includes("server");
@@ -11164,6 +11731,9 @@ var RobloxStudioTools = class {
     const deadline = Date.now() + timeoutSec * 1e3;
     let exactSince;
     while (Date.now() < deadline) {
+      const refresh = this.bridge.refreshTopologyForRouting();
+      if (refresh)
+        await refresh;
       const roles2 = this._rolesForScope(instanceId);
       const clientCount2 = this._clientRolesForScope(instanceId).length;
       if (clientCount2 > expectedClientCount) {
@@ -11186,6 +11756,9 @@ var RobloxStudioTools = class {
   async _waitForRuntimeRolesFresh(instanceId, connectedAfter, requiredRoles, timeoutSec = 60) {
     const deadline = Date.now() + timeoutSec * 1e3;
     while (Date.now() < deadline) {
+      const refresh = this.bridge.refreshTopologyForRouting();
+      if (refresh)
+        await refresh;
       const peers = this.bridge.getPeersInScope(instanceId);
       const roles = peers.map((peer) => peer.role);
       const freshRoles = new Set(peers.filter((peer) => peer.connectedAt >= connectedAfter).map((peer) => peer.role));
@@ -11200,8 +11773,8 @@ var RobloxStudioTools = class {
       timedOut: true
     };
   }
-  async getFileTree(path6 = "", instance_id) {
-    const response = await this._callSingle("/api/file-tree", { path: path6 }, void 0, instance_id);
+  async getFileTree(path7 = "", instance_id) {
+    const response = await this._callSingle("/api/file-tree", { path: path7 }, void 0, instance_id);
     return {
       content: [
         {
@@ -11293,9 +11866,9 @@ var RobloxStudioTools = class {
       ]
     };
   }
-  async getProjectStructure(path6, maxDepth, scriptsOnly, instance_id) {
+  async getProjectStructure(path7, maxDepth, scriptsOnly, instance_id) {
     const response = await this._callSingle("/api/project-structure", {
-      path: path6,
+      path: path7,
       maxDepth,
       scriptsOnly
     }, void 0, instance_id);
@@ -11456,7 +12029,7 @@ var RobloxStudioTools = class {
     };
   }
   async setSelection(paths, mode, instance_id) {
-    if (!Array.isArray(paths) || paths.some((path6) => typeof path6 !== "string" || path6.length === 0)) {
+    if (!Array.isArray(paths) || paths.some((path7) => typeof path7 !== "string" || path7.length === 0)) {
       throw new Error("selection paths must contain only non-empty instance paths");
     }
     const selectionMode = mode ?? "set";
@@ -11483,6 +12056,9 @@ var RobloxStudioTools = class {
     if (angleY !== void 0 && (angleY < -89 || angleY > 89)) {
       throw new Error("selection angleY must be between -89 and 89");
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const { instanceId, clientRole } = this._resolveRuntime(instance_id);
     const response = await this._callSingle("/api/focus-viewport", {
       path: instancePath,
@@ -11547,6 +12123,9 @@ var RobloxStudioTools = class {
   }
   async setNetworkProfile(profile, target, overrides, instance_id) {
     const values = normalizeNetworkProfile(profile, overrides);
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const instanceId = this._resolveInstanceIdOnly(instance_id);
     const clientRoles = this._clientRolesForScope(instanceId);
     const selectedTarget = target ?? "client-1";
@@ -11613,6 +12192,9 @@ var RobloxStudioTools = class {
     const selectedInclude = this._normalizeSimulationInclude(include);
     const includeNetwork = selectedInclude === "network" || selectedInclude === "both";
     const includeDeviceSimulator = selectedInclude === "deviceSimulator" || selectedInclude === "both";
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this._resolveSimulationTargets(target, instance_id, "get_simulation_state");
     const roleEntries = await Promise.all(resolved.roles.map(async (role) => {
       const state = {};
@@ -11659,6 +12241,9 @@ var RobloxStudioTools = class {
     if (!resetNetwork && !resetDeviceSimulator) {
       throw new Error("reset_simulation_state requires network=true and/or deviceSimulator=true; both default to true");
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this._resolveSimulationTargets(target, instance_id, "reset_simulation_state");
     const roleEntries = await Promise.all(resolved.roles.map(async (role) => {
       const result = {};
@@ -11717,6 +12302,9 @@ var RobloxStudioTools = class {
     if (deviceId !== void 0 && (typeof deviceId !== "string" || deviceId.trim() === "")) {
       throw new Error("deviceId must be a non-empty string when provided");
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this._resolveDeviceSimulatorSingleTarget(target, instance_id, "get_device_simulator_state");
     const state = await this._executeDeviceSimulatorOperation(resolved.instanceId, resolved.role, "get", {
       includeDeviceList: includeDeviceList !== false,
@@ -11741,6 +12329,9 @@ var RobloxStudioTools = class {
     if (stopSimulation !== true && !hasDeviceSimulatorSettings(settings)) {
       throw new Error("set_device_simulator requires stopSimulation=true or at least one simulator setting");
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this._resolveDeviceSimulatorSetTargets(target, instance_id);
     const responses = await Promise.allSettled(resolved.roles.map(async (role) => {
       const result = await this._executeDeviceSimulatorOperation(resolved.instanceId, role, "set", stopSimulation === true ? { stopSimulation: true } : { settings });
@@ -11799,6 +12390,9 @@ var RobloxStudioTools = class {
         label: raw.label
       };
     });
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this._resolveDeviceSimulatorSingleTarget(target, instance_id, "capture_device_matrix");
     if (resolved.role.startsWith("client-") && await this._isMultiplayerTestRunning(resolved.instanceId)) {
       throw new Error("capture_device_matrix does not support StudioTestService multiplayer client targets because Roblox scopes temporary screenshot textures per client process");
@@ -12150,6 +12744,9 @@ var RobloxStudioTools = class {
     if (outputPath) {
       data.__mcp_include_raw_json = true;
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this.bridge.resolveTarget({ instance_id, target: targetRole });
     if (!resolved.ok)
       throw new RoutingFailure(resolved.error);
@@ -12169,9 +12766,9 @@ var RobloxStudioTools = class {
       const rawJson = mutable.raw_json;
       if (typeof rawJson === "string") {
         if (typeof outputPath === "string" && outputPath !== "") {
-          const resolvedOutputPath = path5.resolve(outputPath);
-          fs3.mkdirSync(path5.dirname(resolvedOutputPath), { recursive: true });
-          fs3.writeFileSync(resolvedOutputPath, rawJson, "utf8");
+          const resolvedOutputPath = path6.resolve(outputPath);
+          fs4.mkdirSync(path6.dirname(resolvedOutputPath), { recursive: true });
+          fs4.writeFileSync(resolvedOutputPath, rawJson, "utf8");
           mutable.output_path = resolvedOutputPath;
         }
         delete mutable.raw_json;
@@ -12210,6 +12807,9 @@ var RobloxStudioTools = class {
     if (summaryOutputPath || baselinePath || baseline || includeComparisonIndex) {
       data.__mcp_include_comparison_index = true;
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this.bridge.resolveTarget({ instance_id, target: targetRole });
     if (!resolved.ok)
       throw new RoutingFailure(resolved.error);
@@ -12229,9 +12829,9 @@ var RobloxStudioTools = class {
       const rawSnapshotBase64 = mutable.raw_snapshot_base64;
       if (typeof rawSnapshotBase64 === "string") {
         if (typeof outputPath === "string" && outputPath !== "") {
-          const resolvedOutputPath = path5.resolve(outputPath);
-          fs3.mkdirSync(path5.dirname(resolvedOutputPath), { recursive: true });
-          fs3.writeFileSync(resolvedOutputPath, Buffer.from(rawSnapshotBase64, "base64"));
+          const resolvedOutputPath = path6.resolve(outputPath);
+          fs4.mkdirSync(path6.dirname(resolvedOutputPath), { recursive: true });
+          fs4.writeFileSync(resolvedOutputPath, Buffer.from(rawSnapshotBase64, "base64"));
           mutable.output_path = resolvedOutputPath;
         }
         delete mutable.raw_snapshot_base64;
@@ -12245,9 +12845,9 @@ var RobloxStudioTools = class {
         });
       }
       if (typeof summaryOutputPath === "string" && summaryOutputPath !== "") {
-        const resolvedSummaryPath = path5.resolve(summaryOutputPath);
-        fs3.mkdirSync(path5.dirname(resolvedSummaryPath), { recursive: true });
-        fs3.writeFileSync(resolvedSummaryPath, JSON.stringify(mutable, null, 2), "utf8");
+        const resolvedSummaryPath = path6.resolve(summaryOutputPath);
+        fs4.mkdirSync(path6.dirname(resolvedSummaryPath), { recursive: true });
+        fs4.writeFileSync(resolvedSummaryPath, JSON.stringify(mutable, null, 2), "utf8");
         mutable.summary_output_path = resolvedSummaryPath;
       }
       if (!includeComparisonIndex) {
@@ -12264,6 +12864,9 @@ var RobloxStudioTools = class {
     const data = { ...request, action };
     delete data.target;
     delete data.instance_id;
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this.bridge.resolveTarget({ instance_id, target: targetRole });
     if (!resolved.ok)
       throw new RoutingFailure(resolved.error);
@@ -12306,7 +12909,7 @@ var RobloxStudioTools = class {
       return record.placeId !== void 0 && instance.placeId === record.placeId;
     }
     if ((record.source === "baseplate" || record.source === "local_file") && record.localPlaceFile) {
-      const expectedName = path5.basename(record.localPlaceFile);
+      const expectedName = path6.basename(record.localPlaceFile);
       return instance.placeName === expectedName || instance.dataModelName === expectedName;
     }
     return true;
@@ -12453,6 +13056,7 @@ var RobloxStudioTools = class {
         });
       }
       return this._textResult({
+        test_worker_job_name: parseStudioTestWorkerJobName(process.env.RSMCP_STUDIO_TEST_WORKER_JOB),
         managed: (await this.instanceManager.list()).filter((record2) => record2.closedAt === void 0).map((record2) => this._managedStatus(record2)),
         connected: this.bridge.getPublicInstances().map((instance) => ({
           instance_id: instance.id,
@@ -12531,10 +13135,9 @@ var RobloxStudioTools = class {
         }
         record2 = active[0];
       }
-      if (record2.instanceId)
-        await this.bridge.unregisterInstanceIdEverywhere(record2.instanceId);
       const closeResult = await this.instanceManager.close(record2);
       if (record2.instanceId) {
+        await this.bridge.unregisterInstanceIdEverywhere(record2.instanceId);
         await sleep(500);
         await this.bridge.unregisterInstanceIdEverywhere(record2.instanceId);
       }
@@ -12614,6 +13217,9 @@ var RobloxStudioTools = class {
       throw new Error("solo_playtest requires action=start|stop|status");
     }
     if (action === "status") {
+      const refresh = this.bridge.refreshTopologyForRouting();
+      if (refresh)
+        await refresh;
       const instanceId = this._resolveInstanceIdOnly(instance_id);
       const { roles, runtimeRoles } = this._briefRoles(instanceId);
       return this._textResult({
@@ -12674,6 +13280,9 @@ var RobloxStudioTools = class {
     }
     const data = { mode };
     const startedAt = Date.now();
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this.bridge.resolveTarget({ instance_id, target: void 0 });
     if (!resolved.ok)
       throw new RoutingFailure(resolved.error);
@@ -12724,6 +13333,9 @@ var RobloxStudioTools = class {
     };
   }
   async stopPlaytest(instance_id, timeout = 15) {
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const { instanceId } = this._resolveSingleTarget("edit", instance_id);
     let response;
     let stopRequestError;
@@ -12774,6 +13386,9 @@ var RobloxStudioTools = class {
     };
   }
   async _buildMultiplayerState(instanceId) {
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const peers = this.bridge.getPublicPeers().filter((peer) => this.bridge.getInstanceIdsInScope(instanceId).includes(peer.instanceId)).sort((a, b) => a.role.localeCompare(b.role));
     const multiplayerGroup = this.bridge.getMultiplayerGroups().find((group) => group.instanceIds.includes(instanceId));
     const body = {
@@ -12819,6 +13434,9 @@ var RobloxStudioTools = class {
   async _waitForMultiplayerEditDone(instanceId, timeoutSec = 30) {
     const deadline = Date.now() + timeoutSec * 1e3;
     while (Date.now() < deadline) {
+      const refresh = this.bridge.refreshTopologyForRouting();
+      if (refresh)
+        await refresh;
       if (!this._rolesForScope(instanceId).includes("edit"))
         return false;
       try {
@@ -12833,6 +13451,9 @@ var RobloxStudioTools = class {
     return false;
   }
   async _isMultiplayerTestRunning(instanceId) {
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     return this.bridge.getMultiplayerGroups().some((group) => group.instanceIds.includes(instanceId));
   }
   async _waitForMultiplayerStart(instanceId, clientCount, timeoutSec = 30, connectedAfter) {
@@ -12873,6 +13494,9 @@ var RobloxStudioTools = class {
       throw new Error("multiplayer_playtest requires action=start|status|add_players|leave_client|end");
     }
     const briefState = async (instanceId) => {
+      const refresh = this.bridge.refreshTopologyForRouting();
+      if (refresh)
+        await refresh;
       const state = await this._buildMultiplayerState(this._resolveInstanceIdOnly(instanceId));
       const roles = Array.isArray(state.peers) ? state.peers.flatMap((peer) => peer !== null && typeof peer === "object" && "role" in peer && typeof peer.role === "string" ? [peer.role] : []) : [];
       return {
@@ -12970,6 +13594,9 @@ var RobloxStudioTools = class {
     if (!Number.isInteger(numPlayers) || numPlayers < 1 || numPlayers > 8) {
       throw new Error("numPlayers must be an integer from 1 to 8");
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const editTarget = this._resolveSingleTarget("edit", instance_id);
     const existingRuntime = this._runtimeTargetsForScope(editTarget.instanceId);
     if (existingRuntime.length > 0) {
@@ -13026,6 +13653,9 @@ var RobloxStudioTools = class {
     };
   }
   async multiplayerTestState(instance_id) {
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const instanceId = this._resolveInstanceIdOnly(instance_id);
     const state = await this._buildMultiplayerState(instanceId);
     return { content: [{ type: "text", text: JSON.stringify(state) }] };
@@ -13034,6 +13664,9 @@ var RobloxStudioTools = class {
     if (!Number.isInteger(numPlayers) || numPlayers < 1 || numPlayers > 8) {
       throw new Error("numPlayers must be an integer from 1 to 8");
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const serverTarget = this._resolveSingleTarget("server", instance_id);
     const group = this.bridge.getMultiplayerGroups().find((candidate) => candidate.instanceIds.includes(serverTarget.instanceId));
     const scopeInstanceId = group?.controllerInstanceId ?? serverTarget.instanceId;
@@ -13062,6 +13695,9 @@ var RobloxStudioTools = class {
     if (!/^client-\d+$/.test(target)) {
       throw new Error(`multiplayer_test_leave_client requires target=client-N (got: ${target})`);
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const clientTarget = this._resolveSingleTarget(target, instance_id);
     const group = this.bridge.getMultiplayerGroups().find((candidate) => candidate.instanceIds.includes(clientTarget.instanceId));
     const scopeInstanceId = group?.controllerInstanceId ?? clientTarget.instanceId;
@@ -13085,6 +13721,9 @@ var RobloxStudioTools = class {
     };
   }
   async multiplayerTestEnd(value, timeout, instance_id) {
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     let serverTarget;
     try {
       serverTarget = this._resolveSingleTarget("server", instance_id);
@@ -13133,6 +13772,9 @@ var RobloxStudioTools = class {
     return result;
   }
   async getConnectedInstances() {
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     return this._textResult({
       instances: this.bridge.getConnectedInstances(),
       multiplayerGroups: this.bridge.getConnectedMultiplayerGroups()
@@ -13598,11 +14240,11 @@ var RobloxStudioTools = class {
     return this.resolveUploadedReferenceImageId(decalId, instance_id);
   }
   async uploadAsset(filePath, assetType, displayName, description, userId, groupId) {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    const fileContent = fs3.readFileSync(filePath);
-    const fileName = path5.basename(filePath);
+    const fileContent = fs4.readFileSync(filePath);
+    const fileName = path6.basename(filePath);
     const resolvedGroupId = groupId || process.env.ROBLOX_CREATOR_GROUP_ID;
     const resolvedUserId = userId || process.env.ROBLOX_CREATOR_USER_ID;
     if (assetType === "Decal" && this.cookieClient.hasCookie()) {
@@ -13674,6 +14316,9 @@ var RobloxStudioTools = class {
     if (!action) {
       throw new Error("action is required for simulate_mouse_input");
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const { instanceId, clientRole } = this._resolveRuntime(instance_id);
     const response = await this._callSingle("/api/simulate-mouse-input", {
       action,
@@ -13692,6 +14337,9 @@ var RobloxStudioTools = class {
     if (!keyCode && text === void 0) {
       throw new Error("keyCode or text is required for simulate_keyboard_input");
     }
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const { instanceId, clientRole } = this._resolveRuntime(instance_id);
     const response = await this._callSingle("/api/simulate-keyboard-input", {
       keyCode,
@@ -13730,6 +14378,9 @@ var RobloxStudioTools = class {
     const data = {};
     if (tags !== void 0)
       data.tags = tags;
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this.bridge.resolveTarget({ instance_id, target: tgt });
     if (!resolved.ok)
       throw new RoutingFailure(resolved.error);
@@ -13763,6 +14414,9 @@ var RobloxStudioTools = class {
       data.topN = topN;
     if (raw !== void 0)
       data.raw = raw;
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const resolved = this.bridge.resolveTarget({ instance_id, target: tgt });
     if (!resolved.ok)
       throw new RoutingFailure(resolved.error);
@@ -13806,10 +14460,10 @@ var RobloxStudioTools = class {
       return { content: [{ type: "text", text: JSON.stringify({ error: "plugin returned no base64 payload" }) }] };
     }
     const bytes = Buffer.from(response.base64, "base64");
-    const resolved = path5.resolve(outputPath);
+    const resolved = path6.resolve(outputPath);
     try {
-      fs3.mkdirSync(path5.dirname(resolved), { recursive: true });
-      fs3.writeFileSync(resolved, bytes);
+      fs4.mkdirSync(path6.dirname(resolved), { recursive: true });
+      fs4.writeFileSync(resolved, bytes);
     } catch (err2) {
       return { content: [{ type: "text", text: JSON.stringify({ error: `failed to write ${resolved}: ${err2.message}` }) }] };
     }
@@ -13842,9 +14496,9 @@ var RobloxStudioTools = class {
     let bytes;
     let sourceLabel;
     if (source.path !== void 0) {
-      const resolved = path5.resolve(source.path);
+      const resolved = path6.resolve(source.path);
       try {
-        bytes = fs3.readFileSync(resolved);
+        bytes = fs4.readFileSync(resolved);
       } catch (err2) {
         return { content: [{ type: "text", text: JSON.stringify({ error: `failed to read ${resolved}: ${err2.message}` }) }] };
       }
@@ -13894,19 +14548,57 @@ var RobloxStudioTools = class {
     }, tgt, instance_id);
     return { content: [{ type: "text", text: JSON.stringify(response) }] };
   }
+  // Even native capture must wait while another call has fitted the simulator
+  // or drawn markers. Otherwise it could observe temporary UI or dimensions.
   async _captureViewportImage(instanceId, targetRole, format, quality, maxBytes = MAX_INLINE_IMAGE_BYTES) {
-    let response;
-    if (targetRole.startsWith("client-")) {
-      const begin = await this._callSingle("/api/capture-begin", {}, targetRole, instanceId);
-      if (begin.error) {
-        return { success: false, error: begin.error };
+    const previous = this.viewportCaptureQueues.get(instanceId) ?? Promise.resolve();
+    const capture = previous.then(() => this._captureViewportImageNow(instanceId, targetRole, format, quality, maxBytes));
+    const settled = capture.then(() => void 0, () => void 0);
+    this.viewportCaptureQueues.set(instanceId, settled);
+    try {
+      return await capture;
+    } finally {
+      if (this.viewportCaptureQueues.get(instanceId) === settled)
+        this.viewportCaptureQueues.delete(instanceId);
+    }
+  }
+  async _captureViewportImageNow(instanceId, targetRole, format, quality, maxBytes = MAX_INLINE_IMAGE_BYTES) {
+    const fmt = format === "png" ? "png" : "jpeg";
+    const q = quality === void 0 ? 92 : Math.max(1, Math.min(100, Math.floor(quality)));
+    let response = await this._callSingle("/api/capture-studio", { encoding: fmt === "png" ? "png" : "rgba8" }, targetRole, instanceId);
+    const studioFastPathMissing = response.unavailable !== void 0 || (response.error?.includes("/api/capture-studio") ?? false);
+    if (studioFastPathMissing) {
+      if (targetRole.startsWith("client-")) {
+        const begin = await this._callSingle("/api/capture-begin", {}, targetRole, instanceId);
+        if (begin.error) {
+          return { success: false, error: begin.error };
+        }
+        if (!begin.contentId) {
+          return { success: false, error: "Screenshot capture failed: no content id returned from client." };
+        }
+        response = await this._callSingle("/api/capture-read", { contentId: begin.contentId }, "edit", instanceId);
+      } else {
+        response = await this._callSingle("/api/capture-screenshot", {}, "edit", instanceId);
       }
-      if (!begin.contentId) {
-        return { success: false, error: "Screenshot capture failed: no content id returned from client." };
+    }
+    let hostNote = "";
+    let hostReason;
+    try {
+      hostReason = response.error ? `Studio's capture failed (${response.error})` : this._isUniformCaptureResponse(response) ? "Studio's CaptureService returned a blank (single-colour) frame" : void 0;
+    } catch (error) {
+      response = { ...response, error: `Could not decode Studio's screenshot: ${error instanceof Error ? error.message : String(error)}` };
+      hostReason = `Studio's capture failed (${response.error})`;
+    }
+    if (hostReason !== void 0) {
+      const host = await this._captureViewportFromHostWindow(instanceId, targetRole);
+      if (host.success) {
+        response = host.response;
+        hostNote = ` Captured from the Studio window through the host OS because ${hostReason}.`;
+      } else if (response.error) {
+        response = { ...response, error: `${response.error} Host window capture also failed: ${host.error}.` };
+      } else {
+        hostNote = ` Warning: ${hostReason} and host window capture also failed (${host.error}), so this image may be blank.`;
       }
-      response = await this._callSingle("/api/capture-read", { contentId: begin.contentId }, "edit", instanceId);
-    } else {
-      response = await this._callSingle("/api/capture-screenshot", {}, "edit", instanceId);
     }
     if (response.error) {
       let text = response.error;
@@ -13920,11 +14612,19 @@ var RobloxStudioTools = class {
     if (w === void 0 || h === void 0) {
       return { success: false, error: "Screenshot response missing dimensions." };
     }
-    const fmt = format === "png" ? "png" : "jpeg";
-    const q = quality === void 0 ? 92 : Math.max(1, Math.min(100, Math.floor(quality)));
-    const encoded = encodeImageFromRgbaResponse(response, fmt, q);
-    let { buffer } = encoded;
-    const { mimeType } = encoded;
+    let buffer;
+    let mimeType;
+    if (response.encoding === "png") {
+      if (!response.data) {
+        return { success: false, error: "Screenshot response missing PNG data." };
+      }
+      buffer = Buffer.from(response.data, "base64");
+      mimeType = "image/png";
+    } else {
+      const encoded = encodeImageFromRgbaResponse(response, fmt, q);
+      buffer = encoded.buffer;
+      mimeType = encoded.mimeType;
+    }
     let usedQ = q;
     let note = "";
     if (buffer.length > maxBytes) {
@@ -13949,7 +14649,7 @@ var RobloxStudioTools = class {
     }
     const nativeW = response.nativeWidth ?? w;
     const nativeH = response.nativeHeight ?? h;
-    const message = nativeW !== w || nativeH !== h ? `Screenshot ${w}x${h}px (${fmt}${fmt === "jpeg" ? ` q${usedQ}` : ""})${note}, downscaled from the ${nativeW}x${nativeH} viewport to fit transport limits. For simulate_mouse_input, multiply x read off this image by ${(nativeW / w).toFixed(4)} and y by ${(nativeH / h).toFixed(4)} to get viewport pixel coordinates ((0,0) at the top-left).` : `Screenshot ${w}x${h}px (${fmt}${fmt === "jpeg" ? ` q${usedQ}` : ""})${note}. For simulate_mouse_input, x/y are pixel coordinates in this exact image with (0,0) at the top-left; it is not downscaled, so use coordinates as you read them off the image.`;
+    const message = (nativeW !== w || nativeH !== h ? `Screenshot ${w}x${h}px (${fmt}${fmt === "jpeg" ? ` q${usedQ}` : ""})${note}, downscaled from the ${nativeW}x${nativeH} viewport to fit transport limits. For simulate_mouse_input, multiply x read off this image by ${(nativeW / w).toFixed(4)} and y by ${(nativeH / h).toFixed(4)} to get viewport pixel coordinates ((0,0) at the top-left).` : `Screenshot ${w}x${h}px (${fmt}${fmt === "jpeg" ? ` q${usedQ}` : ""})${note}. For simulate_mouse_input, x/y are pixel coordinates in this exact image with (0,0) at the top-left; it is not downscaled, so use coordinates as you read them off the image.`) + hostNote;
     return {
       success: true,
       width: w,
@@ -13962,7 +14662,153 @@ var RobloxStudioTools = class {
       message
     };
   }
+  _isUniformCaptureResponse(response) {
+    if (!response.data || !response.width || !response.height)
+      return false;
+    const data = Buffer.from(response.data, "base64");
+    if (response.encoding === "png")
+      return isUniformPng(data);
+    return isUniformFrame(data, response.width, response.height);
+  }
+  _hostCaptureTitleHint(instanceId) {
+    const peers = this.bridge.getPeers().filter((peer) => peer.instanceId === instanceId);
+    const edit = peers.find((peer) => peer.role === "edit") ?? peers[0];
+    const name = edit?.dataModelName || edit?.placeName;
+    return name ? name : void 0;
+  }
+  async _callViewportMarkers(action, targetRole, instanceId, captureId) {
+    return await this._callSingle("/api/capture-markers", { action, ...captureId ? { captureId } : {} }, targetRole, instanceId);
+  }
+  // Always restore the simulator, including failures and cached window grabs.
+  async _captureViewportFromHostWindow(instanceId, targetRole) {
+    let prepared;
+    let result;
+    try {
+      prepared = await this._callViewportMarkers("prepare", targetRole, instanceId);
+      if (prepared.error || !prepared.captureId || !prepared.viewportWidth || !prepared.viewportHeight) {
+        result = { success: false, error: prepared.error ?? "the Studio plugin could not prepare host capture (update the plugin)" };
+      } else {
+        if (prepared.viewportChanged)
+          this.hostViewportRects.delete(`${instanceId}|${targetRole}`);
+        result = await this._capturePreparedViewportFromHostWindow(instanceId, targetRole, prepared);
+      }
+    } catch (error) {
+      result = { success: false, error: `host capture failed: ${error instanceof Error ? error.message : String(error)}` };
+    } finally {
+      if (prepared?.captureId) {
+        try {
+          const restored = await this._callViewportMarkers("finish", targetRole, instanceId, prepared.captureId);
+          if (restored.error)
+            result = { success: false, error: `could not restore the Studio viewport: ${restored.error}` };
+          else if (restored.stale || !restored.success)
+            result = { success: false, error: "the host capture transaction expired or lost ownership; retry the capture" };
+        } catch (error) {
+          result = { success: false, error: `could not restore the Studio viewport: ${error instanceof Error ? error.message : String(error)}` };
+        }
+      }
+    }
+    if (!result.success)
+      this.hostViewportRects.delete(`${instanceId}|${targetRole}`);
+    return result;
+  }
+  // Grabs the Studio window through the host OS and crops it to the viewport
+  // of `targetRole`. The plugin pins magenta markers to the viewport corners
+  // so the crop is exact regardless of Studio's dock layout or DPI scale; the
+  // located rect is cached briefly so repeated captures cost one window grab.
+  async _capturePreparedViewportFromHostWindow(instanceId, targetRole, prepared) {
+    const titleHint = this._hostCaptureTitleHint(instanceId);
+    const cacheKey = `${instanceId}|${targetRole}`;
+    const cached = this.hostViewportRects.get(cacheKey);
+    let sizeInfo;
+    try {
+      sizeInfo = await this._callViewportMarkers("query", targetRole, instanceId, prepared.captureId);
+    } catch (error) {
+      return { success: false, error: `viewport markers unavailable: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (sizeInfo.error || !sizeInfo.viewportWidth || !sizeInfo.viewportHeight) {
+      return {
+        success: false,
+        error: sizeInfo.error ?? "the Studio plugin did not report a viewport size (update the plugin to a build with /api/capture-markers)"
+      };
+    }
+    const viewportWidth = prepared.viewportWidth ?? sizeInfo.viewportWidth;
+    const viewportHeight = prepared.viewportHeight ?? sizeInfo.viewportHeight;
+    if (cached && Date.now() - cached.cachedAt < HOST_VIEWPORT_RECT_TTL_MS && cached.viewportWidth === viewportWidth && cached.viewportHeight === viewportHeight) {
+      const grab = await this.hostWindowCapture(titleHint);
+      if (!grab.ok)
+        return { success: false, error: grab.error };
+      if (grab.capture.width === cached.windowWidth && grab.capture.height === cached.windowHeight) {
+        return {
+          success: true,
+          response: this._hostResponseFromCrop(grab.capture.rgba, grab.capture.width, grab.capture.height, cached.rect, viewportWidth, viewportHeight)
+        };
+      }
+      this.hostViewportRects.delete(cacheKey);
+    }
+    let shown;
+    try {
+      shown = await this._callViewportMarkers("show", targetRole, instanceId, prepared.captureId);
+    } catch (error) {
+      return { success: false, error: `could not draw viewport markers: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (shown.error)
+      return { success: false, error: `could not draw viewport markers: ${shown.error}` };
+    const markerSize = shown.markerSize ?? 12;
+    let markerGrab;
+    let hidden;
+    try {
+      markerGrab = await this.hostWindowCapture(titleHint);
+    } finally {
+      hidden = await this._callViewportMarkers("hide", targetRole, instanceId, prepared.captureId);
+    }
+    if (hidden.error)
+      return { success: false, error: `could not hide viewport markers: ${hidden.error}` };
+    if (!markerGrab.ok)
+      return { success: false, error: markerGrab.error };
+    const located = findViewportRect(markerGrab.capture.rgba, markerGrab.capture.width, markerGrab.capture.height, {
+      viewportWidth: shown.viewportWidth ?? viewportWidth,
+      viewportHeight: shown.viewportHeight ?? viewportHeight,
+      markerSize
+    });
+    if ("error" in located)
+      return { success: false, error: located.error };
+    this.hostViewportRects.set(cacheKey, {
+      rect: located.rect,
+      windowWidth: markerGrab.capture.width,
+      windowHeight: markerGrab.capture.height,
+      viewportWidth,
+      viewportHeight,
+      cachedAt: Date.now()
+    });
+    const cleanGrab = await this.hostWindowCapture(titleHint);
+    if (!cleanGrab.ok)
+      return { success: false, error: cleanGrab.error };
+    if (cleanGrab.capture.width !== markerGrab.capture.width || cleanGrab.capture.height !== markerGrab.capture.height) {
+      this.hostViewportRects.delete(cacheKey);
+      return { success: false, error: "the Studio window was resized while locating the viewport; retry the capture" };
+    }
+    return {
+      success: true,
+      response: this._hostResponseFromCrop(cleanGrab.capture.rgba, cleanGrab.capture.width, cleanGrab.capture.height, located.rect, viewportWidth, viewportHeight)
+    };
+  }
+  _hostResponseFromCrop(rgba, width, height, rect, viewportWidth, viewportHeight) {
+    const cropped = cropToViewport(rgba, width, height, rect, viewportWidth, viewportHeight);
+    return {
+      success: true,
+      encoding: "rgba8",
+      source: "host-window",
+      width: cropped.width,
+      height: cropped.height,
+      nativeWidth: viewportWidth,
+      nativeHeight: viewportHeight,
+      data: cropped.rgba.toString("base64")
+    };
+  }
   async captureScreenshot(instance_id, format, quality) {
+    const refresh = this.bridge.refreshTopologyForRouting();
+    if (refresh)
+      await refresh;
     const { instanceId, clientRole } = this._resolveRuntime(instance_id);
     const capture = await this._captureViewportImage(instanceId, clientRole ?? "edit", format, quality);
     if (!capture.success) {
@@ -14160,6 +15006,13 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
       headers: this.authHeaders({ "Content-Type": "application/json" }),
       body: JSON.stringify({ groupId })
     });
+    if (response.status === 409) {
+      const refusal = await response.json().catch(() => void 0);
+      if (refusal && typeof refusal === "object" && !Array.isArray(refusal) && "success" in refusal && refusal.success === false && "error" in refusal && refusal.error === "multiplayer_group_in_use" && "groupId" in refusal && refusal.groupId === groupId) {
+        throw new MultiplayerGroupInUseError(groupId);
+      }
+      throw new Error("Proxy Multiplayer Group removal returned an invalid refusal.");
+    }
     if (!response.ok) {
       const body = await response.text().catch(() => "");
       throw new Error(`Proxy Multiplayer Group removal failed (${response.status}): ${body || response.statusText}`);
@@ -16495,10 +17348,10 @@ var getReadOnlyTools = () => TOOL_DEFINITIONS.filter((t) => t.category === "read
 
 // ../core/dist/install-plugin-helpers.js
 var import_saxes = __toESM(require_saxes(), 1);
-import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync, rmSync as rmSync2, rmdirSync, statSync as statSync3, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync7, renameSync, rmSync as rmSync3, rmdirSync, statSync as statSync3, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 import { execSync } from "child_process";
 import { randomUUID as randomUUID5 } from "crypto";
-import { basename as basename3, join as join5 } from "path";
+import { basename as basename3, join as join6 } from "path";
 import { homedir as homedir4 } from "os";
 import { isUtf8 } from "buffer";
 var DEFAULT_PLUGIN_PORT = 58741;
@@ -16550,15 +17403,15 @@ function getPluginsFolder() {
   if (process.env.MCP_PLUGINS_DIR)
     return process.env.MCP_PLUGINS_DIR;
   if (process.platform === "win32") {
-    return join5(process.env.LOCALAPPDATA || join5(homedir4(), "AppData", "Local"), "Roblox", "Plugins");
+    return join6(process.env.LOCALAPPDATA || join6(homedir4(), "AppData", "Local"), "Roblox", "Plugins");
   }
   if (isWSL()) {
     const localAppData = getWindowsUserLocalAppData();
     if (localAppData)
-      return join5(localAppData.linuxPath, "Roblox", "Plugins");
+      return join6(localAppData.linuxPath, "Roblox", "Plugins");
     console.warn("[install-plugin] WSL detected but could not resolve Windows %LOCALAPPDATA%. Falling back to ~/Documents/Roblox/Plugins/ - you will likely need to copy the rbxmx to /mnt/c/Users/<you>/AppData/Local/Roblox/Plugins/ manually. Set MCP_PLUGINS_DIR to skip detection.");
   }
-  return join5(homedir4(), "Documents", "Roblox", "Plugins");
+  return join6(homedir4(), "Documents", "Roblox", "Plugins");
 }
 var STALE_TEST_PLUGINS_DIRECTORY = "RsmcpIsolatedPlugins";
 function pluginDirectorySettingPattern() {
@@ -16568,12 +17421,12 @@ function escapeXmlText(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 function repairStaleStudioPluginDirectorySetting({ settingsPath, studioPluginsDirectory }) {
-  if (!existsSync6(settingsPath))
+  if (!existsSync7(settingsPath))
     return false;
   if (studioPluginsDirectory === "") {
     throw new Error("studioPluginsDirectory must be a non-empty path.");
   }
-  const contents = readFileSync6(settingsPath, "utf8");
+  const contents = readFileSync7(settingsPath, "utf8");
   const matches = [...contents.matchAll(pluginDirectorySettingPattern())];
   if (matches.length !== 1) {
     throw new Error(`Expected exactly one Studio.PluginsDir QDir in ${settingsPath}; found ${matches.length}.`);
@@ -16590,7 +17443,7 @@ function repairStaleStudioPluginDirectorySetting({ settingsPath, studioPluginsDi
     });
     renameSync(temporaryPath, settingsPath);
   } finally {
-    rmSync2(temporaryPath, { force: true });
+    rmSync3(temporaryPath, { force: true });
   }
   return true;
 }
@@ -16601,16 +17454,16 @@ function repairDefaultStudioPluginDirectorySetting(pluginsFolder, log) {
   let defaultPluginsFolder;
   let studioPluginsDirectory;
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || join5(homedir4(), "AppData", "Local");
-    defaultPluginsFolder = join5(localAppData, "Roblox", "Plugins");
-    settingsPath = join5(localAppData, "Roblox", "GlobalSettings_13.xml");
+    const localAppData = process.env.LOCALAPPDATA || join6(homedir4(), "AppData", "Local");
+    defaultPluginsFolder = join6(localAppData, "Roblox", "Plugins");
+    settingsPath = join6(localAppData, "Roblox", "GlobalSettings_13.xml");
     studioPluginsDirectory = defaultPluginsFolder.replaceAll("\\", "/");
   } else if (isWSL()) {
     const localAppData = getWindowsUserLocalAppData();
     if (!localAppData)
       return;
-    defaultPluginsFolder = join5(localAppData.linuxPath, "Roblox", "Plugins");
-    settingsPath = join5(localAppData.linuxPath, "Roblox", "GlobalSettings_13.xml");
+    defaultPluginsFolder = join6(localAppData.linuxPath, "Roblox", "Plugins");
+    settingsPath = join6(localAppData.linuxPath, "Roblox", "GlobalSettings_13.xml");
     studioPluginsDirectory = [
       localAppData.windowsPath.replace(/[\\/]+$/u, ""),
       "Roblox",
@@ -16626,8 +17479,8 @@ function repairDefaultStudioPluginDirectorySetting(pluginsFolder, log) {
   }
 }
 function handleVariantConflict({ pluginsFolder, otherAssetName, replace, log = console.log, warn = console.warn }) {
-  const otherDest = join5(pluginsFolder, otherAssetName);
-  if (!existsSync6(otherDest))
+  const otherDest = join6(pluginsFolder, otherAssetName);
+  if (!existsSync7(otherDest))
     return;
   if (replace) {
     try {
@@ -16652,11 +17505,11 @@ function pluginInstallLockError(lockPath, reason) {
   return new Error(`${reason}: ${lockPath}. If no installer or lock recovery is running, remove that lock directory and retry.`);
 }
 function readPluginInstallLockOwner(lockPath) {
-  const ownerPath = join5(lockPath, "owner.json");
+  const ownerPath = join6(lockPath, "owner.json");
   if (!lstatSync(lockPath).isDirectory() || !lstatSync(ownerPath).isFile()) {
     throw new Error("Lock and owner metadata must be a directory and regular file");
   }
-  const owner = JSON.parse(readFileSync6(ownerPath, "utf8"));
+  const owner = JSON.parse(readFileSync7(ownerPath, "utf8"));
   if (owner === null || typeof owner !== "object" || !("pid" in owner) || typeof owner.pid !== "number" || !Number.isSafeInteger(owner.pid) || owner.pid <= 0 || owner.pid > 2147483647 || !("token" in owner) || typeof owner.token !== "string" || !/^[a-zA-Z0-9-]{1,128}$/.test(owner.token) || !("createdAt" in owner) || typeof owner.createdAt !== "number" || !Number.isFinite(owner.createdAt) || owner.createdAt < 0) {
     throw new Error("Invalid lock owner metadata");
   }
@@ -16682,7 +17535,7 @@ function recoverPluginInstallLock(lockPath, warn) {
     throw pluginInstallLockError(lockPath, `Cannot safely read plugin installation lock owner (${error})`);
   }
   assertPluginInstallOwnerExited(lockPath, owner);
-  const claimPath = join5(lockPath, `recovery-${owner.token}`);
+  const claimPath = join6(lockPath, `recovery-${owner.token}`);
   try {
     mkdirSync4(claimPath);
   } catch (error) {
@@ -16715,14 +17568,14 @@ function recoverPluginInstallLock(lockPath, warn) {
     }
   }
   try {
-    rmSync2(abandonedPath, { recursive: true, force: true });
+    rmSync3(abandonedPath, { recursive: true, force: true });
   } catch (error) {
     warn(`[install-plugin] Could not clean abandoned install lock ${abandonedPath}: ${error}`);
   }
 }
 function acquirePluginInstallLock(pluginsFolder, warn) {
-  const lockPath = join5(pluginsFolder, PLUGIN_INSTALL_LOCK_NAME);
-  const ownerPath = join5(lockPath, "owner.json");
+  const lockPath = join6(pluginsFolder, PLUGIN_INSTALL_LOCK_NAME);
+  const ownerPath = join6(lockPath, "owner.json");
   const owner = {
     pid: process.pid,
     token: randomUUID5(),
@@ -16750,7 +17603,7 @@ function acquirePluginInstallLock(pluginsFolder, warn) {
     });
   } catch (error) {
     try {
-      rmSync2(lockPath, { recursive: true, force: true });
+      rmSync3(lockPath, { recursive: true, force: true });
     } catch (cleanupError) {
       warn(`[install-plugin] Could not clean failed install lock ${lockPath}: ${cleanupError}`);
     }
@@ -16760,7 +17613,7 @@ function acquirePluginInstallLock(pluginsFolder, warn) {
     try {
       const currentOwner = readPluginInstallLockOwner(lockPath);
       if (currentOwner.pid === owner.pid && currentOwner.token === owner.token) {
-        rmSync2(lockPath, { recursive: true, force: true });
+        rmSync3(lockPath, { recursive: true, force: true });
       }
     } catch (error) {
       if (errorCode(error) !== "ENOENT") {
@@ -16852,11 +17705,11 @@ function assertPluginAssetIdentity(source, assetName, expectedVersion, expectedV
   }
 }
 function installedFileMatches(source, destination) {
-  if (!existsSync6(destination))
+  if (!existsSync7(destination))
     return false;
   if (!lstatSync(destination).isFile())
     return false;
-  const installed = readFileSync6(destination);
+  const installed = readFileSync7(destination);
   return installed.length === source.length && installed.equals(source);
 }
 function installPluginAsset({ pluginsFolder, assetName, otherAssetName, source, expectedVersion, expectedVariant, rawPort, replaceVariant = true, log = console.log, warn = console.warn }) {
@@ -16868,12 +17721,12 @@ function installPluginAsset({ pluginsFolder, assetName, otherAssetName, source,
   const configured = configurePluginAssetForPort(source, rawPort);
   assertPluginAssetIdentity(configured, assetName, expectedVersion, expectedVariant);
   mkdirSync4(pluginsFolder, { recursive: true });
-  const destination = join5(pluginsFolder, assetName);
+  const destination = join6(pluginsFolder, assetName);
   const releaseLock = acquirePluginInstallLock(pluginsFolder, warn);
   try {
     let installed = false;
     if (!installedFileMatches(configured, destination)) {
-      const staged = join5(pluginsFolder, `.${assetName}.${process.pid}.${randomUUID5()}.tmp`);
+      const staged = join6(pluginsFolder, `.${assetName}.${process.pid}.${randomUUID5()}.tmp`);
       try {
         writeFileSync3(staged, configured, { flag: "wx" });
         renameSync(staged, destination);
@@ -16906,8 +17759,8 @@ function installPluginAsset({ pluginsFolder, assetName, otherAssetName, source,
 import { createRequire } from "module";
 
 // src/install-plugin.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname5, join as join6 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname5, join as join7 } from "path";
 import { fileURLToPath } from "url";
 import { get } from "https";
 var REPO = "chrrxs/robloxstudio-mcp";
@@ -16967,18 +17820,18 @@ async function fetchJson(url) {
 function bundledAssetPath() {
   const currentDir = dirname5(fileURLToPath(import.meta.url));
   const candidates = [
-    join6(currentDir, "..", "studio-plugin", ASSET_NAME),
-    join6(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
+    join7(currentDir, "..", "studio-plugin", ASSET_NAME),
+    join7(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
   ];
-  return candidates.find((candidate) => existsSync7(candidate)) ?? null;
+  return candidates.find((candidate) => existsSync8(candidate)) ?? null;
 }
 function resolvePluginAssetPath(sourcePath) {
   if (sourcePath === void 0) return bundledAssetPath();
-  return existsSync7(sourcePath) ? sourcePath : null;
+  return existsSync8(sourcePath) ? sourcePath : null;
 }
 function packageVersion() {
   const currentDir = dirname5(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync7(join6(currentDir, "..", "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync8(join7(currentDir, "..", "package.json"), "utf8"));
   if (!pkg.version) {
     throw new Error("Package version not found");
   }
@@ -16998,7 +17851,7 @@ async function installBundledPlugin(options = {}) {
     pluginsFolder: getPluginsFolder(),
     assetName: ASSET_NAME,
     otherAssetName: OTHER_VARIANT,
-    source: readFileSync7(sourcePath),
+    source: readFileSync8(sourcePath),
     expectedVersion: packageVersion(),
     expectedVariant: "inspector",
     replaceVariant,
@@ -17022,7 +17875,7 @@ async function installPlugin(options = {}) {
       pluginsFolder: getPluginsFolder(),
       assetName: ASSET_NAME,
       otherAssetName: OTHER_VARIANT,
-      source: readFileSync7(bundled),
+      source: readFileSync8(bundled),
       expectedVersion: packageVersion(),
       expectedVariant: "inspector",
       replaceVariant,