conduit-mcp 2.0.0

package/dist/chunk-JDWBW44K.js

@@ -0,0 +1,2120 @@
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/bridge.ts
+import { EventEmitter } from "events";
+import http from "http";
+import { WebSocketServer, WebSocket } from "ws";
+
+// src/protocol.ts
+import { randomUUID } from "crypto";
+function generateId() {
+  return randomUUID().slice(0, 8);
+}
+function isHeartbeat(msg) {
+  return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "heartbeat";
+}
+function isStudioRegistration(msg) {
+  return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "register" && "studioId" in msg;
+}
+function isBridgeError(msg) {
+  return typeof msg === "object" && msg !== null && "id" in msg && "error" in msg;
+}
+function isBridgeResponse(msg) {
+  return typeof msg === "object" && msg !== null && "id" in msg && "result" in msg;
+}
+
+// src/utils/logger.ts
+var log = {
+  info: (...args) => console.error("[conduit]", ...args),
+  warn: (...args) => console.error("[conduit:warn]", ...args),
+  error: (...args) => console.error("[conduit:error]", ...args),
+  debug: (...args) => {
+    if (process.env.CONDUIT_DEBUG) {
+      console.error("[conduit:debug]", ...args);
+    }
+  }
+};
+
+// src/bridge.ts
+var REQUEST_TIMEOUT_MS = 3e4;
+var HEARTBEAT_CHECK_INTERVAL_MS = 5e3;
+var HEARTBEAT_TIMEOUT_MS = 15e3;
+var LONG_POLL_TIMEOUT_MS = 25e3;
+var MAX_PORT_RETRIES = 10;
+var Bridge = class extends EventEmitter {
+  constructor(port = 3200) {
+    super();
+    this.port = port;
+  }
+  port;
+  httpServer = null;
+  wsServer = null;
+  studios = /* @__PURE__ */ new Map();
+  activeStudioId = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  lastHeartbeats = /* @__PURE__ */ new Map();
+  heartbeatTimer = null;
+  actualPort = 0;
+  // HTTP-only studios (no WebSocket connection)
+  httpStudios = /* @__PURE__ */ new Map();
+  // Unregistered WebSocket connections waiting for a registration message
+  pendingWs = /* @__PURE__ */ new Set();
+  // HTTP fallback state (per-studio)
+  httpPendingCommands = /* @__PURE__ */ new Map();
+  httpPollWaiters = /* @__PURE__ */ new Map();
+  get isConnected() {
+    const studio = this.getActiveStudio();
+    return studio !== void 0 && studio.ws.readyState === WebSocket.OPEN;
+  }
+  get listeningPort() {
+    return this.actualPort;
+  }
+  // ── Public studio management ───────────────────────────────────
+  getStudios() {
+    const wsStudios = Array.from(this.studios.values()).map((s) => s.info);
+    const httpOnly = Array.from(this.httpStudios.values()).filter(
+      (s) => !this.studios.has(s.studioId)
+    );
+    return [...wsStudios, ...httpOnly];
+  }
+  getActiveStudioId() {
+    return this.activeStudioId;
+  }
+  setActiveStudio(studioId) {
+    if (!this.studios.has(studioId) && !this.httpStudios.has(studioId)) {
+      throw new Error(
+        `Studio "${studioId}" is not connected. Connected studios: ${this.getStudios().map((s) => s.studioId).join(", ") || "none"}`
+      );
+    }
+    this.activeStudioId = studioId;
+    log.info(`Active studio set to: ${studioId}`);
+  }
+  // ── Server lifecycle ───────────────────────────────────────────
+  async start() {
+    return new Promise((resolve, reject) => {
+      let attempts = 0;
+      const tryPort = (port) => {
+        const server = http.createServer(
+          (req, res) => this.handleHttp(req, res)
+        );
+        server.once("error", (err) => {
+          if (err.code === "EADDRINUSE" && attempts < MAX_PORT_RETRIES) {
+            attempts++;
+            tryPort(port + 1);
+          } else {
+            reject(err);
+          }
+        });
+        server.listen(port, "127.0.0.1", () => {
+          this.httpServer = server;
+          this.actualPort = port;
+          this.wsServer = new WebSocketServer({ server });
+          this.wsServer.on("connection", (ws) => this.handleWsConnection(ws));
+          log.info(`Bridge listening on 127.0.0.1:${port}`);
+          resolve(port);
+        });
+      };
+      tryPort(this.port);
+    });
+  }
+  async stop() {
+    for (const [id, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Bridge shutting down"));
+      this.pendingRequests.delete(id);
+    }
+    for (const [, studio] of this.studios) {
+      studio.ws.close();
+    }
+    this.studios.clear();
+    this.httpStudios.clear();
+    this.activeStudioId = null;
+    for (const ws of this.pendingWs) {
+      ws.close();
+    }
+    this.pendingWs.clear();
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    for (const [, waiters] of this.httpPollWaiters) {
+      for (const waiter of waiters) {
+        clearTimeout(waiter.timer);
+        waiter.res.writeHead(503);
+        waiter.res.end();
+      }
+    }
+    this.httpPollWaiters.clear();
+    this.httpPendingCommands.clear();
+    await new Promise((resolve) => {
+      if (this.wsServer) {
+        this.wsServer.close(() => {
+          this.wsServer = null;
+          if (this.httpServer) {
+            this.httpServer.close(() => {
+              this.httpServer = null;
+              resolve();
+            });
+          } else {
+            resolve();
+          }
+        });
+      } else if (this.httpServer) {
+        this.httpServer.close(() => {
+          this.httpServer = null;
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  async send(method, params) {
+    const id = generateId();
+    const request = { id, method, params };
+    const json = JSON.stringify(request);
+    const studio = this.resolveTargetStudio();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(
+          new Error(
+            `Request ${method} timed out after ${REQUEST_TIMEOUT_MS}ms \u2014 is the Conduit plugin running in Roblox Studio?`
+          )
+        );
+      }, REQUEST_TIMEOUT_MS);
+      this.pendingRequests.set(id, { resolve, reject, timer });
+      if (studio) {
+        studio.ws.send(json);
+      } else {
+        const studioId = this.activeStudioId ?? "_default";
+        const queue = this.httpPendingCommands.get(studioId) ?? [];
+        queue.push(request);
+        this.httpPendingCommands.set(studioId, queue);
+        this.flushHttpPollers(studioId);
+      }
+    });
+  }
+  // ── Internal helpers ───────────────────────────────────────────
+  getActiveStudio() {
+    if (this.activeStudioId) {
+      return this.studios.get(this.activeStudioId);
+    }
+    return void 0;
+  }
+  resolveTargetStudio() {
+    const active = this.getActiveStudio();
+    if (active && active.ws.readyState === WebSocket.OPEN) {
+      return active;
+    }
+    if (this.studios.size === 1) {
+      const [studioId, studio] = this.studios.entries().next().value;
+      if (studio.ws.readyState === WebSocket.OPEN) {
+        this.activeStudioId = studioId;
+        return studio;
+      }
+    }
+    if (this.studios.size === 0) {
+      return void 0;
+    }
+    throw new Error(
+      `Multiple Studio instances connected but none is active. Use set_active_studio to choose one. Connected: ${Array.from(
+        this.studios.values()
+      ).map((s) => `${s.info.studioId} (${s.info.placeName ?? "unknown"})`).join(", ")}`
+    );
+  }
+  // ── WebSocket handling ─────────────────────────────────────────
+  handleWsConnection(ws) {
+    log.info("New WebSocket connection \u2014 waiting for registration");
+    this.pendingWs.add(ws);
+    const onFirstMessage = (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (isStudioRegistration(msg)) {
+          ws.removeListener("message", onFirstMessage);
+          this.pendingWs.delete(ws);
+          this.registerStudio(ws, {
+            studioId: msg.studioId,
+            placeId: msg.placeId,
+            placeName: msg.placeName,
+            connectedAt: Date.now()
+          });
+          return;
+        }
+        ws.removeListener("message", onFirstMessage);
+        this.pendingWs.delete(ws);
+        const syntheticId = "studio-1";
+        log.info(
+          "Legacy plugin detected (no registration), assigning ID: " + syntheticId
+        );
+        this.registerStudio(ws, {
+          studioId: syntheticId,
+          connectedAt: Date.now()
+        });
+        this.handlePluginMessage(msg);
+      } catch (err) {
+        log.warn("Failed to parse first plugin message:", err);
+      }
+    };
+    ws.on("message", onFirstMessage);
+    ws.on("close", () => {
+      this.pendingWs.delete(ws);
+    });
+    ws.on("error", (err) => {
+      log.warn("WebSocket error:", err.message);
+    });
+  }
+  registerStudio(ws, info) {
+    const { studioId } = info;
+    const existing = this.studios.get(studioId);
+    if (existing) {
+      log.warn(`Studio "${studioId}" reconnected \u2014 closing old connection`);
+      existing.ws.close();
+    }
+    this.studios.set(studioId, { ws, info });
+    this.lastHeartbeats.set(studioId, Date.now());
+    if (this.activeStudioId === null) {
+      this.activeStudioId = studioId;
+    }
+    this.emit("studio-connected", info);
+    log.info(
+      `Studio registered: ${studioId}` + (info.placeName ? ` (${info.placeName})` : "")
+    );
+    this.startHeartbeatMonitor();
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (isHeartbeat(msg)) {
+          this.lastHeartbeats.set(studioId, Date.now());
+          return;
+        }
+        this.handlePluginMessage(msg);
+      } catch (err) {
+        log.warn("Failed to parse plugin message:", err);
+      }
+    });
+    ws.on("close", () => {
+      const current = this.studios.get(studioId);
+      if (current && current.ws === ws) {
+        this.studios.delete(studioId);
+        this.lastHeartbeats.delete(studioId);
+        this.emit("studio-disconnected", info);
+        log.info(`Studio disconnected: ${studioId}`);
+        if (this.activeStudioId === studioId) {
+          if (this.studios.size === 1) {
+            this.activeStudioId = this.studios.keys().next().value;
+            log.info(
+              `Auto-switched active studio to: ${this.activeStudioId}`
+            );
+          } else {
+            this.activeStudioId = null;
+          }
+        }
+        if (this.studios.size === 0) {
+          this.stopHeartbeatMonitor();
+        }
+      }
+    });
+  }
+  handlePluginMessage(msg) {
+    if (isBridgeResponse(msg)) {
+      const pending = this.pendingRequests.get(msg.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(msg.id);
+        pending.resolve(msg.result);
+      }
+      return;
+    }
+    if (isBridgeError(msg)) {
+      const pending = this.pendingRequests.get(msg.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(msg.id);
+        pending.reject(new Error(`${msg.error.code}: ${msg.error.message}`));
+      }
+      return;
+    }
+    log.debug("Unknown message from plugin:", msg);
+  }
+  startHeartbeatMonitor() {
+    if (this.heartbeatTimer) return;
+    this.heartbeatTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [studioId, lastBeat] of this.lastHeartbeats) {
+        if (now - lastBeat > HEARTBEAT_TIMEOUT_MS) {
+          const studio = this.studios.get(studioId);
+          if (studio) {
+            log.warn(
+              `Heartbeat timeout for studio "${studioId}" \u2014 disconnecting`
+            );
+            studio.ws.terminate();
+          } else if (this.httpStudios.has(studioId)) {
+            log.warn(
+              `Heartbeat timeout for HTTP studio "${studioId}" \u2014 evicting`
+            );
+            const info = this.httpStudios.get(studioId);
+            this.httpStudios.delete(studioId);
+            this.lastHeartbeats.delete(studioId);
+            this.emit("studio-disconnected", info);
+            if (this.activeStudioId === studioId) {
+              const remaining = this.getStudios();
+              this.activeStudioId = remaining.length > 0 ? remaining[0].studioId : null;
+            }
+          }
+        }
+      }
+    }, HEARTBEAT_CHECK_INTERVAL_MS);
+  }
+  stopHeartbeatMonitor() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  // ── HTTP fallback handling ─────────────────────────────────────
+  handleHttp(req, res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const parsedUrl = new URL(req.url ?? "/", `http://127.0.0.1`);
+    const pathname = parsedUrl.pathname;
+    if (req.method === "GET" && pathname === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          status: "ok",
+          connected: this.isConnected,
+          port: this.actualPort,
+          studios: this.getStudios()
+        })
+      );
+      return;
+    }
+    if (req.method === "GET" && pathname === "/poll") {
+      const studioId = parsedUrl.searchParams.get("studioId") ?? this.activeStudioId ?? "_default";
+      this.handlePoll(studioId, res);
+      return;
+    }
+    if (req.method === "POST" && pathname === "/result") {
+      this.handleResult(req, res);
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not found");
+  }
+  handlePoll(studioId, res) {
+    if (!this.studios.has(studioId) && studioId !== "_default") {
+      if (!this.httpStudios.has(studioId)) {
+        const info = {
+          studioId,
+          connectedAt: Date.now()
+        };
+        this.httpStudios.set(studioId, info);
+        this.emit("studio-connected", info);
+        log.info(`HTTP-only studio registered: ${studioId}`);
+      }
+      this.lastHeartbeats.set(studioId, Date.now());
+      if (this.activeStudioId === null) {
+        this.activeStudioId = studioId;
+      }
+    }
+    this.lastHeartbeats.set(studioId, Date.now());
+    const queue = this.httpPendingCommands.get(studioId) ?? [];
+    if (queue.length > 0) {
+      const cmd = queue.shift();
+      if (queue.length === 0) {
+        this.httpPendingCommands.delete(studioId);
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(cmd));
+      return;
+    }
+    if (studioId !== "_default") {
+      const defaultQueue = this.httpPendingCommands.get("_default") ?? [];
+      if (defaultQueue.length > 0) {
+        const cmd = defaultQueue.shift();
+        if (defaultQueue.length === 0) {
+          this.httpPendingCommands.delete("_default");
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(cmd));
+        return;
+      }
+    }
+    const timer = setTimeout(() => {
+      const waiters2 = this.httpPollWaiters.get(studioId);
+      if (waiters2) {
+        const idx = waiters2.findIndex((w) => w.res === res);
+        if (idx !== -1) waiters2.splice(idx, 1);
+        if (waiters2.length === 0) this.httpPollWaiters.delete(studioId);
+      }
+      res.writeHead(204);
+      res.end();
+    }, LONG_POLL_TIMEOUT_MS);
+    const waiters = this.httpPollWaiters.get(studioId) ?? [];
+    waiters.push({ res, timer });
+    this.httpPollWaiters.set(studioId, waiters);
+  }
+  handleResult(req, res) {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => {
+      try {
+        const msg = JSON.parse(body);
+        this.handlePluginMessage(msg);
+        res.writeHead(200);
+        res.end("ok");
+      } catch {
+        res.writeHead(400);
+        res.end("Invalid JSON");
+      }
+    });
+  }
+  flushHttpPollers(studioId) {
+    const waiters = this.httpPollWaiters.get(studioId) ?? [];
+    const queue = this.httpPendingCommands.get(studioId) ?? [];
+    while (waiters.length > 0 && queue.length > 0) {
+      const waiter = waiters.shift();
+      const cmd = queue.shift();
+      clearTimeout(waiter.timer);
+      waiter.res.writeHead(200, { "Content-Type": "application/json" });
+      waiter.res.end(JSON.stringify(cmd));
+    }
+    if (waiters.length === 0) this.httpPollWaiters.delete(studioId);
+    if (queue.length === 0) this.httpPendingCommands.delete(studioId);
+  }
+};
+
+// src/tools/explore.ts
+import { z } from "zod";
+
+// src/utils/tokens.ts
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function truncateToTokenBudget(text, budget) {
+  const maxChars = budget * CHARS_PER_TOKEN;
+  if (text.length <= maxChars) {
+    return { text, truncated: false };
+  }
+  const totalEstimate = estimateTokens(text);
+  const truncated = text.slice(0, maxChars);
+  const lastNewline = truncated.lastIndexOf("\n");
+  const cleanCut = lastNewline > maxChars * 0.8 ? truncated.slice(0, lastNewline) : truncated;
+  return {
+    text: cleanCut + `
+
+---
+*Truncated \u2014 showing ~${budget} of ~${totalEstimate} tokens. Narrow your query with filter, depth, or lineRange.*`,
+    truncated: true
+  };
+}
+
+// src/utils/formatting.ts
+var DEFAULT_TOKEN_BUDGET = 4e3;
+function formatTree(data, depth = 0, indent = "") {
+  let line = `${indent}- **${data.name}** \`${data.className}\``;
+  if (data.properties && Object.keys(data.properties).length > 0) {
+    const props = Object.entries(data.properties).map(([k, v]) => `${k}=${formatValue(v)}`).join(", ");
+    line += ` (${props})`;
+  }
+  let result = line + "\n";
+  if (data.children && depth > 0) {
+    for (const child of data.children) {
+      result += formatTree(child, depth - 1, indent + "  ");
+    }
+  } else {
+    const count = data.children?.length ?? data.childCount ?? 0;
+    if (count > 0) {
+      result += `${indent}  *\u2026 ${count} children*
+`;
+    }
+  }
+  return result;
+}
+function formatInstanceList(instances) {
+  if (instances.length === 0) return "*No instances found.*";
+  return instances.map((i) => `- **${i.path}** \`${i.className}\``).join("\n");
+}
+function formatScript(source, path) {
+  return `### ${path}
+\`\`\`lua
+${source}
+\`\`\``;
+}
+function applyTokenBudget(text, maxTokens) {
+  const budget = maxTokens ?? DEFAULT_TOKEN_BUDGET;
+  const { text: result } = truncateToTokenBudget(text, budget);
+  return result;
+}
+function formatValue(v) {
+  if (v === null || v === void 0) return "nil";
+  if (typeof v === "string") return `"${v}"`;
+  if (typeof v === "object") {
+    const obj = v;
+    if (obj.Type) return `${obj.Type}(\u2026)`;
+    return JSON.stringify(v);
+  }
+  return String(v);
+}
+
+// src/tools/explore.ts
+function register(server, bridge) {
+  server.registerTool(
+    "explore",
+    {
+      title: "Explore Instance Tree",
+      description: "Browse the Roblox instance hierarchy, get/set the current selection, or list top-level services.\n\nActions:\n- `tree` (default): Browse DataModel tree from a root path with depth, filter, and property options.\n- `get_selection`: Return the currently selected instances in Studio.\n- `set_selection`: Select specific instances in Studio by path.\n- `services`: List all top-level game services.\n- `state`: Get current Studio state (playtest status, place info, undo availability).",
+      inputSchema: z.object({
+        action: z.enum(["tree", "get_selection", "set_selection", "services", "state"]).default("tree").describe("Action to perform"),
+        path: z.string().default("game").describe("Root path to explore (for 'tree' action)"),
+        depth: z.number().int().min(0).max(10).default(2).describe("How many levels deep to recurse (for 'tree' action)"),
+        filter: z.string().optional().describe("Only include instances whose ClassName matches (for 'tree' action)"),
+        includeProperties: z.boolean().default(false).describe("Include property values in output (for 'tree' action)"),
+        paths: z.array(z.string()).optional().describe("Instance paths to select (for 'set_selection' action)"),
+        maxTokens: z.number().optional().describe("Maximum token budget for the response")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      if (params.action === "get_selection") {
+        const result2 = await bridge.send("get_selection", {});
+        const text2 = formatInstanceList(result2.selection);
+        return {
+          content: [
+            { type: "text", text: applyTokenBudget(text2, params.maxTokens) }
+          ]
+        };
+      }
+      if (params.action === "set_selection") {
+        if (!params.paths || params.paths.length === 0) {
+          return {
+            content: [
+              { type: "text", text: "set_selection requires a non-empty `paths` array." }
+            ]
+          };
+        }
+        const result2 = await bridge.send("set_selection", {
+          paths: params.paths
+        });
+        return {
+          content: [
+            { type: "text", text: `Selected ${result2.selected} instance(s).` }
+          ]
+        };
+      }
+      if (params.action === "services") {
+        const result2 = await bridge.send("get_services", {});
+        const text2 = result2.services.length === 0 ? "*No services found.*" : result2.services.map((s) => `- **${s.name}** \`${s.className}\``).join("\n");
+        return {
+          content: [
+            { type: "text", text: applyTokenBudget(text2, params.maxTokens) }
+          ]
+        };
+      }
+      if (params.action === "state") {
+        const result2 = await bridge.send("get_studio_state", {});
+        let mode = "Edit";
+        if (result2.isRunning) {
+          if (result2.isClient) mode = "Playtest (Client)";
+          else if (result2.isServer) mode = "Playtest (Server)";
+          else mode = "Running";
+        }
+        const lines = [
+          "### Studio State",
+          `- **Mode:** ${mode}`,
+          `- **Place ID:** ${result2.placeId}${result2.placeName ? ` \u2014 ${result2.placeName}` : ""}`,
+          `- **Game ID:** ${result2.gameId}`
+        ];
+        if (result2.canUndo !== void 0) {
+          lines.push(`- **Can Undo:** ${result2.canUndo ? "Yes" : "No"}`);
+        }
+        if (result2.canRedo !== void 0) {
+          lines.push(`- **Can Redo:** ${result2.canRedo ? "Yes" : "No"}`);
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      }
+      const result = await bridge.send("explore", {
+        path: params.path,
+        depth: params.depth,
+        filter: params.filter,
+        includeProperties: params.includeProperties
+      });
+      const text = formatTree(result, params.depth);
+      return {
+        content: [
+          { type: "text", text: applyTokenBudget(text, params.maxTokens) }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "get_info",
+    {
+      title: "Get Instance Info",
+      description: "Get detailed information about a single instance: class, parent, children count, properties, attributes, tags, and optionally a typed property list \u2014 all in one call.",
+      inputSchema: z.object({
+        path: z.string().describe("Path to the instance, e.g. 'game.Workspace.Part'"),
+        includeProperties: z.boolean().default(true).describe("Include property values"),
+        includeAttributes: z.boolean().default(true).describe("Include custom attributes"),
+        includeTags: z.boolean().default(true).describe("Include CollectionService tags"),
+        includePropertyList: z.boolean().default(false).describe("Include a typed list of all discoverable properties with types and values"),
+        propertyFilter: z.string().optional().describe("Filter property names by substring match (for property list)"),
+        maxTokens: z.number().optional().describe("Maximum token budget for the response")
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      const result = await bridge.send("get_info", {
+        path: params.path,
+        includeProperties: params.includeProperties,
+        includeAttributes: params.includeAttributes,
+        includeTags: params.includeTags,
+        includePropertyList: params.includePropertyList,
+        propertyFilter: params.propertyFilter
+      });
+      const lines = [
+        `### ${result.name} \`${result.className}\``,
+        `- **Path:** \`${result.path}\``,
+        `- **Parent:** ${result.parent ? `\`${result.parent}\`` : "none"}`,
+        `- **Children:** ${result.childCount}`
+      ];
+      if (result.tags && result.tags.length > 0) {
+        lines.push(`- **Tags:** ${result.tags.join(", ")}`);
+      }
+      if (result.attributes && Object.keys(result.attributes).length > 0) {
+        lines.push("", "**Attributes:**");
+        for (const [k, v] of Object.entries(result.attributes)) {
+          lines.push(`- ${k} = \`${JSON.stringify(v)}\``);
+        }
+      }
+      if (result.properties && Object.keys(result.properties).length > 0) {
+        lines.push("", "**Properties:**");
+        for (const [k, v] of Object.entries(result.properties)) {
+          lines.push(`- ${k} = \`${JSON.stringify(v)}\``);
+        }
+      }
+      if (result.propertyList && result.propertyList.length > 0) {
+        lines.push("", "**Property List:**");
+        for (const p of result.propertyList) {
+          lines.push(`- **${p.name}** \`${p.type}\` = \`${JSON.stringify(p.value)}\``);
+        }
+      }
+      const text = lines.join("\n");
+      return {
+        content: [
+          { type: "text", text: applyTokenBudget(text, params.maxTokens) }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/instances.ts
+import { z as z2 } from "zod";
+function registerReadOnly(server, bridge) {
+  registerQuery(server, bridge);
+}
+function register2(server, bridge) {
+  registerQuery(server, bridge);
+  registerWrite(server, bridge);
+}
+function registerQuery(server, bridge) {
+  server.registerTool(
+    "query",
+    {
+      title: "Query Instances & Scripts",
+      description: "Find instances or search script source code.\n\nActions:\n- `instances` (default): Find instances by class, tag, attribute, or name pattern.\n- `scripts`: Search across all script sources for a text pattern (grep).",
+      inputSchema: z2.object({
+        action: z2.enum(["instances", "scripts"]).default("instances").describe("Query mode"),
+        // Instance query params
+        basePath: z2.string().default("game").describe("Root path to search from"),
+        filters: z2.object({
+          className: z2.string().optional().describe("Only include instances of this class"),
+          tag: z2.string().optional().describe("Only include instances with this tag"),
+          attribute: z2.object({
+            name: z2.string().describe("Attribute name"),
+            value: z2.unknown().optional().describe("Required attribute value")
+          }).optional().describe("Filter by attribute"),
+          namePattern: z2.string().optional().describe("Lua pattern to match against instance Name")
+        }).optional().describe("Filters for instance query (AND-combined)"),
+        limit: z2.number().int().default(50).describe("Max results"),
+        // Script grep params
+        pattern: z2.string().optional().describe("Text pattern to search for (for 'scripts' action)"),
+        caseSensitive: z2.boolean().default(false).describe("Case-sensitive search (for 'scripts' action)"),
+        contextLines: z2.number().int().default(1).describe("Lines of context around each match (for 'scripts' action)"),
+        maxTokens: z2.number().optional().describe("Maximum token budget for the response")
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      if (params.action === "scripts") {
+        if (!params.pattern) {
+          return {
+            content: [{ type: "text", text: "scripts action requires a `pattern` parameter." }]
+          };
+        }
+        const result2 = await bridge.send("grep_scripts", {
+          basePath: params.basePath,
+          pattern: params.pattern,
+          caseSensitive: params.caseSensitive,
+          contextLines: params.contextLines,
+          limit: params.limit
+        });
+        if (result2.results.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `*No matches found for "${params.pattern}" across ${result2.scriptsSearched} scripts.*`
+              }
+            ]
+          };
+        }
+        const lines = result2.results.map(
+          (r) => `- \`${r.scriptPath}:${r.lineNumber}\`: ${r.line.trim()}`
+        );
+        let text2 = lines.join("\n");
+        if (result2.totalMatches > result2.results.length) {
+          text2 += `
+
+*Showing ${result2.results.length} of ${result2.totalMatches} matches across ${result2.scriptsSearched} scripts.*`;
+        } else {
+          text2 += `
+
+*${result2.totalMatches} match(es) across ${result2.scriptsSearched} scripts.*`;
+        }
+        return {
+          content: [
+            { type: "text", text: applyTokenBudget(text2, params.maxTokens) }
+          ]
+        };
+      }
+      const result = await bridge.send("query_instances", {
+        basePath: params.basePath,
+        filters: params.filters ?? {},
+        limit: params.limit
+      });
+      let text;
+      if (result.results.length === 0) {
+        text = "*No instances matched the query.*";
+      } else {
+        const lines = result.results.map(
+          (r) => `- \`${r.path}\` (${r.className})`
+        );
+        text = lines.join("\n");
+        if (result.total > result.results.length) {
+          text += `
+
+*Showing ${result.results.length} of ${result.total} matches \u2014 increase limit or narrow filters.*`;
+        }
+      }
+      return {
+        content: [
+          { type: "text", text: applyTokenBudget(text, params.maxTokens) }
+        ]
+      };
+    }
+  );
+}
+function registerWrite(server, bridge) {
+  server.registerTool(
+    "create",
+    {
+      title: "Create or Clone Instances",
+      description: "Create new instances or clone existing ones.\n\nActions:\n- `new` (default): Create instances with className, parent, name, and properties.\n- `clone`: Clone existing instances to a target parent.",
+      inputSchema: z2.object({
+        action: z2.enum(["new", "clone"]).default("new").describe("Create mode"),
+        // For 'new' action
+        operations: z2.array(
+          z2.object({
+            className: z2.string().describe("Roblox class, e.g. 'Part'"),
+            parent: z2.string().describe("Parent path, e.g. 'game.Workspace'"),
+            name: z2.string().describe("Instance name"),
+            properties: z2.record(z2.unknown()).optional().describe("Initial properties")
+          })
+        ).optional().describe("Instances to create (for 'new' action)"),
+        // For 'clone' action
+        sources: z2.array(z2.string()).optional().describe("Paths of instances to clone (for 'clone' action)"),
+        targetParent: z2.string().optional().describe("Parent to place clones under (for 'clone' action)")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      if (params.action === "clone") {
+        if (!params.sources || params.sources.length === 0) {
+          return { content: [{ type: "text", text: "clone action requires a non-empty `sources` array." }] };
+        }
+        if (!params.targetParent) {
+          return { content: [{ type: "text", text: "clone action requires a `targetParent`." }] };
+        }
+        const result2 = await bridge.send("clone_instances", {
+          sources: params.sources,
+          targetParent: params.targetParent
+        });
+        const text2 = result2.cloned.map((r) => `- \`${r.path}\` (${r.className})`).join("\n");
+        return { content: [{ type: "text", text: text2 }] };
+      }
+      if (!params.operations || params.operations.length === 0) {
+        return { content: [{ type: "text", text: "new action requires a non-empty `operations` array." }] };
+      }
+      const result = await bridge.send("create_instances", {
+        operations: params.operations
+      });
+      const text = result.created.map((r) => `- \`${r.path}\` (${r.className})`).join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.registerTool(
+    "modify",
+    {
+      title: "Modify Instances",
+      description: "Modify existing instances.\n\nModes:\n- `targeted` (default): Per-instance modifications with properties, attributes, tags, name, parent.\n- `bulk`: Set one property to the same value across many instances.",
+      inputSchema: z2.object({
+        mode: z2.enum(["targeted", "bulk"]).default("targeted").describe("Modification mode"),
+        // For 'targeted' mode
+        operations: z2.array(
+          z2.object({
+            path: z2.string().describe("Path to instance"),
+            properties: z2.record(z2.unknown()).optional().describe("Properties to set"),
+            attributes: z2.record(z2.unknown()).optional().describe("Attributes to set"),
+            tags: z2.object({
+              add: z2.array(z2.string()).optional().describe("Tags to add"),
+              remove: z2.array(z2.string()).optional().describe("Tags to remove")
+            }).optional().describe("Tag modifications"),
+            name: z2.string().optional().describe("New name"),
+            parent: z2.string().optional().describe("New parent path")
+          })
+        ).optional().describe("Per-instance modifications (for 'targeted' mode)"),
+        // For 'bulk' mode
+        paths: z2.array(z2.string()).optional().describe("Instance paths (for 'bulk' mode)"),
+        property: z2.string().optional().describe("Property name (for 'bulk' mode)"),
+        value: z2.unknown().optional().describe("Property value (for 'bulk' mode)"),
+        strict: z2.boolean().default(false).describe("If true, any single failure rolls back the entire batch (for 'bulk' mode)")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      if (params.mode === "bulk") {
+        if (!params.paths || params.paths.length === 0) {
+          return { content: [{ type: "text", text: "bulk mode requires a non-empty `paths` array." }] };
+        }
+        if (!params.property) {
+          return { content: [{ type: "text", text: "bulk mode requires a `property` name." }] };
+        }
+        const result2 = await bridge.send("batch_modify", {
+          paths: params.paths,
+          property: params.property,
+          value: params.value,
+          strict: params.strict
+        });
+        let text2 = `Modified **${params.property}** on ${result2.modified} instance(s).`;
+        if (result2.failed.length > 0) {
+          text2 += "\n\nFailed:\n" + result2.failed.map((f) => `- \`${f.path}\`: ${f.error}`).join("\n");
+        }
+        return { content: [{ type: "text", text: text2 }] };
+      }
+      if (!params.operations || params.operations.length === 0) {
+        return { content: [{ type: "text", text: "targeted mode requires a non-empty `operations` array." }] };
+      }
+      const result = await bridge.send("modify_instances", {
+        operations: params.operations
+      });
+      const text = result.modified.map((r) => `- \`${r.path}\` \u2014 modified: ${r.modified.join(", ")}`).join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.registerTool(
+    "delete",
+    {
+      title: "Delete Instances",
+      description: "Permanently delete one or more instances by path. Destructive \u2014 use undo_redo to revert.",
+      inputSchema: z2.object({
+        paths: z2.array(z2.string()).describe("Paths of instances to delete")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      const result = await bridge.send("delete_instances", {
+        paths: params.paths
+      });
+      const text = result.deleted.map((p) => `- \`${p}\` \u2014 deleted`).join("\n");
+      return { content: [{ type: "text", text }] };
+    }
+  );
+}
+
+// src/tools/scripts.ts
+import { z as z3 } from "zod";
+function registerReadOnly2(server, bridge) {
+  registerReadScript(server, bridge);
+}
+function register3(server, bridge) {
+  registerReadScript(server, bridge);
+  registerWriteTools(server, bridge);
+}
+function registerReadScript(server, bridge) {
+  server.registerTool(
+    "read_script",
+    {
+      title: "Read Script Source",
+      description: "Read the Lua source code of a script instance. Optionally restrict to a line range.",
+      inputSchema: z3.object({
+        path: z3.string().describe("Path to the script instance"),
+        lineRange: z3.object({
+          start: z3.number().int().min(1).describe("Start line (1-based)"),
+          end: z3.number().int().min(1).describe("End line (1-based, inclusive)")
+        }).optional().describe("Optional line range to read"),
+        maxTokens: z3.number().optional().describe("Maximum token budget for the response")
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      const result = await bridge.send("read_script", {
+        path: params.path,
+        lineRange: params.lineRange
+      });
+      const text = formatScript(result.source, params.path);
+      return {
+        content: [
+          { type: "text", text: applyTokenBudget(text, params.maxTokens) }
+        ]
+      };
+    }
+  );
+}
+function registerWriteTools(server, bridge) {
+  server.registerTool(
+    "edit_script",
+    {
+      title: "Edit Script Source",
+      description: "Edit the Lua source code of a script. Supports four modes: 'full' replaces the entire source, 'range' replaces specific line/column ranges, 'find_replace' does text find-and-replace on one script, and 'multi_replace' does find-and-replace across multiple scripts in one undoable operation.",
+      inputSchema: z3.object({
+        path: z3.string().describe("Path to the script instance"),
+        mode: z3.enum(["full", "range", "find_replace", "multi_replace"]).describe("Edit mode: full, range, find_replace, or multi_replace"),
+        source: z3.string().optional().describe("Complete new source (for 'full' mode)"),
+        edits: z3.array(
+          z3.object({
+            startLine: z3.number().int().describe("Start line (1-based)"),
+            startColumn: z3.number().int().describe("Start column (1-based)"),
+            endLine: z3.number().int().describe("End line (1-based)"),
+            endColumn: z3.number().int().describe("End column (1-based)"),
+            text: z3.string().describe("Replacement text")
+          })
+        ).optional().describe("Range edits (for 'range' mode)"),
+        find: z3.string().optional().describe("Text or pattern to find (for 'find_replace' mode)"),
+        replace: z3.string().optional().describe("Replacement text (for 'find_replace' mode)"),
+        regex: z3.boolean().optional().describe("Treat 'find' as a Lua pattern (for 'find_replace' and 'multi_replace' modes)"),
+        scripts: z3.array(z3.string()).optional().describe("Array of script paths to apply find/replace across (for 'multi_replace' mode)")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      if (params.mode === "multi_replace") {
+        if (!params.scripts || params.scripts.length === 0) {
+          return { content: [{ type: "text", text: "multi_replace mode requires a non-empty `scripts` array." }] };
+        }
+        if (!params.find) {
+          return { content: [{ type: "text", text: "multi_replace mode requires a `find` parameter." }] };
+        }
+        const result2 = await bridge.send("multi_replace_scripts", {
+          scripts: params.scripts,
+          find: params.find,
+          replace: params.replace ?? "",
+          regex: params.regex
+        });
+        const lines = [
+          `**Multi-script find/replace** \u2014 ${result2.totalReplacements} replacements across ${result2.scriptsModified} script(s)`,
+          ""
+        ];
+        for (const r of result2.results) {
+          lines.push(`- \`${r.path}\`: ${r.replacements} replacement(s)`);
+        }
+        if (result2.errors && result2.errors.length > 0) {
+          lines.push("", "**Errors:**");
+          for (const e of result2.errors) {
+            lines.push(`- \`${e.path}\`: ${e.error}`);
+          }
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      }
+      const result = await bridge.send("edit_script", {
+        path: params.path,
+        mode: params.mode,
+        source: params.source,
+        edits: params.edits,
+        find: params.find,
+        replace: params.replace,
+        regex: params.regex
+      });
+      let detail = `mode=${result.mode}, ${result.totalLines} total lines`;
+      if (result.appliedEdits !== void 0) {
+        detail += `, ${result.appliedEdits} edits applied`;
+      }
+      if (result.replacements !== void 0) {
+        detail += `, ${result.replacements} replacements`;
+      }
+      const text = `Script **${params.path}** updated (${detail}).`;
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.registerTool(
+    "execute_lua",
+    {
+      title: "Execute Luau Code",
+      description: "Run arbitrary Luau code in the Studio plugin context (edit mode \u2014 no active playtest required). Use this as an escape hatch for any operation the other tools don't cover. Has access to all Studio APIs and services.",
+      inputSchema: z3.object({
+        code: z3.string().describe("Luau code to execute"),
+        maxTokens: z3.number().optional().describe("Maximum token budget for the response")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (params) => {
+      const result = await bridge.send("execute_lua", {
+        code: params.code
+      });
+      const lines = [];
+      if (result.error) {
+        lines.push(`**Error:** ${result.error}`);
+      }
+      if (result.result) {
+        lines.push(`**Return value:** ${result.result}`);
+      }
+      if (result.output && result.output.length > 0) {
+        const outputText = result.output.map((o) => `[${o.messageType}] ${o.message}`).join("\n");
+        lines.push(`**Output:**
+\`\`\`
+${outputText}
+\`\`\``);
+      }
+      const text = lines.length > 0 ? lines.join("\n\n") : `Execution completed (${result.status})`;
+      return {
+        content: [
+          { type: "text", text: applyTokenBudget(text, params.maxTokens) }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/playtest.ts
+import { z as z4 } from "zod";
+function register4(server, bridge) {
+  server.registerTool(
+    "playtest",
+    {
+      title: "Playtest Control & Virtual Input",
+      description: "Control Roblox Studio playtesting and simulate user input.\n\nActions:\n- `start`: Begin a playtest session.\n- `stop`: End the current playtest.\n- `execute`: Run Lua code in the running game context.\n- `get_output`: Get console/log output from Studio (works in edit mode and during playtest).\n- `inspect`: Evaluate a Luau expression and return the typed result (requires active playtest).\n- `navigate`: Walk the player character to a position using PathfindingService (requires client playtest).\n- `mouse_click`: Simulate a mouse click at screen coordinates.\n- `mouse_move`: Move the virtual mouse to screen coordinates.\n- `key_press`: Press and release a key.\n- `key_down`: Hold a key down.\n- `key_up`: Release a held key.",
+      inputSchema: z4.object({
+        action: z4.enum(["start", "stop", "execute", "get_output", "inspect", "navigate", "mouse_click", "mouse_move", "key_press", "key_down", "key_up"]).describe("Playtest action"),
+        code: z4.string().optional().describe("Lua code to execute (for 'execute' action)"),
+        // get_output params
+        messageTypes: z4.array(z4.string()).optional().describe("Filter by message types: 'MessageOutput', 'MessageWarning', 'MessageError', 'MessageInfo' (for 'get_output')"),
+        since: z4.number().optional().describe("Only return logs with timestamp >= this value (for 'get_output')"),
+        limit: z4.number().optional().describe("Maximum number of log entries to return (for 'get_output')"),
+        // inspect params
+        expression: z4.string().optional().describe("Luau expression to evaluate, e.g. 'game.Players.Player1.Character.Humanoid.Health' (for 'inspect')"),
+        // navigate params
+        target: z4.object({
+          x: z4.number(),
+          y: z4.number(),
+          z: z4.number()
+        }).optional().describe("Target position to navigate to (for 'navigate')"),
+        targetPath: z4.string().optional().describe("Instance path to navigate to \u2014 uses its Position (for 'navigate')"),
+        timeout: z4.number().optional().describe("Navigation timeout in seconds, default 15 (for 'navigate')"),
+        // Virtual input params
+        x: z4.number().optional().describe("Screen X coordinate (for mouse actions)"),
+        y: z4.number().optional().describe("Screen Y coordinate (for mouse actions)"),
+        button: z4.enum(["Left", "Right", "Middle"]).default("Left").describe("Mouse button (for 'mouse_click')"),
+        key: z4.string().optional().describe("Key name matching Enum.KeyCode, e.g. 'W', 'Space', 'Return' (for key actions)")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (params) => {
+      if (params.action === "get_output") {
+        const result2 = await bridge.send("get_log_output", {
+          messageTypes: params.messageTypes,
+          since: params.since,
+          limit: params.limit
+        });
+        if (result2.logs.length === 0) {
+          return { content: [{ type: "text", text: "No log output found." }] };
+        }
+        const header = `**Console Output** (${result2.logs.length}${result2.logs.length < result2.total ? ` of ${result2.total}` : ""} entries)`;
+        const logText = result2.logs.map((l) => `[${l.messageType}] ${l.message}`).join("\n");
+        const text2 = `${header}
+
+\`\`\`
+${logText}
+\`\`\``;
+        return {
+          content: [{ type: "text", text: applyTokenBudget(text2, void 0) }]
+        };
+      }
+      if (params.action === "inspect") {
+        if (!params.expression) {
+          return {
+            content: [{ type: "text", text: "inspect action requires an `expression` parameter." }]
+          };
+        }
+        const result2 = await bridge.send("playtest_inspect", {
+          expression: params.expression
+        });
+        const valueStr = typeof result2.value === "object" ? JSON.stringify(result2.value, null, 2) : String(result2.value);
+        const text2 = `**Expression:** \`${result2.expression}\`
+**Type:** \`${result2.type}\`
+**Value:** ${valueStr}`;
+        return { content: [{ type: "text", text: text2 }] };
+      }
+      if (params.action === "navigate") {
+        if (!params.target && !params.targetPath) {
+          return {
+            content: [{ type: "text", text: "navigate action requires either `target` or `targetPath`." }]
+          };
+        }
+        const result2 = await bridge.send("playtest_navigate", {
+          target: params.target,
+          targetPath: params.targetPath,
+          timeout: params.timeout
+        });
+        const posStr = result2.position ? `(${result2.position.x.toFixed(1)}, ${result2.position.y.toFixed(1)}, ${result2.position.z.toFixed(1)})` : "unknown";
+        const text2 = `**Navigation:** ${result2.status}
+**Final position:** ${posStr}${result2.message ? `
+${result2.message}` : ""}`;
+        return { content: [{ type: "text", text: text2 }] };
+      }
+      if (params.action === "mouse_click" || params.action === "mouse_move" || params.action === "key_press" || params.action === "key_down" || params.action === "key_up") {
+        const result2 = await bridge.send("virtual_input", {
+          action: params.action,
+          x: params.x,
+          y: params.y,
+          button: params.button,
+          key: params.key
+        });
+        return {
+          content: [
+            { type: "text", text: result2.message ?? `Virtual input ${params.action}: ${result2.status}` }
+          ]
+        };
+      }
+      const result = await bridge.send("playtest", {
+        action: params.action,
+        code: params.code
+      });
+      let text;
+      if (params.action === "execute") {
+        const lines = [];
+        if (result.error) {
+          lines.push(`**Error:** ${result.error}`);
+        }
+        if (result.result) {
+          lines.push(`**Return value:** ${result.result}`);
+        }
+        if (result.output && result.output.length > 0) {
+          const outputText = result.output.map((o) => `[${o.messageType}] ${o.message}`).join("\n");
+          lines.push(`**Output:**
+\`\`\`
+${outputText}
+\`\`\``);
+        }
+        text = lines.length > 0 ? lines.join("\n\n") : `Execution completed (${result.status})`;
+        text = applyTokenBudget(text, void 0);
+      } else {
+        text = `Playtest ${params.action}: ${result.status}`;
+      }
+      return { content: [{ type: "text", text }] };
+    }
+  );
+}
+
+// src/tools/environment.ts
+import { z as z5 } from "zod";
+var Vector3Schema = z5.object({
+  X: z5.number().describe("X coordinate"),
+  Y: z5.number().describe("Y coordinate"),
+  Z: z5.number().describe("Z coordinate")
+});
+var RegionSchema = z5.object({
+  min: Vector3Schema.describe("Minimum corner of the region"),
+  max: Vector3Schema.describe("Maximum corner of the region")
+});
+function register5(server, bridge) {
+  server.registerTool(
+    "environment",
+    {
+      title: "Environment & Terrain",
+      description: "Manage terrain and workspace/lighting settings.\n\nActions:\n- `terrain_fill`: Fill a region with a material.\n- `terrain_clear`: Clear terrain in a region (or all).\n- `terrain_read`: Read terrain data in a region.\n- `settings_get`: Get Workspace and Lighting properties.\n- `settings_set`: Set Workspace and Lighting properties.",
+      inputSchema: z5.object({
+        action: z5.enum(["terrain_fill", "terrain_clear", "terrain_read", "settings_get", "settings_set"]).describe("Environment action"),
+        // Terrain params
+        region: RegionSchema.optional().describe("Region for terrain operations"),
+        material: z5.string().optional().describe("Terrain material name (for 'terrain_fill'), e.g. 'Grass'"),
+        size: Vector3Schema.optional().describe("Size override for terrain fill"),
+        // Settings params
+        settings: z5.record(z5.unknown()).optional().describe("Settings to set (for 'settings_set'). Keys: 'Workspace.Gravity', 'Lighting.ClockTime', etc.")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      if (params.action === "settings_get") {
+        const result2 = await bridge.send("workspace_settings", {
+          action: "get"
+        });
+        const lines = ["**Current Settings:**", ""];
+        for (const [k, v] of Object.entries(result2.settings)) {
+          lines.push(`- **${k}** = \`${JSON.stringify(v)}\``);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      }
+      if (params.action === "settings_set") {
+        if (!params.settings) {
+          return { content: [{ type: "text", text: "settings_set requires a `settings` object." }] };
+        }
+        const result2 = await bridge.send("workspace_settings", {
+          action: "set",
+          settings: params.settings
+        });
+        const text2 = `Updated ${result2.modified?.length ?? 0} setting(s): ${result2.modified?.join(", ") ?? "none"}`;
+        return { content: [{ type: "text", text: text2 }] };
+      }
+      const terrainAction = params.action.replace("terrain_", "");
+      const result = await bridge.send("terrain", {
+        action: terrainAction,
+        region: params.region,
+        material: params.material,
+        size: params.size
+      });
+      let text;
+      if (terrainAction === "read" && result.materials) {
+        const data = {
+          region: result.region,
+          resolution: result.resolution,
+          totalVoxels: result.totalVoxels,
+          filledVoxels: result.filledVoxels,
+          materials: result.materials
+        };
+        text = `**Terrain data:**
+\`\`\`json
+${JSON.stringify(data, null, 2)}
+\`\`\``;
+        text = applyTokenBudget(text, void 0);
+      } else {
+        text = `Terrain ${terrainAction}: ${result.status}`;
+      }
+      return { content: [{ type: "text", text }] };
+    }
+  );
+}
+
+// src/tools/assets.ts
+import { z as z6 } from "zod";
+function register6(server, bridge) {
+  server.registerTool(
+    "assets",
+    {
+      title: "Asset Search & Insert",
+      description: "Search the Roblox asset catalog or insert assets by ID.\n\nActions:\n- `search`: Search for models, meshes, images, audio.\n- `insert`: Insert an asset into the game by ID.",
+      inputSchema: z6.object({
+        action: z6.enum(["search", "insert"]).describe("Asset action"),
+        // Search params
+        query: z6.string().optional().describe("Search query (for 'search' action)"),
+        category: z6.string().optional().describe("Asset category: 'models', 'decals', 'images', etc. (for 'search')"),
+        maxResults: z6.number().int().default(10).describe("Max search results (for 'search')"),
+        // Insert params
+        assetId: z6.number().int().optional().describe("Roblox asset ID (for 'insert' action)"),
+        parent: z6.string().optional().describe("Parent path to insert under (for 'insert' action)")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (params) => {
+      if (params.action === "insert") {
+        if (!params.assetId) {
+          return { content: [{ type: "text", text: "insert action requires an `assetId`." }] };
+        }
+        if (!params.parent) {
+          return { content: [{ type: "text", text: "insert action requires a `parent` path." }] };
+        }
+        const result2 = await bridge.send("insert_asset", {
+          assetId: params.assetId,
+          parent: params.parent
+        });
+        const text2 = result2.inserted.length === 1 ? `Inserted asset **${params.assetId}** at \`${result2.inserted[0].path}\`` : `Inserted asset **${params.assetId}**:
+` + result2.inserted.map((i) => `- \`${i.path}\` (${i.className})`).join("\n");
+        return { content: [{ type: "text", text: text2 }] };
+      }
+      if (!params.query) {
+        return { content: [{ type: "text", text: "search action requires a `query`." }] };
+      }
+      const result = await bridge.send("search_assets", {
+        query: params.query,
+        category: params.category,
+        maxResults: params.maxResults
+      });
+      let text;
+      if (result.results.length === 0) {
+        text = "*No assets found matching your query.*";
+      } else {
+        text = result.results.map((a) => `- **${a.name}** (ID: ${a.assetId}) by ${a.creatorName}`).join("\n");
+      }
+      return {
+        content: [{ type: "text", text: applyTokenBudget(text, void 0) }]
+      };
+    }
+  );
+}
+
+// src/tools/utility.ts
+import { z as z7 } from "zod";
+
+// src/context/api-data.json
+var api_data_default = {
+  classes: [
+    {
+      name: "Instance",
+      properties: [
+        { name: "Name", type: "string" },
+        { name: "ClassName", type: "string", tags: ["ReadOnly"] },
+        { name: "Parent", type: "Instance?" }
+      ],
+      methods: [
+        { name: "FindFirstChild", parameters: [{ name: "name", type: "string" }, { name: "recursive", type: "boolean?" }], returnType: "Instance?" },
+        { name: "GetChildren", parameters: [], returnType: "{Instance}" },
+        { name: "GetDescendants", parameters: [], returnType: "{Instance}" },
+        { name: "Destroy", parameters: [], returnType: "void" },
+        { name: "Clone", parameters: [], returnType: "Instance" },
+        { name: "IsA", parameters: [{ name: "className", type: "string" }], returnType: "boolean" },
+        { name: "SetAttribute", parameters: [{ name: "name", type: "string" }, { name: "value", type: "any" }], returnType: "void" },
+        { name: "GetAttribute", parameters: [{ name: "name", type: "string" }], returnType: "any" },
+        { name: "GetAttributes", parameters: [], returnType: "{[string]: any}" }
+      ],
+      events: [
+        { name: "ChildAdded" },
+        { name: "ChildRemoved" },
+        { name: "Changed" }
+      ]
+    },
+    {
+      name: "BasePart",
+      superclass: "PVInstance",
+      properties: [
+        { name: "Position", type: "Vector3" },
+        { name: "Size", type: "Vector3" },
+        { name: "CFrame", type: "CFrame" },
+        { name: "Color", type: "Color3" },
+        { name: "BrickColor", type: "BrickColor" },
+        { name: "Material", type: "Enum.Material" },
+        { name: "Transparency", type: "number" },
+        { name: "Anchored", type: "boolean" },
+        { name: "CanCollide", type: "boolean" },
+        { name: "Massless", type: "boolean" }
+      ],
+      methods: [],
+      events: [{ name: "Touched" }]
+    },
+    {
+      name: "Part",
+      superclass: "BasePart",
+      properties: [
+        { name: "Shape", type: "Enum.PartType" }
+      ],
+      methods: [],
+      events: []
+    },
+    {
+      name: "Model",
+      superclass: "PVInstance",
+      properties: [
+        { name: "PrimaryPart", type: "BasePart?" }
+      ],
+      methods: [
+        { name: "GetBoundingBox", parameters: [], returnType: "(CFrame, Vector3)" },
+        { name: "MoveTo", parameters: [{ name: "position", type: "Vector3" }], returnType: "void" }
+      ],
+      events: []
+    },
+    {
+      name: "Workspace",
+      superclass: "WorldRoot",
+      properties: [
+        { name: "CurrentCamera", type: "Camera?" },
+        { name: "Gravity", type: "number" },
+        { name: "Terrain", type: "Terrain" }
+      ],
+      methods: [
+        { name: "Raycast", parameters: [{ name: "origin", type: "Vector3" }, { name: "direction", type: "Vector3" }, { name: "raycastParams", type: "RaycastParams?" }], returnType: "RaycastResult?" }
+      ],
+      events: []
+    },
+    {
+      name: "Script",
+      superclass: "BaseScript",
+      properties: [
+        { name: "Source", type: "string" }
+      ],
+      methods: [],
+      events: []
+    },
+    {
+      name: "LocalScript",
+      superclass: "BaseScript",
+      properties: [
+        { name: "Source", type: "string" }
+      ],
+      methods: [],
+      events: []
+    },
+    {
+      name: "ModuleScript",
+      superclass: "LuaSourceContainer",
+      properties: [
+        { name: "Source", type: "string" }
+      ],
+      methods: [],
+      events: []
+    }
+  ],
+  enums: [
+    {
+      name: "Material",
+      items: [
+        { name: "Plastic", value: 256 },
+        { name: "Wood", value: 512 },
+        { name: "Slate", value: 800 },
+        { name: "Concrete", value: 816 },
+        { name: "CorrodedMetal", value: 1040 },
+        { name: "DiamondPlate", value: 1056 },
+        { name: "Foil", value: 1072 },
+        { name: "Grass", value: 1280 },
+        { name: "Ice", value: 1536 },
+        { name: "Marble", value: 784 },
+        { name: "Granite", value: 832 },
+        { name: "Brick", value: 848 },
+        { name: "Pebble", value: 864 },
+        { name: "Sand", value: 1296 },
+        { name: "Fabric", value: 1312 },
+        { name: "SmoothPlastic", value: 272 },
+        { name: "Metal", value: 1024 },
+        { name: "WoodPlanks", value: 528 },
+        { name: "Neon", value: 288 },
+        { name: "Glass", value: 1568 }
+      ]
+    },
+    {
+      name: "PartType",
+      items: [
+        { name: "Ball", value: 0 },
+        { name: "Block", value: 1 },
+        { name: "Cylinder", value: 2 }
+      ]
+    }
+  ]
+};
+
+// src/context/api-index.ts
+var apiData = api_data_default;
+function searchApi(query, maxResults = 20) {
+  const data = apiData;
+  const q = query.toLowerCase();
+  const results = [];
+  for (const cls of data.classes) {
+    if (cls.name.toLowerCase().includes(q)) {
+      const props = cls.properties.map((p) => p.name).join(", ");
+      const methods = cls.methods.map((m) => m.name).join(", ");
+      results.push({
+        type: "class",
+        name: cls.name,
+        detail: `Inherits: ${cls.superclass ?? "none"}
+Properties: ${props || "none"}
+Methods: ${methods || "none"}`
+      });
+    }
+    for (const prop of cls.properties) {
+      if (prop.name.toLowerCase().includes(q)) {
+        results.push({
+          type: "property",
+          className: cls.name,
+          name: prop.name,
+          detail: `${cls.name}.${prop.name}: ${prop.type ?? "unknown"}${prop.tags?.length ? ` [${prop.tags.join(", ")}]` : ""}`
+        });
+      }
+    }
+    for (const method of cls.methods) {
+      if (method.name.toLowerCase().includes(q)) {
+        const params = method.parameters?.map((p) => `${p.name}: ${p.type}`).join(", ") ?? "";
+        results.push({
+          type: "method",
+          className: cls.name,
+          name: method.name,
+          detail: `${cls.name}:${method.name}(${params}): ${method.returnType ?? "void"}`
+        });
+      }
+    }
+    for (const event of cls.events) {
+      if (event.name.toLowerCase().includes(q)) {
+        results.push({
+          type: "event",
+          className: cls.name,
+          name: event.name,
+          detail: `${cls.name}.${event.name}`
+        });
+      }
+    }
+    if (results.length >= maxResults * 3) break;
+  }
+  for (const en of data.enums) {
+    if (en.name.toLowerCase().includes(q)) {
+      const items = en.items.map((i) => i.name).join(", ");
+      results.push({
+        type: "enum",
+        name: en.name,
+        detail: `Enum.${en.name}: ${items}`
+      });
+    }
+  }
+  results.sort((a, b) => {
+    const aExact = a.name.toLowerCase() === q ? 0 : 1;
+    const bExact = b.name.toLowerCase() === q ? 0 : 1;
+    if (aExact !== bExact) return aExact - bExact;
+    return a.name.length - b.name.length;
+  });
+  return results.slice(0, maxResults);
+}
+function formatSearchResults(results) {
+  if (results.length === 0) {
+    return "*No results found. Try a different search term.*";
+  }
+  const lines = [];
+  for (const r of results) {
+    const prefix = r.type.charAt(0).toUpperCase() + r.type.slice(1);
+    lines.push(`### ${prefix}: ${r.name}`);
+    lines.push(r.detail);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/utility.ts
+function register7(server, bridge) {
+  server.registerTool(
+    "undo_redo",
+    {
+      title: "Undo / Redo",
+      description: "Trigger undo or redo in Roblox Studio's change history. Supports repeating multiple times with the count parameter.",
+      inputSchema: z7.object({
+        action: z7.enum(["undo", "redo"]).describe("Whether to undo or redo"),
+        count: z7.number().int().min(1).default(1).describe("Number of times to repeat the action")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      const result = await bridge.send("undo_redo", {
+        action: params.action,
+        count: params.count
+      });
+      const text = `${params.action === "undo" ? "Undo" : "Redo"} x${result.count}: ${result.status}`;
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.registerTool(
+    "screenshot",
+    {
+      title: "Take Screenshot",
+      description: "Capture a screenshot of the current Roblox Studio viewport. Returns base64 image data when available for vision model consumption.",
+      inputSchema: z7.object({}),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async () => {
+      const result = await bridge.send("screenshot", {});
+      if (result.imageBase64 && result.mimeType) {
+        return {
+          content: [
+            {
+              type: "image",
+              data: result.imageBase64,
+              mimeType: result.mimeType
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          { type: "text", text: `Screenshot: ${result.message ?? result.status}` }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "lookup_api",
+    {
+      title: "Lookup Roblox API",
+      description: "Search the Roblox engine API reference for classes, properties, methods, events, and enums. Runs locally \u2014 no Studio connection required.",
+      inputSchema: z7.object({
+        query: z7.string().describe("Search query, e.g. 'BasePart', 'Touched', 'TweenService'"),
+        maxTokens: z7.number().optional().describe("Maximum token budget for the response")
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      const results = searchApi(params.query);
+      const text = formatSearchResults(results);
+      return {
+        content: [
+          { type: "text", text: applyTokenBudget(text, params.maxTokens) }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "transaction",
+    {
+      title: "Transaction Control",
+      description: "Group multiple mutating tool calls into a single Ctrl+Z undo point.\n\nActions:\n- `begin`: Start a transaction. All subsequent writes share one undo recording.\n- `commit`: Finish the transaction and commit all changes as one undo point.\n- `rollback`: Cancel the transaction and undo all changes made since begin.\n\nTransactions auto-rollback after 60 seconds if not committed.",
+      inputSchema: z7.object({
+        action: z7.enum(["begin", "commit", "rollback"]).describe("Transaction action"),
+        name: z7.string().optional().describe("Transaction name for the undo history (for 'begin' action)")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      if (params.action === "begin") {
+        const result2 = await bridge.send("begin_transaction", {
+          name: params.name
+        });
+        return {
+          content: [
+            { type: "text", text: `Transaction started: **${result2.transactionId}**
+All subsequent writes will be grouped into one undo point. Call commit or rollback to finish.` }
+          ]
+        };
+      }
+      if (params.action === "commit") {
+        const result2 = await bridge.send("commit_transaction", {});
+        return {
+          content: [
+            { type: "text", text: `Transaction ${result2.status}. All changes are now a single undo point.` }
+          ]
+        };
+      }
+      const result = await bridge.send("rollback_transaction", {});
+      return {
+        content: [
+          { type: "text", text: `Transaction ${result.status}. All changes since begin have been reverted.` }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/studio.ts
+import { z as z8 } from "zod";
+function register8(server, bridge) {
+  server.registerTool(
+    "list_studios",
+    {
+      title: "List Connected Studios",
+      description: "List all Roblox Studio instances currently connected to Conduit. Shows studio ID, place name, place ID, and which studio is active. Use set_active_studio to switch between them.",
+      inputSchema: z8.object({}),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async () => {
+      const studios = bridge.getStudios();
+      const activeId = bridge.getActiveStudioId();
+      if (studios.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "*No Roblox Studio instances connected.* Make sure the Conduit plugin is installed and running."
+            }
+          ]
+        };
+      }
+      const lines = studios.map((s) => {
+        const active = s.studioId === activeId ? " **\u2190 active**" : "";
+        const place = s.placeName ? ` \u2014 ${s.placeName}` : "";
+        const placeId = s.placeId ? ` (Place ID: ${s.placeId})` : "";
+        const duration = Math.floor((Date.now() - s.connectedAt) / 1e3);
+        return `- \`${s.studioId}\`${place}${placeId} \u2014 connected ${duration}s ago${active}`;
+      });
+      const text = `**Connected Studios (${studios.length}):**
+${lines.join("\n")}`;
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.registerTool(
+    "set_active_studio",
+    {
+      title: "Set Active Studio",
+      description: "Switch which Roblox Studio instance receives tool commands. Use list_studios to see available IDs.",
+      inputSchema: z8.object({
+        studioId: z8.string().describe("The studio ID to set as active (from list_studios)")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      bridge.setActiveStudio(params.studioId);
+      const studios = bridge.getStudios();
+      const studio = studios.find((s) => s.studioId === params.studioId);
+      const name = studio?.placeName ?? "unknown";
+      const text = `Active studio set to \`${params.studioId}\` (${name}).`;
+      return { content: [{ type: "text", text }] };
+    }
+  );
+}
+
+// src/tools/builds.ts
+import { z as z9 } from "zod";
+
+// src/utils/builds.ts
+import { homedir } from "os";
+import { join } from "path";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  statSync
+} from "fs";
+var BUILDS_DIR = join(homedir(), ".conduit", "builds");
+function ensureDir() {
+  if (!existsSync(BUILDS_DIR)) {
+    mkdirSync(BUILDS_DIR, { recursive: true });
+  }
+}
+function saveBuild(name, root, description) {
+  ensureDir();
+  const rootObj = root;
+  const data = {
+    name,
+    description,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    root
+  };
+  const filePath = join(BUILDS_DIR, `${name}.json`);
+  writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+  return {
+    name,
+    description,
+    createdAt: data.createdAt,
+    rootClassName: rootObj.className ?? "unknown",
+    childCount: rootObj.children?.length ?? 0
+  };
+}
+function loadBuild(name) {
+  const filePath = join(BUILDS_DIR, `${name}.json`);
+  if (!existsSync(filePath)) {
+    throw new Error(`Build "${name}" not found. Use builds --action list to see available builds.`);
+  }
+  return JSON.parse(readFileSync(filePath, "utf-8"));
+}
+function listBuilds() {
+  ensureDir();
+  const files = readdirSync(BUILDS_DIR).filter((f) => f.endsWith(".json"));
+  return files.map((f) => {
+    const filePath = join(BUILDS_DIR, f);
+    try {
+      const data = JSON.parse(readFileSync(filePath, "utf-8"));
+      const rootObj = data.root;
+      return {
+        name: data.name,
+        description: data.description,
+        createdAt: data.createdAt,
+        rootClassName: rootObj.className ?? "unknown",
+        childCount: rootObj.children?.length ?? 0
+      };
+    } catch {
+      const stat = statSync(filePath);
+      return {
+        name: f.replace(".json", ""),
+        createdAt: stat.mtime.toISOString(),
+        rootClassName: "unknown",
+        childCount: 0
+      };
+    }
+  });
+}
+
+// src/tools/builds.ts
+function register9(server, bridge) {
+  server.registerTool(
+    "builds",
+    {
+      title: "Build Library",
+      description: "Export, import, or list reusable instance trees (build library).\n\nActions:\n- `export`: Serialize an instance tree and save it as a named build.\n- `import`: Reconstruct a saved build under a target parent.\n- `list`: List all saved builds.",
+      inputSchema: z9.object({
+        action: z9.enum(["export", "import", "list"]).describe("Build library action"),
+        // Export params
+        path: z9.string().optional().describe("Path to instance to export (for 'export' action)"),
+        name: z9.string().optional().describe("Build name (for 'export' and 'import' actions)"),
+        description: z9.string().optional().describe("Build description (for 'export' action)"),
+        // Import params
+        targetParent: z9.string().optional().describe("Parent path to import under (for 'import' action)")
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      if (params.action === "list") {
+        const builds = listBuilds();
+        if (builds.length === 0) {
+          return {
+            content: [
+              { type: "text", text: "*No builds saved. Use `builds --action export` to save one.*" }
+            ]
+          };
+        }
+        const lines = builds.map(
+          (b) => `- **${b.name}** \`${b.rootClassName}\` (${b.childCount} children) \u2014 ${b.createdAt}${b.description ? `
+  ${b.description}` : ""}`
+        );
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      }
+      if (params.action === "export") {
+        if (!params.path) {
+          return { content: [{ type: "text", text: "export action requires a `path`." }] };
+        }
+        if (!params.name) {
+          return { content: [{ type: "text", text: "export action requires a `name`." }] };
+        }
+        const serialized = await bridge.send("export_build", {
+          path: params.path
+        });
+        const meta = saveBuild(params.name, serialized, params.description);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Build **${meta.name}** saved.
+- Root: \`${meta.rootClassName}\`
+- Children: ${meta.childCount}
+- Created: ${meta.createdAt}`
+            }
+          ]
+        };
+      }
+      if (params.action === "import") {
+        if (!params.name) {
+          return { content: [{ type: "text", text: "import action requires a `name`." }] };
+        }
+        if (!params.targetParent) {
+          return { content: [{ type: "text", text: "import action requires a `targetParent`." }] };
+        }
+        const build = loadBuild(params.name);
+        const result = await bridge.send("import_build", {
+          tree: build.root,
+          targetParent: params.targetParent
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Build **${params.name}** imported at \`${result.path}\` (${result.className}, ${result.childCount} children).`
+            }
+          ]
+        };
+      }
+      return { content: [{ type: "text", text: "Unknown builds action." }] };
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server, bridge, options = {}) {
+  const mode = options.mode ?? "full";
+  register8(server, bridge);
+  register(server, bridge);
+  register7(server, bridge);
+  if (mode === "full") {
+    register2(server, bridge);
+    register3(server, bridge);
+    register4(server, bridge);
+    register5(server, bridge);
+    register6(server, bridge);
+    register9(server, bridge);
+  } else {
+    registerReadOnly(server, bridge);
+    registerReadOnly2(server, bridge);
+  }
+  if (options.withCloud) {
+    import("./cloud-HQIBAMRL.js").then((mod) => mod.register(server));
+  }
+  if (options.withRojo) {
+    import("./rojo-TXV4K4PB.js").then((mod) => mod.register(server));
+  }
+}
+
+// src/index.ts
+async function startServer(port = 3200, options = {}) {
+  const bridge = new Bridge(port);
+  const server = new McpServer(
+    {
+      name: "conduit-mcp",
+      version: "2.0.0"
+    },
+    {
+      instructions: [
+        "Conduit bridges AI assistants to Roblox Studio via WebSocket.",
+        "The Conduit plugin must be running in Roblox Studio and connected.",
+        "",
+        "Workflow tips:",
+        "- Use `explore` first to understand the DataModel before making changes.",
+        "- Use `read_script` to read source before editing with `edit_script`.",
+        "- All mutations are undoable via Ctrl+Z in Studio (ChangeHistoryService).",
+        "- Use `lookup_api` to check Roblox API signatures before writing Luau code.",
+        "- Batch operations: `create` and `modify` accept arrays of operations.",
+        "- Token budgets: pass `maxTokens` to limit response size on large DataModels.",
+        "- Use `query` to find instances by class, tag, or attribute.",
+        "- Use `query --action scripts` to grep across all script sources.",
+        "- Use `execute_lua` as an escape hatch for anything tools don't cover.",
+        "- Use `explore --action set_selection` to select instances in Studio.",
+        "",
+        "Multi-Studio:",
+        "- Multiple Studio instances can connect simultaneously.",
+        "- Use `list_studios` to see connected instances and `set_active_studio` to switch.",
+        "- With a single Studio, routing is automatic."
+      ].join("\n")
+    }
+  );
+  const toolOptions = {
+    mode: options.mode,
+    withCloud: options.withCloud,
+    withRojo: options.withRojo
+  };
+  registerAllTools(server, bridge, toolOptions);
+  bridge.on("studio-connected", (info) => {
+    log.info(
+      `Roblox Studio connected: ${info.studioId}` + (info.placeName ? ` (${info.placeName})` : "")
+    );
+  });
+  bridge.on("studio-disconnected", (info) => {
+    log.warn(
+      `Roblox Studio disconnected: ${info.studioId}` + (info.placeName ? ` (${info.placeName})` : "")
+    );
+  });
+  const actualPort = await bridge.start();
+  log.info(`Bridge listening on port ${actualPort}`);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  log.info("MCP server connected via stdio");
+  const shutdown = async () => {
+    log.info("Shutting down...");
+    await bridge.stop();
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+export {
+  startServer
+};
+//# sourceMappingURL=chunk-JDWBW44K.js.map