@chrrxs/robloxstudio-mcp 3.1.5 → 3.1.6

package/dist/index.js

@@ -2710,7 +2710,7 @@ var BridgeService = class {
     if (this.pendingRequests.size >= MAX_PENDING_REQUESTS || this.pendingRequestBytes + requestBytes > MAX_PENDING_REQUEST_BYTES) {
       return Promise.reject(new RequestFailure(`Request ${requestId} rejected at admission: pending capacity exceeded (${this.pendingRequests.size}/${MAX_PENDING_REQUESTS} requests, ${this.pendingRequestBytes + requestBytes}/${MAX_PENDING_REQUEST_BYTES} bytes); queued; not_executed`, "request_capacity_exceeded", { ...details, bytes: this.pendingRequestBytes + requestBytes, limitBytes: MAX_PENDING_REQUEST_BYTES }));
     }
-    const { promise, resolve: resolve5, reject } = Promise.withResolvers();
+    const { promise, resolve: resolve6, reject } = Promise.withResolvers();
     const abortListener = () => {
       const pending = this.pendingRequests.get(requestId);
       if (pending)
@@ -2728,7 +2728,7 @@ var BridgeService = class {
       data,
       targetPeerId,
       timestamp: now,
-      resolve: resolve5,
+      resolve: resolve6,
       reject,
       promise,
       timeoutId,
@@ -3127,19 +3127,20 @@ async function fetchDocCatalog() {
   }
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-  let response;
+  let html;
   try {
-    response = await fetch(DOCS_INDEX_URL, {
+    const response = await fetch(DOCS_INDEX_URL, {
       signal: controller.signal,
       headers: { Accept: "text/html" }
     });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new Error(`Failed to fetch Roblox docs index: HTTP ${response.status}`);
+    }
+    html = await response.text();
   } finally {
     clearTimeout(timer);
   }
-  if (!response.ok) {
-    throw new Error(`Failed to fetch Roblox docs index: HTTP ${response.status}`);
-  }
-  const html = await response.text();
   const pages = /* @__PURE__ */ new Map();
   const routePattern = /reference\/engine\/(classes|enums|datatypes|libraries|globals)\/([A-Za-z0-9_]+)/g;
   for (const match of html.matchAll(routePattern)) {
@@ -3192,27 +3193,30 @@ async function fetchRobloxDoc(category, name) {
   }
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-  let response;
   try {
-    response = await fetch(docUrl(category, name), {
+    const response = await fetch(docUrl(category, name), {
       signal: controller.signal,
       headers: { Accept: "text/markdown, text/plain" }
     });
+    if (response.status === 404) {
+      await response.body?.cancel();
+      cacheSet(key, { fetchedAt: Date.now(), notFound: true });
+      throw new DocNotFoundError(category, name);
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const content = await response.text();
+    cacheSet(key, { fetchedAt: Date.now(), content });
+    return content;
   } catch (error) {
+    if (error instanceof DocNotFoundError)
+      throw error;
     throw new Error(`Failed to fetch Roblox docs for ${key}: ${error instanceof Error ? error.message : String(error)}`);
   } finally {
     clearTimeout(timer);
   }
-  if (response.status === 404) {
-    cacheSet(key, { fetchedAt: Date.now(), notFound: true });
-    throw new DocNotFoundError(category, name);
-  }
-  if (!response.ok) {
-    throw new Error(`Failed to fetch Roblox docs for ${key}: HTTP ${response.status}`);
-  }
-  const content = await response.text();
-  cacheSet(key, { fetchedAt: Date.now(), content });
-  return content;
 }
 function listSections(markdown) {
   const sections = [];
@@ -3414,14 +3418,100 @@ import { execFile, execFileSync as execFileSync2, spawn } from "child_process";
 import { copyFileSync, existsSync as existsSync2, mkdirSync, readdirSync, readFileSync as readFileSync2, realpathSync, rmSync, statSync } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 import * as os2 from "os";
-import * as path2 from "path";
+import * as path3 from "path";
 import { promisify } from "util";
 
+// ../core/dist/studio-sign-in.js
+import { open, readdir } from "fs/promises";
+import * as path from "path";
+import { setTimeout as delay } from "timers/promises";
+var SESSION_LOG = /^[\d.]+_(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z_Studio_[A-Fa-f0-9]+_last\.log$/u;
+var LINE_TIME = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z),/u;
+var SIGN_IN_START = /\[FLog::StudioKeyEvents\] login \([^)]*\) \[start\]/u;
+var SIGN_IN_END = /\[FLog::StudioKeyEvents\] login \[end\]\[(success|failure)\]/u;
+var HEAD_BYTES = 1024 * 1024;
+var FILETIME_UNIX_EPOCH = 116444736000000000n;
+function fileTimeToUnixMs(fileTime) {
+  return Number((BigInt(fileTime) - FILETIME_UNIX_EPOCH) / 10000n);
+}
+function studioSessionLogStartMs(name) {
+  const match = SESSION_LOG.exec(name);
+  if (!match)
+    return void 0;
+  const [, year, month, day, hour, minute, second] = match.map(Number);
+  return Date.UTC(year, month - 1, day, hour, minute, second);
+}
+function parseStudioSignIn(name, text) {
+  const session = { name, signingIn: false };
+  for (const line of text.split(/\r?\n/u)) {
+    if (SIGN_IN_START.test(line)) {
+      session.signingIn = true;
+      continue;
+    }
+    const end = SIGN_IN_END.exec(line);
+    if (!end)
+      continue;
+    session.signingIn = false;
+    session.outcome = end[1];
+    const time = LINE_TIME.exec(line)?.[1];
+    if (time !== void 0)
+      session.lastEndMs = Date.parse(time);
+  }
+  return session;
+}
+async function readStudioSignInSessions(logsRoot, fromMs, toMs) {
+  let names;
+  try {
+    names = await readdir(logsRoot);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  const sessions = [];
+  for (const name of names) {
+    const startedAt = studioSessionLogStartMs(name);
+    if (startedAt === void 0 || startedAt < fromMs || startedAt > toMs)
+      continue;
+    const file = await open(path.join(logsRoot, name), "r");
+    try {
+      const buffer = Buffer.alloc(HEAD_BYTES);
+      const { bytesRead } = await file.read(buffer, 0, HEAD_BYTES, 0);
+      sessions.push(parseStudioSignIn(name, buffer.subarray(0, bytesRead).toString("utf8")));
+    } finally {
+      await file.close();
+    }
+  }
+  return sessions;
+}
+async function waitForStudioSignInToSettle({ logsRoot, processStartedAtMs, timeoutMs = 15e3, settleMs = 1500, youngMs = 5e3, now = Date.now, sleep: sleep2 = delay }) {
+  const begin = now();
+  for (; ; ) {
+    const sessions = await readStudioSignInSessions(logsRoot, processStartedAtMs - 2e3, processStartedAtMs + 3e4);
+    const signingIn = sessions.some((session) => session.signingIn);
+    const concluded = sessions.some((session) => session.outcome !== void 0);
+    const undecided = !signingIn && !concluded && now() - processStartedAtMs < youngMs;
+    if (!signingIn && !undecided) {
+      const ends = sessions.flatMap((session) => session.lastEndMs === void 0 ? [] : [session.lastEndMs]);
+      if (!ends.length)
+        return "idle";
+      const sinceEnd = now() - Math.max(...ends);
+      const remaining = Math.min(settleMs, Math.max(0, settleMs - sinceEnd));
+      if (remaining > 0)
+        await sleep2(remaining);
+      return "settled";
+    }
+    if (now() - begin >= timeoutMs)
+      return "timeout";
+    await sleep2(250);
+  }
+}
+
 // ../core/dist/managed-instance-registry.js
 import * as fs from "fs/promises";
 import { randomUUID as randomUUID2 } from "crypto";
 import * as os from "os";
-import * as path from "path";
+import * as path2 from "path";
 import { setTimeout as delayTimer } from "timers/promises";
 var REGISTRY_VERSION = 1;
 var LOCK_STALE_MS = 1e4;
@@ -3438,14 +3528,14 @@ function defaultManagedInstanceRegistryDir() {
     return process.env.ROBLOXSTUDIO_MCP_MANAGED_INSTANCE_REGISTRY_DIR;
   }
   if (process.platform === "win32" && process.env.LOCALAPPDATA) {
-    return path.join(process.env.LOCALAPPDATA, "robloxstudio-mcp", "managed-instances", "v1");
+    return path2.join(process.env.LOCALAPPDATA, "robloxstudio-mcp", "managed-instances", "v1");
   }
   if (process.platform === "darwin") {
-    return path.join(os.homedir(), "Library", "Application Support", "robloxstudio-mcp", "managed-instances", "v1");
+    return path2.join(os.homedir(), "Library", "Application Support", "robloxstudio-mcp", "managed-instances", "v1");
   }
-  return path.join(os.homedir(), ".local", "state", "robloxstudio-mcp", "managed-instances", "v1");
+  return path2.join(os.homedir(), ".local", "state", "robloxstudio-mcp", "managed-instances", "v1");
 }
-function delay(ms) {
+function delay2(ms) {
   return delayTimer(ms, void 0, { ref: false });
 }
 function ymd(timestamp) {
@@ -3540,7 +3630,7 @@ var ManagedInstanceRegistry = class {
   }
   async withLock(fn) {
     await this.ensureDir();
-    const lockDir = path.join(this.dir, ".lock");
+    const lockDir = path2.join(this.dir, ".lock");
     const deadline = Date.now() + LOCK_TIMEOUT_MS;
     const owner = {
       pid: process.pid,
@@ -3553,7 +3643,7 @@ var ManagedInstanceRegistry = class {
         activeLockTokens.add(owner.token);
         activeLockPaths.add(lockDir);
         try {
-          await fs.writeFile(path.join(lockDir, "owner.json"), `${JSON.stringify(owner)}
+          await fs.writeFile(path2.join(lockDir, "owner.json"), `${JSON.stringify(owner)}
 `, {
             encoding: "utf8",
             flag: "wx"
@@ -3583,7 +3673,7 @@ var ManagedInstanceRegistry = class {
         if (Date.now() > deadline) {
           throw new Error(`Timed out waiting for managed instance registry lock: ${lockDir}`);
         }
-        await delay(LOCK_RETRY_MS);
+        await delay2(LOCK_RETRY_MS);
       }
     }
     try {
@@ -3604,7 +3694,7 @@ var ManagedInstanceRegistry = class {
   }
   async readLockOwner(lockPath, isDirectory) {
     try {
-      const contents = await fs.readFile(isDirectory ? path.join(lockPath, "owner.json") : lockPath, "utf8");
+      const contents = await fs.readFile(isDirectory ? path2.join(lockPath, "owner.json") : lockPath, "utf8");
       const parsed = JSON.parse(contents);
       return isLockOwner(parsed) ? parsed : void 0;
     } catch {
@@ -3615,10 +3705,10 @@ var ManagedInstanceRegistry = class {
     await fs.mkdir(this.dir, { recursive: true });
   }
   recordPath(recordId) {
-    return path.join(this.dir, `${recordId}.json`);
+    return path2.join(this.dir, `${recordId}.json`);
   }
   async recordFilesUnlocked() {
-    return (await fs.readdir(this.dir)).filter((name) => name.endsWith(".json")).map((name) => path.join(this.dir, name));
+    return (await fs.readdir(this.dir)).filter((name) => name.endsWith(".json")).map((name) => path2.join(this.dir, name));
   }
   async readRecordUnlocked(recordId) {
     try {
@@ -3647,7 +3737,7 @@ var ManagedInstanceRegistry = class {
   async writeRecordUnlocked(record) {
     await this.ensureDir();
     const finalPath = this.recordPath(record.recordId);
-    const tmpPath = path.join(this.dir, `${record.recordId}.${process.pid}.${Date.now()}.tmp`);
+    const tmpPath = path2.join(this.dir, `${record.recordId}.${process.pid}.${Date.now()}.tmp`);
     const fd = await fs.open(tmpPath, "w");
     try {
       await fd.writeFile(`${JSON.stringify(record, null, 2)}
@@ -3662,7 +3752,7 @@ var ManagedInstanceRegistry = class {
     await fs.rm(this.recordPath(recordId), { force: true });
   }
   async appendEventUnlocked(event, now) {
-    const file = path.join(this.dir, `events-${ymd(now)}.jsonl`);
+    const file = path2.join(this.dir, `events-${ymd(now)}.jsonl`);
     await fs.appendFile(file, `${JSON.stringify({
       ts: new Date(now).toISOString(),
       ...event
@@ -3676,7 +3766,7 @@ var ManagedInstanceRegistry = class {
       if (!date || date >= cutoff)
         continue;
       try {
-        await fs.rm(path.join(this.dir, name), { force: true });
+        await fs.rm(path2.join(this.dir, name), { force: true });
       } catch {
       }
     }
@@ -3928,7 +4018,7 @@ function getStudioPlatformCapabilities() {
 }
 
 // ../core/dist/studio-instance-manager.js
-var BASEPLATE_TEMP_DIR = path2.join(os2.tmpdir(), "robloxstudio-mcp-baseplates");
+var BASEPLATE_TEMP_DIR = path3.join(os2.tmpdir(), "robloxstudio-mcp-baseplates");
 var BASEPLATE_TEMP_NAME = /^Baseplate-\d+-\d+\.rbxl$/;
 var BASEPLATE_TEMPLATE_NAME = "Baseplate.rbxl";
 var retainedLaunchControls = /* @__PURE__ */ new Map();
@@ -4054,7 +4144,7 @@ async function toWslPathAsync(windowsPath) {
   return runAsync("wslpath", ["-u", windowsPath]);
 }
 async function toStudioLaunchArgAsync(arg) {
-  if (!isWsl() || !path2.isAbsolute(arg) || !existsSync2(arg))
+  if (!isWsl() || !path3.isAbsolute(arg) || !existsSync2(arg))
     return arg;
   return runAsync("wslpath", ["-w", arg]);
 }
@@ -4546,6 +4636,19 @@ function buildWindowsStudioStopScript(processId, startedAt) {
     "} finally { if ($null -ne $studio) { $studio.Dispose() } }"
   ].join("; ");
 }
+var studioLogsRoot;
+async function settleWindowsStudioSignIn(startedAt) {
+  studioLogsRoot ??= (async () => {
+    const localAppData = await windowsLocalAppDataAsync();
+    return localAppData ? path3.join(await toWslPathAsync(localAppData), "Roblox", "logs") : void 0;
+  })();
+  const logsRoot = await studioLogsRoot;
+  if (!logsRoot)
+    return;
+  const result = await waitForStudioSignInToSettle({ logsRoot, processStartedAtMs: fileTimeToUnixMs(startedAt) });
+  if (result === "timeout")
+    console.error("[studio] Studio was still signing in after 15 s; closing it anyway.");
+}
 async function stopWindowsStudio(processId, startedAt, timeoutMs = 15e3) {
   await powershellAsync(buildWindowsStudioStopScript(processId, startedAt), timeoutMs);
 }
@@ -4559,7 +4662,7 @@ async function spawnWindowsStudio(exe, args, processEnvironment, studioWorkingDi
     stdio: ["pipe", "pipe", "pipe"],
     windowsHide: true
   });
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let stdout = "";
     let controlOutput = "";
     let stderr = "";
@@ -4706,7 +4809,7 @@ async function spawnWindowsStudio(exe, args, processEnvironment, studioWorkingDi
           throw new Error("PowerShell returned an invalid native Studio process identity.");
         }
         identity = { pid: nativePid, startedAt: nativeStartedAt };
-        resolve5({
+        resolve6({
           pid: nativePid,
           nativePid,
           nativeStartedAt,
@@ -4774,21 +4877,21 @@ function resolveEntrypointDir() {
   if (!entrypoint)
     return void 0;
   try {
-    return path2.dirname(realpathSync(entrypoint));
+    return path3.dirname(realpathSync(entrypoint));
   } catch {
-    return path2.dirname(path2.resolve(entrypoint));
+    return path3.dirname(path3.resolve(entrypoint));
   }
 }
 function resolveBaseplateTemplatePath() {
   const entrypointDir = resolveEntrypointDir();
   const candidates = [
     ...entrypointDir ? [
-      path2.join(entrypointDir, "assets", BASEPLATE_TEMPLATE_NAME),
-      path2.join(entrypointDir, "..", "assets", BASEPLATE_TEMPLATE_NAME)
+      path3.join(entrypointDir, "assets", BASEPLATE_TEMPLATE_NAME),
+      path3.join(entrypointDir, "..", "assets", BASEPLATE_TEMPLATE_NAME)
     ] : [],
-    path2.join(process.cwd(), "packages", "core", "assets", BASEPLATE_TEMPLATE_NAME),
-    path2.join(process.cwd(), "packages", "robloxstudio-mcp", "dist", "assets", BASEPLATE_TEMPLATE_NAME),
-    path2.join(process.cwd(), "assets", BASEPLATE_TEMPLATE_NAME)
+    path3.join(process.cwd(), "packages", "core", "assets", BASEPLATE_TEMPLATE_NAME),
+    path3.join(process.cwd(), "packages", "robloxstudio-mcp", "dist", "assets", BASEPLATE_TEMPLATE_NAME),
+    path3.join(process.cwd(), "assets", BASEPLATE_TEMPLATE_NAME)
   ];
   for (const candidate of candidates) {
     if (existsSync2(candidate))
@@ -4821,7 +4924,7 @@ function sweepStaleBaseplateFiles() {
       continue;
     if (Number(match[1]) !== process.pid && isProcessAlive2(Number(match[1])))
       continue;
-    const file = path2.join(BASEPLATE_TEMP_DIR, entry);
+    const file = path3.join(BASEPLATE_TEMP_DIR, entry);
     try {
       if (statSync(file).mtimeMs < cutoff)
         rmSync(file, { force: true });
@@ -4832,13 +4935,13 @@ function sweepStaleBaseplateFiles() {
 function createBaseplatePlaceFile() {
   mkdirSync(BASEPLATE_TEMP_DIR, { recursive: true });
   sweepStaleBaseplateFiles();
-  const file = path2.join(BASEPLATE_TEMP_DIR, `Baseplate-${process.pid}-${Date.now()}.rbxl`);
+  const file = path3.join(BASEPLATE_TEMP_DIR, `Baseplate-${process.pid}-${Date.now()}.rbxl`);
   copyFileSync(resolveBaseplateTemplatePath(), file);
   return file;
 }
 function isGeneratedBaseplatePlaceFile(file) {
-  const resolvedFile = path2.resolve(file);
-  return path2.dirname(resolvedFile) === path2.resolve(BASEPLATE_TEMP_DIR) && BASEPLATE_TEMP_NAME.test(path2.basename(resolvedFile));
+  const resolvedFile = path3.resolve(file);
+  return path3.dirname(resolvedFile) === path3.resolve(BASEPLATE_TEMP_DIR) && BASEPLATE_TEMP_NAME.test(path3.basename(resolvedFile));
 }
 function cleanupManagedBaseplateFiles(record) {
   if (record.source !== "baseplate" || !record.localPlaceFile)
@@ -4864,14 +4967,14 @@ 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);
+  const candidates = readdirSync(root).filter((name) => name.startsWith("version-")).map((name) => path3.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 installationDir = path3.dirname(exe);
   const hasIncompleteDownload = readdirSync(installationDir).some((name) => /\.crdownload$/i.test(name));
-  const settings = statSync(path2.join(installationDir, "AppSettings.xml"), { throwIfNoEntry: false });
+  const settings = statSync(path3.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.`);
@@ -4888,7 +4991,7 @@ function resolveStudioExe() {
     throw new Error("Roblox Studio executable auto-discovery is only supported on Windows, WSL, and macOS. Set ROBLOX_STUDIO_EXE.");
   }
   const localAppData = windowsLocalAppData();
-  const root = localAppData ? path2.join(toWslPath(localAppData), "Roblox", "Versions") : path2.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
+  const root = localAppData ? path3.join(toWslPath(localAppData), "Roblox", "Versions") : path3.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
   return resolveStudioExeFromVersions(root);
 }
 async function resolveStudioExeAsync() {
@@ -4901,7 +5004,7 @@ async function resolveStudioExeAsync() {
     throw new Error("Roblox Studio executable auto-discovery is only supported on Windows, WSL, and macOS. Set ROBLOX_STUDIO_EXE.");
   }
   const localAppData = await windowsLocalAppDataAsync();
-  const root = localAppData ? path2.join(await toWslPathAsync(localAppData), "Roblox", "Versions") : path2.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
+  const root = localAppData ? path3.join(await toWslPathAsync(localAppData), "Roblox", "Versions") : path3.join(os2.homedir(), "AppData", "Local", "Roblox", "Versions");
   return resolveStudioExeFromVersions(root);
 }
 var WINDOWS_STUDIO_PROCESS_QUERY = [
@@ -5005,11 +5108,11 @@ function buildStudioLaunchArgs(options) {
       ];
   }
 }
-function delay2(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+function delay3(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function basenameAny(filePath) {
-  return path2.basename(filePath.replace(/\\/g, "/"));
+  return path3.basename(filePath.replace(/\\/g, "/"));
 }
 var StudioInstanceManager = class {
   managedByInstanceId = /* @__PURE__ */ new Map();
@@ -5026,6 +5129,7 @@ var StudioInstanceManager = class {
   snapshotCacheMs;
   launchCompletionTimeoutMs;
   closeTimeoutMs;
+  settleSignIn;
   coordinatorTimer;
   coordinatorRefresh;
   cachedSnapshot;
@@ -5041,6 +5145,7 @@ var StudioInstanceManager = class {
     this.snapshotCacheMs = options.snapshotCacheMs ?? 0;
     this.launchCompletionTimeoutMs = options.launchCompletionTimeoutMs ?? LAUNCH_COMPLETION_TIMEOUT_MS;
     this.closeTimeoutMs = options.closeTimeoutMs ?? 1e4;
+    this.settleSignIn = options.settleSignIn ?? (!this.processAdapter.stopProcess && (process.platform === "win32" || isWsl()) ? settleWindowsStudioSignIn : void 0);
   }
   getLifecycleCapabilities() {
     const platform = this.platformCapabilities ?? getStudioPlatformCapabilities();
@@ -5220,8 +5325,8 @@ var StudioInstanceManager = class {
   async launch(options) {
     const previous = this.launchQueue;
     let release;
-    this.launchQueue = new Promise((resolve5) => {
-      release = resolve5;
+    this.launchQueue = new Promise((resolve6) => {
+      release = resolve6;
     });
     await previous;
     try {
@@ -5380,7 +5485,7 @@ var StudioInstanceManager = class {
         await this.persist(record);
         break;
       }
-      await delay2(250);
+      await delay3(250);
     }
     if (record.nativeProcessId === void 0 && process.platform !== "win32" && !isWsl()) {
       record.nativeProcessId = proc.pid;
@@ -5438,7 +5543,7 @@ var StudioInstanceManager = class {
         instanceId: record.instanceId
       };
     }
-    const deadline = Date.now() + this.closeTimeoutMs;
+    let 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.`);
@@ -5477,6 +5582,8 @@ var StudioInstanceManager = class {
         };
       }
     }
+    if (!abort)
+      deadline = await this.beforeStudioStop(record.nativeProcessStartedAt, deadline);
     try {
       await this.closeProcess(processId, record.nativeProcessStartedAt, abort, deadline);
     } catch (error) {
@@ -5525,7 +5632,7 @@ var StudioInstanceManager = class {
     };
   }
   async closeConnectedInstance(instance) {
-    const deadline = Date.now() + this.closeTimeoutMs;
+    let 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}`);
@@ -5534,8 +5641,20 @@ var StudioInstanceManager = class {
     if (!process2) {
       throw new Error(`Could not find a Studio process for connected instance "${instance.instanceId}".`);
     }
+    deadline = await this.beforeStudioStop(process2.StartTimeUtcFileTime, deadline);
     await this.closeProcess(process2.Id, process2.StartTimeUtcFileTime, void 0, deadline);
   }
+  async beforeStudioStop(startedAt, deadline) {
+    if (!this.settleSignIn || startedAt === void 0 || !/^[1-9]\d*$/u.test(startedAt))
+      return deadline;
+    const waitStarted = Date.now();
+    try {
+      await this.settleSignIn(startedAt);
+    } catch (error) {
+      console.error(`[studio] Could not check Studio sign-in before closing: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return deadline + (Date.now() - waitStarted);
+  }
   async closeProcess(processId, startedAt, stop, deadline = Date.now() + this.closeTimeoutMs) {
     this.cachedSnapshot = void 0;
     await beforeCloseDeadline(async () => {
@@ -5557,7 +5676,7 @@ var StudioInstanceManager = class {
         }
       }
     }, deadline, processId);
-    while (true) {
+    for (; ; ) {
       const observation = await beforeCloseDeadline(() => this.observeClosingProcess(processId, startedAt, deadline), deadline, processId);
       if (observation.status === "not_running")
         return;
@@ -5568,7 +5687,7 @@ var StudioInstanceManager = class {
       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));
+      await delay3(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);
       }
@@ -5736,13 +5855,13 @@ var StudioInstanceManager = class {
     const processId = record.nativeProcessId ?? record.spawnPid;
     if (record.spawnPid && record.spawnPid === processId && studioProcess.Id === processId)
       return true;
-    const processPath = studioProcess.Path ? path2.normalize(studioProcess.Path).toLowerCase() : "";
-    const exePath = record.exe ? path2.normalize(record.exe).toLowerCase() : "";
+    const processPath = studioProcess.Path ? path3.normalize(studioProcess.Path).toLowerCase() : "";
+    const exePath = record.exe ? path3.normalize(record.exe).toLowerCase() : "";
     if (processPath && exePath && (processPath === exePath || basenameAny(processPath) === basenameAny(exePath))) {
       return true;
     }
     const commandLine = studioProcess.CommandLine ?? "";
-    if (record.localPlaceFile && commandLine.includes(path2.basename(record.localPlaceFile)))
+    if (record.localPlaceFile && commandLine.includes(path3.basename(record.localPlaceFile)))
       return true;
     if (record.placeId !== void 0 && commandLine.includes(String(record.placeId)))
       return true;
@@ -6273,11 +6392,21 @@ function createToolHttpHandler(options) {
 
 // ../core/dist/auth.js
 import { randomBytes, createHash as createHash2, timingSafeEqual } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync, chmodSync } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync, linkSync, unlinkSync } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
 import { homedir as homedir3 } from "os";
 function authTokenFilePath() {
-  return join3(homedir3(), ".robloxstudio-mcp", "auth-token");
+  return join4(homedir3(), ".robloxstudio-mcp", "auth-token");
+}
+var EMPTY_TOKEN_RETRY_MS = 25;
+var EMPTY_TOKEN_RETRIES = 20;
+function readTokenFile(filePath) {
+  for (let attempt = 0; ; attempt++) {
+    const token = readFileSync3(filePath, "utf8").trim();
+    if (token || attempt >= EMPTY_TOKEN_RETRIES)
+      return token;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, EMPTY_TOKEN_RETRY_MS);
+  }
 }
 function resolveAuthToken() {
   const noAuth = (process.env.ROBLOX_STUDIO_NO_AUTH || "").toLowerCase();
@@ -6290,20 +6419,36 @@ function resolveAuthToken() {
   }
   const filePath = authTokenFilePath();
   try {
-    if (existsSync3(filePath)) {
-      const existing = readFileSync3(filePath, "utf8").trim();
-      if (existing) {
-        return { token: existing, source: "file", filePath };
-      }
+    try {
+      const existing = readTokenFile(filePath);
+      if (!existing)
+        throw new Error("Auth token file is empty; remove it while all MCP servers are stopped to reinitialize it.");
+      return { token: existing, source: "file", filePath };
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
     }
     const fresh = randomBytes(32).toString("hex");
     mkdirSync2(dirname2(filePath), { recursive: true, mode: 448 });
-    writeFileSync(filePath, fresh + "\n", { encoding: "utf8", mode: 384 });
+    const stagingPath = `${filePath}.${process.pid}.${randomBytes(16).toString("hex")}.tmp`;
+    writeFileSync(stagingPath, fresh + "\n", { encoding: "utf8", mode: 384, flag: "wx" });
     try {
-      chmodSync(filePath, 384);
-    } catch {
+      try {
+        linkSync(stagingPath, filePath);
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+      const token = readTokenFile(filePath);
+      if (!token)
+        throw new Error("Auth token file is empty.");
+      return { token, source: "file", filePath };
+    } finally {
+      try {
+        unlinkSync(stagingPath);
+      } catch {
+      }
     }
-    return { token: fresh, source: "file", filePath };
   } catch (err2) {
     console.error(`[auth] Could not read/create ${filePath} (${err2 instanceof Error ? err2.message : err2}). Using an in-memory token for this process; set ROBLOX_STUDIO_AUTH_TOKEN to share one across sessions.`);
     return { token: randomBytes(32).toString("hex"), source: "file" };
@@ -6821,7 +6966,7 @@ var TOOL_HANDLERS = {
   get_memory_breakdown: (tools, body) => tools.getMemoryBreakdown(body.target, body.tags, body.instance_id),
   get_scene_analysis: (tools, body) => tools.getSceneAnalysis(body.mode, body.target, body.topN, body.raw, body.instance_id),
   export_rbxm: (tools, body) => tools.exportRbxm(body.instance_paths, body.output_path, body.target, body.instance_id),
-  import_rbxm: (tools, body) => tools.importRbxm(body.source, body.parent_path, body.target, body.instance_id),
+  import_rbxm: (tools, body, context) => tools.importRbxm(body.source, body.parent_path, body.target, body.instance_id, context?.signal),
   find_and_replace_in_scripts: (tools, body) => tools.findAndReplaceInScripts(body.pattern, body.replacement, {
     caseSensitive: body.caseSensitive,
     usePattern: body.usePattern,
@@ -6990,8 +7135,8 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   });
   const authToken = security?.authToken;
   const authRequired = (requestPath) => {
-    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";
+    const path9 = requestPath.toLowerCase().replace(/\/+$/, "");
+    return path9 === "/mcp" || path9.startsWith("/mcp/") || path9 === "/proxy" || path9 === "/topology" || path9 === "/request-status" || path9 === "/unregister-instance-id" || path9 === "/create-multiplayer-group" || path9 === "/remove-multiplayer-group";
   };
   app.use((req, res, next) => {
     if (!authToken || !authRequired(req.path)) {
@@ -7420,6 +7565,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     studioTransport.close();
     webSocketServer.close();
     await mcpHandler?.close();
+    await tools.dispose();
   };
   return app;
 }
@@ -7440,7 +7586,7 @@ async function listenWithRetry(app, host, startPort, maxAttempts = 5) {
   throw new Error(`All ports ${startPort}-${startPort + maxAttempts - 1} are in use. Stop some MCP server instances and retry.`);
 }
 function bindPort(app, host, port) {
-  const { promise, resolve: resolve5, reject } = Promise.withResolvers();
+  const { promise, resolve: resolve6, reject } = Promise.withResolvers();
   const server = http.createServer(app);
   const onError = (err2) => {
     server.removeListener("error", onError);
@@ -7453,7 +7599,7 @@ function bindPort(app, host, port) {
       if ("attachStudioTransport" in app && typeof app.attachStudioTransport === "function") {
         app.attachStudioTransport(server);
       }
-      resolve5(server);
+      resolve6(server);
     } catch (error) {
       server.close();
       reject(error);
@@ -7462,6 +7608,123 @@ function bindPort(app, host, port) {
   return promise;
 }
 
+// ../core/dist/rbxm-input.js
+import { open as open3 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+var ENVELOPE_RESERVE_BYTES = 16 * 1024;
+var DOWNLOAD_TIMEOUT_MS = 3e4;
+function rbxmInputByteLimit(parentPath, sourceLabel) {
+  const metadataBytes = Buffer.byteLength(JSON.stringify({
+    base64: "",
+    parent_path: parentPath,
+    source_label: sourceLabel
+  }));
+  const encodedBytes = Math.min(HTTP_BODY_LIMIT_BYTES, MAX_STUDIO_FRAME_BYTES) - ENVELOPE_RESERVE_BYTES - metadataBytes;
+  if (encodedBytes < 4)
+    throw new Error("RBXM import metadata exceeds the transport byte budget.");
+  return Math.floor(encodedBytes / 4) * 3;
+}
+function tooLarge(limit) {
+  return new Error(`RBXM input exceeds the ${limit}-byte limit after allowing for base64 and transport overhead.`);
+}
+async function readBoundedResponse(response, limit) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > limit) {
+    await response.body?.cancel();
+    throw tooLarge(limit);
+  }
+  if (!response.body)
+    return Buffer.alloc(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      size += value.byteLength;
+      if (size > limit)
+        throw tooLarge(limit);
+      chunks.push(Buffer.from(value));
+    }
+    return Buffer.concat(chunks, size);
+  } finally {
+    await reader.cancel().catch(() => {
+    });
+    reader.releaseLock();
+  }
+}
+async function readRbxmInput(source, parentPath, signal) {
+  const modes = ["path", "url", "base64"];
+  const provided = modes.filter((key) => source[key] !== void 0);
+  if (provided.length !== 1 || typeof source[provided[0]] !== "string") {
+    throw new Error("source must contain exactly one string: path, url, or base64");
+  }
+  signal?.throwIfAborted();
+  if (source.path !== void 0) {
+    const sourceLabel = resolve2(source.path);
+    const limit2 = rbxmInputByteLimit(parentPath, sourceLabel);
+    const file = await open3(sourceLabel, "r");
+    try {
+      const stats = await file.stat();
+      if (!stats.isFile())
+        throw new Error("RBXM source must be a regular file.");
+      if (stats.size > limit2)
+        throw tooLarge(limit2);
+      const chunks = [];
+      let size = 0;
+      for (; ; ) {
+        signal?.throwIfAborted();
+        const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, limit2 - size + 1));
+        const { bytesRead } = await file.read(chunk);
+        if (bytesRead === 0)
+          break;
+        size += bytesRead;
+        if (size > limit2)
+          throw tooLarge(limit2);
+        chunks.push(chunk.subarray(0, bytesRead));
+      }
+      return { bytes: Buffer.concat(chunks, size), sourceLabel };
+    } finally {
+      await file.close();
+    }
+  }
+  if (source.url !== void 0) {
+    const url = new URL(source.url);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new Error(`import_rbxm url must use http(s); got ${url.protocol}`);
+    }
+    const limit2 = rbxmInputByteLimit(parentPath, source.url);
+    const deadline = AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS);
+    const response = await fetch(url, {
+      signal: signal ? AbortSignal.any([signal, deadline]) : deadline
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw new Error(`RBXM download returned HTTP ${response.status}`);
+    }
+    return { bytes: await readBoundedResponse(response, limit2), sourceLabel: source.url };
+  }
+  const limit = rbxmInputByteLimit(parentPath, "base64(9999999999B)");
+  const maxEncoded = 4 * Math.ceil(limit / 3);
+  if (source.base64.length > maxEncoded + 2 * Math.ceil(maxEncoded / 64))
+    throw tooLarge(limit);
+  const encoded = source.base64.replace(/[\t\n\r ]+/g, "");
+  if (encoded.length > maxEncoded)
+    throw tooLarge(limit);
+  if (encoded.length % 4 === 1 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.includes("=") && encoded.length % 4 !== 0) {
+    throw new Error("RBXM base64 must be valid base64.");
+  }
+  const bytes = Buffer.from(encoded, "base64");
+  if (bytes.length > limit)
+    throw tooLarge(limit);
+  if (bytes.toString("base64").replace(/=+$/, "") !== encoded.replace(/=+$/, "")) {
+    throw new Error("RBXM base64 is not canonical.");
+  }
+  return { bytes, sourceLabel: `base64(${bytes.length}B)` };
+}
+
 // ../core/dist/tools/studio-client.js
 var StudioHttpClient = class {
   bridge;
@@ -7529,7 +7792,6 @@ var OpenCloudClient = class {
         body: body ? JSON.stringify(body) : void 0,
         signal: controller.signal
       });
-      clearTimeout(timeoutId);
       if (!response.ok) {
         const errorBody = await response.text();
         let errorMessage2;
@@ -7551,7 +7813,8 @@ var OpenCloudClient = class {
       }
       return await response.json();
     } catch (error) {
-      clearTimeout(timeoutId);
+      if (controller.signal.aborted)
+        throw new Error("Request timed out");
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           throw new Error("Request timed out");
@@ -7559,6 +7822,8 @@ var OpenCloudClient = class {
         throw error;
       }
       throw new Error(`Unknown error: ${String(error)}`);
+    } finally {
+      clearTimeout(timeoutId);
     }
   }
   async searchAssets(params) {
@@ -7593,7 +7858,8 @@ var OpenCloudClient = class {
   async getAssetThumbnail(assetId, size = "420x420") {
     const url = `https://thumbnails.roblox.com/v1/assets?assetIds=${assetId}&size=${size}&format=Png`;
     try {
-      const response = await fetch(url);
+      const signal = AbortSignal.timeout(this.timeout);
+      const response = await fetch(url, { signal });
       if (!response.ok)
         return null;
       const data = await response.json();
@@ -7601,7 +7867,7 @@ var OpenCloudClient = class {
       if (!thumbnail || thumbnail.state !== "Completed" || !thumbnail.imageUrl) {
         return null;
       }
-      const imageResponse = await fetch(thumbnail.imageUrl);
+      const imageResponse = await fetch(thumbnail.imageUrl, { signal });
       if (!imageResponse.ok)
         return null;
       const arrayBuffer = await imageResponse.arrayBuffer();
@@ -7622,7 +7888,7 @@ var OpenCloudClient = class {
     for (const batch of batches) {
       const url = `https://thumbnails.roblox.com/v1/assets?assetIds=${batch.join(",")}&size=${size}&format=Png`;
       try {
-        const response = await fetch(url);
+        const response = await fetch(url, { signal: AbortSignal.timeout(this.timeout) });
         if (response.ok) {
           const data = await response.json();
           for (const thumbnail of data.data) {
@@ -7683,7 +7949,7 @@ var OpenCloudClient = class {
       const chunks = [];
       let totalBytes = 0;
       const reader = contentResponse.body.getReader();
-      while (true) {
+      for (; ; ) {
         const { done, value } = await reader.read();
         if (done)
           break;
@@ -7764,7 +8030,6 @@ var OpenCloudClient = class {
         body: formData,
         signal: controller.signal
       });
-      clearTimeout(timeoutId);
       if (!response.ok) {
         const errorBody = await response.text();
         let errorMessage2;
@@ -7786,7 +8051,8 @@ var OpenCloudClient = class {
       }
       return await response.json();
     } catch (error) {
-      clearTimeout(timeoutId);
+      if (controller.signal.aborted)
+        throw new Error("Request timed out");
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           throw new Error("Request timed out");
@@ -7794,6 +8060,8 @@ var OpenCloudClient = class {
         throw error;
       }
       throw new Error(`Unknown error: ${String(error)}`);
+    } finally {
+      clearTimeout(timeoutId);
     }
   }
   async pollOperation(operationPath, maxAttempts = 30, intervalMs = 2e3) {
@@ -7805,7 +8073,7 @@ var OpenCloudClient = class {
       if (result.error) {
         throw new Error(`Asset upload failed: ${result.error.message}`);
       }
-      await new Promise((resolve5) => setTimeout(resolve5, intervalMs));
+      await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
     }
     throw new Error(`Asset upload timed out after ${maxAttempts * intervalMs / 1e3}s. Operation ID: ${operationId}`);
   }
@@ -7822,6 +8090,7 @@ var RobloxCookieClient = class {
     return !!this.cookie;
   }
   async fetchWithCsrf(url, options = {}) {
+    options = { ...options, signal: options.signal ?? AbortSignal.timeout(3e4) };
     const headers = {
       Cookie: `.ROBLOSECURITY=${this.cookie}`,
       ...options.headers || {}
@@ -7835,6 +8104,7 @@ var RobloxCookieClient = class {
       if (newToken) {
         this.csrfToken = newToken;
         headers["X-CSRF-TOKEN"] = newToken;
+        await response.body?.cancel();
         return fetch(url, { ...options, headers });
       }
     }
@@ -7954,7 +8224,7 @@ var RobloxCookieClient = class {
         throw new Error("Image upload completed without an asset ID.");
       }
       if (attempt < maxAttempts - 1) {
-        await new Promise((resolve5) => setTimeout(resolve5, intervalMs));
+        await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
       }
     }
     throw new Error(`Image upload timed out after ${maxAttempts * intervalMs / 1e3}s. Operation ID: ${operationId}`);
@@ -7978,7 +8248,7 @@ var RobloxCookieClient = class {
 
 // ../core/dist/image-decode.js
 import * as fs2 from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 import { inflateSync } from "zlib";
 var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 var MAX_EDITABLE_IMAGE_DIMENSION = 1024;
@@ -8310,14 +8580,14 @@ function decodePngBase64ToRgba(encoded) {
   return decodePngToRgba(data);
 }
 function decodeImagePathToRgba(imagePath) {
-  const resolved = path3.resolve(imagePath);
+  const resolved = path4.resolve(imagePath);
   return decodePngToRgba(readPngFileWithinLimit(resolved, imagePath));
 }
 
 // ../core/dist/studio-skills.js
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import * as path4 from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import * as path5 from "path";
 
 // ../../node_modules/fzstd/esm/index.mjs
 var ab = ArrayBuffer;
@@ -9205,7 +9475,7 @@ function parseBuiltInStudioSkills(buffer) {
   }).sort((left, right) => left.name.localeCompare(right.name));
 }
 function discoverNamedFile(root, fileName, depth = 0) {
-  if (depth > MAX_DISCOVERY_DEPTH || !existsSync4(root))
+  if (depth > MAX_DISCOVERY_DEPTH || !existsSync3(root))
     return [];
   const matches = [];
   let entries;
@@ -9215,7 +9485,7 @@ function discoverNamedFile(root, fileName, depth = 0) {
     return matches;
   }
   for (const entry of entries) {
-    const entryPath = path4.join(root, entry.name);
+    const entryPath = path5.join(root, entry.name);
     if (entry.isFile() && entry.name.toLowerCase() === fileName.toLowerCase()) {
       matches.push(entryPath);
     } else if (entry.isDirectory()) {
@@ -9227,20 +9497,20 @@ function discoverNamedFile(root, fileName, depth = 0) {
 function resolveAssistantBundlePath(studioExe) {
   const override = process.env.ROBLOX_STUDIO_ASSISTANT_BUNDLE;
   if (override) {
-    if (!existsSync4(override)) {
+    if (!existsSync3(override)) {
       throw new Error(`ROBLOX_STUDIO_ASSISTANT_BUNDLE does not exist: ${override}`);
     }
     return override;
   }
-  const exeDirectory = path4.dirname(studioExe ?? resolveStudioExe());
+  const exeDirectory = path5.dirname(studioExe ?? resolveStudioExe());
   const roots = [
-    path4.join(exeDirectory, "BuiltInStandalonePlugins"),
-    path4.resolve(exeDirectory, "..", "Resources", "BuiltInStandalonePlugins"),
-    path4.resolve(exeDirectory, "..", "..", "OTAPlugins")
+    path5.join(exeDirectory, "BuiltInStandalonePlugins"),
+    path5.resolve(exeDirectory, "..", "Resources", "BuiltInStandalonePlugins"),
+    path5.resolve(exeDirectory, "..", "..", "OTAPlugins")
   ];
-  const direct = path4.join(exeDirectory, "BuiltInStandalonePlugins", "Optimized_Embedded_Signature", "Assistant.rbxm");
+  const direct = path5.join(exeDirectory, "BuiltInStandalonePlugins", "Optimized_Embedded_Signature", "Assistant.rbxm");
   const candidates = /* @__PURE__ */ new Set();
-  if (existsSync4(direct))
+  if (existsSync3(direct))
     candidates.add(direct);
   for (const root of roots) {
     for (const candidate of discoverNamedFile(root, "Assistant.rbxm"))
@@ -9263,7 +9533,7 @@ function loadBuiltInStudioSkills(bundlePath = resolveAssistantBundlePath()) {
   if (skills.length === 0) {
     throw new Error(`No built-in skill documents found in ${bundlePath}`);
   }
-  const studioVersion = bundlePath.split(path4.sep).find((segment) => /^version-[a-z0-9]+$/i.test(segment));
+  const studioVersion = bundlePath.split(path5.sep).find((segment) => /^version-[a-z0-9]+$/i.test(segment));
   const value = {
     bundlePath,
     bundleModifiedAt: stats.mtime.toISOString(),
@@ -10284,10 +10554,280 @@ function rgbaToPng(rgba, width, height) {
 }
 
 // ../core/dist/host-capture.js
+import { spawn as spawn3 } from "child_process";
+import * as fs4 from "fs";
+import * as os4 from "os";
+import * as path7 from "path";
+
+// ../core/dist/host-capture-macos.js
 import { spawn as spawn2 } from "child_process";
 import * as fs3 from "fs";
 import * as os3 from "os";
-import * as path5 from "path";
+import * as path6 from "path";
+var MAX_IMAGE_BYTES = 128 * 1024 * 1024;
+var MAX_OUTPUT_BYTES = 64 * 1024;
+var STUDIO_BUNDLE_ID = "com.Roblox.RobloxStudio";
+var MACOS_CAPTURE_SOURCE = String.raw`
+import Foundation
+import AppKit
+import CoreGraphics
+import ScreenCaptureKit
+
+struct CaptureFailure: Error { let message: String }
+func fail(_ message: String) throws -> Never { throw CaptureFailure(message: message) }
+func emit(_ value: [String: Any]) {
+    if let data = try? JSONSerialization.data(withJSONObject: value), let text = String(data: data, encoding: .utf8) {
+        print(text)
+    }
+}
+
+// Local files can use their absolute path in the macOS window title while
+// Studio reports only the basename as DataModel.Name. Match that basename
+// after removing Studio's exact title suffix; retain ambiguity checks below.
+func matchesStudioTitle(_ title: String, hint: String) -> Bool {
+    if hint.isEmpty || title == hint || title.hasPrefix(hint) { return true }
+    let suffix = " - Roblox Studio"
+    guard title.hasSuffix(suffix) else { return false }
+    let place = String(title.dropLast(suffix.count))
+    return place.hasPrefix("/") && (place as NSString).lastPathComponent == hint
+}
+
+@available(macOS 14.0, *)
+@MainActor
+func capture() async throws {
+    // Never request or bypass Screen Recording permission from an MCP call.
+    guard CGPreflightScreenCaptureAccess() else {
+        try fail("macOS Screen Recording permission is not granted to the MCP host. Enable it in System Settings > Privacy & Security > Screen Recording, then restart the MCP host.")
+    }
+    // A command-line helper must establish its WindowServer connection before
+    // ScreenCaptureKit uses Core Graphics. Do not activate or create any UI.
+    NSApplication.shared.setActivationPolicy(.prohibited)
+    let env = ProcessInfo.processInfo.environment
+    let hint = env["MCP_CAPTURE_TITLE_HINT"] ?? ""
+    let content = try await SCShareableContent.excludingDesktopWindows(true, onScreenWindowsOnly: true)
+    let candidates = content.windows.filter { window in
+        window.owningApplication?.bundleIdentifier == "com.Roblox.RobloxStudio" &&
+        window.windowLayer == 0 && window.isOnScreen &&
+        window.frame.width > 0 && window.frame.height > 0 &&
+        matchesStudioTitle(window.title ?? "", hint: hint)
+    }
+    guard candidates.count == 1, let window = candidates.first, let app = window.owningApplication else {
+        try fail(candidates.isEmpty ? "no visible Roblox Studio window matches the requested place title" : "multiple Roblox Studio windows match the requested place title; the capture is ambiguous")
+    }
+    if let expected = env["MCP_CAPTURE_EXPECTED_IDENTITY"], !expected.isEmpty {
+        guard let data = expected.data(using: .utf8),
+              let identity = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+              (identity["windowId"] as? NSNumber)?.uint32Value == window.windowID,
+              (identity["processId"] as? NSNumber)?.int32Value == app.processID,
+              identity["bundleIdentifier"] as? String == app.bundleIdentifier else {
+            try fail("the selected Roblox Studio window identity changed between captures")
+        }
+    }
+    let filter = SCContentFilter(desktopIndependentWindow: window)
+    let scale = CGFloat(filter.pointPixelScale)
+    let pixelWidth = filter.contentRect.width * scale
+    let pixelHeight = filter.contentRect.height * scale
+    guard pixelWidth.isFinite, pixelHeight.isFinite, pixelWidth > 0, pixelHeight > 0,
+          pixelWidth <= 16384, pixelHeight <= 16384 else { try fail("invalid Studio window capture dimensions") }
+    let width = Int(pixelWidth.rounded(.up))
+    let height = Int(pixelHeight.rounded(.up))
+    guard width * height * 4 <= 134217728 else { try fail("Studio window capture exceeds the image byte limit") }
+    let config = SCStreamConfiguration()
+    config.width = width
+    config.height = height
+    config.showsCursor = false
+    config.ignoreShadowsSingleWindow = true
+    config.ignoreGlobalClipSingleWindow = true
+    let image = try await SCScreenshotManager.captureImage(contentFilter: filter, configuration: config)
+    guard image.width == width, image.height == height else { try fail("Studio window capture returned unexpected dimensions") }
+    var bytes = [UInt8](repeating: 0, count: width * height * 4)
+    try bytes.withUnsafeMutableBytes { raw in
+        guard let context = CGContext(data: raw.baseAddress, width: width, height: height,
+            bitsPerComponent: 8, bytesPerRow: width * 4, space: CGColorSpace(name: CGColorSpace.sRGB)!,
+            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue | CGBitmapInfo.byteOrder32Big.rawValue) else {
+            try fail("could not allocate the RGBA capture context")
+        }
+        // Quartz draws the image upright into row-major top-to-bottom bitmap storage.
+        context.setBlendMode(.copy)
+        context.draw(image, in: CGRect(x: 0, y: 0, width: width, height: height))
+    }
+    guard let output = env["MCP_CAPTURE_OUT"] else { try fail("missing capture output path") }
+    try Data(bytes).write(to: URL(fileURLWithPath: output), options: .atomic)
+    emit(["ok": true, "width": width, "height": height, "title": String((window.title ?? "").prefix(2048)),
+          "identity": ["windowId": window.windowID, "processId": app.processID, "bundleIdentifier": app.bundleIdentifier]])
+}
+
+@main struct Main {
+    @MainActor
+    static func main() async {
+        do {
+            if #available(macOS 14.0, *) { try await capture() }
+            else { try fail("macOS host window capture requires macOS 14 or newer") }
+        } catch {
+            emit(["ok": false, "error": String(((error as? CaptureFailure)?.message ?? error.localizedDescription).prefix(2048))])
+        }
+    }
+}
+`;
+function runBoundedCaptureProcess(executable, args, timeoutMs, env = process.env) {
+  return new Promise((resolve6, reject) => {
+    const processGroup = process.platform !== "win32";
+    const child = spawn2(executable, args, { env, stdio: ["ignore", "pipe", "pipe"], detached: processGroup });
+    let stdout = "";
+    let stderr = "";
+    let outputBytes = 0;
+    let failure;
+    const stop = (message) => {
+      failure ??= new Error(message);
+      try {
+        if (processGroup && child.pid)
+          process.kill(-child.pid, "SIGKILL");
+        else
+          child.kill("SIGKILL");
+      } catch {
+        child.kill("SIGKILL");
+      }
+    };
+    const timer = setTimeout(() => stop(`macOS host capture helper timed out after ${timeoutMs}ms`), timeoutMs);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    const collect = (chunk, isError) => {
+      outputBytes += Buffer.byteLength(chunk);
+      if (outputBytes > MAX_OUTPUT_BYTES) {
+        stop("macOS host capture helper exceeded its output byte limit");
+        return;
+      }
+      if (isError)
+        stderr += chunk;
+      else
+        stdout += chunk;
+    };
+    child.stdout.on("data", (chunk) => collect(chunk, false));
+    child.stderr.on("data", (chunk) => collect(chunk, true));
+    child.on("error", (error) => {
+      failure ??= error;
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (failure)
+        reject(failure);
+      else if (code !== 0)
+        reject(new Error(`macOS host capture helper exited with code ${code}: ${stderr.trim().slice(0, 600)}`));
+      else
+        resolve6(stdout);
+    });
+  });
+}
+var MISSING_SWIFT_TOOLCHAIN = "macOS host capture requires Xcode or the Xcode Command Line Tools (xcrun swiftc). Install them with `xcode-select --install`, then retry the capture.";
+async function assertSwiftToolchain(env = process.env, selectedDeveloperDir = () => runBoundedCaptureProcess("/usr/bin/xcode-select", ["-p"], 5e3, env), exists = fs3.existsSync) {
+  let developerDir = env.DEVELOPER_DIR?.trim();
+  if (!developerDir) {
+    try {
+      developerDir = (await selectedDeveloperDir()).trim();
+    } catch {
+      throw new Error(MISSING_SWIFT_TOOLCHAIN);
+    }
+  }
+  const compilers = [
+    path6.join(developerDir, "usr", "bin", "swiftc"),
+    path6.join(developerDir, "Toolchains", "XcodeDefault.xctoolchain", "usr", "bin", "swiftc")
+  ];
+  if (!path6.isAbsolute(developerDir) || !compilers.some((compiler) => exists(compiler))) {
+    throw new Error(MISSING_SWIFT_TOOLCHAIN);
+  }
+}
+var compiledHelper;
+async function getHelper() {
+  if (!compiledHelper) {
+    compiledHelper = (async () => {
+      await assertSwiftToolchain();
+      const directory = fs3.mkdtempSync(path6.join(os3.tmpdir(), "robloxstudio-mcp-macos-helper-"));
+      const cleanup = () => fs3.rmSync(directory, { recursive: true, force: true });
+      try {
+        const source = path6.join(directory, "capture.swift");
+        const executable = path6.join(directory, "capture");
+        fs3.writeFileSync(source, MACOS_CAPTURE_SOURCE, { mode: 384 });
+        await runBoundedCaptureProcess("/usr/bin/xcrun", [
+          "swiftc",
+          "-parse-as-library",
+          source,
+          "-o",
+          executable,
+          "-module-cache-path",
+          path6.join(directory, "modules")
+        ], 6e4);
+        process.once("exit", cleanup);
+        return executable;
+      } catch (error) {
+        cleanup();
+        throw error;
+      }
+    })();
+    compiledHelper.catch(() => {
+      compiledHelper = void 0;
+    });
+  }
+  return compiledHelper;
+}
+async function prepareMacHostCapture() {
+  await getHelper();
+}
+function validIdentity(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const id = value;
+  return Number.isSafeInteger(id.windowId) && id.windowId > 0 && id.windowId <= 4294967295 && Number.isSafeInteger(id.processId) && id.processId > 0 && id.processId <= 2147483647 && id.bundleIdentifier === STUDIO_BUNDLE_ID;
+}
+function parseMacCaptureReport(stdout, expectedIdentity) {
+  if (Buffer.byteLength(stdout) > MAX_OUTPUT_BYTES)
+    throw new Error("macOS capture report exceeds its byte limit");
+  const value = JSON.parse(stdout.trim());
+  if (!value || typeof value !== "object")
+    throw new Error("invalid macOS capture report");
+  if (value.ok === false && typeof value.error === "string")
+    return { ok: false, error: value.error.slice(0, 2048) };
+  const { width, height, title, identity } = value;
+  if (value.ok !== true || !Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0 || width > 16384 || height > 16384 || width * height * 4 > MAX_IMAGE_BYTES || typeof title !== "string" || title.length > 2048 || !validIdentity(identity)) {
+    throw new Error("invalid macOS capture dimensions or window identity");
+  }
+  if (expectedIdentity && (identity.windowId !== expectedIdentity.windowId || identity.processId !== expectedIdentity.processId || identity.bundleIdentifier !== expectedIdentity.bundleIdentifier)) {
+    throw new Error("the selected Roblox Studio window identity changed between captures");
+  }
+  return { ok: true, width, height, title, identity };
+}
+async function runMacCapture(output, titleHint, expectedIdentity) {
+  const executable = await getHelper();
+  return runBoundedCaptureProcess(executable, [], 2e4, {
+    ...process.env,
+    MCP_CAPTURE_TITLE_HINT: titleHint ?? "",
+    MCP_CAPTURE_OUT: output,
+    MCP_CAPTURE_EXPECTED_IDENTITY: expectedIdentity ? JSON.stringify(expectedIdentity) : ""
+  });
+}
+async function captureMacStudioWindow(titleHint, expectedIdentity, runCapture = runMacCapture) {
+  const directory = fs3.mkdtempSync(path6.join(os3.tmpdir(), "robloxstudio-mcp-macos-capture-"));
+  try {
+    const output = path6.join(directory, "capture.rgba");
+    const stdout = await runCapture(output, titleHint, expectedIdentity);
+    const report = parseMacCaptureReport(stdout, expectedIdentity);
+    if (!report.ok)
+      return report;
+    const expectedBytes = report.width * report.height * 4;
+    const stat2 = fs3.lstatSync(output);
+    if (!stat2.isFile() || stat2.size !== expectedBytes)
+      throw new Error("macOS capture returned an invalid RGBA byte count");
+    const rgba = fs3.readFileSync(output);
+    if (rgba.length !== expectedBytes)
+      throw new Error("macOS capture RGBA byte count changed during read");
+    return { ok: true, capture: { width: report.width, height: report.height, title: report.title, identity: report.identity, rgba } };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  } finally {
+    fs3.rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+// ../core/dist/host-capture.js
 var HOST_CAPTURE_TIMEOUT_MS = 2e4;
 var MARKER_MIN_RB = 200;
 var MARKER_MAX_G = 60;
@@ -10297,10 +10837,14 @@ function isHostCaptureDisabled(env = process.env) {
   return value === "0" || value === "false" || value === "off";
 }
 function isHostCaptureSupported(platform = process.platform) {
-  return platform === "win32";
+  return platform === "win32" || platform === "darwin";
 }
 function hostCaptureUnsupportedReason(platform = process.platform) {
-  return `host window capture is only implemented on Windows (this is ${platform})`;
+  return `host window capture is only implemented on Windows and macOS (this is ${platform})`;
+}
+async function prepareHostWindowCapture() {
+  if (process.platform === "darwin" && !isHostCaptureDisabled())
+    await prepareMacHostCapture();
 }
 function isUniformFrame(rgba, width, height) {
   const pixels = width * height;
@@ -10450,17 +10994,40 @@ public static class McpStudioCapture {
 }
 "@
 function Emit($obj) { Write-Output ($obj | ConvertTo-Json -Compress) }
+# Local files show their absolute path in the window title while Studio reports
+# only the basename as DataModel.Name. Match that basename after removing
+# Studio's exact title suffix; the ambiguity checks below still apply.
+function Test-StudioTitle([string]$title, [string]$hint) {
+  if (-not $hint -or $title.StartsWith($hint, [StringComparison]::Ordinal)) { return $true }
+  $suffix = ' - Roblox Studio'
+  if (-not $title.EndsWith($suffix, [StringComparison]::Ordinal)) { return $false }
+  $place = $title.Substring(0, $title.Length - $suffix.Length)
+  if ($place -cnotmatch '^(?:[A-Za-z]:[\\/]|\\\\|/)') { return $false }
+  return $place.Substring($place.LastIndexOfAny([char[]]@([char]'\', [char]'/')) + 1) -ceq $hint
+}
 $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
+$matching = @($candidates | Where-Object { Test-StudioTitle $_.Title $hint })
+$expectedJson = $env:MCP_CAPTURE_EXPECTED_IDENTITY
+if ($expectedJson) {
+  try { $expected = $expectedJson | ConvertFrom-Json -ErrorAction Stop }
+  catch { Emit @{ ok = $false; error = 'invalid expected Studio window identity' }; exit 0 }
+  $matching = @($matching | Where-Object {
+    $_.Handle.ToInt64() -eq $expected.windowId -and $_.Pid -eq $expected.processId -and
+    $expected.bundleIdentifier -ceq 'RobloxStudioBeta'
+  })
+  if ($matching.Count -ne 1) {
+    Emit @{ ok = $false; error = 'the selected Roblox Studio window identity changed between captures' }; exit 0
+  }
+} elseif ($matching.Count -ne 1) {
+  $reason = if ($matching.Count -eq 0) { 'no visible Roblox Studio window matches the requested place title' }
+    else { 'multiple Roblox Studio windows match the requested place title; the capture is ambiguous' }
+  Emit @{ ok = $false; error = $reason }; exit 0
 }
+$pick = $matching[0]
+$identity = @{ windowId = $pick.Handle.ToInt64(); processId = [long]$pick.Pid; bundleIdentifier = 'RobloxStudioBeta' }
 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
 }
@@ -10482,83 +11049,110 @@ $bytes = New-Object byte[] ($data.Stride * $h)
 $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 }
+Emit @{ ok = $true; width = $w; height = $h; stride = $stride; title = $pick.Title; identity = $identity }
 `;
+function validWindowsIdentity(value) {
+  return value !== null && typeof value === "object" && "windowId" in value && typeof value.windowId === "number" && Number.isSafeInteger(value.windowId) && value.windowId > 0 && "processId" in value && typeof value.processId === "number" && Number.isSafeInteger(value.processId) && value.processId > 0 && value.processId <= 4294967295 && "bundleIdentifier" in value && value.bundleIdentifier === "RobloxStudioBeta";
+}
+function parseWindowsCaptureReport(value, expectedIdentity) {
+  if (value === null || typeof value !== "object" || !("ok" in value))
+    throw new Error("invalid Windows capture report");
+  if (value.ok === false && "error" in value && typeof value.error === "string")
+    return { ok: false, error: value.error };
+  if (!("identity" in value) || !validWindowsIdentity(value.identity))
+    throw new Error("invalid Windows capture window identity");
+  const identity = value.identity;
+  if (expectedIdentity && (identity.windowId !== expectedIdentity.windowId || identity.processId !== expectedIdentity.processId || identity.bundleIdentifier !== expectedIdentity.bundleIdentifier)) {
+    throw new Error("the selected Roblox Studio window identity changed between captures");
+  }
+  if (value.ok !== true || !("width" in value) || typeof value.width !== "number" || !Number.isSafeInteger(value.width) || value.width <= 0 || !("height" in value) || typeof value.height !== "number" || !Number.isSafeInteger(value.height) || value.height <= 0 || !("stride" in value) || typeof value.stride !== "number" || !Number.isSafeInteger(value.stride) || value.stride < value.width * 4 || value.width > 16384 || value.height > 16384 || value.stride * value.height > 128 * 1024 * 1024 || !("title" in value) || typeof value.title !== "string") {
+    throw new Error("invalid Windows capture dimensions or title");
+  }
+  return { ok: true, width: value.width, height: value.height, stride: value.stride, title: value.title, identity };
+}
 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))
+    const candidate = path7.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    if (fs4.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)
+function runWindowsCapture(titleHint, outFile, expectedIdentity) {
+  const { promise, resolve: resolve6, reject } = Promise.withResolvers();
+  const encoded = Buffer.from(WINDOWS_CAPTURE_SCRIPT, "utf16le").toString("base64");
+  const child = spawn3(powershellPath(), ["-NoProfile", "-NonInteractive", "-NoLogo", "-ExecutionPolicy", "Bypass", "-EncodedCommand", encoded], {
+    env: {
+      ...process.env,
+      MCP_CAPTURE_TITLE_HINT: titleHint ?? "",
+      MCP_CAPTURE_OUT: outFile,
+      MCP_CAPTURE_EXPECTED_IDENTITY: expectedIdentity ? JSON.stringify(expectedIdentity) : ""
+    },
+    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 {
+        resolve6(JSON.parse(last));
         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 {
-        }
+      } catch {
       }
-      const detail = (stderr.trim() || stdout.trim()).slice(0, 600);
-      reject(new Error(`host window capture helper exited with code ${code}${detail ? `: ${detail}` : ""}`));
-    });
+    }
+    const detail = (stderr.trim() || stdout.trim()).slice(0, 600);
+    reject(new Error(`host window capture helper exited with code ${code}${detail ? `: ${detail}` : ""}`));
   });
+  return promise;
 }
-async function captureStudioWindow(titleHint) {
+async function captureStudioWindow(titleHint, expectedIdentity) {
   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`);
+  if (process.platform === "darwin")
+    return captureMacStudioWindow(titleHint, expectedIdentity);
+  const outFile = path7.join(os4.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 report = parseWindowsCaptureReport(await runWindowsCapture(titleHint, outFile, expectedIdentity), expectedIdentity);
+    if (!report.ok)
+      return report;
+    const raw = fs4.readFileSync(outFile);
+    if (raw.length !== report.stride * report.height)
+      throw new Error("Windows capture returned an invalid BGRA byte count");
     const { width, height, stride } = report;
     const rgba = Buffer.alloc(width * height * 4);
     for (let y = 0; y < height; y++) {
@@ -10573,17 +11167,20 @@ async function captureStudioWindow(titleHint) {
         rgba[d + 3] = 255;
       }
     }
-    return { ok: true, capture: { width, height, rgba, title: report.title ?? "" } };
+    return { ok: true, capture: { width, height, rgba, title: report.title, identity: report.identity } };
   } catch (error) {
     return { ok: false, error: error instanceof Error ? error.message : String(error) };
   } finally {
-    fs3.rmSync(outFile, { force: true });
+    fs4.rmSync(outFile, { force: true });
   }
 }
 
 // ../core/dist/tools/index.js
-import * as fs4 from "fs";
-import * as path6 from "path";
+import * as fs5 from "fs";
+import * as path8 from "path";
+function sameHostWindowIdentity(actual, expected) {
+  return actual?.windowId === expected.windowId && actual.processId === expected.processId && actual.bundleIdentifier === expected.bundleIdentifier;
+}
 var HOST_VIEWPORT_RECT_TTL_MS = 6e4;
 var MAX_INLINE_IMAGE_BYTES = 6e6;
 var MAX_MATRIX_IMAGE_BYTES = 8e6;
@@ -10669,7 +11266,7 @@ function encodeImageFromRgbaResponse(response, format, quality) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -10763,9 +11360,9 @@ function compactSoundReference(sound) {
     name: stringField(sound, "name"),
     className: stringField(sound, "className")
   };
-  const path7 = stringField(sound, "path");
-  if (path7)
-    compact.path = path7;
+  const path9 = stringField(sound, "path");
+  if (path9)
+    compact.path = path9;
   const assetId = robloxAssetIdFromContentId(sound.assetId ?? sound.soundId ?? sound.asset);
   if (assetId !== void 0)
     compact.assetId = assetId;
@@ -10828,8 +11425,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 = path6.resolve(sourcePath);
-    const parsed = JSON.parse(fs4.readFileSync(resolved, "utf8"));
+    const resolved = path8.resolve(sourcePath);
+    const parsed = JSON.parse(fs5.readFileSync(resolved, "utf8"));
     const record = asRecord(parsed);
     if (!record)
       throw new Error(`baseline_path did not contain a JSON object: ${resolved}`);
@@ -11331,6 +11928,7 @@ var RobloxStudioTools = class {
   cookieClient;
   instanceManager;
   managedConnectionAssociations = Promise.resolve();
+  unsubscribePeerRegistered;
   hostWindowCapture = captureStudioWindow;
   hostViewportRects = /* @__PURE__ */ new Map();
   viewportCaptureQueues = /* @__PURE__ */ new Map();
@@ -11340,7 +11938,7 @@ var RobloxStudioTools = class {
     this.openCloudClient = new OpenCloudClient();
     this.cookieClient = new RobloxCookieClient();
     this.instanceManager = new StudioInstanceManager();
-    this.bridge.onPeerRegistered((peer) => {
+    this.unsubscribePeerRegistered = this.bridge.onPeerRegistered((peer) => {
       const instanceManager = this.instanceManager;
       const association = this.managedConnectionAssociations.then(() => this._associateManagedEditConnection(peer, instanceManager));
       this.managedConnectionAssociations = association.catch((error) => {
@@ -11351,6 +11949,10 @@ var RobloxStudioTools = class {
   getStudioLifecycleCapabilities() {
     return this.instanceManager.getLifecycleCapabilities();
   }
+  async dispose() {
+    this.unsubscribePeerRegistered();
+    await this.managedConnectionAssociations;
+  }
   _textResult(body) {
     return { content: [{ type: "text", text: JSON.stringify(body) }] };
   }
@@ -11474,8 +12076,8 @@ var RobloxStudioTools = class {
     }
     return this._requestPeer(endpoint, data, resolved.targetPeerId, timeoutMs, signal, operationId);
   }
-  // Prefer the first client role in the selected process/group scope for live
-  // viewport and input operations; otherwise retain the default Peer's Instance.
+  // Honor an explicitly selected client for viewport/input operations; otherwise
+  // prefer the first client in the scope, then retain the default Peer's Instance.
   _resolveRuntime(instance_id) {
     const resolved = this.bridge.resolveTarget({ instance_id, target: void 0 });
     if (!resolved.ok)
@@ -11487,7 +12089,9 @@ var RobloxStudioTools = class {
         data: this._routingErrorData()
       });
     }
-    const client = this.bridge.getPeersInScope(resolved.targetInstanceId).filter((peer) => /^client-\d+$/.test(peer.role)).sort((a, b) => a.role.localeCompare(b.role) || a.peerId.localeCompare(b.peerId))[0];
+    const clients = this.bridge.getPeersInScope(resolved.targetInstanceId).filter((peer) => /^client-\d+$/.test(peer.role));
+    const selectedClients = clients.filter((peer) => instance_id === peer.instanceId || instance_id === `${peer.instanceId}-${peer.role}`);
+    const client = selectedClients.length === 1 ? selectedClients[0] : clients.sort((a, b) => a.role.localeCompare(b.role) || a.peerId.localeCompare(b.peerId))[0];
     return {
       instanceId: client?.instanceId ?? resolved.targetInstanceId,
       clientRole: client?.role
@@ -11773,8 +12377,8 @@ var RobloxStudioTools = class {
       timedOut: true
     };
   }
-  async getFileTree(path7 = "", instance_id) {
-    const response = await this._callSingle("/api/file-tree", { path: path7 }, void 0, instance_id);
+  async getFileTree(path9 = "", instance_id) {
+    const response = await this._callSingle("/api/file-tree", { path: path9 }, void 0, instance_id);
     return {
       content: [
         {
@@ -11866,9 +12470,9 @@ var RobloxStudioTools = class {
       ]
     };
   }
-  async getProjectStructure(path7, maxDepth, scriptsOnly, instance_id) {
+  async getProjectStructure(path9, maxDepth, scriptsOnly, instance_id) {
     const response = await this._callSingle("/api/project-structure", {
-      path: path7,
+      path: path9,
       maxDepth,
       scriptsOnly
     }, void 0, instance_id);
@@ -12029,7 +12633,7 @@ var RobloxStudioTools = class {
     };
   }
   async setSelection(paths, mode, instance_id) {
-    if (!Array.isArray(paths) || paths.some((path7) => typeof path7 !== "string" || path7.length === 0)) {
+    if (!Array.isArray(paths) || paths.some((path9) => typeof path9 !== "string" || path9.length === 0)) {
       throw new Error("selection paths must contain only non-empty instance paths");
     }
     const selectionMode = mode ?? "set";
@@ -12766,9 +13370,9 @@ var RobloxStudioTools = class {
       const rawJson = mutable.raw_json;
       if (typeof rawJson === "string") {
         if (typeof outputPath === "string" && outputPath !== "") {
-          const resolvedOutputPath = path6.resolve(outputPath);
-          fs4.mkdirSync(path6.dirname(resolvedOutputPath), { recursive: true });
-          fs4.writeFileSync(resolvedOutputPath, rawJson, "utf8");
+          const resolvedOutputPath = path8.resolve(outputPath);
+          fs5.mkdirSync(path8.dirname(resolvedOutputPath), { recursive: true });
+          fs5.writeFileSync(resolvedOutputPath, rawJson, "utf8");
           mutable.output_path = resolvedOutputPath;
         }
         delete mutable.raw_json;
@@ -12829,9 +13433,9 @@ var RobloxStudioTools = class {
       const rawSnapshotBase64 = mutable.raw_snapshot_base64;
       if (typeof rawSnapshotBase64 === "string") {
         if (typeof outputPath === "string" && outputPath !== "") {
-          const resolvedOutputPath = path6.resolve(outputPath);
-          fs4.mkdirSync(path6.dirname(resolvedOutputPath), { recursive: true });
-          fs4.writeFileSync(resolvedOutputPath, Buffer.from(rawSnapshotBase64, "base64"));
+          const resolvedOutputPath = path8.resolve(outputPath);
+          fs5.mkdirSync(path8.dirname(resolvedOutputPath), { recursive: true });
+          fs5.writeFileSync(resolvedOutputPath, Buffer.from(rawSnapshotBase64, "base64"));
           mutable.output_path = resolvedOutputPath;
         }
         delete mutable.raw_snapshot_base64;
@@ -12845,9 +13449,9 @@ var RobloxStudioTools = class {
         });
       }
       if (typeof summaryOutputPath === "string" && summaryOutputPath !== "") {
-        const resolvedSummaryPath = path6.resolve(summaryOutputPath);
-        fs4.mkdirSync(path6.dirname(resolvedSummaryPath), { recursive: true });
-        fs4.writeFileSync(resolvedSummaryPath, JSON.stringify(mutable, null, 2), "utf8");
+        const resolvedSummaryPath = path8.resolve(summaryOutputPath);
+        fs5.mkdirSync(path8.dirname(resolvedSummaryPath), { recursive: true });
+        fs5.writeFileSync(resolvedSummaryPath, JSON.stringify(mutable, null, 2), "utf8");
         mutable.summary_output_path = resolvedSummaryPath;
       }
       if (!includeComparisonIndex) {
@@ -12909,7 +13513,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 = path6.basename(record.localPlaceFile);
+      const expectedName = path8.basename(record.localPlaceFile);
       return instance.placeName === expectedName || instance.dataModelName === expectedName;
     }
     return true;
@@ -12922,7 +13526,7 @@ var RobloxStudioTools = class {
       await instanceManager.attachInstanceId(candidate, instance.instanceId);
   }
   async _deriveUniverseId(placeId) {
-    const response = await fetch(`https://apis.roblox.com/universes/v1/places/${placeId}/universe`);
+    const response = await fetch(`https://apis.roblox.com/universes/v1/places/${placeId}/universe`, { signal: AbortSignal.timeout(3e4) });
     if (!response.ok) {
       const body = await response.text().catch(() => "");
       throw new Error(`Could not resolve the universe for place_id ${placeId} (${response.status}): ${body}`);
@@ -14240,11 +14844,11 @@ var RobloxStudioTools = class {
     return this.resolveUploadedReferenceImageId(decalId, instance_id);
   }
   async uploadAsset(filePath, assetType, displayName, description, userId, groupId) {
-    if (!fs4.existsSync(filePath)) {
+    if (!fs5.existsSync(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    const fileContent = fs4.readFileSync(filePath);
-    const fileName = path6.basename(filePath);
+    const fileContent = fs5.readFileSync(filePath);
+    const fileName = path8.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()) {
@@ -14460,10 +15064,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 = path6.resolve(outputPath);
+    const resolved = path8.resolve(outputPath);
     try {
-      fs4.mkdirSync(path6.dirname(resolved), { recursive: true });
-      fs4.writeFileSync(resolved, bytes);
+      fs5.mkdirSync(path8.dirname(resolved), { recursive: true });
+      fs5.writeFileSync(resolved, bytes);
     } catch (err2) {
       return { content: [{ type: "text", text: JSON.stringify({ error: `failed to write ${resolved}: ${err2.message}` }) }] };
     }
@@ -14478,7 +15082,7 @@ var RobloxStudioTools = class {
       }]
     };
   }
-  async importRbxm(source, parentPath, target, instance_id) {
+  async importRbxm(source, parentPath, target, instance_id, signal) {
     if (!source || typeof source !== "object") {
       throw new Error("source is required for import_rbxm");
     }
@@ -14493,59 +15097,18 @@ var RobloxStudioTools = class {
     if (modes.length !== 1) {
       throw new Error(`source must contain exactly one of { path, url, base64 } (got: ${modes.join(", ") || "none"})`);
     }
-    let bytes;
-    let sourceLabel;
-    if (source.path !== void 0) {
-      const resolved = path6.resolve(source.path);
-      try {
-        bytes = fs4.readFileSync(resolved);
-      } catch (err2) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: `failed to read ${resolved}: ${err2.message}` }) }] };
-      }
-      sourceLabel = resolved;
-    } else if (source.url !== void 0) {
-      let parsedUrl;
-      try {
-        parsedUrl = new URL(source.url);
-      } catch {
-        return { content: [{ type: "text", text: JSON.stringify({ error: `import_rbxm url is not a valid URL: ${source.url}` }) }] };
-      }
-      if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
-        return { content: [{ type: "text", text: JSON.stringify({ error: `import_rbxm url must use http(s); got ${parsedUrl.protocol}` }) }] };
-      }
-      const MAX_IMPORT_BYTES = 50 * 1024 * 1024;
-      try {
-        const res = await fetch(source.url);
-        if (!res.ok) {
-          const snippet = (await res.text()).slice(0, 500);
-          return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url} returned ${res.status}: ${snippet}` }) }] };
-        }
-        const claimed = Number(res.headers.get("content-length") ?? "0");
-        if (claimed > MAX_IMPORT_BYTES) {
-          return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url}: content-length ${claimed} exceeds ${MAX_IMPORT_BYTES} byte cap` }) }] };
-        }
-        const arr = await res.arrayBuffer();
-        if (arr.byteLength > MAX_IMPORT_BYTES) {
-          return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url}: downloaded ${arr.byteLength} bytes exceeds ${MAX_IMPORT_BYTES} byte cap` }) }] };
-        }
-        bytes = Buffer.from(arr);
-      } catch (err2) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url} failed: ${err2.message}` }) }] };
-      }
-      sourceLabel = source.url;
-    } else {
-      try {
-        bytes = Buffer.from(source.base64, "base64");
-      } catch (err2) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: `base64 decode failed: ${err2.message}` }) }] };
-      }
-      sourceLabel = `base64(${bytes.length}B)`;
+    let input;
+    try {
+      input = await readRbxmInput(source, parentPath, signal);
+    } catch (error) {
+      return this._textResult({ error: error instanceof Error ? error.message : String(error) });
     }
+    const { bytes, sourceLabel } = input;
     const response = await this._callSingle("/api/import-rbxm", {
       base64: bytes.toString("base64"),
       parent_path: parentPath,
       source_label: sourceLabel
-    }, tgt, instance_id);
+    }, tgt, instance_id, void 0, signal);
     return { content: [{ type: "text", text: JSON.stringify(response) }] };
   }
   // Even native capture must wait while another call has fitted the simulator
@@ -14567,24 +15130,26 @@ var RobloxStudioTools = class {
     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);
+    const studioFastPathUnavailable = studioFastPathMissing ? response.unavailable ?? response.error : void 0;
     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 = { error: begin.error };
+        } else if (!begin.contentId) {
+          response = { error: "Screenshot capture failed: no content id returned from client." };
+        } else {
+          response = await this._callSingle("/api/capture-read", { contentId: begin.contentId }, "edit", instanceId);
         }
-        response = await this._callSingle("/api/capture-read", { contentId: begin.contentId }, "edit", instanceId);
       } else {
         response = await this._callSingle("/api/capture-screenshot", {}, "edit", instanceId);
       }
+      response.source ??= "CaptureService";
     }
     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;
+      hostReason = response.error ? `Studio's capture failed (${response.error})` : this._isUniformCaptureResponse(response) ? `Studio's ${response.source ?? "capture"} 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})`;
@@ -14605,7 +15170,7 @@ var RobloxStudioTools = class {
       if (targetRole.startsWith("client-") && response.error.includes("Failed to load texture, unexpected format") && await this._isMultiplayerTestRunning(instanceId)) {
         text = `Screenshot capture reached the multiplayer client, but Roblox returned a temporary screenshot texture that the edit peer cannot read in StudioTestService multiplayer sessions. Regular solo_playtest capture works because the temporary rbxtemp:// handle is readable from the edit process; multiplayer client handles appear to be scoped to the client process. Raw error: ${response.error}`;
       }
-      return { success: false, error: text };
+      return { success: false, error: text, studioFastPathUnavailable };
     }
     const w = response.width;
     const h = response.height;
@@ -14659,7 +15224,9 @@ var RobloxStudioTools = class {
       note,
       data: buffer.toString("base64"),
       mimeType,
-      message
+      message,
+      source: response.source,
+      studioFastPathUnavailable
     };
   }
   _isUniformCaptureResponse(response) {
@@ -14681,6 +15248,19 @@ var RobloxStudioTools = class {
   }
   // Always restore the simulator, including failures and cached window grabs.
   async _captureViewportFromHostWindow(instanceId, targetRole) {
+    if (isHostCaptureDisabled()) {
+      return { success: false, error: "host window capture is disabled by ROBLOX_STUDIO_HOST_CAPTURE" };
+    }
+    if (!isHostCaptureSupported()) {
+      return { success: false, error: hostCaptureUnsupportedReason() };
+    }
+    if (this.hostWindowCapture === captureStudioWindow) {
+      try {
+        await prepareHostWindowCapture();
+      } catch (error) {
+        return { success: false, error: `could not prepare host capture: ${error instanceof Error ? error.message : String(error)}` };
+      }
+    }
     let prepared;
     let result;
     try {
@@ -14734,9 +15314,12 @@ var RobloxStudioTools = class {
     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);
+      const grab = await this.hostWindowCapture(titleHint, cached.identity);
       if (!grab.ok)
         return { success: false, error: grab.error };
+      if (cached.identity !== void 0 && !sameHostWindowIdentity(grab.capture.identity, cached.identity)) {
+        return { success: false, error: "the Studio window identity changed since locating the viewport; retry the capture" };
+      }
       if (grab.capture.width === cached.windowWidth && grab.capture.height === cached.windowHeight) {
         return {
           success: true,
@@ -14772,21 +15355,25 @@ var RobloxStudioTools = class {
     });
     if ("error" in located)
       return { success: false, error: located.error };
+    const cleanGrab = await this.hostWindowCapture(titleHint, markerGrab.capture.identity);
+    if (!cleanGrab.ok)
+      return { success: false, error: cleanGrab.error };
+    if (markerGrab.capture.identity !== void 0 && !sameHostWindowIdentity(cleanGrab.capture.identity, markerGrab.capture.identity)) {
+      return { success: false, error: "the Studio window identity changed while locating the viewport; retry the capture" };
+    }
+    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" };
+    }
     this.hostViewportRects.set(cacheKey, {
       rect: located.rect,
+      identity: markerGrab.capture.identity,
       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)
@@ -14812,7 +15399,7 @@ var RobloxStudioTools = class {
     const { instanceId, clientRole } = this._resolveRuntime(instance_id);
     const capture = await this._captureViewportImage(instanceId, clientRole ?? "edit", format, quality);
     if (!capture.success) {
-      return this._textResult({ error: capture.error });
+      return this._textResult({ error: capture.error, studioFastPathUnavailable: capture.studioFastPathUnavailable });
     }
     return {
       content: [
@@ -14824,7 +15411,9 @@ var RobloxStudioTools = class {
             format: capture.format,
             mimeType: capture.mimeType,
             ...capture.quality === void 0 ? {} : { quality: capture.quality },
-            message: capture.message
+            message: capture.message,
+            source: capture.source,
+            studioFastPathUnavailable: capture.studioFastPathUnavailable
           })
         },
         {
@@ -14974,6 +15563,7 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
     const response = await fetch(`${this.primaryBaseUrl}/create-multiplayer-group`, {
       method: "POST",
       headers: this.authHeaders({ "Content-Type": "application/json" }),
+      signal: AbortSignal.timeout(5e3),
       body: JSON.stringify({ groupId, controllerInstanceId })
     });
     if (!response.ok) {
@@ -15004,6 +15594,7 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
     const response = await fetch(`${this.primaryBaseUrl}/remove-multiplayer-group`, {
       method: "POST",
       headers: this.authHeaders({ "Content-Type": "application/json" }),
+      signal: AbortSignal.timeout(5e3),
       body: JSON.stringify({ groupId })
     });
     if (response.status === 409) {
@@ -15035,6 +15626,7 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
     const response = await fetch(`${this.primaryBaseUrl}/unregister-instance-id`, {
       method: "POST",
       headers: this.authHeaders({ "Content-Type": "application/json" }),
+      signal: AbortSignal.timeout(5e3),
       body: JSON.stringify({ instanceId })
     });
     if (!response.ok) {
@@ -15064,7 +15656,8 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
   }
   async getRequestStatusEverywhere(requestId) {
     const response = await fetch(`${this.primaryBaseUrl}/request-status?requestId=${encodeURIComponent(requestId)}`, {
-      headers: this.authHeaders()
+      headers: this.authHeaders(),
+      signal: AbortSignal.timeout(5e3)
     });
     if (!response.ok)
       throw new Error(`Proxy request status failed (${response.status})`);
@@ -15369,8 +15962,8 @@ var BoundedStdioTransport = class {
       this.onStreamError(error);
       return Promise.reject(error);
     }
-    const { promise, resolve: resolve5, reject } = Promise.withResolvers();
-    const pending = { resolve: resolve5, reject };
+    const { promise, resolve: resolve6, reject } = Promise.withResolvers();
+    const pending = { resolve: resolve6, reject };
     this.pendingSends.add(pending);
     this.pendingWrites++;
     try {
@@ -15382,7 +15975,7 @@ var BoundedStdioTransport = class {
       });
       if (writable) {
         this.pendingSends.delete(pending);
-        resolve5();
+        resolve6();
       } else if (!this.closed) {
         this.outputBlocked = true;
         this.input.pause();
@@ -15481,6 +16074,7 @@ var RobloxStudioMCPServer = class {
         try {
           const result = await listenWithRetry(candidateApp, host, basePort, 1);
           const oldBridge = this.bridge;
+          const oldTools = this.tools;
           this.bridge = candidateBridge;
           this.tools = candidateTools;
           if (oldBridge instanceof ProxyBridgeService) {
@@ -15494,6 +16088,7 @@ var RobloxStudioMCPServer = class {
           console.error(`Promoted from proxy to primary on port ${boundPort}`);
           if (promotionInterval)
             clearInterval(promotionInterval);
+          await oldTools.dispose();
         } catch {
           await candidateApp.cleanup().catch(() => {
           });
@@ -15558,6 +16153,7 @@ var RobloxStudioMCPServer = class {
       });
       if (httpHandle)
         httpHandle.close();
+      await this.tools.dispose();
       process.exit(0);
     };
     process.on("SIGTERM", shutdown);
@@ -17219,7 +17815,7 @@ var TOOL_DEFINITIONS = [
       properties: {
         source: {
           type: "object",
-          description: "Exactly one path, URL, or base64 source; URLs cap at 50 MiB.",
+          description: "Exactly one path, URL, or base64 source. All inputs are capped below 37.5 MiB to fit base64 plus routing metadata within transport limits; URL downloads have a 30-second deadline.",
           properties: {
             path: { type: "string", description: "Absolute local .rbxm path." },
             url: { type: "string", description: "HTTP or HTTPS .rbxm URL." },
@@ -17348,10 +17944,10 @@ var getAllTools = () => [...TOOL_DEFINITIONS];
 
 // ../core/dist/install-plugin-helpers.js
 var import_saxes = __toESM(require_saxes(), 1);
-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 { existsSync as existsSync7, lstatSync as lstatSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync, rmSync as rmSync4, rmdirSync, statSync as statSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
 import { execSync } from "child_process";
 import { randomUUID as randomUUID5 } from "crypto";
-import { basename as basename3, join as join6 } from "path";
+import { basename as basename3, join as join8 } from "path";
 import { homedir as homedir4 } from "os";
 import { isUtf8 } from "buffer";
 var DEFAULT_PLUGIN_PORT = 58741;
@@ -17403,15 +17999,15 @@ function getPluginsFolder() {
   if (process.env.MCP_PLUGINS_DIR)
     return process.env.MCP_PLUGINS_DIR;
   if (process.platform === "win32") {
-    return join6(process.env.LOCALAPPDATA || join6(homedir4(), "AppData", "Local"), "Roblox", "Plugins");
+    return join8(process.env.LOCALAPPDATA || join8(homedir4(), "AppData", "Local"), "Roblox", "Plugins");
   }
   if (isWSL()) {
     const localAppData = getWindowsUserLocalAppData();
     if (localAppData)
-      return join6(localAppData.linuxPath, "Roblox", "Plugins");
+      return join8(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 join6(homedir4(), "Documents", "Roblox", "Plugins");
+  return join8(homedir4(), "Documents", "Roblox", "Plugins");
 }
 var STALE_TEST_PLUGINS_DIRECTORY = "RsmcpIsolatedPlugins";
 function pluginDirectorySettingPattern() {
@@ -17426,7 +18022,7 @@ function repairStaleStudioPluginDirectorySetting({ settingsPath, studioPluginsDi
   if (studioPluginsDirectory === "") {
     throw new Error("studioPluginsDirectory must be a non-empty path.");
   }
-  const contents = readFileSync7(settingsPath, "utf8");
+  const contents = readFileSync8(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}.`);
@@ -17434,16 +18030,16 @@ function repairStaleStudioPluginDirectorySetting({ settingsPath, studioPluginsDi
   if (matches[0][2] !== STALE_TEST_PLUGINS_DIRECTORY)
     return false;
   const studioPath = escapeXmlText(studioPluginsDirectory);
-  const updated = contents.replace(pluginDirectorySettingPattern(), (_match, open2, _value, close) => `${open2}${studioPath}${close}`);
+  const updated = contents.replace(pluginDirectorySettingPattern(), (_match, open4, _value, close) => `${open4}${studioPath}${close}`);
   const temporaryPath = `${settingsPath}.rsmcp-install-${process.pid}-${randomUUID5()}.tmp`;
   try {
-    writeFileSync3(temporaryPath, updated, {
+    writeFileSync4(temporaryPath, updated, {
       encoding: "utf8",
       mode: statSync3(settingsPath).mode
     });
     renameSync(temporaryPath, settingsPath);
   } finally {
-    rmSync3(temporaryPath, { force: true });
+    rmSync4(temporaryPath, { force: true });
   }
   return true;
 }
@@ -17454,16 +18050,16 @@ function repairDefaultStudioPluginDirectorySetting(pluginsFolder, log) {
   let defaultPluginsFolder;
   let studioPluginsDirectory;
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || join6(homedir4(), "AppData", "Local");
-    defaultPluginsFolder = join6(localAppData, "Roblox", "Plugins");
-    settingsPath = join6(localAppData, "Roblox", "GlobalSettings_13.xml");
+    const localAppData = process.env.LOCALAPPDATA || join8(homedir4(), "AppData", "Local");
+    defaultPluginsFolder = join8(localAppData, "Roblox", "Plugins");
+    settingsPath = join8(localAppData, "Roblox", "GlobalSettings_13.xml");
     studioPluginsDirectory = defaultPluginsFolder.replaceAll("\\", "/");
   } else if (isWSL()) {
     const localAppData = getWindowsUserLocalAppData();
     if (!localAppData)
       return;
-    defaultPluginsFolder = join6(localAppData.linuxPath, "Roblox", "Plugins");
-    settingsPath = join6(localAppData.linuxPath, "Roblox", "GlobalSettings_13.xml");
+    defaultPluginsFolder = join8(localAppData.linuxPath, "Roblox", "Plugins");
+    settingsPath = join8(localAppData.linuxPath, "Roblox", "GlobalSettings_13.xml");
     studioPluginsDirectory = [
       localAppData.windowsPath.replace(/[\\/]+$/u, ""),
       "Roblox",
@@ -17479,12 +18075,12 @@ function repairDefaultStudioPluginDirectorySetting(pluginsFolder, log) {
   }
 }
 function handleVariantConflict({ pluginsFolder, otherAssetName, replace, log = console.log, warn = console.warn }) {
-  const otherDest = join6(pluginsFolder, otherAssetName);
+  const otherDest = join8(pluginsFolder, otherAssetName);
   if (!existsSync7(otherDest))
     return;
   if (replace) {
     try {
-      unlinkSync(otherDest);
+      unlinkSync2(otherDest);
       log(`Removed conflicting ${otherAssetName}.`);
     } catch (err2) {
       warn(`[install-plugin] Could not remove ${otherDest}: ${err2}. Continuing.`);
@@ -17505,11 +18101,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 = join6(lockPath, "owner.json");
-  if (!lstatSync(lockPath).isDirectory() || !lstatSync(ownerPath).isFile()) {
+  const ownerPath = join8(lockPath, "owner.json");
+  if (!lstatSync2(lockPath).isDirectory() || !lstatSync2(ownerPath).isFile()) {
     throw new Error("Lock and owner metadata must be a directory and regular file");
   }
-  const owner = JSON.parse(readFileSync7(ownerPath, "utf8"));
+  const owner = JSON.parse(readFileSync8(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");
   }
@@ -17535,7 +18131,7 @@ function recoverPluginInstallLock(lockPath, warn) {
     throw pluginInstallLockError(lockPath, `Cannot safely read plugin installation lock owner (${error})`);
   }
   assertPluginInstallOwnerExited(lockPath, owner);
-  const claimPath = join6(lockPath, `recovery-${owner.token}`);
+  const claimPath = join8(lockPath, `recovery-${owner.token}`);
   try {
     mkdirSync4(claimPath);
   } catch (error) {
@@ -17568,14 +18164,14 @@ function recoverPluginInstallLock(lockPath, warn) {
     }
   }
   try {
-    rmSync3(abandonedPath, { recursive: true, force: true });
+    rmSync4(abandonedPath, { recursive: true, force: true });
   } catch (error) {
     warn(`[install-plugin] Could not clean abandoned install lock ${abandonedPath}: ${error}`);
   }
 }
 function acquirePluginInstallLock(pluginsFolder, warn) {
-  const lockPath = join6(pluginsFolder, PLUGIN_INSTALL_LOCK_NAME);
-  const ownerPath = join6(lockPath, "owner.json");
+  const lockPath = join8(pluginsFolder, PLUGIN_INSTALL_LOCK_NAME);
+  const ownerPath = join8(lockPath, "owner.json");
   const owner = {
     pid: process.pid,
     token: randomUUID5(),
@@ -17596,14 +18192,14 @@ function acquirePluginInstallLock(pluginsFolder, warn) {
     }
   }
   try {
-    writeFileSync3(ownerPath, `${JSON.stringify(owner)}
+    writeFileSync4(ownerPath, `${JSON.stringify(owner)}
 `, {
       encoding: "utf8",
       flag: "wx"
     });
   } catch (error) {
     try {
-      rmSync3(lockPath, { recursive: true, force: true });
+      rmSync4(lockPath, { recursive: true, force: true });
     } catch (cleanupError) {
       warn(`[install-plugin] Could not clean failed install lock ${lockPath}: ${cleanupError}`);
     }
@@ -17613,7 +18209,7 @@ function acquirePluginInstallLock(pluginsFolder, warn) {
     try {
       const currentOwner = readPluginInstallLockOwner(lockPath);
       if (currentOwner.pid === owner.pid && currentOwner.token === owner.token) {
-        rmSync3(lockPath, { recursive: true, force: true });
+        rmSync4(lockPath, { recursive: true, force: true });
       }
     } catch (error) {
       if (errorCode(error) !== "ENOENT") {
@@ -17707,9 +18303,9 @@ function assertPluginAssetIdentity(source, assetName, expectedVersion, expectedV
 function installedFileMatches(source, destination) {
   if (!existsSync7(destination))
     return false;
-  if (!lstatSync(destination).isFile())
+  if (!lstatSync2(destination).isFile())
     return false;
-  const installed = readFileSync7(destination);
+  const installed = readFileSync8(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 }) {
@@ -17721,19 +18317,19 @@ function installPluginAsset({ pluginsFolder, assetName, otherAssetName, source,
   const configured = configurePluginAssetForPort(source, rawPort);
   assertPluginAssetIdentity(configured, assetName, expectedVersion, expectedVariant);
   mkdirSync4(pluginsFolder, { recursive: true });
-  const destination = join6(pluginsFolder, assetName);
+  const destination = join8(pluginsFolder, assetName);
   const releaseLock = acquirePluginInstallLock(pluginsFolder, warn);
   try {
     let installed = false;
     if (!installedFileMatches(configured, destination)) {
-      const staged = join6(pluginsFolder, `.${assetName}.${process.pid}.${randomUUID5()}.tmp`);
+      const staged = join8(pluginsFolder, `.${assetName}.${process.pid}.${randomUUID5()}.tmp`);
       try {
-        writeFileSync3(staged, configured, { flag: "wx" });
+        writeFileSync4(staged, configured, { flag: "wx" });
         renameSync(staged, destination);
         installed = true;
       } finally {
         try {
-          unlinkSync(staged);
+          unlinkSync2(staged);
         } catch (error) {
           if (errorCode(error) !== "ENOENT") {
             warn(`[install-plugin] Could not remove staging file ${staged}: ${error}`);
@@ -17755,175 +18351,156 @@ function installPluginAsset({ pluginsFolder, assetName, otherAssetName, source,
   }
 }
 
-// src/index.ts
-import { createRequire } from "module";
-
-// src/install-plugin.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname5, join as join7 } from "path";
+// ../core/dist/plugin-installer.js
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname5, join as join9 } from "path";
 import { fileURLToPath } from "url";
 import { get } from "https";
 var REPO = "chrrxs/robloxstudio-mcp";
-var ASSET_NAME = "MCPPlugin.rbxmx";
-var OTHER_VARIANT = "MCPInspectorPlugin.rbxmx";
 var TIMEOUT_MS = 3e4;
 var MAX_REDIRECTS = 5;
 var MAX_ASSET_BYTES = 64 * 1024 * 1024;
-function httpsGet(url) {
-  return new Promise((resolve5, reject) => {
-    const req = get(url, { headers: { "User-Agent": "robloxstudio-mcp" } }, resolve5);
-    req.on("error", reject);
-    req.setTimeout(TIMEOUT_MS, () => {
-      req.destroy(new Error(`Request timed out after ${TIMEOUT_MS}ms`));
+function createPluginInstaller(moduleUrl, variant) {
+  const currentDir = dirname5(fileURLToPath(moduleUrl));
+  const ASSET_NAME = variant === "main" ? "MCPPlugin.rbxmx" : "MCPInspectorPlugin.rbxmx";
+  const OTHER_VARIANT = variant === "main" ? "MCPInspectorPlugin.rbxmx" : "MCPPlugin.rbxmx";
+  const userAgent = variant === "main" ? "robloxstudio-mcp" : "robloxstudio-mcp-inspector";
+  const buildCommand = variant === "main" ? "build:plugin" : "build:plugin:inspector";
+  function httpsGet(url) {
+    return new Promise((resolve6, reject) => {
+      const req = get(url, { headers: { "User-Agent": userAgent } }, resolve6);
+      req.on("error", reject);
+      req.setTimeout(TIMEOUT_MS, () => {
+        req.destroy(new Error(`Request timed out after ${TIMEOUT_MS}ms`));
+      });
     });
-  });
-}
-async function download(url, redirects = 0) {
-  const res = await httpsGet(url);
-  if (res.statusCode === 301 || res.statusCode === 302) {
-    if (redirects >= MAX_REDIRECTS) throw new Error(`Too many redirects (max ${MAX_REDIRECTS})`);
-    const location = res.headers.location;
-    if (!location) throw new Error("Redirect with no location header");
-    for await (const _chunk of res) {
-    }
-    return download(location, redirects + 1);
   }
-  if (res.statusCode !== 200) {
-    throw new Error(`Download failed: HTTP ${res.statusCode}`);
-  }
-  const chunks = [];
-  let totalBytes = 0;
-  for await (const chunk of res) {
-    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    totalBytes += bytes.length;
-    if (totalBytes > MAX_ASSET_BYTES) {
-      res.destroy();
-      throw new Error(
-        `${ASSET_NAME} download exceeds the ${MAX_ASSET_BYTES}-byte limit.`
-      );
+  async function download(url, redirects = 0) {
+    const res = await httpsGet(url);
+    if (res.statusCode === 301 || res.statusCode === 302) {
+      if (redirects >= MAX_REDIRECTS)
+        throw new Error(`Too many redirects (max ${MAX_REDIRECTS})`);
+      const location = res.headers.location;
+      if (!location)
+        throw new Error("Redirect with no location header");
+      for await (const chunk of res) {
+        void chunk;
+      }
+      return download(location, redirects + 1);
+    }
+    if (res.statusCode !== 200) {
+      throw new Error(`Download failed: HTTP ${res.statusCode}`);
     }
-    chunks.push(bytes);
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of res) {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      totalBytes += bytes.length;
+      if (totalBytes > MAX_ASSET_BYTES) {
+        res.destroy();
+        throw new Error(`${ASSET_NAME} download exceeds the ${MAX_ASSET_BYTES}-byte limit.`);
+      }
+      chunks.push(bytes);
+    }
+    return Buffer.concat(chunks, totalBytes);
   }
-  return Buffer.concat(chunks, totalBytes);
-}
-async function fetchJson(url) {
-  const res = await httpsGet(url);
-  if (res.statusCode !== 200) {
-    throw new Error(`GitHub API returned HTTP ${res.statusCode}`);
+  async function fetchJson(url) {
+    const res = await httpsGet(url);
+    if (res.statusCode !== 200) {
+      throw new Error(`GitHub API returned HTTP ${res.statusCode}`);
+    }
+    const chunks = [];
+    for await (const chunk of res) {
+      chunks.push(chunk);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString());
   }
-  const chunks = [];
-  for await (const chunk of res) {
-    chunks.push(chunk);
+  function bundledAssetPath() {
+    const candidates = [
+      join9(currentDir, "..", "studio-plugin", ASSET_NAME),
+      join9(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
+    ];
+    return candidates.find((candidate) => existsSync8(candidate)) ?? null;
   }
-  return JSON.parse(Buffer.concat(chunks).toString());
-}
-async function findDevRelease() {
-  const releases = await fetchJson(`https://api.github.com/repos/${REPO}/releases?per_page=20`);
-  const prerelease = releases.find(
-    (r) => r.prerelease && r.assets.some((a) => a.name === ASSET_NAME)
-  );
-  if (!prerelease) {
-    throw new Error(`No prerelease found with ${ASSET_NAME}`);
-  }
-  return prerelease;
-}
-function bundledAssetPath() {
-  const currentDir = dirname5(fileURLToPath(import.meta.url));
-  const candidates = [
-    join7(currentDir, "..", "studio-plugin", ASSET_NAME),
-    join7(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
-  ];
-  return candidates.find((candidate) => existsSync8(candidate)) ?? null;
-}
-function resolvePluginAssetPath(sourcePath) {
-  if (sourcePath === void 0) return bundledAssetPath();
-  return existsSync8(sourcePath) ? sourcePath : null;
-}
-function packageVersion() {
-  const currentDir = dirname5(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync8(join7(currentDir, "..", "package.json"), "utf8"));
-  if (!pkg.version) {
-    throw new Error("Package version not found");
+  function resolvePluginAssetPath(sourcePath) {
+    if (sourcePath === void 0)
+      return bundledAssetPath();
+    return existsSync8(sourcePath) ? sourcePath : null;
   }
-  return pkg.version;
-}
-async function installBundledPlugin(options = {}) {
-  const log = options.log ?? console.log;
-  const warn = options.warn ?? console.warn;
-  const replaceVariant = options.replaceVariant ?? true;
-  const sourcePath = resolvePluginAssetPath(options.sourcePath);
-  if (!sourcePath) {
-    throw new Error(
-      `Bundled ${ASSET_NAME} not found. Run npm run build:plugin in this worktree first.`
-    );
-  }
-  const result = await installPluginAsset({
-    pluginsFolder: getPluginsFolder(),
-    assetName: ASSET_NAME,
-    otherAssetName: OTHER_VARIANT,
-    source: readFileSync8(sourcePath),
-    expectedVersion: packageVersion(),
-    expectedVariant: "main",
-    replaceVariant,
-    log,
-    warn
-  });
-  if (result.installed) {
-    log(`Installed ${ASSET_NAME} to ${result.destination}`);
+  function packageVersion() {
+    const pkg = JSON.parse(readFileSync9(join9(currentDir, "..", "package.json"), "utf8"));
+    if (!pkg.version) {
+      throw new Error("Package version not found");
+    }
+    return pkg.version;
   }
-}
-async function installPlugin(options = {}) {
-  const dev = options.dev ?? process.argv.includes("--dev");
-  const replaceVariant = options.replaceVariant ?? true;
-  const log = options.log ?? console.log;
-  const warn = options.warn ?? console.warn;
-  const bundled = resolvePluginAssetPath(options.sourcePath);
-  if (options.sourcePath !== void 0 && !bundled) {
-    throw new Error(`Plugin asset not found at explicit path ${options.sourcePath}.`);
-  }
-  if (bundled) {
-    const result2 = await installPluginAsset({
+  function installSource(source, options) {
+    return installPluginAsset({
       pluginsFolder: getPluginsFolder(),
       assetName: ASSET_NAME,
       otherAssetName: OTHER_VARIANT,
-      source: readFileSync8(bundled),
+      source,
       expectedVersion: packageVersion(),
-      expectedVariant: "main",
-      replaceVariant,
-      log,
-      warn
+      expectedVariant: variant,
+      replaceVariant: options.replaceVariant ?? true,
+      log: options.log ?? console.log,
+      warn: options.warn ?? console.warn
     });
-    if (result2.installed) {
-      log(`Installed bundled ${ASSET_NAME} to ${result2.destination}`);
+  }
+  async function installBundledPlugin2(options = {}) {
+    const log = options.log ?? console.log;
+    const sourcePath = resolvePluginAssetPath(options.sourcePath);
+    if (!sourcePath) {
+      throw new Error(`Bundled ${ASSET_NAME} not found. Run npm run ${buildCommand} in this worktree first.`);
+    }
+    const result = installSource(readFileSync9(sourcePath), options);
+    if (result.installed) {
+      log(`Installed ${ASSET_NAME} to ${result.destination}`);
+    }
+  }
+  async function installPlugin2(options = {}, dev = false) {
+    const log = options.log ?? console.log;
+    const bundled = resolvePluginAssetPath(options.sourcePath);
+    if (options.sourcePath !== void 0 && !bundled) {
+      throw new Error(`Plugin asset not found at explicit path ${options.sourcePath}.`);
+    }
+    if (bundled) {
+      const result2 = installSource(readFileSync9(bundled), options);
+      if (result2.installed) {
+        log(`Installed bundled ${ASSET_NAME} to ${result2.destination}`);
+      } else {
+        log(`${ASSET_NAME} already installed.`);
+      }
+      return;
+    }
+    log(dev ? "Fetching matching dev release..." : "Fetching matching release...");
+    const release = await fetchJson(`https://api.github.com/repos/${REPO}/releases/tags/v${encodeURIComponent(packageVersion())}`);
+    const asset = release.assets?.find((a) => a.name === ASSET_NAME);
+    if (!asset) {
+      throw new Error(`${ASSET_NAME} not found in release ${release.tag_name}`);
+    }
+    log(`Downloading ${ASSET_NAME} from ${release.tag_name}...`);
+    const downloaded = await download(asset.browser_download_url);
+    const result = installSource(downloaded, options);
+    if (result.installed) {
+      log(`Installed to ${result.destination}`);
     } else {
       log(`${ASSET_NAME} already installed.`);
     }
-    return;
-  }
-  log(dev ? "Fetching latest dev prerelease..." : "Fetching latest release...");
-  const release = dev ? await findDevRelease() : await fetchJson(`https://api.github.com/repos/${REPO}/releases/latest`);
-  const asset = release.assets?.find((a) => a.name === ASSET_NAME);
-  if (!asset) {
-    throw new Error(`${ASSET_NAME} not found in release ${release.tag_name}`);
-  }
-  log(`Downloading ${ASSET_NAME} from ${release.tag_name}...`);
-  const downloaded = await download(asset.browser_download_url);
-  const result = await installPluginAsset({
-    pluginsFolder: getPluginsFolder(),
-    assetName: ASSET_NAME,
-    otherAssetName: OTHER_VARIANT,
-    source: downloaded,
-    expectedVersion: release.tag_name.replace(/^v/, ""),
-    expectedVariant: "main",
-    replaceVariant,
-    log,
-    warn
-  });
-  if (result.installed) {
-    log(`Installed to ${result.destination}`);
-  } else {
-    log(`${ASSET_NAME} already installed.`);
   }
+  return { installBundledPlugin: installBundledPlugin2, installPlugin: installPlugin2 };
+}
+
+// src/index.ts
+import { createRequire } from "module";
+
+// src/install-plugin.ts
+var installer = createPluginInstaller(import.meta.url, "main");
+async function installBundledPlugin(options = {}) {
+  await installer.installBundledPlugin(options);
+}
+async function installPlugin(options = {}) {
+  await installer.installPlugin(options, options.dev ?? process.argv.includes("--dev"));
 }
 
 // src/index.ts