@chrrxs/robloxstudio-mcp-inspector 2.21.0 → 2.22.0

package/dist/index.js

@@ -51,7 +51,26 @@ var init_bridge_service = __esm({
       // Keyed by pluginSessionId (the per-plugin GUID).
       instances = /* @__PURE__ */ new Map();
       instanceAliases = /* @__PURE__ */ new Map();
+      instanceRegisteredListeners = /* @__PURE__ */ new Set();
       requestTimeout = 3e4;
+      onInstanceRegistered(listener) {
+        this.instanceRegisteredListeners.add(listener);
+        for (const instance of this.getPublicInstances()) {
+          try {
+            listener(instance);
+          } catch {
+          }
+        }
+        return () => this.instanceRegisteredListeners.delete(listener);
+      }
+      notifyInstanceRegistered(instance) {
+        for (const listener of this.instanceRegisteredListeners) {
+          try {
+            listener(instance);
+          } catch {
+          }
+        }
+      }
       canonicalInstanceId(instanceId, placeId) {
         return publishedInstanceId(placeId) ?? instanceId;
       }
@@ -157,7 +176,7 @@ var init_bridge_service = __esm({
             }
           };
         }
-        this.instances.set(pluginSessionId, {
+        const registered = {
           pluginSessionId,
           instanceId,
           role: assignedRole,
@@ -171,7 +190,9 @@ var init_bridge_service = __esm({
           versionMismatch,
           lastActivity: Date.now(),
           connectedAt: prior?.connectedAt ?? Date.now()
-        });
+        };
+        this.instances.set(pluginSessionId, registered);
+        this.notifyInstanceRegistered(toPublic(registered));
         return { ok: true, assignedRole, instanceId };
       }
       unregisterInstance(pluginSessionId) {
@@ -369,7 +390,7 @@ var init_bridge_service = __esm({
       async sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs = this.requestTimeout) {
         const requestId = uuidv4();
         const effectiveTimeoutMs = Math.max(1, timeoutMs);
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve5, reject) => {
           const timeoutId = setTimeout(() => {
             if (this.pendingRequests.has(requestId)) {
               this.pendingRequests.delete(requestId);
@@ -384,7 +405,7 @@ var init_bridge_service = __esm({
             targetRole,
             timestamp: Date.now(),
             inFlight: false,
-            resolve: resolve4,
+            resolve: resolve5,
             reject,
             timeoutId,
             timeoutMs: effectiveTimeoutMs
@@ -686,8 +707,8 @@ function resolveAuthToken() {
     } catch {
     }
     return { token: fresh, source: "file", filePath };
-  } catch (err) {
-    console.error(`[auth] Could not read/create ${filePath} (${err instanceof Error ? err.message : err}). Using an in-memory token for this process; set ROBLOX_STUDIO_AUTH_TOKEN to share one across sessions.`);
+  } 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" };
   }
 }
@@ -811,7 +832,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     next();
   });
   const authToken = security?.authToken;
-  const authRequired = (path5) => path5 === "/mcp" || path5.startsWith("/mcp/") || path5 === "/proxy" || path5 === "/instances" || path5 === "/unregister-instance-id";
+  const authRequired = (path6) => path6 === "/mcp" || path6.startsWith("/mcp/") || path6 === "/proxy" || path6 === "/instances" || path6 === "/unregister-instance-id";
   app.use((req, res, next) => {
     if (!authToken || !authRequired(req.path)) {
       next();
@@ -891,11 +912,11 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
         pluginVariant: typeof pluginVariant === "string" ? pluginVariant : "unknown",
         serverVersion: serverConfig?.version ?? ""
       });
-    } catch (err) {
+    } catch (err2) {
       res.status(500).json({
         success: false,
         error: "ready_registration_exception",
-        message: err instanceof Error ? err.message : String(err),
+        message: err2 instanceof Error ? err2.message : String(err2),
         request: requestContext
       });
       return;
@@ -1046,8 +1067,8 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     try {
       const response = await bridge.sendRequest(endpoint, data, targetInstanceId, targetRole);
       res.json({ response });
-    } catch (err) {
-      res.status(500).json({ error: err.message || "Proxy request failed" });
+    } catch (err2) {
+      res.status(500).json({ error: err2.message || "Proxy request failed" });
     }
   });
   if (serverConfig) {
@@ -1159,19 +1180,19 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   return app;
 }
 function listenWithRetry(app, host, startPort, maxAttempts = 5) {
-  return new Promise(async (resolve4, reject) => {
+  return new Promise(async (resolve5, reject) => {
     for (let i = 0; i < maxAttempts; i++) {
       const port = startPort + i;
       try {
         const server = await bindPort(app, host, port);
-        resolve4({ server, port });
+        resolve5({ server, port });
         return;
-      } catch (err) {
-        if (err.code === "EADDRINUSE") {
+      } catch (err2) {
+        if (err2.code === "EADDRINUSE") {
           console.error(`Port ${port} in use, trying next...`);
           continue;
         }
-        reject(err);
+        reject(err2);
         return;
       }
     }
@@ -1179,16 +1200,16 @@ function listenWithRetry(app, host, startPort, maxAttempts = 5) {
   });
 }
 function bindPort(app, host, port) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const server = http.createServer(app);
-    const onError = (err) => {
+    const onError = (err2) => {
       server.removeListener("error", onError);
-      reject(err);
+      reject(err2);
     };
     server.once("error", onError);
     server.listen(port, host, () => {
       server.removeListener("error", onError);
-      resolve4(server);
+      resolve5(server);
     });
   });
 }
@@ -1200,6 +1221,7 @@ var init_http_server = __esm({
     init_mcp_compat();
     init_auth();
     TOOL_HANDLERS = {
+      get_roblox_skills: (tools, body) => tools.getRobloxSkills(body.action, body.name),
       get_roblox_docs: (tools, body) => tools.getRobloxDocs(body.name, body.doc_type, body.section),
       get_file_tree: (tools, body) => tools.getFileTree(body.path, body.instance_id),
       search_files: (tools, body) => tools.searchFiles(body.query, body.searchType, body.instance_id),
@@ -1382,8 +1404,8 @@ function runRestrictedScript(code, globals, options) {
   let ast;
   try {
     ast = acorn.parse(code, { ecmaVersion: 2022, sourceType: "script" });
-  } catch (err) {
-    throw new Error(`Syntax error: ${err.message}`);
+  } catch (err2) {
+    throw new Error(`Syntax error: ${err2.message}`);
   }
   const globalScope = new Scope(void 0, true);
   for (const [name, value] of Object.entries(globals)) {
@@ -1694,15 +1716,15 @@ function runRestrictedScript(code, globals, options) {
       case "TryStatement": {
         try {
           execute(node.block, scope);
-        } catch (err) {
-          if (err instanceof BreakSignal || err instanceof ContinueSignal || err instanceof ReturnSignal)
-            throw err;
-          if (err instanceof ScriptTimeoutError)
-            throw err;
+        } catch (err2) {
+          if (err2 instanceof BreakSignal || err2 instanceof ContinueSignal || err2 instanceof ReturnSignal)
+            throw err2;
+          if (err2 instanceof ScriptTimeoutError)
+            throw err2;
           if (node.handler) {
             const catchScope = new Scope(scope);
             if (node.handler.param) {
-              const message = err instanceof Error ? { message: err.message } : err;
+              const message = err2 instanceof Error ? { message: err2.message } : err2;
               bindPattern(node.handler.param, message, catchScope, "let");
             }
             execute(node.handler.body, catchScope);
@@ -2580,11 +2602,11 @@ function runBuildExecutor(code, palette, seed, options) {
   };
   try {
     runRestrictedScript(code, sandbox, { timeoutMs: timeout });
-  } catch (err) {
-    if (err instanceof ScriptTimeoutError) {
+  } catch (err2) {
+    if (err2 instanceof ScriptTimeoutError) {
       throw new Error(`Build code execution timed out after ${timeout}ms`);
     }
-    throw new Error(`Build code execution error: ${err?.message ?? String(err)}`);
+    throw new Error(`Build code execution error: ${err2?.message ?? String(err2)}`);
   }
   if (parts.length === 0) {
     throw new Error("Build code produced no parts. Make sure to call part(), wall(), floor(), etc.");
@@ -2843,7 +2865,7 @@ var init_opencloud_client = __esm({
           if (result.error) {
             throw new Error(`Asset upload failed: ${result.error.message}`);
           }
-          await new Promise((resolve4) => setTimeout(resolve4, intervalMs));
+          await new Promise((resolve5) => setTimeout(resolve5, intervalMs));
         }
         throw new Error(`Asset upload timed out after ${maxAttempts * intervalMs / 1e3}s. Operation ID: ${operationId}`);
       }
@@ -2964,7 +2986,7 @@ function isRecord(value) {
   const record = value;
   return record.version === REGISTRY_VERSION && typeof record.recordId === "string" && typeof record.source === "string" && typeof record.exe === "string" && Array.isArray(record.args) && typeof record.launchedAt === "number" && typeof record.bootId === "string";
 }
-var REGISTRY_VERSION, LOCK_STALE_MS, LOCK_RETRY_MS, LOCK_TIMEOUT_MS, EVENT_RETENTION_DAYS, ManagedInstanceRegistry;
+var REGISTRY_VERSION, LOCK_STALE_MS, LOCK_RETRY_MS, LOCK_TIMEOUT_MS, EVENT_RETENTION_DAYS, TERMINAL_RECORD_RETENTION_MS, ManagedInstanceRegistry;
 var init_managed_instance_registry = __esm({
   "../core/dist/managed-instance-registry.js"() {
     "use strict";
@@ -2973,6 +2995,7 @@ var init_managed_instance_registry = __esm({
     LOCK_RETRY_MS = 25;
     LOCK_TIMEOUT_MS = 5e3;
     EVENT_RETENTION_DAYS = 2;
+    TERMINAL_RECORD_RETENTION_MS = 24 * 60 * 60 * 1e3;
     ManagedInstanceRegistry = class {
       dir;
       constructor(dir = defaultManagedInstanceRegistryDir()) {
@@ -3000,12 +3023,21 @@ var init_managed_instance_registry = __esm({
       findAnyByInstanceId(instanceId) {
         return this.withLock(() => this.readRecordsUnlocked().find((record) => record.instanceId === instanceId));
       }
+      findAnyByRecordId(recordId, options) {
+        return this.withLock(() => {
+          this.sweepUnlocked(options);
+          return this.readRecordsUnlocked().find((record) => record.recordId === recordId);
+        });
+      }
       listOpen(options) {
         return this.withLock(() => {
           this.sweepUnlocked(options);
           return this.readOpenRecordsUnlocked();
         });
       }
+      listOpenUnchecked() {
+        return this.withLock(() => this.readOpenRecordsUnlocked());
+      }
       markClosed(recordId, closedAt = Date.now()) {
         this.withLock(() => {
           const record = this.readRecordUnlocked(recordId);
@@ -3177,41 +3209,52 @@ var init_managed_instance_registry = __esm({
             }, now);
             continue;
           }
-          if (parsed.closedAt !== void 0) {
-            fs.rmSync(file, { force: true });
-            this.appendEventUnlocked({
-              event: "registry_pruned_closed_record",
-              recordId: parsed.recordId,
-              instanceId: parsed.instanceId,
-              source: parsed.source,
-              reason: "closed_at_present",
-              action: "deleted_record"
-            }, now);
+          const terminalAt = parsed.closedAt ?? parsed.exitedAt;
+          if (terminalAt !== void 0) {
+            if (now - terminalAt > TERMINAL_RECORD_RETENTION_MS) {
+              fs.rmSync(file, { force: true });
+              this.appendEventUnlocked({
+                event: "registry_pruned_terminal_record",
+                recordId: parsed.recordId,
+                instanceId: parsed.instanceId,
+                source: parsed.source,
+                reason: "terminal_retention_expired",
+                action: "deleted_record"
+              }, now);
+            }
             continue;
           }
           if (parsed.bootId !== options.currentBootId) {
             this.cleanupRecord(options, parsed);
-            fs.rmSync(file, { force: true });
+            parsed.state = parsed.state === "failed" ? "failed" : "exited";
+            parsed.exitedAt = now;
+            parsed.closedAt = now;
+            parsed.failureReason ??= "Studio process belongs to a previous host boot.";
+            this.writeRecordUnlocked(parsed);
             this.appendEventUnlocked({
-              event: "registry_pruned_previous_boot",
+              event: "registry_marked_previous_boot_exited",
               recordId: parsed.recordId,
               instanceId: parsed.instanceId,
               source: parsed.source,
               reason: "boot_id_changed",
-              action: "deleted_record_and_cleaned_baseplate"
+              action: "marked_exited_and_cleaned_baseplate"
             }, now);
             continue;
           }
           if (options.isProcessRunning && (parsed.nativeProcessId || parsed.spawnPid) && !options.isProcessRunning(parsed)) {
             this.cleanupRecord(options, parsed);
-            fs.rmSync(file, { force: true });
+            parsed.state = parsed.state === "failed" ? "failed" : "exited";
+            parsed.exitedAt = now;
+            parsed.closedAt = now;
+            parsed.failureReason ??= parsed.instanceId ? "Studio process exited." : "Studio process exited before the MCP plugin connected.";
+            this.writeRecordUnlocked(parsed);
             this.appendEventUnlocked({
-              event: "registry_pruned_stale_process",
+              event: "registry_marked_process_exited",
               recordId: parsed.recordId,
               instanceId: parsed.instanceId,
               source: parsed.source,
               reason: "pid_not_running",
-              action: "deleted_record_and_cleaned_baseplate"
+              action: "marked_exited_and_cleaned_baseplate"
             }, now);
           }
         }
@@ -3270,6 +3313,63 @@ function toStudioLaunchArg(arg) {
     return arg;
   return run("wslpath", ["-w", arg]);
 }
+function powershellStringLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function quoteWindowsCommandLineArg(value) {
+  if (value.length > 0 && !/[\s"]/u.test(value))
+    return value;
+  let quoted = '"';
+  let backslashes = 0;
+  for (const char of value) {
+    if (char === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    if (char === '"') {
+      quoted += "\\".repeat(backslashes * 2 + 1) + '"';
+      backslashes = 0;
+      continue;
+    }
+    quoted += "\\".repeat(backslashes) + char;
+    backslashes = 0;
+  }
+  return `${quoted}${"\\".repeat(backslashes * 2)}"`;
+}
+function buildWindowsStudioStartScript(exe, args) {
+  const windowsExe = toStudioLaunchArg(exe);
+  const commandLine = args.map(quoteWindowsCommandLineArg).join(" ");
+  return [
+    "$psi = New-Object System.Diagnostics.ProcessStartInfo",
+    `$psi.FileName = ${powershellStringLiteral(windowsExe)}`,
+    `$psi.Arguments = ${powershellStringLiteral(commandLine)}`,
+    // With UseShellExecute=false, Studio inherits the synchronous
+    // powershell.exe invocation's stdout/stderr pipe handles under WSL. Those
+    // handles keep execFileSync waiting until Studio exits even though
+    // PowerShell already printed the PID. Shell execution prevents that
+    // inheritance while Process.Start still returns the native Studio PID.
+    "$psi.UseShellExecute = $true",
+    "$studio = [System.Diagnostics.Process]::Start($psi)",
+    'if ($null -eq $studio) { throw "Roblox Studio process did not start." }'
+  ].join("; ");
+}
+function spawnWindowsStudioFromWsl(exe, args) {
+  const script = buildWindowsStudioStartScript(exe, args);
+  const output = powershell(`${script}; [PSCustomObject]@{ pid = $studio.Id; started = $studio.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() } | ConvertTo-Json -Compress`);
+  const parsed = JSON.parse(output);
+  const nativePid = Number(parsed.pid);
+  const nativeStartedAt = typeof parsed.started === "string" && /^\d+$/u.test(parsed.started) ? parsed.started : void 0;
+  if (!Number.isSafeInteger(nativePid) || nativePid <= 0) {
+    throw new Error(`Could not determine the Windows Studio process id from: ${nativePid}`);
+  }
+  return {
+    pid: nativePid,
+    nativePid,
+    nativeStartedAt,
+    unref: () => {
+    }
+  };
+}
 function resolveEntrypointDir() {
   const entrypoint = process.argv[1];
   if (!entrypoint)
@@ -3301,8 +3401,8 @@ function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
     return true;
-  } catch (err) {
-    return err.code === "EPERM";
+  } catch (err2) {
+    return err2.code === "EPERM";
   }
 }
 function sweepStaleBaseplateFiles() {
@@ -3395,7 +3495,7 @@ function listStudioProcesses() {
     return [];
   let out = "";
   try {
-    out = powershell("Get-Process RobloxStudioBeta -ErrorAction SilentlyContinue | Select-Object Id,Name,Path,MainWindowTitle | ConvertTo-Json -Compress");
+    out = powershell("Get-Process RobloxStudioBeta -ErrorAction SilentlyContinue | ForEach-Object { [PSCustomObject]@{ Id = $_.Id; Name = $_.Name; Path = $_.Path; MainWindowTitle = $_.MainWindowTitle; StartTimeUtcFileTime = $_.StartTime.ToUniversalTime().ToFileTimeUtc().ToString() } } | ConvertTo-Json -Compress");
   } catch {
     return [];
   }
@@ -3459,7 +3559,7 @@ function buildStudioLaunchArgs(options) {
   }
 }
 function delay(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function basenameAny(filePath) {
   return path2.basename(filePath.replace(/\\/g, "/"));
@@ -3477,6 +3577,8 @@ var init_studio_instance_manager = __esm({
     StudioInstanceManager = class {
       managedByInstanceId = /* @__PURE__ */ new Map();
       pending = /* @__PURE__ */ new Set();
+      monitors = /* @__PURE__ */ new Map();
+      connectionTimers = /* @__PURE__ */ new Map();
       registry;
       processAdapter;
       constructor(options = {}) {
@@ -3485,6 +3587,9 @@ var init_studio_instance_manager = __esm({
       }
       list() {
         this.sweepRegistry();
+        for (const record of [...this.managedByInstanceId.values(), ...this.pending]) {
+          this.refresh(record);
+        }
         const records = [...this.managedByInstanceId.values(), ...this.pending];
         for (const registryRecord of this.registry.listOpen(this.registrySweepOptions())) {
           const record = this.fromRegistryRecord(registryRecord);
@@ -3493,27 +3598,82 @@ var init_studio_instance_manager = __esm({
           }
           records.push(record);
         }
-        return records.filter((instance, index, all) => all.indexOf(instance) === index);
+        return records.filter((record) => record.closedAt === void 0).filter((instance, index, all) => all.indexOf(instance) === index);
       }
       get(instanceId) {
         this.sweepRegistry();
         const memoryRecord = this.managedByInstanceId.get(instanceId);
         if (memoryRecord)
-          return memoryRecord;
-        const registryRecord = this.registry.findOpenByInstanceId(instanceId, this.registrySweepOptions());
-        return registryRecord ? this.fromRegistryRecord(registryRecord) : void 0;
+          return this.refresh(memoryRecord);
+        const registryRecord = this.registry.findAnyByInstanceId(instanceId);
+        return registryRecord ? this.refresh(this.fromRegistryRecord(registryRecord)) : void 0;
+      }
+      getByLaunchId(launchId) {
+        this.sweepRegistry();
+        const memoryRecord = [...this.managedByInstanceId.values(), ...this.pending].find((record) => record.recordId === launchId);
+        if (memoryRecord)
+          return this.refresh(memoryRecord);
+        const registryRecord = this.registry.findAnyByRecordId(launchId, this.registrySweepOptions());
+        return registryRecord ? this.refresh(this.fromRegistryRecord(registryRecord)) : void 0;
+      }
+      pendingLaunches() {
+        const now = Date.now();
+        const records = [...this.pending];
+        for (const registryRecord of this.registry.listOpenUnchecked()) {
+          if (registryRecord.bootId !== this.getCurrentBootId())
+            continue;
+          if (records.some((record) => record.recordId === registryRecord.recordId))
+            continue;
+          records.push(this.fromRegistryRecord(registryRecord));
+        }
+        return records.filter((record) => record.instanceId === void 0).filter((record) => record.state === "launching").filter((record) => record.connectionDeadlineAt === void 0 || record.connectionDeadlineAt > now);
       }
       attachInstanceId(record, instanceId) {
+        this.refresh(record);
+        if (record.closedAt !== void 0 || record.state === "failed" || record.state === "exited")
+          return;
+        if (record.instanceId && record.instanceId !== instanceId)
+          return;
         record.instanceId = instanceId;
+        record.state = "connected";
+        record.connectedAt = record.connectedAt ?? Date.now();
+        this.clearConnectionTimer(record);
         this.pending.delete(record);
         this.managedByInstanceId.set(instanceId, record);
-        if (record.recordId) {
-          this.registry.attachInstanceId(record.recordId, instanceId);
+        this.persist(record);
+      }
+      markFailed(record, reason) {
+        this.refresh(record);
+        if (record.closedAt !== void 0 || record.state !== "launching")
+          return record;
+        record.state = "failed";
+        record.failedAt = Date.now();
+        record.failureReason = reason;
+        this.clearConnectionTimer(record);
+        this.persist(record);
+        return record;
+      }
+      refresh(record) {
+        if (record.closedAt !== void 0)
+          return record;
+        const processId = record.nativeProcessId ?? record.spawnPid;
+        const studioProcess = processId ? this.findProcessById(processId) : void 0;
+        if (processId && (!studioProcess || !this.verifyProcessForRecord(record, studioProcess))) {
+          return this.markProcessExited(record, void 0, studioProcess ? "Studio process identity changed; the retained PID was not reused." : record.instanceId ? "Studio process exited." : "Studio process exited before the MCP plugin connected.");
         }
+        if (record.state === "launching" && record.connectionDeadlineAt !== void 0 && Date.now() >= record.connectionDeadlineAt) {
+          record.state = "failed";
+          record.failedAt = Date.now();
+          record.failureReason = "Studio launched, but the MCP plugin did not connect before timeout.";
+          this.clearConnectionTimer(record);
+          this.persist(record);
+        }
+        return record;
       }
       async launch(options) {
         this.sweepRegistry();
         const preparedOptions = prepareStudioLaunchOptions(options);
+        const bootId = this.getCurrentBootId();
         const before = new Set(this.listStudioProcesses().map((proc2) => proc2.Id));
         const exe = this.processAdapter.resolveStudioExe?.() ?? resolveStudioExe();
         const args = buildStudioLaunchArgs(preparedOptions).map(toStudioLaunchArg);
@@ -3522,11 +3682,35 @@ var init_studio_instance_manager = __esm({
           detached: true,
           stdio: "ignore"
         };
-        const proc = this.processAdapter.spawnStudio ? this.processAdapter.spawnStudio(exe, args, spawnOptions) : spawn(exe, args, spawnOptions);
-        proc.unref();
+        let proc;
+        try {
+          if (this.processAdapter.spawnStudio) {
+            proc = this.processAdapter.spawnStudio(exe, args, spawnOptions);
+          } else if (isWsl()) {
+            proc = spawnWindowsStudioFromWsl(exe, args);
+          } else {
+            const child = spawn(exe, args, spawnOptions);
+            proc = {
+              pid: child.pid,
+              nativePid: child.pid,
+              unref: () => child.unref(),
+              onExit: (listener) => {
+                child.once("exit", listener);
+              },
+              onError: (listener) => {
+                child.once("error", listener);
+              }
+            };
+          }
+        } catch (error) {
+          cleanupManagedBaseplateFiles({ source: preparedOptions.source, localPlaceFile: preparedOptions.localPlaceFile });
+          throw error;
+        }
         const record = {
           recordId: randomUUID(),
           source: options.source,
+          nativeProcessId: proc.nativePid,
+          nativeProcessStartedAt: proc.nativeStartedAt,
           spawnPid: proc.pid,
           exe,
           args,
@@ -3535,29 +3719,74 @@ var init_studio_instance_manager = __esm({
           placeVersion: preparedOptions.placeVersion,
           localPlaceFile: preparedOptions.localPlaceFile,
           launchedAt: Date.now(),
+          connectionDeadlineAt: Date.now() + (options.connectionTimeoutMs ?? 12e4),
+          state: "launching",
           ownerPid: process.pid,
-          bootId: this.getCurrentBootId(),
+          bootId,
           deleteLocalPlaceFileOnClose: options.source === "baseplate"
         };
         this.pending.add(record);
-        this.registry.upsert(this.toRegistryRecord(record));
+        try {
+          this.persist(record);
+        } catch (error) {
+          this.pending.delete(record);
+          const processId = record.nativeProcessId ?? record.spawnPid;
+          let stopError;
+          if (processId) {
+            try {
+              this.closeProcess(processId);
+            } catch (caught) {
+              stopError = caught;
+            }
+          }
+          cleanupManagedBaseplateFiles(record);
+          const detail = error instanceof Error ? error.message : String(error);
+          const cleanupDetail = stopError ? ` The newly launched process could not be stopped: ${stopError instanceof Error ? stopError.message : String(stopError)}` : "";
+          throw new Error(`Studio launched, but its managed-instance record could not be persisted: ${detail}.${cleanupDetail}`);
+        }
+        proc.unref();
+        proc.onExit?.((code, signal) => {
+          this.markProcessExited(record, code ?? void 0, signal ? `Studio process exited from signal ${signal}.` : record.instanceId ? "Studio process exited." : "Studio process exited before the MCP plugin connected.");
+        });
+        proc.onError?.((error) => {
+          this.markFailed(record, `Studio process failed to start: ${error.message}`);
+        });
         const deadline = Date.now() + 5e3;
         while (Date.now() < deadline && record.nativeProcessId === void 0) {
           const created = this.listStudioProcesses().find((candidate) => !before.has(candidate.Id));
           if (created) {
             record.nativeProcessId = created.Id;
-            this.registry.upsert(this.toRegistryRecord(record));
+            record.nativeProcessStartedAt = created.StartTimeUtcFileTime;
+            this.persist(record);
             break;
           }
           await delay(250);
         }
         if (record.nativeProcessId === void 0 && process.platform !== "win32" && !isWsl()) {
           record.nativeProcessId = proc.pid;
-          this.registry.upsert(this.toRegistryRecord(record));
+          this.persist(record);
         }
+        if (record.nativeProcessId !== void 0 && record.nativeProcessStartedAt === void 0) {
+          const nativeProcess = this.findProcessById(record.nativeProcessId);
+          if (nativeProcess?.StartTimeUtcFileTime !== void 0) {
+            record.nativeProcessStartedAt = nativeProcess.StartTimeUtcFileTime;
+            this.persist(record);
+          }
+        }
+        this.startMonitor(record);
         return record;
       }
+      closeByLaunchId(launchId) {
+        const record = this.getByLaunchId(launchId);
+        if (!record)
+          return { status: "not_found", launchId };
+        if (record.closedAt !== void 0) {
+          return { status: "already_closed", launchId, instanceId: record.instanceId };
+        }
+        return this.close(record);
+      }
       closeByInstanceId(instanceId) {
+        this.sweepRegistry();
         const memoryRecord = this.managedByInstanceId.get(instanceId);
         if (memoryRecord)
           return this.close(memoryRecord);
@@ -3568,33 +3797,24 @@ var init_studio_instance_manager = __esm({
         }
         if (registryRecord.closedAt !== void 0) {
           this.cleanupManagedRecord(registryRecord);
-          this.registry.delete(registryRecord.recordId);
           this.registry.logEvent({
             event: "registry_close_already_stopped",
             recordId: registryRecord.recordId,
             instanceId: registryRecord.instanceId,
             source: registryRecord.source,
             reason: "closed_at_present",
-            action: "deleted_record_and_cleaned_baseplate"
-          });
-          return { status: "already_closed", instanceId };
-        }
-        if (registryRecord.bootId !== this.getCurrentBootId()) {
-          this.cleanupManagedRecord(registryRecord);
-          this.registry.delete(registryRecord.recordId);
-          this.registry.logEvent({
-            event: "registry_pruned_previous_boot",
-            recordId: registryRecord.recordId,
-            instanceId: registryRecord.instanceId,
-            source: registryRecord.source,
-            reason: "boot_id_changed",
-            action: "deleted_record_and_cleaned_baseplate"
+            action: "retained_terminal_record_and_cleaned_baseplate"
           });
-          return { status: "already_closed", instanceId };
+          return { status: "already_closed", launchId: registryRecord.recordId, instanceId };
         }
         return this.close(this.fromRegistryRecord(registryRecord));
       }
       close(record) {
+        this.stopMonitor(record);
+        this.refresh(record);
+        if (record.closedAt !== void 0) {
+          return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
+        }
         const processId = record.nativeProcessId ?? record.spawnPid;
         if (!processId) {
           throw new Error(`Cannot close ${record.instanceId ?? "Studio launch"} because its process id was not detected.`);
@@ -3602,8 +3822,7 @@ var init_studio_instance_manager = __esm({
         const studioProcess = this.findProcessById(processId);
         if (!studioProcess) {
           this.cleanupManagedRecord(record);
-          this.markClosedInMemory(record);
-          this.markClosedInRegistry(record);
+          this.markProcessExited(record, void 0, record.failureReason);
           this.registry.logEvent({
             event: "registry_close_already_stopped",
             recordId: record.recordId,
@@ -3612,7 +3831,7 @@ var init_studio_instance_manager = __esm({
             reason: "pid_not_running",
             action: "marked_closed_and_cleaned_baseplate"
           });
-          return { status: "already_closed", instanceId: record.instanceId };
+          return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
         }
         if (!this.verifyProcessForRecord(record, studioProcess)) {
           this.registry.logEvent({
@@ -3638,15 +3857,18 @@ var init_studio_instance_manager = __esm({
             action: "marked_closed_and_cleaned_baseplate"
           });
           this.cleanupManagedRecord(record);
-          this.markClosedInMemory(record);
-          this.markClosedInRegistry(record);
-          return { status: "already_closed", instanceId: record.instanceId };
-        }
-        record.closedAt = Date.now();
+          this.markProcessExited(record, void 0, record.failureReason);
+          return { status: "already_closed", launchId: record.recordId, instanceId: record.instanceId };
+        }
+        const closedAt = Date.now();
+        record.closedAt = closedAt;
+        record.exitedAt = record.exitedAt ?? closedAt;
+        if (record.state !== "failed")
+          record.state = "exited";
         this.cleanupManagedRecord(record);
         this.markClosedInMemory(record);
-        this.markClosedInRegistry(record);
-        return { status: "closed", instanceId: record.instanceId };
+        this.persist(record);
+        return { status: "closed", launchId: record.recordId, instanceId: record.instanceId };
       }
       closeConnectedInstance(instance) {
         const process2 = this.findProcessForConnectedInstance(instance);
@@ -3721,6 +3943,9 @@ var init_studio_instance_manager = __esm({
         const processName = `${studioProcess.Name ?? ""} ${studioProcess.Path ?? ""}`.toLowerCase();
         if (!processName.includes("robloxstudio"))
           return false;
+        if (record.nativeProcessStartedAt !== void 0 && studioProcess.StartTimeUtcFileTime !== record.nativeProcessStartedAt) {
+          return false;
+        }
         const processId = record.nativeProcessId ?? record.spawnPid;
         if (record.spawnPid && record.spawnPid === processId && studioProcess.Id === processId)
           return true;
@@ -3746,10 +3971,64 @@ var init_studio_instance_manager = __esm({
         if (record.instanceId)
           this.managedByInstanceId.delete(record.instanceId);
         this.pending.delete(record);
+        this.stopMonitor(record);
+      }
+      markProcessExited(record, exitCode, reason) {
+        if (record.closedAt !== void 0)
+          return record;
+        const exitedAt = Date.now();
+        record.exitedAt = exitedAt;
+        record.closedAt = exitedAt;
+        if (record.state !== "failed")
+          record.state = "exited";
+        if (exitCode !== void 0)
+          record.exitCode = exitCode;
+        if (reason)
+          record.failureReason = reason;
+        this.cleanupManagedRecord(record);
+        this.markClosedInMemory(record);
+        this.persist(record);
+        return record;
       }
-      markClosedInRegistry(record) {
-        if (record.recordId)
-          this.registry.markClosed(record.recordId, record.closedAt ?? Date.now());
+      startMonitor(record) {
+        if (!record.recordId || record.closedAt !== void 0 || this.monitors.has(record.recordId))
+          return;
+        if (record.state === "launching" && record.connectionDeadlineAt !== void 0) {
+          const timeout = setTimeout(() => {
+            this.markFailed(record, "Studio launched, but the MCP plugin did not connect before timeout.");
+          }, Math.max(0, record.connectionDeadlineAt - Date.now()));
+          if (typeof timeout === "object" && "unref" in timeout)
+            timeout.unref();
+          this.connectionTimers.set(record.recordId, timeout);
+        }
+        const timer = setInterval(() => {
+          this.refresh(record);
+          if (record.closedAt !== void 0)
+            this.stopMonitor(record);
+        }, 5e3);
+        if (typeof timer === "object" && "unref" in timer)
+          timer.unref();
+        this.monitors.set(record.recordId, timer);
+      }
+      stopMonitor(record) {
+        if (!record.recordId)
+          return;
+        const timer = this.monitors.get(record.recordId);
+        if (timer)
+          clearInterval(timer);
+        this.monitors.delete(record.recordId);
+        this.clearConnectionTimer(record);
+      }
+      clearConnectionTimer(record) {
+        if (!record.recordId)
+          return;
+        const timer = this.connectionTimers.get(record.recordId);
+        if (timer)
+          clearTimeout(timer);
+        this.connectionTimers.delete(record.recordId);
+      }
+      persist(record) {
+        this.registry.upsert(this.toRegistryRecord(record));
       }
       toRegistryRecord(record) {
         if (!record.recordId)
@@ -3762,6 +4041,7 @@ var init_studio_instance_manager = __esm({
           instanceId: record.instanceId,
           source: record.source,
           nativeProcessId: record.nativeProcessId,
+          nativeProcessStartedAt: record.nativeProcessStartedAt,
           spawnPid: record.spawnPid,
           exe: record.exe,
           args: record.args,
@@ -3771,18 +4051,26 @@ var init_studio_instance_manager = __esm({
           localPlaceFile: record.localPlaceFile,
           deleteLocalPlaceFileOnClose: record.deleteLocalPlaceFileOnClose,
           launchedAt: record.launchedAt,
-          attachedAt: record.instanceId ? Date.now() : void 0,
+          attachedAt: record.connectedAt,
+          connectionDeadlineAt: record.connectionDeadlineAt,
+          state: record.state,
+          failedAt: record.failedAt,
+          exitedAt: record.exitedAt,
+          exitCode: record.exitCode,
+          failureReason: record.failureReason,
           closedAt: record.closedAt,
           ownerPid: record.ownerPid,
           bootId: record.bootId
         };
       }
       fromRegistryRecord(record) {
+        const state = record.state ?? (record.closedAt !== void 0 ? "exited" : record.instanceId ? "connected" : "launching");
         return {
           recordId: record.recordId,
           source: record.source,
           instanceId: record.instanceId,
           nativeProcessId: record.nativeProcessId,
+          nativeProcessStartedAt: record.nativeProcessStartedAt,
           spawnPid: record.spawnPid,
           exe: record.exe,
           args: record.args,
@@ -3791,6 +4079,13 @@ var init_studio_instance_manager = __esm({
           placeVersion: record.placeVersion,
           localPlaceFile: record.localPlaceFile,
           launchedAt: record.launchedAt,
+          connectionDeadlineAt: record.connectionDeadlineAt ?? (state === "launching" ? record.launchedAt + 12e4 : void 0),
+          state,
+          connectedAt: record.attachedAt,
+          failedAt: record.failedAt,
+          exitedAt: record.exitedAt,
+          exitCode: record.exitCode,
+          failureReason: record.failureReason,
           closedAt: record.closedAt,
           ownerPid: record.ownerPid,
           bootId: record.bootId,
@@ -3976,6 +4271,982 @@ var init_image_decode = __esm({
   }
 });
 
+// ../../node_modules/fzstd/esm/index.mjs
+function decompress(dat, buf) {
+  var bufs = [], nb = +!buf;
+  var bt = 0, ol = 0;
+  for (; dat.length; ) {
+    var st = rzfh(dat, nb || buf);
+    if (typeof st == "object") {
+      if (nb) {
+        buf = null;
+        if (st.w.length == st.u) {
+          bufs.push(buf = st.w);
+          ol += st.u;
+        }
+      } else {
+        bufs.push(buf);
+        st.e = 0;
+      }
+      for (; !st.l; ) {
+        var blk = rzb(dat, st, buf);
+        if (!blk)
+          err(5);
+        if (buf)
+          st.e = st.y;
+        else {
+          bufs.push(blk);
+          ol += blk.length;
+          cpw(st.w, 0, blk.length);
+          st.w.set(blk, st.w.length - blk.length);
+        }
+      }
+      bt = st.b + st.c * 4;
+    } else
+      bt = st;
+    dat = dat.subarray(bt);
+  }
+  return cct(bufs, ol);
+}
+var ab, u8, u16, i16, i32, slc, fill, cpw, ec, err, rb, b4, rzfh, msb, rfse, rhu, dllt, dmlt, doct, b2bl, llb, llbl, mlb, mlbl, dhu, dhu4, rzb, cct;
+var init_esm = __esm({
+  "../../node_modules/fzstd/esm/index.mjs"() {
+    "use strict";
+    ab = ArrayBuffer;
+    u8 = Uint8Array;
+    u16 = Uint16Array;
+    i16 = Int16Array;
+    i32 = Int32Array;
+    slc = function(v, s, e) {
+      if (u8.prototype.slice)
+        return u8.prototype.slice.call(v, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      var n = new u8(e - s);
+      n.set(v.subarray(s, e));
+      return n;
+    };
+    fill = function(v, n, s, e) {
+      if (u8.prototype.fill)
+        return u8.prototype.fill.call(v, n, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      for (; s < e; ++s)
+        v[s] = n;
+      return v;
+    };
+    cpw = function(v, t, s, e) {
+      if (u8.prototype.copyWithin)
+        return u8.prototype.copyWithin.call(v, t, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      while (s < e) {
+        v[t++] = v[s++];
+      }
+    };
+    ec = [
+      "invalid zstd data",
+      "window size too large (>2046MB)",
+      "invalid block type",
+      "FSE accuracy too high",
+      "match distance too far back",
+      "unexpected EOF"
+    ];
+    err = function(ind, msg, nt) {
+      var e = new Error(msg || ec[ind]);
+      e.code = ind;
+      if (Error.captureStackTrace)
+        Error.captureStackTrace(e, err);
+      if (!nt)
+        throw e;
+      return e;
+    };
+    rb = function(d, b, n) {
+      var i = 0, o = 0;
+      for (; i < n; ++i)
+        o |= d[b++] << (i << 3);
+      return o;
+    };
+    b4 = function(d, b) {
+      return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+    };
+    rzfh = function(dat, w) {
+      var n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
+      if (n3 == 3126568 && dat[3] == 253) {
+        var flg = dat[4];
+        var ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = flg & 3, fcf = flg >> 6;
+        if (flg & 8)
+          err(0);
+        var bt = 6 - ss;
+        var db = df == 3 ? 4 : df;
+        var di = rb(dat, bt, db);
+        bt += db;
+        var fsb = fcf ? 1 << fcf : ss;
+        var fss = rb(dat, bt, fsb) + (fcf == 1 && 256);
+        var ws = fss;
+        if (!ss) {
+          var wb = 1 << 10 + (dat[5] >> 3);
+          ws = wb + (wb >> 3) * (dat[5] & 7);
+        }
+        if (ws > 2145386496)
+          err(1);
+        var buf = new u8((w == 1 ? fss || ws : w ? 0 : ws) + 12);
+        buf[0] = 1, buf[4] = 4, buf[8] = 8;
+        return {
+          b: bt + fsb,
+          y: 0,
+          l: 0,
+          d: di,
+          w: w && w != 1 ? w : buf.subarray(12),
+          e: ws,
+          o: new i32(buf.buffer, 0, 3),
+          u: fss,
+          c: cc,
+          m: Math.min(131072, ws)
+        };
+      } else if ((n3 >> 4 | dat[3] << 20) == 25481893) {
+        return b4(dat, 4) + 8;
+      }
+      err(0);
+    };
+    msb = function(val) {
+      var bits = 0;
+      for (; 1 << bits <= val; ++bits)
+        ;
+      return bits - 1;
+    };
+    rfse = function(dat, bt, mal) {
+      var tpos = (bt << 3) + 4;
+      var al = (dat[bt] & 15) + 5;
+      if (al > mal)
+        err(3);
+      var sz = 1 << al;
+      var probs = sz, sym = -1, re = -1, i = -1, ht = sz;
+      var buf = new ab(512 + (sz << 2));
+      var freq = new i16(buf, 0, 256);
+      var dstate = new u16(buf, 0, 256);
+      var nstate = new u16(buf, 512, sz);
+      var bb1 = 512 + (sz << 1);
+      var syms = new u8(buf, bb1, sz);
+      var nbits = new u8(buf, bb1 + sz);
+      while (sym < 255 && probs > 0) {
+        var bits = msb(probs + 1);
+        var cbt = tpos >> 3;
+        var msk = (1 << bits + 1) - 1;
+        var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (tpos & 7) & msk;
+        var msk1fb = (1 << bits) - 1;
+        var msv = msk - probs - 1;
+        var sval = val & msk1fb;
+        if (sval < msv)
+          tpos += bits, val = sval;
+        else {
+          tpos += bits + 1;
+          if (val > msk1fb)
+            val -= msv;
+        }
+        freq[++sym] = --val;
+        if (val == -1) {
+          probs += val;
+          syms[--ht] = sym;
+        } else
+          probs -= val;
+        if (!val) {
+          do {
+            var rbt = tpos >> 3;
+            re = (dat[rbt] | dat[rbt + 1] << 8) >> (tpos & 7) & 3;
+            tpos += 2;
+            sym += re;
+          } while (re == 3);
+        }
+      }
+      if (sym > 255 || probs)
+        err(0);
+      var sympos = 0;
+      var sstep = (sz >> 1) + (sz >> 3) + 3;
+      var smask = sz - 1;
+      for (var s = 0; s <= sym; ++s) {
+        var sf = freq[s];
+        if (sf < 1) {
+          dstate[s] = -sf;
+          continue;
+        }
+        for (i = 0; i < sf; ++i) {
+          syms[sympos] = s;
+          do {
+            sympos = sympos + sstep & smask;
+          } while (sympos >= ht);
+        }
+      }
+      if (sympos)
+        err(0);
+      for (i = 0; i < sz; ++i) {
+        var ns = dstate[syms[i]]++;
+        var nb = nbits[i] = al - msb(ns);
+        nstate[i] = (ns << nb) - sz;
+      }
+      return [tpos + 7 >> 3, {
+        b: al,
+        s: syms,
+        n: nbits,
+        t: nstate
+      }];
+    };
+    rhu = function(dat, bt) {
+      var i = 0, wc = -1;
+      var buf = new u8(292), hb = dat[bt];
+      var hw = buf.subarray(0, 256);
+      var rc = buf.subarray(256, 268);
+      var ri = new u16(buf.buffer, 268);
+      if (hb < 128) {
+        var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];
+        bt += hb;
+        var epos = ebt << 3;
+        var lb = dat[bt];
+        if (!lb)
+          err(0);
+        var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
+        var fpos = (++bt << 3) - 8 + msb(lb);
+        for (; ; ) {
+          fpos -= btr1;
+          if (fpos < epos)
+            break;
+          var cbt = fpos >> 3;
+          st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr1) - 1;
+          hw[++wc] = fdt.s[st1];
+          fpos -= btr2;
+          if (fpos < epos)
+            break;
+          cbt = fpos >> 3;
+          st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr2) - 1;
+          hw[++wc] = fdt.s[st2];
+          btr1 = fdt.n[st1];
+          st1 = fdt.t[st1];
+          btr2 = fdt.n[st2];
+          st2 = fdt.t[st2];
+        }
+        if (++wc > 255)
+          err(0);
+      } else {
+        wc = hb - 127;
+        for (; i < wc; i += 2) {
+          var byte = dat[++bt];
+          hw[i] = byte >> 4;
+          hw[i + 1] = byte & 15;
+        }
+        ++bt;
+      }
+      var wes = 0;
+      for (i = 0; i < wc; ++i) {
+        var wt = hw[i];
+        if (wt > 11)
+          err(0);
+        wes += wt && 1 << wt - 1;
+      }
+      var mb = msb(wes) + 1;
+      var ts = 1 << mb;
+      var rem = ts - wes;
+      if (rem & rem - 1)
+        err(0);
+      hw[wc++] = msb(rem) + 1;
+      for (i = 0; i < wc; ++i) {
+        var wt = hw[i];
+        ++rc[hw[i] = wt && mb + 1 - wt];
+      }
+      var hbuf = new u8(ts << 1);
+      var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
+      ri[mb] = 0;
+      for (i = mb; i > 0; --i) {
+        var pv = ri[i];
+        fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
+      }
+      if (ri[0] != ts)
+        err(0);
+      for (i = 0; i < wc; ++i) {
+        var bits = hw[i];
+        if (bits) {
+          var code = ri[bits];
+          fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
+        }
+      }
+      return [bt, {
+        n: nb,
+        b: mb,
+        s: syms
+      }];
+    };
+    dllt = rfse(/* @__PURE__ */ new u8([
+      81,
+      16,
+      99,
+      140,
+      49,
+      198,
+      24,
+      99,
+      12,
+      33,
+      196,
+      24,
+      99,
+      102,
+      102,
+      134,
+      70,
+      146,
+      4
+    ]), 0, 6)[1];
+    dmlt = rfse(/* @__PURE__ */ new u8([
+      33,
+      20,
+      196,
+      24,
+      99,
+      140,
+      33,
+      132,
+      16,
+      66,
+      8,
+      33,
+      132,
+      16,
+      66,
+      8,
+      33,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      36,
+      9
+    ]), 0, 6)[1];
+    doct = rfse(/* @__PURE__ */ new u8([
+      32,
+      132,
+      16,
+      66,
+      102,
+      70,
+      68,
+      68,
+      68,
+      68,
+      36,
+      73,
+      2
+    ]), 0, 5)[1];
+    b2bl = function(b, s) {
+      var len = b.length, bl = new i32(len);
+      for (var i = 0; i < len; ++i) {
+        bl[i] = s;
+        s += 1 << b[i];
+      }
+      return bl;
+    };
+    llb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+      0,
+      0,
+      0,
+      0,
+      16843009,
+      50528770,
+      134678020,
+      202050057,
+      269422093
+    ])).buffer, 0, 36);
+    llbl = /* @__PURE__ */ b2bl(llb, 0);
+    mlb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16843009,
+      50528770,
+      117769220,
+      185207048,
+      252579084,
+      16
+    ])).buffer, 0, 53);
+    mlbl = /* @__PURE__ */ b2bl(mlb, 3);
+    dhu = function(dat, out, hu) {
+      var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
+      if (!lb)
+        err(0);
+      var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
+      for (; pos > eb && i < ss; ) {
+        var cbt = pos >> 3;
+        var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (pos & 7);
+        st = (st << btr | val) & msk;
+        out[++i] = hu.s[st];
+        pos -= btr = hu.n[st];
+      }
+      if (pos != eb || i + 1 != ss)
+        err(0);
+    };
+    dhu4 = function(dat, out, hu) {
+      var bt = 6;
+      var ss = out.length, sz1 = ss + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
+      dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
+      dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
+      dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
+      dhu(dat.subarray(bt), out.subarray(sz3), hu);
+    };
+    rzb = function(dat, st, out) {
+      var _a;
+      var bt = st.b;
+      var b0 = dat[bt], btype = b0 >> 1 & 3;
+      st.l = b0 & 1;
+      var sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
+      var ebt = (bt += 3) + sz;
+      if (btype == 1) {
+        if (bt >= dat.length)
+          return;
+        st.b = bt + 1;
+        if (out) {
+          fill(out, dat[bt], st.y, st.y += sz);
+          return out;
+        }
+        return fill(new u8(sz), dat[bt]);
+      }
+      if (ebt > dat.length)
+        return;
+      if (btype == 0) {
+        st.b = ebt;
+        if (out) {
+          out.set(dat.subarray(bt, ebt), st.y);
+          st.y += sz;
+          return out;
+        }
+        return slc(dat, bt, ebt);
+      }
+      if (btype == 2) {
+        var b3 = dat[bt], lbt = b3 & 3, sf = b3 >> 2 & 3;
+        var lss = b3 >> 4, lcs = 0, s4 = 0;
+        if (lbt < 2) {
+          if (sf & 1)
+            lss |= dat[++bt] << 4 | (sf & 2 && dat[++bt] << 12);
+          else
+            lss = b3 >> 3;
+        } else {
+          s4 = sf;
+          if (sf < 2)
+            lss |= (dat[++bt] & 63) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
+          else if (sf == 2)
+            lss |= dat[++bt] << 4 | (dat[++bt] & 3) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
+          else
+            lss |= dat[++bt] << 4 | (dat[++bt] & 63) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
+        }
+        ++bt;
+        var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
+        var spl = buf.length - lss;
+        if (lbt == 0)
+          buf.set(dat.subarray(bt, bt += lss), spl);
+        else if (lbt == 1)
+          fill(buf, dat[bt++], spl);
+        else {
+          var hu = st.h;
+          if (lbt == 2) {
+            var hud = rhu(dat, bt);
+            lcs += bt - (bt = hud[0]);
+            st.h = hu = hud[1];
+          } else if (!hu)
+            err(0);
+          (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
+        }
+        var ns = dat[bt++];
+        if (ns) {
+          if (ns == 255)
+            ns = (dat[bt++] | dat[bt++] << 8) + 32512;
+          else if (ns > 127)
+            ns = ns - 128 << 8 | dat[bt++];
+          var scm = dat[bt++];
+          if (scm & 3)
+            err(0);
+          var dts = [dmlt, doct, dllt];
+          for (var i = 2; i > -1; --i) {
+            var md = scm >> (i << 1) + 2 & 3;
+            if (md == 1) {
+              var rbuf = new u8([0, 0, dat[bt++]]);
+              dts[i] = {
+                s: rbuf.subarray(2, 3),
+                n: rbuf.subarray(0, 1),
+                t: new u16(rbuf.buffer, 0, 1),
+                b: 0
+              };
+            } else if (md == 2) {
+              _a = rfse(dat, bt, 9 - (i & 1)), bt = _a[0], dts[i] = _a[1];
+            } else if (md == 3) {
+              if (!st.t)
+                err(0);
+              dts[i] = st.t[i];
+            }
+          }
+          var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];
+          var lb = dat[ebt - 1];
+          if (!lb)
+            err(0);
+          var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
+          var lst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << llt.b) - 1;
+          cbt = (spos -= oct.b) >> 3;
+          var ost = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << oct.b) - 1;
+          cbt = (spos -= mlt.b) >> 3;
+          var mst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mlt.b) - 1;
+          for (++ns; --ns; ) {
+            var llc = llt.s[lst];
+            var lbtr = llt.n[lst];
+            var mlc = mlt.s[mst];
+            var mbtr = mlt.n[mst];
+            var ofc = oct.s[ost];
+            var obtr = oct.n[ost];
+            cbt = (spos -= ofc) >> 3;
+            var ofp = 1 << ofc;
+            var off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (spos & 7) & ofp - 1);
+            cbt = (spos -= mlb[mlc]) >> 3;
+            var ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << mlb[mlc]) - 1);
+            cbt = (spos -= llb[llc]) >> 3;
+            var ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << llb[llc]) - 1);
+            cbt = (spos -= lbtr) >> 3;
+            lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << lbtr) - 1);
+            cbt = (spos -= mbtr) >> 3;
+            mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mbtr) - 1);
+            cbt = (spos -= obtr) >> 3;
+            ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << obtr) - 1);
+            if (off > 3) {
+              st.o[2] = st.o[1];
+              st.o[1] = st.o[0];
+              st.o[0] = off -= 3;
+            } else {
+              var idx = off - (ll != 0);
+              if (idx) {
+                off = idx == 3 ? st.o[0] - 1 : st.o[idx];
+                if (idx > 1)
+                  st.o[2] = st.o[1];
+                st.o[1] = st.o[0];
+                st.o[0] = off;
+              } else
+                off = st.o[0];
+            }
+            for (var i = 0; i < ll; ++i) {
+              buf[oubt + i] = buf[spl + i];
+            }
+            oubt += ll, spl += ll;
+            var stin = oubt - off;
+            if (stin < 0) {
+              var len = -stin;
+              var bs = st.e + stin;
+              if (len > ml)
+                len = ml;
+              for (var i = 0; i < len; ++i) {
+                buf[oubt + i] = st.w[bs + i];
+              }
+              oubt += len, ml -= len, stin = 0;
+            }
+            for (var i = 0; i < ml; ++i) {
+              buf[oubt + i] = buf[stin + i];
+            }
+            oubt += ml;
+          }
+          if (oubt != spl) {
+            while (spl < buf.length) {
+              buf[oubt++] = buf[spl++];
+            }
+          } else
+            oubt = buf.length;
+          if (out)
+            st.y += oubt;
+          else
+            buf = slc(buf, 0, oubt);
+        } else if (out) {
+          st.y += lss;
+          if (spl) {
+            for (var i = 0; i < lss; ++i) {
+              buf[i] = buf[spl + i];
+            }
+          }
+        } else if (spl)
+          buf = slc(buf, spl);
+        st.b = ebt;
+        return buf;
+      }
+      err(2);
+    };
+    cct = function(bufs, ol) {
+      if (bufs.length == 1)
+        return bufs[0];
+      var buf = new u8(ol);
+      for (var i = 0, b = 0; i < bufs.length; ++i) {
+        var chk = bufs[i];
+        buf.set(chk, b);
+        b += chk.length;
+      }
+      return buf;
+    };
+  }
+});
+
+// ../core/dist/studio-skills.js
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import * as path4 from "path";
+function decompressLz4Block(input, outputLength) {
+  const output = Buffer.allocUnsafe(outputLength);
+  let inputOffset = 0;
+  let outputOffset = 0;
+  const readExtendedLength = (initial) => {
+    let length = initial;
+    if (initial !== 15)
+      return length;
+    let next = 255;
+    while (next === 255) {
+      if (inputOffset >= input.length) {
+        throw new Error("Invalid LZ4 chunk: truncated extended length");
+      }
+      next = input[inputOffset++];
+      length += next;
+    }
+    return length;
+  };
+  while (inputOffset < input.length) {
+    const token = input[inputOffset++];
+    const literalLength = readExtendedLength(token >>> 4);
+    if (inputOffset + literalLength > input.length || outputOffset + literalLength > output.length) {
+      throw new Error("Invalid LZ4 chunk: literal exceeds chunk boundary");
+    }
+    input.copy(output, outputOffset, inputOffset, inputOffset + literalLength);
+    inputOffset += literalLength;
+    outputOffset += literalLength;
+    if (inputOffset === input.length)
+      break;
+    if (inputOffset + 2 > input.length) {
+      throw new Error("Invalid LZ4 chunk: missing match offset");
+    }
+    const matchOffset = input.readUInt16LE(inputOffset);
+    inputOffset += 2;
+    if (matchOffset === 0 || matchOffset > outputOffset) {
+      throw new Error("Invalid LZ4 chunk: invalid match offset");
+    }
+    const matchLength = readExtendedLength(token & 15) + 4;
+    if (outputOffset + matchLength > output.length) {
+      throw new Error("Invalid LZ4 chunk: match exceeds output boundary");
+    }
+    for (let index = 0; index < matchLength; index += 1) {
+      output[outputOffset] = output[outputOffset - matchOffset];
+      outputOffset += 1;
+    }
+  }
+  if (outputOffset !== output.length) {
+    throw new Error(`Invalid LZ4 chunk: produced ${outputOffset} bytes, expected ${output.length}`);
+  }
+  return output;
+}
+function decompressChunk(compressed, outputLength) {
+  if (compressed.subarray(0, ZSTD_MAGIC.length).equals(ZSTD_MAGIC)) {
+    const decompressed = Buffer.from(decompress(compressed));
+    if (decompressed.length !== outputLength) {
+      throw new Error(`Invalid Zstandard chunk: produced ${decompressed.length} bytes, expected ${outputLength}`);
+    }
+    return decompressed;
+  }
+  return decompressLz4Block(compressed, outputLength);
+}
+function readChunk(reader) {
+  if (reader.remaining < RBXM_CHUNK_HEADER_BYTES) {
+    throw new Error("Invalid Assistant.rbxm: truncated chunk header");
+  }
+  const type = reader.readBytes(4).toString("latin1");
+  const compressedLength = reader.readUint32();
+  const uncompressedLength = reader.readUint32();
+  reader.skip(4);
+  if (type === "END\0")
+    return { type };
+  if (compressedLength === 0) {
+    return { type, content: reader.readBytes(uncompressedLength) };
+  }
+  return {
+    type,
+    content: decompressChunk(reader.readBytes(compressedLength), uncompressedLength)
+  };
+}
+function parseFrontmatter(markdown) {
+  const match = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match)
+    return void 0;
+  const fields = /* @__PURE__ */ new Map();
+  for (const line of match[1].split(/\r?\n/)) {
+    const separator = line.indexOf(":");
+    if (separator <= 0)
+      continue;
+    const key = line.slice(0, separator).trim().toLowerCase();
+    let value = line.slice(separator + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      try {
+        value = JSON.parse(value);
+      } catch {
+      }
+    } else if (value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1).replace(/''/g, "'");
+    }
+    fields.set(key, value);
+  }
+  const name = fields.get("name")?.trim();
+  if (!name)
+    return void 0;
+  return { name, description: fields.get("description")?.trim() ?? "" };
+}
+function canonicalBuiltInSkillName(sourceName) {
+  return sourceName.toLowerCase().startsWith("rbx-") ? sourceName : `rbx-${sourceName}`;
+}
+function parseBuiltInStudioSkills(buffer) {
+  if (buffer.length < RBXM_HEADER_BYTES || !buffer.subarray(0, RBXM_MAGIC.length).equals(RBXM_MAGIC)) {
+    throw new Error("Invalid Assistant.rbxm: Roblox binary model header not found");
+  }
+  const reader = new ByteReader(buffer, "Assistant.rbxm");
+  reader.skip(RBXM_MAGIC.length);
+  reader.readUint16();
+  reader.readInt32();
+  reader.readInt32();
+  reader.skip(8);
+  const stringValueClasses = /* @__PURE__ */ new Map();
+  let foundEnd = false;
+  while (reader.remaining > 0) {
+    const chunk = readChunk(reader);
+    if (chunk.type === "END\0") {
+      foundEnd = true;
+      break;
+    }
+    if (!chunk.content)
+      continue;
+    const chunkReader = new ByteReader(chunk.content, `${chunk.type} chunk`);
+    if (chunk.type === "INST") {
+      const classId2 = chunkReader.readUint32();
+      const className = chunkReader.readString();
+      chunkReader.readUint8();
+      const count = chunkReader.readUint32();
+      chunkReader.skip(count * 4);
+      if (className === "StringValue")
+        stringValueClasses.set(classId2, { count });
+      continue;
+    }
+    if (chunk.type !== "PROP")
+      continue;
+    const classId = chunkReader.readUint32();
+    const propertyName = chunkReader.readString();
+    const propertyType = chunkReader.readUint8();
+    const classInfo = stringValueClasses.get(classId);
+    if (!classInfo || propertyType !== STRING_PROPERTY_TYPE)
+      continue;
+    if (propertyName !== "Name" && propertyName !== "Value")
+      continue;
+    const values = [];
+    for (let index = 0; index < classInfo.count; index += 1) {
+      values.push(chunkReader.readString());
+    }
+    if (propertyName === "Name")
+      classInfo.names = values;
+    else
+      classInfo.values = values;
+  }
+  if (!foundEnd)
+    throw new Error("Invalid Assistant.rbxm: END chunk not found");
+  const documents = [];
+  for (const classInfo of stringValueClasses.values()) {
+    if (!classInfo.names || !classInfo.values)
+      continue;
+    for (let index = 0; index < classInfo.count; index += 1) {
+      const document = classInfo.names[index];
+      if (document !== "SKILL" && document !== "SKILL-combined")
+        continue;
+      const content = classInfo.values[index];
+      const frontmatter = parseFrontmatter(content);
+      if (!frontmatter)
+        continue;
+      documents.push({
+        document,
+        sourceName: frontmatter.name,
+        description: frontmatter.description,
+        content
+      });
+    }
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    const key = document.sourceName.toLowerCase();
+    const group = grouped.get(key) ?? {};
+    if (document.document === "SKILL-combined")
+      group.combined = document;
+    else
+      group.base = document;
+    grouped.set(key, group);
+  }
+  return [...grouped.values()].map((group) => {
+    const selected = group.combined ?? group.base;
+    return {
+      name: canonicalBuiltInSkillName(selected.sourceName),
+      sourceName: selected.sourceName,
+      description: selected.description,
+      document: selected.document,
+      hasCombinedDocument: group.combined !== void 0,
+      content: selected.content,
+      contentLength: Buffer.byteLength(selected.content, "utf8"),
+      contentSha256: createHash2("sha256").update(selected.content).digest("hex")
+    };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+}
+function discoverNamedFile(root, fileName, depth = 0) {
+  if (depth > MAX_DISCOVERY_DEPTH || !existsSync4(root))
+    return [];
+  const matches = [];
+  let entries;
+  try {
+    entries = readdirSync3(root, { withFileTypes: true });
+  } catch {
+    return matches;
+  }
+  for (const entry of entries) {
+    const entryPath = path4.join(root, entry.name);
+    if (entry.isFile() && entry.name.toLowerCase() === fileName.toLowerCase()) {
+      matches.push(entryPath);
+    } else if (entry.isDirectory()) {
+      matches.push(...discoverNamedFile(entryPath, fileName, depth + 1));
+    }
+  }
+  return matches;
+}
+function resolveAssistantBundlePath(studioExe = resolveStudioExe()) {
+  const override = process.env.ROBLOX_STUDIO_ASSISTANT_BUNDLE;
+  if (override) {
+    if (!existsSync4(override)) {
+      throw new Error(`ROBLOX_STUDIO_ASSISTANT_BUNDLE does not exist: ${override}`);
+    }
+    return override;
+  }
+  const exeDirectory = path4.dirname(studioExe);
+  const roots = [
+    path4.join(exeDirectory, "BuiltInStandalonePlugins"),
+    path4.resolve(exeDirectory, "..", "Resources", "BuiltInStandalonePlugins"),
+    path4.resolve(exeDirectory, "..", "..", "OTAPlugins")
+  ];
+  const direct = path4.join(exeDirectory, "BuiltInStandalonePlugins", "Optimized_Embedded_Signature", "Assistant.rbxm");
+  const candidates = /* @__PURE__ */ new Set();
+  if (existsSync4(direct))
+    candidates.add(direct);
+  for (const root of roots) {
+    for (const candidate of discoverNamedFile(root, "Assistant.rbxm"))
+      candidates.add(candidate);
+  }
+  const newest = [...candidates].map((candidate) => ({ candidate, modifiedAt: statSync3(candidate).mtimeMs })).sort((left, right) => right.modifiedAt - left.modifiedAt)[0]?.candidate;
+  if (!newest) {
+    throw new Error(`Studio Assistant bundle not found for ${studioExe}. Set ROBLOX_STUDIO_ASSISTANT_BUNDLE to the installed Assistant.rbxm path.`);
+  }
+  return newest;
+}
+function loadBuiltInStudioSkills(bundlePath = resolveAssistantBundlePath()) {
+  const stats = statSync3(bundlePath);
+  if (cachedBundle?.path === bundlePath && cachedBundle.modifiedAt === stats.mtimeMs && cachedBundle.size === stats.size) {
+    return cachedBundle.value;
+  }
+  const buffer = readFileSync5(bundlePath);
+  const skills = parseBuiltInStudioSkills(buffer);
+  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 value = {
+    bundlePath,
+    bundleModifiedAt: stats.mtime.toISOString(),
+    bundleSha256: createHash2("sha256").update(buffer).digest("hex"),
+    studioVersion,
+    skills
+  };
+  cachedBundle = { path: bundlePath, modifiedAt: stats.mtimeMs, size: stats.size, value };
+  return value;
+}
+function findBuiltInStudioSkill(bundle, requestedName) {
+  const wanted = requestedName.trim().toLowerCase();
+  return bundle.skills.find((skill) => skill.name.toLowerCase() === wanted || skill.sourceName.toLowerCase() === wanted);
+}
+var RBXM_MAGIC, RBXM_HEADER_BYTES, RBXM_CHUNK_HEADER_BYTES, ZSTD_MAGIC, STRING_PROPERTY_TYPE, MAX_DISCOVERY_DEPTH, ByteReader, cachedBundle;
+var init_studio_skills = __esm({
+  "../core/dist/studio-skills.js"() {
+    "use strict";
+    init_esm();
+    init_studio_instance_manager();
+    RBXM_MAGIC = Buffer.from("<roblox!\x89\xFF\r\n\n", "latin1");
+    RBXM_HEADER_BYTES = 32;
+    RBXM_CHUNK_HEADER_BYTES = 16;
+    ZSTD_MAGIC = Buffer.from([40, 181, 47, 253]);
+    STRING_PROPERTY_TYPE = 1;
+    MAX_DISCOVERY_DEPTH = 6;
+    ByteReader = class {
+      bytes;
+      label;
+      offset = 0;
+      constructor(bytes, label) {
+        this.bytes = bytes;
+        this.label = label;
+      }
+      get remaining() {
+        return this.bytes.length - this.offset;
+      }
+      requireBytes(length) {
+        if (!Number.isSafeInteger(length) || length < 0 || this.remaining < length) {
+          throw new Error(`Invalid ${this.label}: requested ${length} bytes with ${this.remaining} remaining`);
+        }
+      }
+      readUint8() {
+        this.requireBytes(1);
+        return this.bytes[this.offset++];
+      }
+      readUint16() {
+        this.requireBytes(2);
+        const value = this.bytes.readUInt16LE(this.offset);
+        this.offset += 2;
+        return value;
+      }
+      readUint32() {
+        this.requireBytes(4);
+        const value = this.bytes.readUInt32LE(this.offset);
+        this.offset += 4;
+        return value;
+      }
+      readInt32() {
+        this.requireBytes(4);
+        const value = this.bytes.readInt32LE(this.offset);
+        this.offset += 4;
+        return value;
+      }
+      readBytes(length) {
+        this.requireBytes(length);
+        const value = this.bytes.subarray(this.offset, this.offset + length);
+        this.offset += length;
+        return value;
+      }
+      skip(length) {
+        this.requireBytes(length);
+        this.offset += length;
+      }
+      readString() {
+        const length = this.readUint32();
+        return this.readBytes(length).toString("utf8");
+      }
+    };
+  }
+});
+
 // ../core/dist/jpeg-encoder.js
 function rgbaToJpeg(rgba, width, height, quality = 80) {
   if (width <= 0 || height <= 0)
@@ -4995,7 +6266,7 @@ var init_png_encoder = __esm({
 // ../core/dist/tools/index.js
 import * as fs3 from "fs";
 import * as os3 from "os";
-import * as path4 from "path";
+import * as path5 from "path";
 function multiplayerStopDisabledBody() {
   return {
     success: false,
@@ -5020,7 +6291,7 @@ function encodeImageFromRgbaResponse(response, format, quality) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -5082,7 +6353,7 @@ function loadMicroProfilerBaseline(source, sourcePath) {
     if (typeof sourcePath !== "string" || sourcePath === "") {
       throw new Error("baseline_path must be a non-empty string when provided");
     }
-    const resolved = path4.resolve(sourcePath);
+    const resolved = path5.resolve(sourcePath);
     const parsed = JSON.parse(fs3.readFileSync(resolved, "utf8"));
     const record = asRecord(parsed);
     if (!record)
@@ -5543,6 +6814,7 @@ var init_tools = __esm({
     init_studio_instance_manager();
     init_image_decode();
     init_roblox_docs();
+    init_studio_skills();
     init_jpeg_encoder();
     init_png_encoder();
     MAX_INLINE_IMAGE_BYTES = 6e6;
@@ -5610,10 +6882,52 @@ var init_tools = __esm({
         this.openCloudClient = new OpenCloudClient();
         this.cookieClient = new RobloxCookieClient();
         this.instanceManager = new StudioInstanceManager();
+        this.bridge.onInstanceRegistered((instance) => this._associateManagedEditConnection(instance));
       }
       _textResult(body) {
         return { content: [{ type: "text", text: JSON.stringify(body) }] };
       }
+      async getRobloxSkills(action, name) {
+        if (action !== "list" && action !== "get") {
+          throw new Error('get_roblox_skills action must be "list" or "get"');
+        }
+        const bundle = loadBuiltInStudioSkills();
+        const bundleMetadata = {
+          source: "installed-studio-assistant",
+          studioVersion: bundle.studioVersion,
+          bundlePath: bundle.bundlePath,
+          bundleModifiedAt: bundle.bundleModifiedAt,
+          bundleSha256: bundle.bundleSha256
+        };
+        if (action === "list") {
+          return this._textResult({
+            action,
+            ...bundleMetadata,
+            count: bundle.skills.length,
+            skills: bundle.skills.map((skill2) => ({
+              name: skill2.name,
+              sourceName: skill2.sourceName,
+              description: skill2.description,
+              document: skill2.document,
+              hasCombinedDocument: skill2.hasCombinedDocument,
+              contentLength: skill2.contentLength,
+              contentSha256: skill2.contentSha256
+            }))
+          });
+        }
+        if (!name || typeof name !== "string" || !name.trim()) {
+          throw new Error('get_roblox_skills action="get" requires a skill name from action="list"');
+        }
+        const skill = findBuiltInStudioSkill(bundle, name);
+        if (!skill) {
+          throw new Error(`Built-in Studio skill "${name}" was not found. Available skills: ` + bundle.skills.map((candidate) => candidate.name).join(", "));
+        }
+        return this._textResult({
+          action,
+          ...bundleMetadata,
+          skill
+        });
+      }
       async getRobloxDocs(name, docType, section) {
         if (!name || typeof name !== "string") {
           throw new Error('get_roblox_docs requires a name (e.g. "ProximityPrompt")');
@@ -5966,8 +7280,8 @@ var init_tools = __esm({
           timedOut: true
         };
       }
-      async getFileTree(path5 = "", instance_id) {
-        const response = await this._callSingle("/api/file-tree", { path: path5 }, void 0, instance_id);
+      async getFileTree(path6 = "", instance_id) {
+        const response = await this._callSingle("/api/file-tree", { path: path6 }, void 0, instance_id);
         return {
           content: [
             {
@@ -6084,9 +7398,9 @@ var init_tools = __esm({
           ]
         };
       }
-      async getProjectStructure(path5, maxDepth, scriptsOnly, instance_id) {
+      async getProjectStructure(path6, maxDepth, scriptsOnly, instance_id) {
         const response = await this._callSingle("/api/project-structure", {
-          path: path5,
+          path: path6,
           maxDepth,
           scriptsOnly
         }, void 0, instance_id);
@@ -7010,8 +8324,8 @@ ${code}`
           const rawJson = mutable.raw_json;
           if (typeof rawJson === "string") {
             if (typeof outputPath === "string" && outputPath !== "") {
-              const resolvedOutputPath = path4.resolve(outputPath);
-              fs3.mkdirSync(path4.dirname(resolvedOutputPath), { recursive: true });
+              const resolvedOutputPath = path5.resolve(outputPath);
+              fs3.mkdirSync(path5.dirname(resolvedOutputPath), { recursive: true });
               fs3.writeFileSync(resolvedOutputPath, rawJson, "utf8");
               mutable.output_path = resolvedOutputPath;
             }
@@ -7073,8 +8387,8 @@ ${code}`
           const rawSnapshotBase64 = mutable.raw_snapshot_base64;
           if (typeof rawSnapshotBase64 === "string") {
             if (typeof outputPath === "string" && outputPath !== "") {
-              const resolvedOutputPath = path4.resolve(outputPath);
-              fs3.mkdirSync(path4.dirname(resolvedOutputPath), { recursive: true });
+              const resolvedOutputPath = path5.resolve(outputPath);
+              fs3.mkdirSync(path5.dirname(resolvedOutputPath), { recursive: true });
               fs3.writeFileSync(resolvedOutputPath, Buffer.from(rawSnapshotBase64, "base64"));
               mutable.output_path = resolvedOutputPath;
             }
@@ -7089,8 +8403,8 @@ ${code}`
             });
           }
           if (typeof summaryOutputPath === "string" && summaryOutputPath !== "") {
-            const resolvedSummaryPath = path4.resolve(summaryOutputPath);
-            fs3.mkdirSync(path4.dirname(resolvedSummaryPath), { recursive: true });
+            const resolvedSummaryPath = path5.resolve(summaryOutputPath);
+            fs3.mkdirSync(path5.dirname(resolvedSummaryPath), { recursive: true });
             fs3.writeFileSync(resolvedSummaryPath, JSON.stringify(mutable, null, 2), "utf8");
             mutable.summary_output_path = resolvedSummaryPath;
           }
@@ -7158,11 +8472,18 @@ ${code}`
           return record.placeId !== void 0 && instance.placeId === record.placeId;
         }
         if ((record.source === "baseplate" || record.source === "local_file") && record.localPlaceFile) {
-          const expectedName = path4.basename(record.localPlaceFile);
+          const expectedName = path5.basename(record.localPlaceFile);
           return instance.placeName === expectedName || instance.dataModelName === expectedName;
         }
         return true;
       }
+      _associateManagedEditConnection(instance) {
+        if (instance.role !== "edit")
+          return;
+        const candidate = this.instanceManager.pendingLaunches().filter((record) => instance.connectedAt >= record.launchedAt - 1e3).filter((record) => this._matchesManagedLaunch(record, instance)).sort((a, b) => a.launchedAt - b.launchedAt)[0];
+        if (candidate)
+          this.instanceManager.attachInstanceId(candidate, instance.instanceId);
+      }
       async _deriveUniverseId(placeId) {
         const response = await fetch(`https://apis.roblox.com/universes/v1/places/${placeId}/universe`);
         if (!response.ok) {
@@ -7178,6 +8499,10 @@ ${code}`
       async _waitForManagedEditConnection(record, beforeKeys, timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
+          this.instanceManager.refresh(record);
+          if (record.state === "failed" || record.state === "exited" || record.closedAt !== void 0) {
+            return void 0;
+          }
           const candidates = this.bridge.getPublicInstances().filter((instance) => instance.role === "edit").filter((instance) => !beforeKeys.has(this._publicInstanceKey(instance))).filter((instance) => instance.connectedAt >= record.launchedAt - 1e3).filter((instance) => this._matchesManagedLaunch(record, instance)).sort((a, b) => b.connectedAt - a.connectedAt);
           if (candidates[0])
             return candidates[0];
@@ -7186,12 +8511,25 @@ ${code}`
         return void 0;
       }
       _managedStatus(record) {
+        this.instanceManager.refresh(record);
         const connected = record.instanceId ? this.bridge.getPublicInstances().filter((instance) => instance.instanceId === record.instanceId) : [];
         return {
+          launch_id: record.recordId,
           instance_id: record.instanceId,
+          managed: true,
+          state: record.state,
+          pid: record.nativeProcessId ?? record.spawnPid,
+          process_running: record.closedAt === void 0 && record.exitedAt === void 0,
           source: record.source,
+          local_place_file: record.localPlaceFile,
           place_id: record.placeId,
           place_version: record.placeVersion,
+          launched_at: new Date(record.launchedAt).toISOString(),
+          connected_at: record.connectedAt ? new Date(record.connectedAt).toISOString() : void 0,
+          failed_at: record.failedAt ? new Date(record.failedAt).toISOString() : void 0,
+          exited_at: record.exitedAt ? new Date(record.exitedAt).toISOString() : void 0,
+          exit_code: record.exitCode,
+          failure_reason: record.failureReason,
           connected: connected.length > 0,
           roles: connected.map((instance) => instance.role).sort()
         };
@@ -7203,6 +8541,10 @@ ${code}`
       async manageInstance(request) {
         const action = request.action;
         const instance_id = typeof request.instance_id === "string" ? request.instance_id : void 0;
+        const launch_id = typeof request.launch_id === "string" ? request.launch_id : void 0;
+        if (instance_id && launch_id) {
+          throw new Error("manage_instance accepts only one of instance_id or launch_id.");
+        }
         if (action !== "launch" && action !== "close" && action !== "status" && action !== "list_place_versions") {
           throw new Error("manage_instance requires action=launch|close|status|list_place_versions");
         }
@@ -7230,18 +8572,26 @@ ${code}`
           return this._textResult(body);
         }
         if (action === "status") {
+          if (launch_id) {
+            const record2 = this.instanceManager.getByLaunchId(launch_id);
+            if (!record2)
+              return this._textResult({ error: "Launch is not managed.", launch_id });
+            return this._textResult(this._managedStatus(record2));
+          }
           if (instance_id) {
             const record2 = this.instanceManager.get(instance_id);
             const connected2 = this.bridge.getPublicInstances().filter((instance) => instance.instanceId === instance_id);
             if (!record2 && connected2.length === 0) {
               return this._textResult({ error: "Instance is not connected or managed.", instance_id });
             }
+            if (record2)
+              return this._textResult(this._managedStatus(record2));
             return this._textResult({
               instance_id,
-              managed: !!record2,
-              source: record2?.source,
-              place_id: record2?.placeId ?? connected2[0]?.placeId,
-              place_version: record2?.placeVersion,
+              managed: false,
+              state: "connected",
+              place_id: connected2[0]?.placeId,
+              connected: true,
               roles: connected2.map((instance) => instance.role).sort()
             });
           }
@@ -7257,14 +8607,32 @@ ${code}`
         }
         if (action === "close") {
           let record2;
+          if (launch_id) {
+            record2 = this.instanceManager.getByLaunchId(launch_id);
+            if (!record2)
+              return this._textResult({ error: "Launch is not managed.", launch_id });
+            const connectedInstanceId = record2.instanceId;
+            const closeResult2 = record2.closedAt === void 0 ? this.instanceManager.close(record2) : { status: "already_closed" };
+            if (connectedInstanceId) {
+              await this.bridge.unregisterInstanceIdEverywhere(connectedInstanceId);
+              await sleep(500);
+              await this.bridge.unregisterInstanceIdEverywhere(connectedInstanceId);
+            }
+            return this._textResult({
+              ...this._managedStatus(record2),
+              message: closeResult2.status === "already_closed" ? "Studio instance was already closed." : "Studio instance closed."
+            });
+          }
           if (instance_id) {
+            const recordBeforeClose = this.instanceManager.get(instance_id);
             const managedClose = this.instanceManager.closeByInstanceId(instance_id);
             if (managedClose.status !== "not_found") {
               await this.bridge.unregisterInstanceIdEverywhere(instance_id);
               await sleep(500);
               await this.bridge.unregisterInstanceIdEverywhere(instance_id);
+              const closedRecord = recordBeforeClose ?? (managedClose.launchId ? this.instanceManager.getByLaunchId(managedClose.launchId) : void 0);
               return this._textResult({
-                instance_id,
+                ...closedRecord ? this._managedStatus(closedRecord) : { instance_id },
                 message: managedClose.status === "already_closed" ? "Studio instance was already closed." : "Studio instance closed."
               });
             }
@@ -7311,7 +8679,7 @@ ${code}`
             await this.bridge.unregisterInstanceIdEverywhere(record2.instanceId);
           }
           return this._textResult({
-            instance_id: record2.instanceId,
+            ...this._managedStatus(record2),
             message: closeResult.status === "already_closed" ? "Studio instance was already closed." : "Studio instance closed."
           });
         }
@@ -7338,24 +8706,34 @@ ${code}`
           localPlaceFile,
           placeId,
           universeId,
-          placeVersion
+          placeVersion,
+          connectionTimeoutMs: timeoutMs
         });
         if (!waitForConnection) {
-          return this._textResult({ message: "Studio launch requested." });
+          return this._textResult({
+            ...this._managedStatus(record),
+            message: "Studio launch requested."
+          });
         }
         const connected = await this._waitForManagedEditConnection(record, beforeKeys, timeoutMs);
         if (!connected) {
-          try {
-            this.instanceManager.close(record);
-          } catch {
+          if (record.state === "launching") {
+            this.instanceManager.markFailed(record, "Studio launched, but the MCP plugin did not connect before timeout.");
+          }
+          if (record.closedAt === void 0) {
+            try {
+              this.instanceManager.close(record);
+            } catch {
+            }
           }
           return this._textResult({
-            error: "Studio launched, but the MCP plugin did not connect before timeout."
+            ...this._managedStatus(record),
+            error: record.failureReason ?? "Studio launched, but the MCP plugin did not connect before timeout."
           });
         }
         this.instanceManager.attachInstanceId(record, connected.instanceId);
         return this._textResult({
-          instance_id: connected.instanceId,
+          ...this._managedStatus(record),
           message: launchSource === "place_revision" ? `Studio opened place revision ${placeVersion}.` : "Studio opened."
         });
       }
@@ -7538,16 +8916,16 @@ ${code}`
           try {
             editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
             body.edit = editState;
-          } catch (err) {
-            body.edit = { error: err instanceof Error ? err.message : String(err) };
+          } catch (err2) {
+            body.edit = { error: err2 instanceof Error ? err2.message : String(err2) };
           }
         }
         if (server) {
           try {
             serverState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "server");
             body.server = serverState;
-          } catch (err) {
-            body.server = { error: err instanceof Error ? err.message : String(err) };
+          } catch (err2) {
+            body.server = { error: err2 instanceof Error ? err2.message : String(err2) };
           }
         }
         const session = editState?.session;
@@ -7873,14 +9251,14 @@ ${code}`
         };
       }
       static findProjectRoot(startDir) {
-        let dir = path4.resolve(startDir);
+        let dir = path5.resolve(startDir);
         let previous = "";
         while (dir !== previous) {
-          if (fs3.existsSync(path4.join(dir, ".git")) || fs3.existsSync(path4.join(dir, "package.json"))) {
+          if (fs3.existsSync(path5.join(dir, ".git")) || fs3.existsSync(path5.join(dir, "package.json"))) {
             return dir;
           }
           previous = dir;
-          dir = path4.dirname(dir);
+          dir = path5.dirname(dir);
         }
         return null;
       }
@@ -7894,7 +9272,7 @@ ${code}`
         }
       }
       static ensureWritableDirectory(candidate, label) {
-        const resolved = path4.resolve(candidate);
+        const resolved = path5.resolve(candidate);
         try {
           fs3.mkdirSync(resolved, { recursive: true });
         } catch (error) {
@@ -7915,11 +9293,11 @@ ${code}`
         if (_RobloxStudioTools._cachedLibraryPath)
           return _RobloxStudioTools._cachedLibraryPath;
         const overridePath = process.env.ROBLOXSTUDIO_MCP_BUILD_LIBRARY || process.env.BUILD_LIBRARY_PATH;
-        const cwd = path4.resolve(process.cwd());
+        const cwd = path5.resolve(process.cwd());
         const projectRoot = _RobloxStudioTools.findProjectRoot(cwd);
-        const homeLibraryPath = path4.join(os3.homedir(), ".robloxstudio-mcp", "build-library");
-        const projectLibraryPath = projectRoot ? path4.join(projectRoot, "build-library") : null;
-        const cwdLibraryPath = path4.join(cwd, "build-library");
+        const homeLibraryPath = path5.join(os3.homedir(), ".robloxstudio-mcp", "build-library");
+        const projectLibraryPath = projectRoot ? path5.join(projectRoot, "build-library") : null;
+        const cwdLibraryPath = path5.join(cwd, "build-library");
         let result;
         if (overridePath) {
           result = _RobloxStudioTools.ensureWritableDirectory(overridePath, "override");
@@ -7933,12 +9311,12 @@ ${code}`
             }
           })());
           if (existing) {
-            result = path4.resolve(existing);
+            result = path5.resolve(existing);
           } else if (projectLibraryPath) {
             try {
               result = _RobloxStudioTools.ensureWritableDirectory(projectLibraryPath, "project-root");
-            } catch (err) {
-              console.error(`Warning: could not create build-library at project root (${projectLibraryPath}): ${err.message}. Falling back to home directory.`);
+            } catch (err2) {
+              console.error(`Warning: could not create build-library at project root (${projectLibraryPath}): ${err2.message}. Falling back to home directory.`);
               result = _RobloxStudioTools.ensureWritableDirectory(homeLibraryPath, "home");
             }
           } else {
@@ -7960,8 +9338,8 @@ ${code}`
         if (response && response.success && response.buildData) {
           const buildData = response.buildData;
           const buildId = buildData.id || `${style}/exported`;
-          const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${buildId}.json`);
-          const dirPath = path4.dirname(filePath);
+          const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${buildId}.json`);
+          const dirPath = path5.dirname(filePath);
           if (!fs3.existsSync(dirPath)) {
             fs3.mkdirSync(dirPath, { recursive: true });
           }
@@ -8062,8 +9440,8 @@ ${code}`
         const normalizedParts = this.normalizeBuildParts(parts, new Set(Object.keys(normalizedPalette)));
         const computedBounds = bounds || this.computeBounds(normalizedParts);
         const buildData = { id, style, bounds: computedBounds, palette: normalizedPalette, parts: normalizedParts };
-        const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
-        const dirPath = path4.dirname(filePath);
+        const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
+        const dirPath = path5.dirname(filePath);
         if (!fs3.existsSync(dirPath)) {
           fs3.mkdirSync(dirPath, { recursive: true });
         }
@@ -8121,8 +9499,8 @@ ${code}`
         };
         if (seed !== void 0)
           buildData.generatorSeed = seed;
-        const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
-        const dirPath = path4.dirname(filePath);
+        const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
+        const dirPath = path5.dirname(filePath);
         if (!fs3.existsSync(dirPath)) {
           fs3.mkdirSync(dirPath, { recursive: true });
         }
@@ -8150,13 +9528,13 @@ ${code}`
         }
         let resolved;
         if (typeof buildData === "string") {
-          const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${buildData}.json`);
+          const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${buildData}.json`);
           if (!fs3.existsSync(filePath)) {
             throw new Error(`Build not found in library: ${buildData}`);
           }
           resolved = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
         } else if (buildData.id && !buildData.parts) {
-          const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${buildData.id}.json`);
+          const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${buildData.id}.json`);
           if (!fs3.existsSync(filePath)) {
             throw new Error(`Build not found in library: ${buildData.id}`);
           }
@@ -8183,13 +9561,13 @@ ${code}`
         const styles = style ? [style] : ["medieval", "modern", "nature", "scifi", "misc"];
         const builds = [];
         for (const s of styles) {
-          const dirPath = path4.join(libraryPath, s);
+          const dirPath = path5.join(libraryPath, s);
           if (!fs3.existsSync(dirPath))
             continue;
           const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".json"));
           for (const file of files) {
             try {
-              const content = fs3.readFileSync(path4.join(dirPath, file), "utf-8");
+              const content = fs3.readFileSync(path5.join(dirPath, file), "utf-8");
               const data = JSON.parse(content);
               builds.push({
                 id: data.id || `${s}/${file.replace(".json", "")}`,
@@ -8228,7 +9606,7 @@ ${code}`
         if (!id) {
           throw new Error("Build ID is required for get_build");
         }
-        const filePath = path4.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
+        const filePath = path5.join(_RobloxStudioTools.findLibraryPath(), `${id}.json`);
         if (!fs3.existsSync(filePath)) {
           throw new Error(`Build not found in library: ${id}`);
         }
@@ -8315,7 +9693,7 @@ ${code}`
           if (!buildId) {
             throw new Error(`Invalid ${validatedKeyPath}: model key "${modelKey}" is not defined in sceneData.models`);
           }
-          const filePath = path4.join(libraryPath, `${buildId}.json`);
+          const filePath = path5.join(libraryPath, `${buildId}.json`);
           if (!fs3.existsSync(filePath)) {
             throw new Error(`Build not found in library: ${buildId}`);
           }
@@ -8663,7 +10041,7 @@ ${code}`
           throw new Error(`File not found: ${filePath}`);
         }
         const fileContent = fs3.readFileSync(filePath);
-        const fileName = path4.basename(filePath);
+        const fileName = path5.basename(filePath);
         if (assetType === "Decal" && this.cookieClient.hasCookie()) {
           const result2 = await this.cookieClient.uploadDecal(fileContent, displayName, description || "");
           return {
@@ -8888,12 +10266,12 @@ ${code}`
           return { content: [{ type: "text", text: JSON.stringify({ error: "plugin returned no base64 payload" }) }] };
         }
         const bytes = Buffer.from(response.base64, "base64");
-        const resolved = path4.resolve(outputPath);
+        const resolved = path5.resolve(outputPath);
         try {
-          fs3.mkdirSync(path4.dirname(resolved), { recursive: true });
+          fs3.mkdirSync(path5.dirname(resolved), { recursive: true });
           fs3.writeFileSync(resolved, bytes);
-        } catch (err) {
-          return { content: [{ type: "text", text: JSON.stringify({ error: `failed to write ${resolved}: ${err.message}` }) }] };
+        } catch (err2) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: `failed to write ${resolved}: ${err2.message}` }) }] };
         }
         return {
           content: [{
@@ -8924,11 +10302,11 @@ ${code}`
         let bytes;
         let sourceLabel;
         if (source.path !== void 0) {
-          const resolved = path4.resolve(source.path);
+          const resolved = path5.resolve(source.path);
           try {
             bytes = fs3.readFileSync(resolved);
-          } catch (err) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: `failed to read ${resolved}: ${err.message}` }) }] };
+          } catch (err2) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `failed to read ${resolved}: ${err2.message}` }) }] };
           }
           sourceLabel = resolved;
         } else if (source.url !== void 0) {
@@ -8957,15 +10335,15 @@ ${code}`
               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 (err) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url} failed: ${err.message}` }) }] };
+          } 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 (err) {
-            return { content: [{ type: "text", text: JSON.stringify({ error: `base64 decode failed: ${err.message}` }) }] };
+          } catch (err2) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `base64 decode failed: ${err2.message}` }) }] };
           }
           sourceLabel = `base64(${bytes.length}B)`;
         }
@@ -9098,7 +10476,13 @@ var init_proxy_bridge_service = __esm({
             return;
           const body = await res.json();
           if (Array.isArray(body.instances)) {
+            const previousKeys = new Set(this.cachedInstances.map((instance) => `${instance.pluginSessionId}\0${instance.instanceId}\0${instance.role}\0${instance.connectedAt}`));
             this.cachedInstances = body.instances;
+            for (const instance of body.instances) {
+              const key = `${instance.pluginSessionId}\0${instance.instanceId}\0${instance.role}\0${instance.connectedAt}`;
+              if (!previousKeys.has(key))
+                this.notifyInstanceRegistered(toPublic(instance));
+            }
           }
         } catch {
         }
@@ -9158,12 +10542,12 @@ var init_proxy_bridge_service = __esm({
             throw new Error(result.error);
           }
           return result.response;
-        } catch (err) {
+        } catch (err2) {
           clearTimeout(timeoutId);
-          if (err.name === "AbortError") {
+          if (err2.name === "AbortError") {
             throw new Error("Proxy request timeout");
           }
-          throw err;
+          throw err2;
         }
       }
       cleanupOldRequests() {
@@ -10346,7 +11730,7 @@ var init_definitions = __esm({
       {
         name: "manage_instance",
         category: "write",
-        description: 'Launch, close, inspect, and find revisions for Studio instances. Use action="launch" with source="baseplate" for a blank place, or source="local_file" with local_place_file for a local place; neither uses place_id. Use action="list_place_versions" with place_id to retrieve version numbers through Open Cloud asset versions, then action="launch" with source="place_revision", place_id, and place_version to open an older revision. action="close" can close an MCP-managed instance or an explicitly connected edit instance by instance_id. action="launch" source="published_place" opens the latest published place and is blocked if that place_id is already connected; source="place_revision" is allowed because Studio opens explicit past revisions as anonymous local copies. Requires ROBLOX_OPEN_CLOUD_API_KEY with asset:read for list_place_versions.',
+        description: 'Launch, close, inspect, and find revisions for Studio instances. Every launch returns launch_id, native pid, source, and lifecycle state; status and close accept launch_id before the plugin connects and instance_id after association. Use action="launch" with source="baseplate" for a blank place, or source="local_file" with local_place_file for a local place; neither uses place_id. Use action="list_place_versions" with place_id to retrieve version numbers through Open Cloud asset versions, then action="launch" with source="place_revision", place_id, and place_version to open an older revision. action="launch" source="published_place" opens the latest published place and is blocked if that place_id is already connected; source="place_revision" is allowed because Studio opens explicit past revisions as anonymous local copies. Requires ROBLOX_OPEN_CLOUD_API_KEY with asset:read for list_place_versions.',
         inputSchema: {
           type: "object",
           properties: {
@@ -10374,11 +11758,11 @@ var init_definitions = __esm({
             },
             wait_for_connection: {
               type: "boolean",
-              description: 'For action="launch": wait until the MCP plugin connects and return instance_id (default true).'
+              description: 'For action="launch": wait until the MCP plugin connects and return instance_id (default true). false returns launch_id immediately and continues association/failure tracking asynchronously.'
             },
             timeout_ms: {
               type: "number",
-              description: 'For action="launch": max milliseconds to wait for plugin connection (default 120000).'
+              description: 'For action="launch": max milliseconds for plugin connection (default 120000). The deadline also applies asynchronously when wait_for_connection=false.'
             },
             max_page_size: {
               type: "number",
@@ -10390,7 +11774,11 @@ var init_definitions = __esm({
             },
             instance_id: {
               type: "string",
-              description: 'For action="close" or action="status": Studio instance to inspect or close. close accepts MCP-managed instances and explicitly connected edit instances.'
+              description: 'For action="close" or action="status": connected Studio instance to inspect or close. Mutually exclusive with launch_id.'
+            },
+            launch_id: {
+              type: "string",
+              description: 'For action="close" or action="status": opaque identifier returned by launch. Works before plugin connection and for retained terminal launch status. Mutually exclusive with instance_id.'
             }
           },
           required: ["action"]
@@ -11968,6 +13356,27 @@ part(0,2,0,2,1,1,"b")`,
           required: ["pattern", "replacement"]
         }
       },
+      // === Installed Studio Skills ===
+      {
+        name: "get_roblox_skills",
+        category: "read",
+        description: `List or retrieve Roblox-authored skills embedded in the locally installed Studio Assistant bundle. This reads the installed Assistant.rbxm directly, so it does not require a connected Studio place or Roblox's built-in MCP. Use action="list" to discover available names, then action="get" to retrieve the exact Markdown for one skill.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["list", "get"],
+              description: "List installed built-in skills or get one skill document."
+            },
+            name: {
+              type: "string",
+              description: 'Skill name returned by action="list". Required for action="get"; both canonical rbx-* and embedded source names are accepted.'
+            }
+          },
+          required: ["action"]
+        }
+      },
       // === Documentation ===
       {
         name: "get_roblox_docs",
@@ -12151,15 +13560,15 @@ part(0,2,0,2,1,1,"b")`,
 });
 
 // ../core/dist/install-plugin-helpers.js
-import { existsSync as existsSync5, readFileSync as readFileSync6, unlinkSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7, unlinkSync } from "fs";
 import { execSync } from "child_process";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { homedir as homedir5 } from "os";
 function isWSL() {
   if (process.platform !== "linux")
     return false;
   try {
-    const v = readFileSync6("/proc/version", "utf8");
+    const v = readFileSync7("/proc/version", "utf8");
     return /microsoft|wsl/i.test(v);
   } catch {
     return false;
@@ -12177,7 +13586,7 @@ function getWindowsUserPluginsDir() {
     }).toString().trim();
     if (!linuxPath)
       return null;
-    return join5(linuxPath, "Roblox", "Plugins");
+    return join6(linuxPath, "Roblox", "Plugins");
   } catch {
     return null;
   }
@@ -12186,7 +13595,7 @@ function getPluginsFolder() {
   if (process.env.MCP_PLUGINS_DIR)
     return process.env.MCP_PLUGINS_DIR;
   if (process.platform === "win32") {
-    return join5(process.env.LOCALAPPDATA || join5(homedir5(), "AppData", "Local"), "Roblox", "Plugins");
+    return join6(process.env.LOCALAPPDATA || join6(homedir5(), "AppData", "Local"), "Roblox", "Plugins");
   }
   if (isWSL()) {
     const win = getWindowsUserPluginsDir();
@@ -12194,18 +13603,18 @@ function getPluginsFolder() {
       return win;
     console.warn("[install-plugin] WSL detected but could not resolve Windows %LOCALAPPDATA%. Falling back to ~/Documents/Roblox/Plugins/ - you will likely need to copy the rbxmx to /mnt/c/Users/<you>/AppData/Local/Roblox/Plugins/ manually. Set MCP_PLUGINS_DIR to skip detection.");
   }
-  return join5(homedir5(), "Documents", "Roblox", "Plugins");
+  return join6(homedir5(), "Documents", "Roblox", "Plugins");
 }
 function handleVariantConflict({ pluginsFolder, otherAssetName, replace, log = console.log, warn = console.warn }) {
-  const otherDest = join5(pluginsFolder, otherAssetName);
-  if (!existsSync5(otherDest))
+  const otherDest = join6(pluginsFolder, otherAssetName);
+  if (!existsSync6(otherDest))
     return;
   if (replace) {
     try {
       unlinkSync(otherDest);
       log(`Removed conflicting ${otherAssetName}.`);
-    } catch (err) {
-      warn(`[install-plugin] Could not remove ${otherDest}: ${err}. Continuing.`);
+    } catch (err2) {
+      warn(`[install-plugin] Could not remove ${otherDest}: ${err2}. Continuing.`);
     }
     return;
   }
@@ -12234,6 +13643,7 @@ var init_dist = __esm({
     init_opencloud_client();
     init_install_plugin_helpers();
     init_roblox_cookie_client();
+    init_studio_skills();
   }
 });
 
@@ -12243,13 +13653,13 @@ __export(install_plugin_exports, {
   installBundledPlugin: () => installBundledPlugin,
   installPlugin: () => installPlugin
 });
-import { copyFileSync as copyFileSync2, createWriteStream, existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync7, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname4, join as join6 } from "path";
+import { copyFileSync as copyFileSync2, createWriteStream, existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync8, unlinkSync as unlinkSync2 } from "fs";
+import { dirname as dirname5, join as join7 } from "path";
 import { fileURLToPath } from "url";
 import { get } from "https";
 function httpsGet(url) {
-  return new Promise((resolve4, reject) => {
-    const req = get(url, { headers: { "User-Agent": "robloxstudio-mcp-inspector" } }, resolve4);
+  return new Promise((resolve5, reject) => {
+    const req = get(url, { headers: { "User-Agent": "robloxstudio-mcp-inspector" } }, resolve5);
     req.on("error", reject);
     req.setTimeout(TIMEOUT_MS, () => {
       req.destroy(new Error(`Request timed out after ${TIMEOUT_MS}ms`));
@@ -12267,21 +13677,21 @@ async function download(url, dest, redirects = 0) {
   if (res.statusCode !== 200) {
     throw new Error(`Download failed: HTTP ${res.statusCode}`);
   }
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const file = createWriteStream(dest);
-    const cleanup = (err) => {
+    const cleanup = (err2) => {
       file.close(() => {
         try {
           unlinkSync2(dest);
         } catch {
         }
-        reject(err);
+        reject(err2);
       });
     };
     res.pipe(file);
     file.on("finish", () => {
       file.close();
-      resolve4();
+      resolve5();
     });
     file.on("error", cleanup);
     res.on("error", cleanup);
@@ -12304,7 +13714,7 @@ function prepareInstall({
   warn
 }) {
   const pluginsFolder = getPluginsFolder();
-  if (!existsSync6(pluginsFolder)) {
+  if (!existsSync7(pluginsFolder)) {
     mkdirSync5(pluginsFolder, { recursive: true });
   }
   handleVariantConflict({
@@ -12317,23 +13727,23 @@ function prepareInstall({
   return pluginsFolder;
 }
 function bundledAssetPath() {
-  const currentDir = dirname4(fileURLToPath(import.meta.url));
+  const currentDir = dirname5(fileURLToPath(import.meta.url));
   const candidates = [
-    join6(currentDir, "..", "studio-plugin", ASSET_NAME),
-    join6(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
+    join7(currentDir, "..", "studio-plugin", ASSET_NAME),
+    join7(currentDir, "..", "..", "..", "studio-plugin", ASSET_NAME)
   ];
-  return candidates.find((candidate) => existsSync6(candidate)) ?? null;
+  return candidates.find((candidate) => existsSync7(candidate)) ?? null;
 }
 function packageVersion() {
-  const currentDir = dirname4(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync7(join6(currentDir, "..", "package.json"), "utf8"));
+  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");
   }
   return pkg.version;
 }
 function bundledPluginVersion(source) {
-  const match = readFileSync7(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
+  const match = readFileSync8(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
   return match ? match[1] : null;
 }
 function assertBundledPluginVersion(source) {
@@ -12346,9 +13756,9 @@ function assertBundledPluginVersion(source) {
   }
 }
 function filesMatch(a, b) {
-  if (!existsSync6(b)) return false;
-  const aBytes = readFileSync7(a);
-  const bBytes = readFileSync7(b);
+  if (!existsSync7(b)) return false;
+  const aBytes = readFileSync8(a);
+  const bBytes = readFileSync8(b);
   return aBytes.length === bBytes.length && aBytes.equals(bBytes);
 }
 async function installBundledPlugin(options = {}) {
@@ -12361,7 +13771,7 @@ async function installBundledPlugin(options = {}) {
   }
   assertBundledPluginVersion(source);
   const pluginsFolder = prepareInstall({ replaceVariant, log, warn });
-  const dest = join6(pluginsFolder, ASSET_NAME);
+  const dest = join7(pluginsFolder, ASSET_NAME);
   if (filesMatch(source, dest)) return;
   copyFileSync2(source, dest);
   log(`Installed ${ASSET_NAME} to ${dest}`);
@@ -12374,7 +13784,7 @@ async function installPlugin(options = {}) {
   const bundled = bundledAssetPath();
   if (bundled) {
     assertBundledPluginVersion(bundled);
-    const dest2 = join6(pluginsFolder, ASSET_NAME);
+    const dest2 = join7(pluginsFolder, ASSET_NAME);
     if (filesMatch(bundled, dest2)) {
       log(`${ASSET_NAME} already installed.`);
       return;
@@ -12389,7 +13799,7 @@ async function installPlugin(options = {}) {
   if (!asset) {
     throw new Error(`${ASSET_NAME} not found in release ${release.tag_name}`);
   }
-  const dest = join6(pluginsFolder, ASSET_NAME);
+  const dest = join7(pluginsFolder, ASSET_NAME);
   log(`Downloading ${ASSET_NAME} from ${release.tag_name}...`);
   await download(asset.browser_download_url, dest);
   log(`Installed to ${dest}`);
@@ -12412,8 +13822,8 @@ init_dist();
 import { createRequire } from "module";
 if (process.argv.includes("--install-plugin")) {
   const { installPlugin: installPlugin2 } = await Promise.resolve().then(() => (init_install_plugin(), install_plugin_exports));
-  await installPlugin2().catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
+  await installPlugin2().catch((err2) => {
+    console.error(err2 instanceof Error ? err2.message : String(err2));
     process.exitCode = 1;
   });
 } else {
@@ -12422,9 +13832,9 @@ if (process.argv.includes("--install-plugin")) {
     await installBundledPlugin2({
       log: (message) => console.error(`[install-plugin] ${message}`),
       warn: (message) => console.error(message)
-    }).catch((err) => {
+    }).catch((err2) => {
       console.error(
-        `[install-plugin] Auto-install skipped: ${err instanceof Error ? err.message : String(err)}`
+        `[install-plugin] Auto-install skipped: ${err2 instanceof Error ? err2.message : String(err2)}`
       );
     });
   }