@chrrxs/robloxstudio-mcp 3.0.4 → 3.1.0

package/dist/index.js

@@ -1951,59 +1951,83 @@ var RoutingFailure = class extends Error {
     this.routingError = routingError;
   }
 };
-function toPublic(inst) {
+function toPublicPeer(peer) {
   return {
-    instanceId: inst.instanceId,
-    role: inst.role,
-    placeId: inst.placeId,
-    placeName: inst.placeName,
-    dataModelName: inst.dataModelName,
-    isRunning: inst.isRunning,
-    pluginVersion: inst.pluginVersion,
-    pluginVariant: inst.pluginVariant,
-    serverVersion: inst.serverVersion,
-    lastActivity: inst.lastActivity,
-    connectedAt: inst.connectedAt
+    peerId: peer.peerId,
+    instanceId: peer.instanceId,
+    multiplayerGroupId: peer.multiplayerGroupId,
+    role: peer.role,
+    placeId: peer.placeId,
+    placeName: peer.placeName,
+    placeKey: peer.placeKey,
+    dataModelName: peer.dataModelName,
+    isRunning: peer.isRunning,
+    pluginVersion: peer.pluginVersion,
+    pluginVariant: peer.pluginVariant,
+    serverVersion: peer.serverVersion,
+    lastActivity: peer.lastActivity,
+    connectedAt: peer.connectedAt
   };
 }
-var STALE_INSTANCE_MS = 3e4;
-var DUPLICATE_TAKEOVER_MS = 3e3;
-var INSTANCE_ALIAS_TTL_MS = 5 * 60 * 1e3;
+var STALE_PEER_MS = 3e4;
 var ACCEPTED_REQUEST_TOMBSTONE_TTL_MS = 6e4;
 var MAX_ACCEPTED_REQUEST_TOMBSTONES = 4096;
 var CANCELLATION_TOMBSTONE_TTL_MS = 6e4;
 var MAX_CANCELLATION_TOMBSTONES = 4096;
-function publishedInstanceId(placeId) {
-  if (placeId === void 0 || !Number.isFinite(placeId) || placeId <= 0)
-    return void 0;
-  return `place:${Math.trunc(placeId)}`;
+var MAX_OUTSTANDING_REQUESTS_PER_DELIVERY_OWNER = 4;
+function roleOrder(role) {
+  if (role === "edit")
+    return 0;
+  if (role === "server")
+    return 1;
+  const client = /^client-(\d+)$/.exec(role);
+  return client ? 2 + Number(client[1]) : Number.MAX_SAFE_INTEGER;
+}
+function isRuntimeRole(role) {
+  return role === "server" || /^client-\d+$/.test(role);
+}
+function connectedRuntimeInstanceId(peer) {
+  return `${peer.instanceId}-${peer.role}`;
+}
+function peerIdsByRole(peers) {
+  return Object.fromEntries([...peers].sort((left, right) => roleOrder(left.role) - roleOrder(right.role) || left.peerId.localeCompare(right.peerId)).map((peer) => [peer.role, peer.peerId]));
+}
+function preferredPeer(peers) {
+  return peers.reduce((preferred, candidate) => {
+    const difference = roleOrder(candidate.role) - roleOrder(preferred.role);
+    if (difference !== 0)
+      return difference < 0 ? candidate : preferred;
+    return candidate.connectedAt < preferred.connectedAt ? candidate : preferred;
+  });
+}
+function copyGroup(group) {
+  return { ...group, instanceIds: [...group.instanceIds] };
 }
 var BridgeService = class {
   pendingRequests = /* @__PURE__ */ new Map();
   acceptedRequestIds = /* @__PURE__ */ new Map();
   pendingCancellations = /* @__PURE__ */ new Map();
-  // Keyed by pluginSessionId (the per-plugin GUID).
-  instances = /* @__PURE__ */ new Map();
-  instanceAliases = /* @__PURE__ */ new Map();
-  instanceRegisteredListeners = /* @__PURE__ */ new Set();
+  peersById = /* @__PURE__ */ new Map();
+  multiplayerGroupsById = /* @__PURE__ */ new Map();
+  peerRegisteredListeners = /* @__PURE__ */ new Set();
   requestAvailableListeners = /* @__PURE__ */ new Set();
-  sessionClosedListeners = /* @__PURE__ */ new Set();
-  deliveryOwnersByPhysicalSession = /* @__PURE__ */ new Map();
+  peerClosedListeners = /* @__PURE__ */ new Set();
+  deliveryOwnersByTransportPeer = /* @__PURE__ */ new Map();
   requestTimeout = 3e4;
-  onInstanceRegistered(listener) {
-    this.instanceRegisteredListeners.add(listener);
-    for (const instance of this.getPublicInstances()) {
+  onPeerRegistered(listener) {
+    this.peerRegisteredListeners.add(listener);
+    for (const peer of this.getPublicPeers()) {
       try {
-        listener(instance);
+        listener(peer);
       } catch {
       }
     }
-    return () => this.instanceRegisteredListeners.delete(listener);
+    return () => this.peerRegisteredListeners.delete(listener);
   }
-  notifyInstanceRegistered(instance) {
-    for (const listener of this.instanceRegisteredListeners) {
+  notifyPeerRegistered(peer) {
+    for (const listener of this.peerRegisteredListeners) {
       try {
-        listener(instance);
+        listener(peer);
       } catch {
       }
     }
@@ -2012,16 +2036,16 @@ var BridgeService = class {
     this.requestAvailableListeners.add(listener);
     return () => this.requestAvailableListeners.delete(listener);
   }
-  onSessionClosed(listener) {
-    this.sessionClosedListeners.add(listener);
-    return () => this.sessionClosedListeners.delete(listener);
+  onPeerClosed(listener) {
+    this.peerClosedListeners.add(listener);
+    return () => this.peerClosedListeners.delete(listener);
   }
-  setDeliveryActive(physicalSessionId, owner, active) {
-    let owners = this.deliveryOwnersByPhysicalSession.get(physicalSessionId);
+  setDeliveryActive(transportPeerId, owner, active) {
+    let owners = this.deliveryOwnersByTransportPeer.get(transportPeerId);
     if (active) {
       if (!owners) {
         owners = /* @__PURE__ */ new Set();
-        this.deliveryOwnersByPhysicalSession.set(physicalSessionId, owners);
+        this.deliveryOwnersByTransportPeer.set(transportPeerId, owners);
       }
       owners.add(owner);
       return;
@@ -2030,422 +2054,534 @@ var BridgeService = class {
       return;
     owners.delete(owner);
     if (owners.size === 0)
-      this.deliveryOwnersByPhysicalSession.delete(physicalSessionId);
+      this.deliveryOwnersByTransportPeer.delete(transportPeerId);
   }
-  notifyRequestAvailable(physicalSessionId) {
+  notifyRequestAvailable(transportPeerId) {
     for (const listener of this.requestAvailableListeners) {
       try {
-        listener(physicalSessionId);
+        listener(transportPeerId);
       } catch {
       }
     }
   }
   notifyRequestCancelled(request, reason) {
-    const physicalSessionId = request.lastDeliveryPhysicalSessionId;
-    if (!physicalSessionId || this.pendingCancellations.has(request.id))
+    const transportPeerId = request.lastDeliveryTransportPeerId;
+    if (!transportPeerId || this.pendingCancellations.has(request.id))
       return;
     const now = Date.now();
     this.prunePendingCancellations(now);
     this.pendingCancellations.set(request.id, {
       requestId: request.id,
       reason,
-      physicalSessionId,
+      transportPeerId,
       createdAt: now
     });
     this.prunePendingCancellations(now);
-    this.notifyRequestAvailable(physicalSessionId);
+    this.notifyRequestAvailable(transportPeerId);
   }
-  physicalSessionsForTarget(targetInstanceId, targetRole) {
-    const physicalSessionIds = /* @__PURE__ */ new Set();
-    for (const instance of this.instances.values()) {
-      if (instance.instanceId === targetInstanceId && instance.role === targetRole) {
-        physicalSessionIds.add(instance.physicalSessionId);
-      }
+  groupIdForInstance(instanceId) {
+    for (const group of this.getMultiplayerGroups()) {
+      if (group.instanceIds.includes(instanceId))
+        return group.id;
     }
-    return Array.from(physicalSessionIds);
+    return void 0;
   }
-  canonicalInstanceId(instanceId, placeId) {
-    return publishedInstanceId(placeId) ?? instanceId;
+  peerScopeKey(peer) {
+    return peer.multiplayerGroupId ? `group:${peer.multiplayerGroupId}` : `instance:${peer.instanceId}`;
   }
-  rememberInstanceAlias(aliasInstanceId, targetInstanceId) {
-    if (aliasInstanceId === targetInstanceId)
-      return;
-    this.instanceAliases.set(aliasInstanceId, {
-      targetInstanceId,
-      lastSeen: Date.now()
-    });
+  registrationScopePeers(instanceId, multiplayerGroupId) {
+    if (multiplayerGroupId) {
+      return this.getPeers().filter((peer) => peer.multiplayerGroupId === multiplayerGroupId);
+    }
+    return this.getPeers().filter((peer) => peer.instanceId === instanceId && peer.multiplayerGroupId === void 0);
   }
-  resolveInstanceAlias(instanceId) {
-    const alias = this.instanceAliases.get(instanceId);
-    if (!alias)
-      return instanceId;
-    alias.lastSeen = Date.now();
-    return alias.targetInstanceId;
+  detachInstanceFromOtherGroups(instanceId, retainedGroupId) {
+    for (const group of this.multiplayerGroupsById.values()) {
+      if (group.id === retainedGroupId || !group.instanceIds.includes(instanceId))
+        continue;
+      group.instanceIds = group.instanceIds.filter((id) => id !== instanceId);
+      if (group.controllerInstanceId === instanceId)
+        group.controllerInstanceId = void 0;
+      if (group.instanceIds.length === 0)
+        this.multiplayerGroupsById.delete(group.id);
+    }
+  }
+  groupAttachmentConflict(instanceId, groupId) {
+    const incomingRoles = new Set(this.getPeers().filter((peer) => peer.instanceId === instanceId).map((peer) => peer.role));
+    return this.getPeers().find((peer) => peer.instanceId !== instanceId && peer.multiplayerGroupId === groupId && incomingRoles.has(peer.role));
+  }
+  attachInstanceToGroup(instanceId, groupId) {
+    const conflict = this.groupAttachmentConflict(instanceId, groupId);
+    if (conflict) {
+      throw new Error(`Cannot attach Instance "${instanceId}" to Multiplayer Group "${groupId}": role "${conflict.role}" is already owned by Peer "${conflict.peerId}".`);
+    }
+    this.detachInstanceFromOtherGroups(instanceId, groupId);
+    let group = this.multiplayerGroupsById.get(groupId);
+    if (!group) {
+      group = { id: groupId, instanceIds: [], createdAt: Date.now() };
+      this.multiplayerGroupsById.set(groupId, group);
+    }
+    if (!group.instanceIds.includes(instanceId))
+      group.instanceIds.push(instanceId);
+    for (const peer of this.peersById.values()) {
+      if (peer.instanceId === instanceId)
+        peer.multiplayerGroupId = groupId;
+    }
+    return group;
+  }
+  createMultiplayerGroup(groupId, controllerInstanceId) {
+    const group = this.attachInstanceToGroup(controllerInstanceId, groupId);
+    group.controllerInstanceId = controllerInstanceId;
+    return copyGroup(group);
+  }
+  async createMultiplayerGroupEverywhere(groupId, controllerInstanceId) {
+    return this.createMultiplayerGroup(groupId, controllerInstanceId);
+  }
+  removeMultiplayerGroup(groupId) {
+    const group = this.multiplayerGroupsById.get(groupId);
+    if (!group)
+      return void 0;
+    this.multiplayerGroupsById.delete(groupId);
+    for (const peer of this.peersById.values()) {
+      if (peer.multiplayerGroupId === groupId)
+        peer.multiplayerGroupId = void 0;
+    }
+    return copyGroup(group);
+  }
+  async removeMultiplayerGroupEverywhere(groupId) {
+    return this.removeMultiplayerGroup(groupId);
+  }
+  connectedInstanceIdCollision(peerId, instanceId, role, multiplayerGroupId) {
+    const peers = this.getPeers().filter((peer) => peer.peerId !== peerId);
+    const canonicalCollision = peers.find((peer) => peer.multiplayerGroupId !== void 0 && isRuntimeRole(peer.role) && connectedRuntimeInstanceId(peer) === instanceId);
+    if (canonicalCollision)
+      return canonicalCollision;
+    if (multiplayerGroupId === void 0 || !isRuntimeRole(role))
+      return void 0;
+    const runtimeAlias = `${instanceId}-${role}`;
+    return peers.find((peer) => peer.instanceId === runtimeAlias);
   }
-  migratePendingRequests(fromInstanceId, toInstanceId) {
-    if (fromInstanceId === toInstanceId)
-      return;
-    for (const request of this.pendingRequests.values()) {
-      if (request.targetInstanceId === fromInstanceId) {
-        request.targetInstanceId = toInstanceId;
-      }
+  registerPeer(input) {
+    const prior = this.peersById.get(input.peerId);
+    if (prior && (prior.instanceId !== input.instanceId || prior.transportPeerId !== input.transportPeerId)) {
+      return {
+        ok: false,
+        error: {
+          code: "peer_identity_mismatch",
+          message: `Peer "${input.peerId}" is already registered to Instance "${prior.instanceId}" through transport Peer "${prior.transportPeerId}".`,
+          existing: toPublicPeer(prior)
+        }
+      };
     }
-  }
-  cleanupStaleAliases(now = Date.now()) {
-    for (const [alias, entry] of this.instanceAliases.entries()) {
-      const targetIsLive = this.getInstances().some((inst) => inst.instanceId === entry.targetInstanceId);
-      if (!targetIsLive && now - entry.lastSeen > INSTANCE_ALIAS_TTL_MS) {
-        this.instanceAliases.delete(alias);
-      }
+    const multiplayerGroupId = input.multiplayerGroupId ?? this.groupIdForInstance(input.instanceId) ?? prior?.multiplayerGroupId;
+    const attachmentConflict = multiplayerGroupId ? this.groupAttachmentConflict(input.instanceId, multiplayerGroupId) : void 0;
+    if (attachmentConflict) {
+      return {
+        ok: false,
+        error: {
+          code: "duplicate_scope_role",
+          message: `Multiplayer Group "${multiplayerGroupId}" already has a Peer registered as "${attachmentConflict.role}".`,
+          existing: toPublicPeer(attachmentConflict)
+        }
+      };
     }
-  }
-  routingKeyForInstance(inst) {
-    return publishedInstanceId(inst.placeId) ?? this.resolveInstanceAlias(inst.instanceId);
-  }
-  matchingInstancesForInstanceId(instanceId) {
-    const resolvedInstanceId = this.resolveInstanceAlias(instanceId);
-    const ids = /* @__PURE__ */ new Set([instanceId, resolvedInstanceId]);
-    const placeIds = /* @__PURE__ */ new Set();
-    const addPlaceId = (placeId) => {
-      const published = publishedInstanceId(placeId);
-      if (!published || placeId === void 0)
-        return;
-      ids.add(published);
-      placeIds.add(Math.trunc(placeId));
-    };
-    const placeMatch = resolvedInstanceId.match(/^place:(\d+)$/) ?? instanceId.match(/^place:(\d+)$/);
-    if (placeMatch)
-      addPlaceId(Number(placeMatch[1]));
-    for (const inst of this.getInstances()) {
-      if (ids.has(inst.instanceId))
-        addPlaceId(inst.placeId);
-    }
-    return this.getInstances().filter((inst) => ids.has(inst.instanceId) || inst.placeId > 0 && placeIds.has(Math.trunc(inst.placeId)));
-  }
-  resolveInstanceId(instanceId) {
-    return this.resolveInstanceAlias(instanceId);
-  }
-  registerInstance(input) {
-    const { pluginSessionId, role } = input;
-    const rawInstanceId = input.instanceId;
-    const instanceId = this.canonicalInstanceId(rawInstanceId, input.placeId);
-    const prior = this.instances.get(pluginSessionId);
-    let assignedRole = role;
-    const pluginVersion = input.pluginVersion ?? "";
-    const pluginVariant = input.pluginVariant ?? "unknown";
-    const serverVersion = input.serverVersion ?? "";
-    this.rememberInstanceAlias(rawInstanceId, instanceId);
-    if (prior && prior.instanceId !== instanceId) {
-      this.rememberInstanceAlias(prior.instanceId, instanceId);
-      this.migratePendingRequests(prior.instanceId, instanceId);
-    }
-    if (role === "client") {
-      if (prior && prior.role.match(/^client-\d+$/)) {
+    const scopePeers = this.registrationScopePeers(input.instanceId, multiplayerGroupId).filter((peer) => peer.peerId !== input.peerId);
+    let assignedRole = input.role;
+    if (input.role === "client") {
+      const used = /* @__PURE__ */ new Set();
+      for (const peer of scopePeers) {
+        const match = /^client-(\d+)$/.exec(peer.role);
+        if (match)
+          used.add(Number(match[1]));
+      }
+      const priorOrdinal = prior ? /^client-(\d+)$/.exec(prior.role) : null;
+      if (prior && priorOrdinal && !used.has(Number(priorOrdinal[1]))) {
         assignedRole = prior.role;
       } else {
-        const used = /* @__PURE__ */ new Set();
-        for (const inst of this.instances.values()) {
-          if (inst.instanceId !== instanceId || inst.pluginSessionId === pluginSessionId)
-            continue;
-          const match = inst.role.match(/^client-(\d+)$/);
-          if (match)
-            used.add(Number(match[1]));
-        }
-        let idx = 1;
-        while (used.has(idx))
-          idx++;
-        assignedRole = `client-${idx}`;
+        let ordinal = 1;
+        while (used.has(ordinal))
+          ordinal += 1;
+        assignedRole = `client-${ordinal}`;
       }
     }
-    const existing = Array.from(this.instances.values()).find((i) => i.instanceId === instanceId && i.role === assignedRole && i.pluginSessionId !== pluginSessionId);
+    const instanceIdCollision = this.connectedInstanceIdCollision(input.peerId, input.instanceId, assignedRole, multiplayerGroupId);
+    if (instanceIdCollision) {
+      return {
+        ok: false,
+        error: {
+          code: "instance_id_alias_collision",
+          message: `Instance "${input.instanceId}" would make a grouped runtime Instance ID ambiguous.`,
+          existing: toPublicPeer(instanceIdCollision)
+        }
+      };
+    }
+    const existing = scopePeers.find((peer) => peer.role === assignedRole);
     if (existing) {
-      const existingDeliveryActive = (this.deliveryOwnersByPhysicalSession.get(existing.physicalSessionId)?.size ?? 0) > 0;
-      if (!existingDeliveryActive && Date.now() - existing.lastActivity > DUPLICATE_TAKEOVER_MS) {
-        this.unregisterInstance(existing.pluginSessionId);
-      } else {
-        return {
-          ok: false,
-          error: {
-            code: "duplicate_instance_role",
-            message: `Another plugin is already registered as (${instanceId}, ${assignedRole}).`,
-            existing: toPublic(existing)
-          }
-        };
-      }
+      const scopeDescription = multiplayerGroupId ? `Multiplayer Group "${multiplayerGroupId}"` : `Instance "${input.instanceId}"`;
+      return {
+        ok: false,
+        error: {
+          code: "duplicate_scope_role",
+          message: `${scopeDescription} already has a Peer registered as "${assignedRole}".`,
+          existing: toPublicPeer(existing)
+        }
+      };
     }
+    const now = Date.now();
     const registered = {
-      pluginSessionId,
-      physicalSessionId: input.physicalSessionId,
-      instanceId,
+      peerId: input.peerId,
+      transportPeerId: input.transportPeerId,
+      instanceId: input.instanceId,
+      multiplayerGroupId,
       role: assignedRole,
       placeId: input.placeId ?? 0,
       placeName: input.placeName ?? "",
+      placeKey: input.placeKey,
       dataModelName: input.dataModelName ?? "",
       isRunning: input.isRunning ?? false,
-      pluginVersion,
-      pluginVariant,
-      serverVersion,
-      lastActivity: Date.now(),
-      connectedAt: prior?.connectedAt ?? Date.now()
+      pluginVersion: input.pluginVersion ?? "",
+      pluginVariant: input.pluginVariant ?? "unknown",
+      serverVersion: input.serverVersion ?? "",
+      lastActivity: now,
+      connectedAt: prior?.connectedAt ?? now
+    };
+    this.peersById.set(input.peerId, registered);
+    if (multiplayerGroupId)
+      this.attachInstanceToGroup(input.instanceId, multiplayerGroupId);
+    this.notifyPeerRegistered(toPublicPeer(registered));
+    this.notifyRequestAvailable(registered.transportPeerId);
+    return {
+      ok: true,
+      assignedRole,
+      peerId: registered.peerId,
+      instanceId: registered.instanceId,
+      multiplayerGroupId: registered.multiplayerGroupId
     };
-    this.instances.set(pluginSessionId, registered);
-    this.notifyInstanceRegistered(toPublic(registered));
-    this.notifyRequestAvailable(registered.physicalSessionId);
-    return { ok: true, assignedRole, instanceId };
   }
-  unregisterInstance(pluginSessionId) {
-    const removed = this.instances.get(pluginSessionId);
+  unregisterPeer(peerId) {
+    this.unregisterPeerInternal(peerId, /* @__PURE__ */ new Set());
+  }
+  unregisterPeerInternal(peerId, visited, removedPeers) {
+    if (visited.has(peerId))
+      return;
+    visited.add(peerId);
+    const removed = this.peersById.get(peerId);
     if (!removed)
       return;
-    const logicalChildren = removed.physicalSessionId === pluginSessionId ? Array.from(this.instances.values()).filter((instance) => instance.pluginSessionId !== pluginSessionId && instance.physicalSessionId === pluginSessionId) : [];
-    this.instances.delete(pluginSessionId);
-    const session = {
-      logicalSessionId: pluginSessionId,
-      physicalSessionId: removed.physicalSessionId
-    };
-    for (const listener of this.sessionClosedListeners) {
+    removedPeers?.push(removed);
+    const dependentPeerIds = removed.transportPeerId === peerId ? this.getPeers().filter((peer) => peer.peerId !== peerId && peer.transportPeerId === peerId).map((peer) => peer.peerId) : [];
+    this.peersById.delete(peerId);
+    const session = { peerId, transportPeerId: removed.transportPeerId };
+    for (const listener of this.peerClosedListeners) {
       try {
         listener(session);
       } catch {
       }
     }
-    if (removed.physicalSessionId === pluginSessionId) {
-      this.deliveryOwnersByPhysicalSession.delete(pluginSessionId);
+    if (removed.transportPeerId === peerId) {
+      this.deliveryOwnersByTransportPeer.delete(peerId);
     }
-    for (const child of logicalChildren)
-      this.unregisterInstance(child.pluginSessionId);
-    for (const req of Array.from(this.pendingRequests.values())) {
-      const stillHasHandler = Array.from(this.instances.values()).some((i) => i.instanceId === req.targetInstanceId && i.role === req.targetRole);
-      if (!stillHasHandler) {
-        this.removePendingRequest(req);
-        req.reject(new Error(`Target (${req.targetInstanceId}, ${req.targetRole}) disconnected`));
-      }
+    for (const request of Array.from(this.pendingRequests.values())) {
+      if (request.targetPeerId !== peerId)
+        continue;
+      const deliveryTransportPeerId = request.lastDeliveryTransportPeerId;
+      this.removePendingRequest(request);
+      request.reject(new Error(`Target Peer "${peerId}" disconnected`));
+      if (deliveryTransportPeerId)
+        this.notifyRequestAvailable(deliveryTransportPeerId);
+    }
+    for (const dependentPeerId of dependentPeerIds) {
+      this.unregisterPeerInternal(dependentPeerId, visited, removedPeers);
     }
+    this.removeInstanceFromGroupsWhenDisconnected(removed.instanceId);
+  }
+  removeInstanceFromGroupsWhenDisconnected(instanceId) {
+    if (this.getPeers().some((peer) => peer.instanceId === instanceId))
+      return;
+    this.detachInstanceFromOtherGroups(instanceId);
   }
   unregisterInstanceId(instanceId) {
-    const matching = this.matchingInstancesForInstanceId(instanceId);
-    const removed = matching.map(toPublic);
-    for (const inst of matching) {
-      this.unregisterInstance(inst.pluginSessionId);
+    const matching = this.getPeers().filter((peer) => peer.instanceId === instanceId);
+    const departingRuntimeGroupIds = new Set(matching.flatMap((peer) => peer.multiplayerGroupId !== void 0 && isRuntimeRole(peer.role) ? [peer.multiplayerGroupId] : []));
+    const removedPeers = [];
+    const visited = /* @__PURE__ */ new Set();
+    for (const peer of matching) {
+      this.unregisterPeerInternal(peer.peerId, visited, removedPeers);
     }
-    return removed;
+    this.detachInstanceFromOtherGroups(instanceId);
+    for (const groupId of departingRuntimeGroupIds) {
+      const hasRuntimePeer = this.getPeers().some((peer) => peer.multiplayerGroupId === groupId && isRuntimeRole(peer.role));
+      if (!hasRuntimePeer)
+        this.removeMultiplayerGroup(groupId);
+    }
+    return removedPeers.map(toPublicPeer);
   }
   async unregisterInstanceIdEverywhere(instanceId) {
     return this.unregisterInstanceId(instanceId);
   }
+  getPeers() {
+    return Array.from(this.peersById.values());
+  }
+  getPublicPeers() {
+    return this.getPeers().map(toPublicPeer);
+  }
+  getPeerById(peerId) {
+    return this.getPeers().find((peer) => peer.peerId === peerId);
+  }
   getInstances() {
-    return Array.from(this.instances.values());
+    const peersByInstance = /* @__PURE__ */ new Map();
+    for (const peer of this.getPeers()) {
+      const peers = peersByInstance.get(peer.instanceId);
+      if (peers)
+        peers.push(peer);
+      else
+        peersByInstance.set(peer.instanceId, [peer]);
+    }
+    return Array.from(peersByInstance, ([id, peers]) => {
+      const preferred = preferredPeer(peers);
+      return {
+        id,
+        multiplayerGroupId: this.groupIdForInstance(id) ?? preferred.multiplayerGroupId,
+        placeId: preferred.placeId,
+        placeName: preferred.placeName,
+        peers
+      };
+    });
   }
   getPublicInstances() {
-    return this.getInstances().map(toPublic);
+    return this.getInstances().map((instance) => ({
+      id: instance.id,
+      multiplayerGroupId: instance.multiplayerGroupId,
+      placeId: instance.placeId,
+      placeName: instance.placeName,
+      peers: instance.peers.map(toPublicPeer)
+    }));
+  }
+  getConnectedInstances() {
+    return this.getInstances().flatMap((instance) => {
+      const peers = instance.multiplayerGroupId === void 0 ? instance.peers : instance.peers.filter((peer) => !isRuntimeRole(peer.role));
+      if (peers.length === 0)
+        return [];
+      return [{
+        id: instance.id,
+        multiplayerGroupId: instance.multiplayerGroupId,
+        placeId: instance.placeId,
+        placeName: instance.placeName,
+        peers: peerIdsByRole(peers)
+      }];
+    });
+  }
+  getConnectedMultiplayerGroups() {
+    const peers = this.getPeers();
+    return this.getMultiplayerGroups().map((group) => ({
+      id: group.id,
+      controllerInstanceId: group.controllerInstanceId,
+      instances: Object.fromEntries(peers.filter((peer) => peer.multiplayerGroupId === group.id && isRuntimeRole(peer.role)).sort((left, right) => roleOrder(left.role) - roleOrder(right.role) || left.peerId.localeCompare(right.peerId)).map((peer) => [connectedRuntimeInstanceId(peer), peer.peerId]))
+    }));
   }
-  getInstanceBySessionId(pluginSessionId) {
-    return this.instances.get(pluginSessionId);
+  getMultiplayerGroups() {
+    return Array.from(this.multiplayerGroupsById.values(), copyGroup);
+  }
+  getPublicMultiplayerGroups() {
+    return this.getMultiplayerGroups().map(copyGroup);
+  }
+  getTopologySnapshot() {
+    return {
+      peers: this.getPeers(),
+      instances: this.getInstances(),
+      multiplayerGroups: this.getMultiplayerGroups()
+    };
+  }
+  resolveConnectedInstanceId(instanceId) {
+    const exact = this.getInstances().find((instance) => instance.id === instanceId);
+    const groupedRuntime = this.getPeers().find((peer) => peer.multiplayerGroupId !== void 0 && isRuntimeRole(peer.role) && connectedRuntimeInstanceId(peer) === instanceId);
+    if (exact && groupedRuntime && exact.id !== groupedRuntime.instanceId)
+      return void 0;
+    return exact?.id ?? groupedRuntime?.instanceId;
+  }
+  getInstanceIdsInScope(instanceId) {
+    const resolvedInstanceId = this.resolveConnectedInstanceId(instanceId);
+    if (resolvedInstanceId === void 0)
+      return [];
+    const groupId = this.groupIdForInstance(resolvedInstanceId);
+    if (groupId) {
+      return [...this.getMultiplayerGroups().find((group) => group.id === groupId)?.instanceIds ?? []];
+    }
+    return [resolvedInstanceId];
+  }
+  getPeersInScope(instanceId) {
+    const instanceIds = new Set(this.getInstanceIdsInScope(instanceId));
+    return this.getPeers().filter((peer) => instanceIds.has(peer.instanceId));
   }
   getPendingRequestCount() {
     return this.pendingRequests.size;
   }
-  updateInstanceActivity(pluginSessionId) {
-    const instance = this.instances.get(pluginSessionId);
-    if (!instance)
+  updatePeerActivity(peerId) {
+    const peer = this.getPeerById(peerId);
+    if (!peer)
       return;
     const now = Date.now();
-    for (const candidate of this.instances.values()) {
-      if (candidate.physicalSessionId === instance.physicalSessionId) {
-        candidate.lastActivity = now;
+    if (peer.transportPeerId === peerId) {
+      for (const candidate of this.getPeers()) {
+        if (candidate.transportPeerId === peerId)
+          candidate.lastActivity = now;
       }
+      return;
     }
+    peer.lastActivity = now;
   }
-  updateInstanceMetadata(pluginSessionId, metadata) {
-    const inst = this.instances.get(pluginSessionId);
-    if (!inst)
+  updatePeerMetadata(peerId, metadata) {
+    const peer = this.getPeerById(peerId);
+    if (!peer)
       return;
-    const priorInstanceId = inst.instanceId;
     if (metadata.placeId !== void 0)
-      inst.placeId = metadata.placeId;
+      peer.placeId = metadata.placeId;
     if (metadata.placeName !== void 0)
-      inst.placeName = metadata.placeName;
+      peer.placeName = metadata.placeName;
+    if (metadata.placeKey !== void 0)
+      peer.placeKey = metadata.placeKey;
     if (metadata.dataModelName !== void 0)
-      inst.dataModelName = metadata.dataModelName;
+      peer.dataModelName = metadata.dataModelName;
     if (metadata.isRunning !== void 0)
-      inst.isRunning = metadata.isRunning;
-    const canonicalInstanceId = this.canonicalInstanceId(inst.instanceId, inst.placeId);
-    if (canonicalInstanceId !== inst.instanceId) {
-      const duplicate = Array.from(this.instances.values()).find((other) => other.pluginSessionId !== pluginSessionId && other.instanceId === canonicalInstanceId && other.role === inst.role);
-      if (!duplicate) {
-        this.rememberInstanceAlias(priorInstanceId, canonicalInstanceId);
-        this.migratePendingRequests(priorInstanceId, canonicalInstanceId);
-        inst.instanceId = canonicalInstanceId;
-        this.notifyRequestAvailable(inst.physicalSessionId);
-      }
-    }
+      peer.isRunning = metadata.isRunning;
   }
-  cleanupStaleInstances() {
+  cleanupStalePeers() {
     const now = Date.now();
-    for (const [id, inst] of this.instances.entries()) {
-      const deliveryActive = (this.deliveryOwnersByPhysicalSession.get(inst.physicalSessionId)?.size ?? 0) > 0;
-      if (!deliveryActive && now - inst.lastActivity > STALE_INSTANCE_MS) {
-        this.unregisterInstance(id);
+    for (const peer of this.getPeers()) {
+      const deliveryActive = (this.deliveryOwnersByTransportPeer.get(peer.transportPeerId)?.size ?? 0) > 0;
+      if (!deliveryActive && now - peer.lastActivity > STALE_PEER_MS) {
+        this.unregisterPeer(peer.peerId);
       }
     }
-    this.cleanupStaleAliases(now);
   }
-  getEquivalentInstanceIds(instanceId) {
-    const resolvedInstanceId = this.resolveInstanceAlias(instanceId);
-    const ids = /* @__PURE__ */ new Set([instanceId, resolvedInstanceId]);
-    const placeIds = /* @__PURE__ */ new Set();
-    const addPlaceId = (placeId) => {
-      const published = publishedInstanceId(placeId);
-      if (!published || placeId === void 0)
-        return;
-      ids.add(published);
-      placeIds.add(Math.trunc(placeId));
+  routingErrorData() {
+    const instances = this.getConnectedInstances();
+    const multiplayerGroups = this.getConnectedMultiplayerGroups();
+    return {
+      instances,
+      multiplayerGroups,
+      count: instances.length + multiplayerGroups.length
     };
-    const placeMatch = resolvedInstanceId.match(/^place:(\d+)$/) ?? instanceId.match(/^place:(\d+)$/);
-    if (placeMatch)
-      addPlaceId(Number(placeMatch[1]));
-    for (const inst of this.getInstances()) {
-      if (ids.has(inst.instanceId)) {
-        addPlaceId(inst.placeId);
-      }
+  }
+  resolvedTarget(peer) {
+    return {
+      targetPeerId: peer.peerId,
+      targetInstanceId: peer.instanceId,
+      targetRole: peer.role
+    };
+  }
+  resolveWithinScope(peers, target, errorData, selectedInstanceId) {
+    if (target === "all") {
+      return { ok: true, mode: "fanout", targets: peers.map((peer) => this.resolvedTarget(peer)) };
     }
-    for (const inst of this.getInstances()) {
-      if (inst.placeId > 0 && placeIds.has(Math.trunc(inst.placeId))) {
-        ids.add(inst.instanceId);
+    if (target) {
+      const exact = peers.find((peer) => peer.role === target);
+      if (!exact) {
+        return {
+          ok: false,
+          error: {
+            code: "target_role_not_present_on_instance",
+            message: `${selectedInstanceId ? `Instance "${selectedInstanceId}" scope` : "The connected scope"} has no role "${target}". Available roles: ${peers.map((peer) => peer.role).join(", ")}.`,
+            data: errorData
+          }
+        };
       }
+      return { ok: true, mode: "single", ...this.resolvedTarget(exact) };
     }
-    for (const [alias, entry] of this.instanceAliases.entries()) {
-      if (ids.has(entry.targetInstanceId))
-        ids.add(alias);
+    const edit = peers.find((peer) => peer.role === "edit");
+    if (edit)
+      return { ok: true, mode: "single", ...this.resolvedTarget(edit) };
+    if (peers.length === 1) {
+      return { ok: true, mode: "single", ...this.resolvedTarget(peers[0]) };
     }
-    return Array.from(ids);
+    return {
+      ok: false,
+      error: {
+        code: "target_role_required",
+        message: `${selectedInstanceId ? `Instance "${selectedInstanceId}" scope` : "The connected scope"} has multiple roles connected: ${peers.map((peer) => peer.role).join(", ")}. Pass target=<role>.`,
+        data: errorData
+      }
+    };
   }
-  // Resolves (instance_id, target-role) MCP arguments to a concrete
-  // routing decision: either a single (instanceId, role) tuple or a fanout
-  // list. Returns an error result with the full instance list embedded so
-  // the caller (tool layer) can surface it without a second round-trip.
   resolveTarget(input) {
-    const instances = this.getInstances();
-    const publicList = instances.map(toPublic);
-    const errorData = { instances: publicList, count: publicList.length };
-    const { instance_id, target } = input;
-    const isFanout = target === "all";
-    const role = target && target !== "all" ? target : void 0;
-    if (instance_id !== void 0) {
-      const matchingInstances = this.matchingInstancesForInstanceId(instance_id);
-      if (matchingInstances.length === 0) {
+    const errorData = this.routingErrorData();
+    if (input.instance_id !== void 0) {
+      const peers2 = this.getPeersInScope(input.instance_id);
+      if (peers2.length === 0) {
         return {
           ok: false,
           error: {
             code: "unrecognized_instance_id",
-            message: `instance_id "${instance_id}" is not connected. Pass one from data.instances.`,
+            message: `instance_id "${input.instance_id}" is not connected. Pass a connected top-level or grouped role-suffixed Instance ID.`,
             data: errorData
           }
         };
       }
-      if (isFanout) {
-        return {
-          ok: true,
-          mode: "fanout",
-          targets: matchingInstances.map((i) => ({
-            targetInstanceId: i.instanceId,
-            targetRole: i.role
-          }))
-        };
-      }
-      if (role) {
-        const exact = matchingInstances.find((i) => i.role === role);
-        if (!exact) {
-          return {
-            ok: false,
-            error: {
-              code: "target_role_not_present_on_instance",
-              message: `instance "${instance_id}" has no role "${role}". Available roles: ${matchingInstances.map((i) => i.role).join(", ")}.`,
-              data: errorData
-            }
-          };
-        }
-        return { ok: true, mode: "single", targetInstanceId: exact.instanceId, targetRole: role };
-      }
-      if (matchingInstances.length === 1) {
-        return {
-          ok: true,
-          mode: "single",
-          targetInstanceId: matchingInstances[0].instanceId,
-          targetRole: matchingInstances[0].role
-        };
-      }
-      const edit = matchingInstances.find((i) => i.role === "edit");
-      if (edit) {
-        return { ok: true, mode: "single", targetInstanceId: edit.instanceId, targetRole: "edit" };
-      }
+      return this.resolveWithinScope(peers2, input.target, errorData, input.instance_id);
+    }
+    const scopeKeys = new Set(this.getPeers().map((peer) => this.peerScopeKey(peer)));
+    if (scopeKeys.size === 0) {
       return {
         ok: false,
         error: {
-          code: "target_role_required",
-          message: `instance "${instance_id}" has multiple roles connected: ${matchingInstances.map((i) => i.role).join(", ")}. Pass target=<role>.`,
+          code: "unrecognized_instance_id",
+          message: "No Studio Peer is connected.",
           data: errorData
         }
       };
     }
-    const distinctInstanceIds = new Set(instances.map((i) => this.routingKeyForInstance(i)));
-    if (distinctInstanceIds.size === 0) {
+    if (scopeKeys.size > 1) {
+      const code = input.target ? "ambiguous_target" : "multiple_instances_connected";
       return {
         ok: false,
         error: {
-          code: "unrecognized_instance_id",
-          message: "No Studio plugin is connected.",
+          code,
+          message: input.target ? `target=${input.target} is ambiguous because multiple Studio routing scopes are connected. Pass instance_id to choose a scope.` : "Multiple Studio routing scopes are connected. Pass instance_id to disambiguate.",
           data: errorData
         }
       };
     }
-    if (distinctInstanceIds.size > 1) {
-      const errorCode2 = role ? "ambiguous_target" : "multiple_instances_connected";
-      const msg = role ? `target=${role} is ambiguous because multiple Studio places are connected. Pass instance_id to choose a place.` : "Multiple Studio places are connected. Pass instance_id to disambiguate.";
-      return { ok: false, error: { code: errorCode2, message: msg, data: errorData } };
-    }
-    const onlyInstanceId = distinctInstanceIds.values().next().value;
-    return this.resolveTarget({ instance_id: onlyInstanceId, target });
+    const onlyScope = scopeKeys.values().next().value;
+    const peers = this.getPeers().filter((peer) => this.peerScopeKey(peer) === onlyScope);
+    return this.resolveWithinScope(peers, input.target, errorData);
   }
-  async sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs = this.requestTimeout, signal) {
+  sendRequest(endpoint, data, targetPeerId, timeoutMs = this.requestTimeout, signal) {
     const requestId = randomUUID();
     const effectiveTimeoutMs = Math.max(1, timeoutMs);
     if (signal?.aborted)
-      throw new Error("Request aborted");
-    return new Promise((resolve5, reject) => {
-      const cancelPending = (reason, error) => {
-        const pending = this.pendingRequests.get(requestId);
-        if (!pending || !this.removePendingRequest(pending))
-          return;
-        this.notifyRequestCancelled(pending, reason);
-        pending.reject(error);
-      };
-      const timeoutId = setTimeout(() => cancelPending("timeout", new Error("Request timeout")), effectiveTimeoutMs);
-      const abortListener = () => cancelPending("aborted", new Error("Request aborted"));
-      const request = {
-        id: requestId,
-        endpoint,
-        data,
-        targetInstanceId,
-        targetRole,
-        timestamp: Date.now(),
-        resolve: resolve5,
-        reject,
-        timeoutId,
-        timeoutMs: effectiveTimeoutMs,
-        abortSignal: signal,
-        abortListener
-      };
-      this.pendingRequests.set(requestId, request);
-      signal?.addEventListener("abort", abortListener, { once: true });
-      if (signal?.aborted)
-        abortListener();
-      if (this.pendingRequests.has(requestId)) {
-        for (const physicalSessionId of this.physicalSessionsForTarget(targetInstanceId, targetRole)) {
-          this.notifyRequestAvailable(physicalSessionId);
-        }
-      }
-    });
+      return Promise.reject(new Error("Request aborted"));
+    const { promise, resolve: resolve5, reject } = Promise.withResolvers();
+    const cancelPending = (reason, error) => {
+      const pending = this.pendingRequests.get(requestId);
+      if (!pending || !this.removePendingRequest(pending))
+        return;
+      this.notifyRequestCancelled(pending, reason);
+      pending.reject(error);
+    };
+    const timeoutId = setTimeout(() => cancelPending("timeout", new Error("Request timeout")), effectiveTimeoutMs);
+    const abortListener = () => cancelPending("aborted", new Error("Request aborted"));
+    const request = {
+      id: requestId,
+      endpoint,
+      data,
+      targetPeerId,
+      timestamp: Date.now(),
+      resolve: resolve5,
+      reject,
+      timeoutId,
+      timeoutMs: effectiveTimeoutMs,
+      abortSignal: signal,
+      abortListener
+    };
+    this.pendingRequests.set(requestId, request);
+    signal?.addEventListener("abort", abortListener, { once: true });
+    if (signal?.aborted)
+      abortListener();
+    const target = this.getPeerById(targetPeerId);
+    if (this.pendingRequests.has(requestId) && target) {
+      this.notifyRequestAvailable(target.transportPeerId);
+    }
+    return promise;
   }
   removePendingRequest(request) {
     if (this.pendingRequests.get(request.id) !== request)
@@ -2457,43 +2593,44 @@ var BridgeService = class {
     this.pendingRequests.delete(request.id);
     return true;
   }
-  claimNextRequestForPhysical(physicalSessionId, claimOwner) {
+  claimNextRequestForTransport(transportPeerId, claimOwner) {
+    let outstandingCount = 0;
+    for (const request of this.pendingRequests.values()) {
+      if (request.claimOwner === claimOwner)
+        outstandingCount++;
+    }
+    if (outstandingCount >= MAX_OUTSTANDING_REQUESTS_PER_DELIVERY_OWNER)
+      return null;
     let oldestRequest;
-    let logicalSessionId = "";
     for (const request of this.pendingRequests.values()) {
       if (request.claimOwner !== void 0)
         continue;
-      let matchingSessionId;
-      for (const candidate of this.instances.values()) {
-        if (candidate.physicalSessionId === physicalSessionId && candidate.instanceId === request.targetInstanceId && candidate.role === request.targetRole) {
-          matchingSessionId = candidate.pluginSessionId;
-          break;
-        }
-      }
-      if (!matchingSessionId)
+      const peer2 = this.getPeerById(request.targetPeerId);
+      if (!peer2 || peer2.transportPeerId !== transportPeerId)
         continue;
-      if (!oldestRequest || request.timestamp < oldestRequest.timestamp) {
+      if (!oldestRequest || request.timestamp < oldestRequest.timestamp)
         oldestRequest = request;
-        logicalSessionId = matchingSessionId;
-      }
     }
     if (!oldestRequest)
       return null;
+    const peer = this.getPeerById(oldestRequest.targetPeerId);
+    if (!peer)
+      return null;
     oldestRequest.claimOwner = claimOwner;
-    oldestRequest.lastDeliveryPhysicalSessionId = physicalSessionId;
+    oldestRequest.lastDeliveryTransportPeerId = transportPeerId;
     return {
       requestId: oldestRequest.id,
-      logicalSessionId,
-      target: oldestRequest.targetRole,
+      peerId: oldestRequest.targetPeerId,
+      target: peer.role,
       endpoint: oldestRequest.endpoint,
       data: oldestRequest.data,
       remainingMs: Math.max(1, oldestRequest.timeoutMs - (Date.now() - oldestRequest.timestamp))
     };
   }
-  claimNextCancellationForPhysical(physicalSessionId, claimOwner) {
+  claimNextCancellationForTransport(transportPeerId, claimOwner) {
     this.prunePendingCancellations(Date.now());
     for (const cancellation of this.pendingCancellations.values()) {
-      if (cancellation.physicalSessionId !== physicalSessionId || cancellation.claimOwner !== void 0) {
+      if (cancellation.transportPeerId !== transportPeerId || cancellation.claimOwner !== void 0) {
         continue;
       }
       cancellation.claimOwner = claimOwner;
@@ -2502,24 +2639,23 @@ var BridgeService = class {
     return null;
   }
   releaseDeliveryClaims(claimOwner) {
-    const physicalSessionIds = /* @__PURE__ */ new Set();
+    const transportPeerIds = /* @__PURE__ */ new Set();
     for (const request of this.pendingRequests.values()) {
       if (request.claimOwner !== claimOwner)
         continue;
       request.claimOwner = void 0;
-      for (const physicalSessionId of this.physicalSessionsForTarget(request.targetInstanceId, request.targetRole)) {
-        physicalSessionIds.add(physicalSessionId);
-      }
+      const peer = this.getPeerById(request.targetPeerId);
+      if (peer)
+        transportPeerIds.add(peer.transportPeerId);
     }
     for (const cancellation of this.pendingCancellations.values()) {
       if (cancellation.claimOwner !== claimOwner)
         continue;
       cancellation.claimOwner = void 0;
-      physicalSessionIds.add(cancellation.physicalSessionId);
-    }
-    for (const physicalSessionId of physicalSessionIds) {
-      this.notifyRequestAvailable(physicalSessionId);
+      transportPeerIds.add(cancellation.transportPeerId);
     }
+    for (const transportPeerId of transportPeerIds)
+      this.notifyRequestAvailable(transportPeerId);
   }
   resolveRequest(requestId, response) {
     return this.settleRequest(requestId, (request) => request.resolve(response));
@@ -2531,13 +2667,15 @@ var BridgeService = class {
     const now = Date.now();
     this.pruneAcceptedRequestIds(now);
     const request = this.pendingRequests.get(requestId);
-    if (!request) {
+    if (!request)
       return this.acceptedRequestIds.has(requestId) ? "already_settled" : "unknown";
-    }
+    const deliveryTransportPeerId = request.lastDeliveryTransportPeerId;
     this.removePendingRequest(request);
     this.acceptedRequestIds.set(requestId, now);
     this.pruneAcceptedRequestIds(now);
     settle(request);
+    if (deliveryTransportPeerId)
+      this.notifyRequestAvailable(deliveryTransportPeerId);
     return "accepted";
   }
   pruneAcceptedRequestIds(now) {
@@ -2829,7 +2967,7 @@ Tool descriptions explain selection. Input schemas explain arguments. This guide
 ## Connection and paths
 
 - Use canonical DataModel paths returned by the tools. Paths usually start with game.
-- Call get_connected_instances when more than one place may be connected. Pass the chosen row's id as instance_id on later calls.
+- Call get_connected_instances when more than one Studio process may be connected. Pass either a top-level Instance ID or a multiplayer group's role-suffixed Instance ID as instance_id on later calls.
 - Use get_place_info for the active place identity and settings.
 
 ## Discovery and edit work
@@ -2859,7 +2997,7 @@ Start solo_playtest or multiplayer_playtest before targeting a live server or cl
 
 execute_luau runs through the Studio plugin. eval_server_runtime and eval_client_runtime run inside a live game VM and share that VM's require cache with game scripts. Use the eval tools when module state or the runtime Script or LocalScript environment matters.
 
-Read output with get_runtime_logs. Reuse nextSince or perCaptureNextSince for incremental reads instead of requesting the full buffer again.
+Read output with get_runtime_logs. Reuse nextCursor as cursor for one Instance, or nextCursorByInstance as cursor_by_instance for a Multiplayer Group, instead of requesting the full process streams again.
 
 ## Simulation and input
 
@@ -5388,7 +5526,7 @@ var INTERNAL_RESULT_KEYS = /* @__PURE__ */ new Set([
   "diagnostics",
   "internal",
   "lastActivity",
-  "pluginSessionId",
+  "transportPeerId",
   "pluginVariant",
   "pluginVersion",
   "requestId",
@@ -5492,12 +5630,18 @@ function publicRoutingError(error) {
   return {
     error: error.routingError.code,
     message: error.routingError.message,
+    count: error.routingError.data.count,
     instances: error.routingError.data.instances.map((instance) => ({
-      instance_id: instance.instanceId,
-      role: instance.role,
+      instance_id: instance.id,
+      multiplayer_group_id: instance.multiplayerGroupId,
       place_id: instance.placeId,
       place_name: instance.placeName,
-      running: instance.isRunning
+      peers: instance.peers
+    })),
+    multiplayer_groups: error.routingError.data.multiplayerGroups.map((group) => ({
+      multiplayer_group_id: group.id,
+      controller_instance_id: group.controllerInstanceId,
+      instances: group.instances
     }))
   };
 }
@@ -5563,7 +5707,7 @@ function serverInstructions(definitions) {
   const has = (...toolNames) => toolNames.every((name) => names.has(name));
   const instructions = ["Use canonical DataModel paths returned by tools."];
   if (has("get_connected_instances")) {
-    instructions.push("When more than one place is connected, call get_connected_instances and pass the chosen id as instance_id.");
+    instructions.push("When more than one Studio process scope is connected, call get_connected_instances and pass either a top-level instance id or a multiplayer group's role-suffixed instance id as instance_id.");
   }
   if (has("search_objects", "get_project_structure", "grep_scripts", "execute_luau")) {
     instructions.push("Use search_objects, get_project_structure, or grep_scripts for standard discovery. Use execute_luau for custom traversal or bulk edits.");
@@ -5677,34 +5821,34 @@ var SseStudioTransport = class {
   queue;
   streams = /* @__PURE__ */ new Map();
   unsubscribeRequestAvailable;
-  unsubscribeSessionClosed;
+  unsubscribePeerClosed;
   nextGeneration = 0;
   constructor(queue) {
     this.queue = queue;
-    this.unsubscribeRequestAvailable = queue.onRequestAvailable((physicalSessionId) => {
-      const stream = this.streams.get(physicalSessionId);
+    this.unsubscribeRequestAvailable = queue.onRequestAvailable((transportPeerId) => {
+      const stream = this.streams.get(transportPeerId);
       if (stream)
         this.pump(stream);
     });
-    this.unsubscribeSessionClosed = queue.onSessionClosed((route) => {
-      if (route.logicalSessionId === route.physicalSessionId) {
-        this.closePhysical(route.physicalSessionId);
+    this.unsubscribePeerClosed = queue.onPeerClosed((route) => {
+      if (route.peerId === route.transportPeerId) {
+        this.closeTransport(route.transportPeerId);
       }
     });
   }
   get activeStreamCount() {
     return this.streams.size;
   }
-  canOpen(physicalSessionId) {
-    return this.streams.has(physicalSessionId) || this.streams.size < MAX_ACTIVE_EVENT_STREAMS;
+  canOpen(transportPeerId) {
+    return this.streams.has(transportPeerId) || this.streams.size < MAX_ACTIVE_EVENT_STREAMS;
   }
-  open(physicalSessionId, sink, status) {
-    if (!this.canOpen(physicalSessionId))
+  open(transportPeerId, sink, status) {
+    if (!this.canOpen(transportPeerId))
       return void 0;
     this.nextGeneration += 1;
-    const claimOwner = `sse:${physicalSessionId}:${this.nextGeneration}`;
+    const claimOwner = `sse:${transportPeerId}:${this.nextGeneration}`;
     const stream = {
-      physicalSessionId,
+      transportPeerId,
       claimOwner,
       sink,
       status,
@@ -5719,18 +5863,18 @@ var SseStudioTransport = class {
         this.pump(stream);
       }
     };
-    this.queue.setDeliveryActive(physicalSessionId, claimOwner, true);
-    this.queue.updateInstanceActivity(physicalSessionId);
-    const replaced = this.streams.get(physicalSessionId);
+    this.queue.setDeliveryActive(transportPeerId, claimOwner, true);
+    this.queue.updatePeerActivity(transportPeerId);
+    const replaced = this.streams.get(transportPeerId);
     if (replaced)
       this.closeStream(replaced, true);
-    this.streams.set(physicalSessionId, stream);
+    this.streams.set(transportPeerId, stream);
     sink.on("close", stream.onClose);
     sink.on("error", stream.onClose);
     sink.on("drain", stream.onDrain);
     stream.heartbeatTimer = setInterval(() => {
       if (!stream.closed && !stream.blocked) {
-        this.queue.updateInstanceActivity(physicalSessionId);
+        this.queue.updatePeerActivity(transportPeerId);
         stream.statusPending = true;
         this.pump(stream);
         if (!stream.blocked) {
@@ -5741,13 +5885,13 @@ var SseStudioTransport = class {
     stream.heartbeatTimer.unref();
     this.pump(stream);
     return {
-      physicalSessionId,
+      transportPeerId,
       close: () => this.closeStream(stream, true)
     };
   }
-  refreshStatus(physicalSessionId) {
-    if (physicalSessionId !== void 0) {
-      const stream = this.streams.get(physicalSessionId);
+  refreshStatus(transportPeerId) {
+    if (transportPeerId !== void 0) {
+      const stream = this.streams.get(transportPeerId);
       if (stream) {
         stream.lastStatusJson = void 0;
         stream.statusPending = true;
@@ -5761,8 +5905,8 @@ var SseStudioTransport = class {
       this.pump(stream);
     }
   }
-  closePhysical(physicalSessionId) {
-    const stream = this.streams.get(physicalSessionId);
+  closeTransport(transportPeerId) {
+    const stream = this.streams.get(transportPeerId);
     if (stream)
       this.closeStream(stream, true);
   }
@@ -5771,10 +5915,10 @@ var SseStudioTransport = class {
       this.closeStream(stream, true);
     }
     this.unsubscribeRequestAvailable();
-    this.unsubscribeSessionClosed();
+    this.unsubscribePeerClosed();
   }
   pump(stream) {
-    if (stream.closed || stream.blocked || this.streams.get(stream.physicalSessionId) !== stream)
+    if (stream.closed || stream.blocked || this.streams.get(stream.transportPeerId) !== stream)
       return;
     if (stream.statusPending) {
       stream.statusPending = false;
@@ -5793,20 +5937,20 @@ var SseStudioTransport = class {
       }
     }
     while (!stream.closed && !stream.blocked) {
-      const cancellation = this.queue.claimNextCancellationForPhysical(stream.physicalSessionId, stream.claimOwner);
+      const cancellation = this.queue.claimNextCancellationForTransport(stream.transportPeerId, stream.claimOwner);
       if (!cancellation)
         break;
       if (!this.write(stream, { kind: "cancel", ...cancellation }))
         return;
     }
     while (!stream.closed && !stream.blocked) {
-      const request = this.queue.claimNextRequestForPhysical(stream.physicalSessionId, stream.claimOwner);
+      const request = this.queue.claimNextRequestForTransport(stream.transportPeerId, stream.claimOwner);
       if (!request)
         return;
       const event = {
         kind: "request",
         requestId: request.requestId,
-        logicalSessionId: request.logicalSessionId,
+        peerId: request.peerId,
         target: request.target,
         endpoint: request.endpoint,
         data: request.data === void 0 ? null : request.data,
@@ -5839,11 +5983,11 @@ var SseStudioTransport = class {
     stream.sink.removeListener("close", stream.onClose);
     stream.sink.removeListener("error", stream.onClose);
     stream.sink.removeListener("drain", stream.onDrain);
-    if (this.streams.get(stream.physicalSessionId) === stream) {
-      this.streams.delete(stream.physicalSessionId);
+    if (this.streams.get(stream.transportPeerId) === stream) {
+      this.streams.delete(stream.transportPeerId);
     }
-    this.queue.updateInstanceActivity(stream.physicalSessionId);
-    this.queue.setDeliveryActive(stream.physicalSessionId, stream.claimOwner, false);
+    this.queue.updatePeerActivity(stream.transportPeerId);
+    this.queue.setDeliveryActive(stream.transportPeerId, stream.claimOwner, false);
     this.queue.releaseDeliveryClaims(stream.claimOwner);
     if (endSink) {
       try {
@@ -5855,6 +5999,32 @@ var SseStudioTransport = class {
 };
 
 // ../core/dist/http-server.js
+function toPassivePeer(peer) {
+  return {
+    instanceId: peer.instanceId,
+    multiplayerGroupId: peer.multiplayerGroupId,
+    role: peer.role,
+    placeId: peer.placeId,
+    placeName: peer.placeName,
+    placeKey: peer.placeKey,
+    dataModelName: peer.dataModelName,
+    isRunning: peer.isRunning,
+    pluginVersion: peer.pluginVersion,
+    pluginVariant: peer.pluginVariant,
+    serverVersion: peer.serverVersion,
+    lastActivity: peer.lastActivity,
+    connectedAt: peer.connectedAt
+  };
+}
+function toPassiveInstance(instance) {
+  return {
+    id: instance.id,
+    multiplayerGroupId: instance.multiplayerGroupId,
+    placeId: instance.placeId,
+    placeName: instance.placeName,
+    peers: instance.peers.map(toPassivePeer)
+  };
+}
 function parseLineRange(lineRange) {
   const validLine = (line) => line === void 0 || line >= 1;
   if (typeof lineRange === "string") {
@@ -5946,7 +6116,7 @@ var TOOL_HANDLERS = {
   manage_instance: (tools, body) => tools.manageInstance(body),
   solo_playtest: (tools, body) => tools.soloPlaytest(body.action, body.mode, body.timeout, body.instance_id),
   multiplayer_playtest: (tools, body) => tools.multiplayerPlaytest(body.action, body.numPlayers, body.target, body.testArgs, body.value, body.timeout, body.instance_id),
-  get_runtime_logs: (tools, body) => tools.getRuntimeLogs(body.target, body.since, body.tail, body.filter, body.instance_id),
+  get_runtime_logs: (tools, body) => tools.getRuntimeLogs(body.instance_id, body.multiplayer_group_id, body.cursor, body.cursor_by_instance, body.tail, body.filter),
   capture_script_profiler: (tools, body) => tools.captureScriptProfiler(body.target, {
     duration_ms: body.duration_ms,
     frequency: body.frequency,
@@ -6010,7 +6180,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   let lastMCPActivity = 0;
   let mcpServerStartTime = 0;
   const proxyInstances = /* @__PURE__ */ new Set();
-  const rejectedVersionSessions = /* @__PURE__ */ new Set();
+  const rejectedVersionPeers = /* @__PURE__ */ new Set();
   const eventTransport = new SseStudioTransport(bridge);
   const eventStreamHandles = /* @__PURE__ */ new Set();
   const setMCPServerActive = (active) => {
@@ -6037,20 +6207,20 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       return false;
     return Date.now() - lastMCPActivity < 3e4;
   };
-  const eventStatus = (physicalSessionId) => {
-    const instance = bridge.getInstanceBySessionId(physicalSessionId);
-    const knownInstance = instance?.physicalSessionId === physicalSessionId;
+  const eventStatus = (transportPeerId) => {
+    const peer = bridge.getPeerById(transportPeerId);
+    const knownPeer = peer?.transportPeerId === transportPeerId;
     return {
       kind: "status",
-      knownInstance,
+      knownPeer,
       mcpConnected: isMCPServerActive(),
       serverVersion: serverConfig?.version,
-      pluginVersion: instance?.pluginVersion,
-      pluginVariant: instance?.pluginVariant
+      pluginVersion: peer?.pluginVersion,
+      pluginVariant: peer?.pluginVariant
     };
   };
   const isPluginConnected = () => {
-    return bridge.getInstances().length > 0;
+    return bridge.getPeers().length > 0;
   };
   const allowedOrigins = new Set(security?.allowedOrigins ?? []);
   app.use((req, res, next) => {
@@ -6077,7 +6247,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     next();
   });
   const authToken = security?.authToken;
-  const authRequired = (path6) => path6 === "/mcp" || path6.startsWith("/mcp/") || path6 === "/proxy" || path6 === "/instances" || path6 === "/unregister-instance-id";
+  const authRequired = (path6) => path6 === "/mcp" || path6.startsWith("/mcp/") || path6 === "/proxy" || path6 === "/topology" || path6 === "/unregister-instance-id" || path6 === "/create-multiplayer-group" || path6 === "/remove-multiplayer-group";
   app.use((req, res, next) => {
     if (!authToken || !authRequired(req.path)) {
       next();
@@ -6098,8 +6268,9 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   app.use(express.json({ limit: "50mb" }));
   app.use(express.urlencoded({ limit: "50mb", extended: true }));
   app.get("/health", (req, res) => {
-    const instances = bridge.getInstances();
-    const publicInstances = instances.map(toPublic);
+    const peers = bridge.getPublicPeers().map(toPassivePeer);
+    const instances = bridge.getPublicInstances().map(toPassiveInstance);
+    const multiplayerGroups = bridge.getPublicMultiplayerGroups();
     res.json({
       status: "ok",
       service: "robloxstudio-mcp",
@@ -6115,9 +6286,12 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
           processIdentity: studioLifecycleCapabilities?.processIdentity
         }
       } : {},
-      pluginConnected: instances.length > 0,
+      pluginConnected: peers.length > 0,
       instanceCount: instances.length,
-      instances: publicInstances,
+      peerCount: peers.length,
+      instances,
+      peers,
+      multiplayerGroups,
       mcpServerActive: isMCPServerActive(),
       uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0,
       pendingRequests: bridge.getPendingRequestCount(),
@@ -6127,25 +6301,34 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     });
   });
   app.post("/ready", (req, res) => {
-    const { pluginSessionId, physicalSessionId, instanceId, role, placeId, placeName, dataModelName, isRunning, pluginVersion, pluginVariant } = req.body;
+    const { peerId, transportPeerId, instanceId, multiplayerGroupId, role, placeId, placeName, placeKey, dataModelName, isRunning, pluginVersion, pluginVariant, timestamp } = req.body;
     const requestContext = {
-      physicalSessionId: typeof physicalSessionId === "string" ? physicalSessionId : void 0,
+      peerId: typeof peerId === "string" ? peerId : void 0,
+      transportPeerId: typeof transportPeerId === "string" ? transportPeerId : void 0,
       instanceId: typeof instanceId === "string" ? instanceId : void 0,
+      multiplayerGroupId: typeof multiplayerGroupId === "string" ? multiplayerGroupId : void 0,
       role: typeof role === "string" ? role : void 0,
       placeId: typeof placeId === "number" ? placeId : void 0,
       placeName: typeof placeName === "string" ? placeName : void 0,
+      placeKey: typeof placeKey === "string" ? placeKey : void 0,
       dataModelName: typeof dataModelName === "string" ? dataModelName : void 0,
       isRunning: typeof isRunning === "boolean" ? isRunning : void 0,
       pluginVersion: typeof pluginVersion === "string" ? pluginVersion : void 0,
-      pluginVariant: typeof pluginVariant === "string" ? pluginVariant : void 0
+      pluginVariant: typeof pluginVariant === "string" ? pluginVariant : void 0,
+      timestamp: typeof timestamp === "number" ? timestamp : void 0
     };
     const missingFields = [
-      typeof pluginSessionId !== "string" || pluginSessionId === "" ? "pluginSessionId" : void 0,
-      typeof physicalSessionId !== "string" || physicalSessionId === "" ? "physicalSessionId" : void 0,
+      typeof peerId !== "string" || peerId === "" ? "peerId" : void 0,
+      typeof transportPeerId !== "string" || transportPeerId === "" ? "transportPeerId" : void 0,
       typeof instanceId !== "string" || instanceId === "" ? "instanceId" : void 0,
       typeof role !== "string" || role === "" ? "role" : void 0,
+      typeof placeId !== "number" || !Number.isFinite(placeId) ? "placeId" : void 0,
+      typeof placeName !== "string" ? "placeName" : void 0,
+      typeof dataModelName !== "string" ? "dataModelName" : void 0,
+      typeof isRunning !== "boolean" ? "isRunning" : void 0,
       typeof pluginVersion !== "string" || pluginVersion === "" ? "pluginVersion" : void 0,
-      typeof pluginVariant !== "string" || pluginVariant === "" ? "pluginVariant" : void 0
+      typeof pluginVariant !== "string" || pluginVariant === "" ? "pluginVariant" : void 0,
+      typeof timestamp !== "number" || !Number.isFinite(timestamp) ? "timestamp" : void 0
     ].filter((field) => !!field);
     if (missingFields.length > 0) {
       res.status(400).json({
@@ -6157,6 +6340,15 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       });
       return;
     }
+    if (multiplayerGroupId !== void 0 && (typeof multiplayerGroupId !== "string" || multiplayerGroupId === "")) {
+      res.status(400).json({
+        success: false,
+        error: "invalid_multiplayer_group_id",
+        message: "multiplayerGroupId must be a non-empty string when provided.",
+        request: requestContext
+      });
+      return;
+    }
     const serverVersion = serverConfig?.version;
     if (!serverVersion) {
       res.status(503).json({
@@ -6168,10 +6360,10 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       return;
     }
     if (pluginVersion !== serverVersion) {
-      if (!rejectedVersionSessions.has(pluginSessionId)) {
-        if (rejectedVersionSessions.size >= 256)
-          rejectedVersionSessions.clear();
-        rejectedVersionSessions.add(pluginSessionId);
+      if (!rejectedVersionPeers.has(peerId)) {
+        if (rejectedVersionPeers.size >= 256)
+          rejectedVersionPeers.clear();
+        rejectedVersionPeers.add(peerId);
         console.error(`[plugin-version-rejected] Studio plugin v${pluginVersion} (${pluginVariant}) does not match MCP server v${serverVersion} for ${instanceId}/${role}`);
       }
       res.status(426).json({
@@ -6185,24 +6377,25 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       return;
     }
     const isClientRole = role === "client" || /^client-[1-9]\d*$/.test(role);
-    const isLogicalSession = physicalSessionId !== pluginSessionId;
-    if (isLogicalSession && !isClientRole || !isLogicalSession && isClientRole || !isClientRole && role !== "edit" && role !== "server") {
+    const isProxiedPeer = transportPeerId !== peerId;
+    if (isProxiedPeer && !isClientRole || !isProxiedPeer && isClientRole || !isClientRole && role !== "edit" && role !== "server") {
       res.status(400).json({
         success: false,
-        error: "invalid_session_topology",
-        message: "Physical sessions must use the edit or server role; client roles must use a distinct physical server session.",
+        error: "invalid_peer_topology",
+        message: "Transport Peers must use the edit or server role; client Peers must use a distinct server transport Peer.",
         request: requestContext
       });
       return;
     }
-    if (isLogicalSession) {
-      const physicalOwner = bridge.getInstanceBySessionId(physicalSessionId);
-      const requestedInstanceId = typeof placeId === "number" && Number.isFinite(placeId) && placeId > 0 ? `place:${Math.trunc(placeId)}` : bridge.resolveInstanceId(instanceId);
-      if (!physicalOwner || physicalOwner.pluginSessionId !== physicalSessionId || physicalOwner.physicalSessionId !== physicalSessionId || physicalOwner.role !== "server" || physicalOwner.instanceId !== requestedInstanceId) {
+    if (isProxiedPeer) {
+      const transportOwner = bridge.getPeerById(transportPeerId);
+      const sameInstance = transportOwner?.instanceId === instanceId;
+      const sameMultiplayerGroup = typeof multiplayerGroupId === "string" && transportOwner?.multiplayerGroupId === multiplayerGroupId;
+      if (!transportOwner || transportOwner.peerId !== transportPeerId || transportOwner.transportPeerId !== transportPeerId || transportOwner.role !== "server" || !sameInstance && !sameMultiplayerGroup) {
         res.status(409).json({
           success: false,
-          error: "physical_session_unavailable",
-          message: "A logical client requires a registered physical server session for the same Studio instance.",
+          error: "transport_peer_unavailable",
+          message: "A client Peer requires a registered server transport Peer in the same Instance or explicit MultiplayerGroup.",
           request: requestContext
         });
         return;
@@ -6210,15 +6403,17 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     }
     let result;
     try {
-      result = bridge.registerInstance({
-        pluginSessionId,
-        physicalSessionId,
+      result = bridge.registerPeer({
+        peerId,
+        transportPeerId,
         instanceId,
+        multiplayerGroupId,
         role,
-        placeId: typeof placeId === "number" ? placeId : 0,
-        placeName: typeof placeName === "string" ? placeName : "",
-        dataModelName: typeof dataModelName === "string" ? dataModelName : "",
-        isRunning: !!isRunning,
+        placeId,
+        placeName,
+        placeKey: typeof placeKey === "string" ? placeKey : void 0,
+        dataModelName,
+        isRunning,
         pluginVersion,
         pluginVariant,
         serverVersion
@@ -6242,75 +6437,98 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       });
       return;
     }
-    eventTransport.refreshStatus(physicalSessionId);
+    eventTransport.refreshStatus(transportPeerId);
     res.json({
       success: true,
       assignedRole: result.assignedRole,
+      peerId: result.peerId,
       instanceId: result.instanceId,
+      multiplayerGroupId: result.multiplayerGroupId,
       serverVersion
     });
   });
   app.post("/disconnect", (req, res) => {
-    const { pluginSessionId } = req.body;
-    if (pluginSessionId) {
-      bridge.unregisterInstance(pluginSessionId);
+    const { peerId } = req.body;
+    if (typeof peerId === "string" && peerId !== "") {
+      bridge.unregisterPeer(peerId);
     }
     res.json({ success: true });
   });
-  app.post("/unregister-instance-id", (req, res) => {
+  app.post("/unregister-instance-id", async (req, res) => {
     const { instanceId } = req.body;
     if (typeof instanceId !== "string" || instanceId.length === 0) {
       res.status(400).json({ error: "instanceId is required" });
       return;
     }
-    const removed = bridge.unregisterInstanceId(instanceId);
+    const removed = await bridge.unregisterInstanceIdEverywhere(instanceId);
+    res.json({ success: true, removed });
+  });
+  app.post("/create-multiplayer-group", async (req, res) => {
+    const { groupId, controllerInstanceId } = req.body;
+    if (typeof groupId !== "string" || groupId.length === 0 || typeof controllerInstanceId !== "string" || controllerInstanceId.length === 0) {
+      res.status(400).json({ error: "groupId and controllerInstanceId are required" });
+      return;
+    }
+    const group = await bridge.createMultiplayerGroupEverywhere(groupId, controllerInstanceId);
+    res.json({ success: true, group });
+  });
+  app.post("/remove-multiplayer-group", async (req, res) => {
+    const { groupId } = req.body;
+    if (typeof groupId !== "string" || groupId.length === 0) {
+      res.status(400).json({ error: "groupId is required" });
+      return;
+    }
+    const removed = await bridge.removeMultiplayerGroupEverywhere(groupId);
     res.json({ success: true, removed });
   });
   app.get("/status", (req, res) => {
-    const instances = bridge.getInstances();
-    const publicInstances = instances.map(toPublic);
+    const peers = bridge.getPublicPeers().map(toPassivePeer);
+    const instances = bridge.getPublicInstances().map(toPassiveInstance);
+    const multiplayerGroups = bridge.getPublicMultiplayerGroups();
     res.json({
-      pluginConnected: instances.length > 0,
+      pluginConnected: peers.length > 0,
       instanceCount: instances.length,
-      instances: publicInstances,
+      peerCount: peers.length,
+      instances,
+      peers,
+      multiplayerGroups,
       serverVersion: serverConfig?.version,
       mcpServerActive: isMCPServerActive(),
       lastMCPActivity,
       uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0
     });
   });
-  app.get("/instances", (req, res) => {
-    const instances = bridge.getInstances();
+  app.get("/topology", (req, res) => {
     res.json({
-      instances,
+      ...bridge.getTopologySnapshot(),
       serverVersion: serverConfig?.version
     });
   });
   app.get("/events", (req, res) => {
-    const pluginSessionId = typeof req.query.pluginSessionId === "string" ? req.query.pluginSessionId : void 0;
-    if (!pluginSessionId) {
+    const peerId = typeof req.query.peerId === "string" ? req.query.peerId : void 0;
+    if (!peerId) {
       res.status(400).json({
-        error: "missing_plugin_session_id",
-        message: "pluginSessionId is required"
+        error: "missing_peer_id",
+        message: "peerId is required"
       });
       return;
     }
-    const instance = bridge.getInstanceBySessionId(pluginSessionId);
-    if (!instance) {
+    const peer = bridge.getPeerById(peerId);
+    if (!peer) {
       res.status(404).json({
-        error: "unknown_session",
-        knownInstance: false
+        error: "unknown_peer",
+        knownPeer: false
       });
       return;
     }
-    if (instance.physicalSessionId !== pluginSessionId) {
+    if (peer.transportPeerId !== peerId) {
       res.status(409).json({
-        error: "logical_session_has_no_event_stream",
-        physicalSessionId: instance.physicalSessionId
+        error: "peer_has_no_event_stream",
+        transportPeerId: peer.transportPeerId
       });
       return;
     }
-    if (!eventTransport.canOpen(pluginSessionId)) {
+    if (!eventTransport.canOpen(peerId)) {
       res.setHeader("Retry-After", "1");
       res.status(503).json({
         error: "event_stream_capacity_reached",
@@ -6318,14 +6536,14 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       });
       return;
     }
-    bridge.updateInstanceActivity(pluginSessionId);
+    bridge.updatePeerActivity(peerId);
     res.status(200);
     res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
     res.setHeader("Cache-Control", "no-cache, no-transform");
     res.setHeader("Connection", "keep-alive");
     res.setHeader("X-Accel-Buffering", "no");
     res.flushHeaders();
-    const handle = eventTransport.open(pluginSessionId, res, () => eventStatus(pluginSessionId));
+    const handle = eventTransport.open(peerId, res, () => eventStatus(peerId));
     if (!handle) {
       res.end();
       return;
@@ -6350,9 +6568,9 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     res.json({ success: true, disposition });
   });
   app.post("/proxy", async (req, res) => {
-    const { endpoint, data, targetInstanceId, targetRole, proxyInstanceId, timeoutMs } = req.body;
-    if (!endpoint || !targetInstanceId || !targetRole) {
-      res.status(400).json({ error: "endpoint, targetInstanceId, and targetRole are required" });
+    const { endpoint, data, targetPeerId, proxyInstanceId, timeoutMs } = req.body;
+    if (!endpoint || !targetPeerId) {
+      res.status(400).json({ error: "endpoint and targetPeerId are required" });
       return;
     }
     if (timeoutMs !== void 0 && (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 3e5)) {
@@ -6367,7 +6585,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     req.once("aborted", abort);
     res.once("close", abort);
     try {
-      const response = await bridge.sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs, controller.signal);
+      const response = await bridge.sendRequest(endpoint, data, targetPeerId, timeoutMs, controller.signal);
       res.json({ response });
     } catch (error) {
       if (!res.headersSent && !res.destroyed) {
@@ -6470,10 +6688,9 @@ var StudioHttpClient = class {
   constructor(bridge) {
     this.bridge = bridge;
   }
-  async request(endpoint, data, targetInstanceId, targetRole, timeoutMs, signal) {
+  async request(endpoint, data, targetPeerId, timeoutMs, signal) {
     try {
-      const response = await this.bridge.sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs, signal);
-      return response;
+      return await this.bridge.sendRequest(endpoint, data, targetPeerId, timeoutMs, signal);
     } catch (error) {
       if (error instanceof Error && error.message === "Request timeout") {
         throw new Error("Studio plugin connection timeout. Make sure the Roblox Studio plugin is running and activated.");
@@ -10026,9 +10243,9 @@ var RobloxStudioTools = class {
     this.openCloudClient = new OpenCloudClient();
     this.cookieClient = new RobloxCookieClient();
     this.instanceManager = new StudioInstanceManager();
-    this.bridge.onInstanceRegistered((instance) => {
+    this.bridge.onPeerRegistered((peer) => {
       const instanceManager = this.instanceManager;
-      const association = this.managedConnectionAssociations.then(() => this._associateManagedEditConnection(instance, instanceManager));
+      const association = this.managedConnectionAssociations.then(() => this._associateManagedEditConnection(peer, instanceManager));
       this.managedConnectionAssociations = association.catch((error) => {
         console.warn(`[robloxstudio-mcp] managed Studio connection association failed: ${error instanceof Error ? error.message : String(error)}`);
       });
@@ -10093,93 +10310,109 @@ var RobloxStudioTools = class {
     return { content: [{ type: "text", text: result.content }] };
   }
   _parseTextResult(result) {
-    const text = result?.content?.[0]?.text;
-    if (typeof text !== "string")
+    if (result === null || typeof result !== "object" || !("content" in result) || !Array.isArray(result.content)) {
+      return {};
+    }
+    const first = result.content[0];
+    if (first === null || typeof first !== "object" || !("text" in first) || typeof first.text !== "string") {
       return {};
+    }
     try {
-      const parsed = JSON.parse(text);
-      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+      const parsed = JSON.parse(first.text);
+      return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? { ...parsed } : {};
     } catch {
       return {};
     }
   }
-  _briefRoles(instanceId, equivalentInstances = false) {
-    const roles = equivalentInstances ? this._rolesForEquivalentInstances(instanceId) : this._rolesForInstance(instanceId);
+  _briefRoles(instanceId) {
+    const roles = this._rolesForScope(instanceId);
     return {
       roles,
       runtimeRoles: roles.filter((role) => role === "server" || /^client-\d+$/.test(role))
     };
   }
-  // Resolve (instance_id, target-role) → concrete (instanceId, role) and
-  // dispatch a single request. Throws RoutingFailure if the resolution is
-  // ambiguous, missing, or asks for fanout on a non-fanout-capable tool —
-  // the MCP transport layer surfaces it as a structured error result so
-  // the LLM can recover via the embedded data.instances list.
+  _routingErrorData() {
+    const instances = this.bridge.getConnectedInstances();
+    const multiplayerGroups = this.bridge.getConnectedMultiplayerGroups();
+    return {
+      instances,
+      multiplayerGroups,
+      count: instances.length + multiplayerGroups.length
+    };
+  }
+  _peerForRoleInScope(instanceId, role) {
+    return this.bridge.getPeersInScope(instanceId).find((peer) => peer.role === role);
+  }
+  _requestPeer(endpoint, data, targetPeerId, timeoutMs, signal) {
+    return this.client.request(endpoint, data, targetPeerId, timeoutMs, signal);
+  }
+  _request(endpoint, data, instanceId, role, timeoutMs, signal) {
+    const peer = this._peerForRoleInScope(instanceId, role);
+    if (!peer) {
+      throw new RoutingFailure({
+        code: "target_role_not_present_on_instance",
+        message: `Routing scope for instance "${instanceId}" has no role "${role}".`,
+        data: this._routingErrorData()
+      });
+    }
+    return this._requestPeer(endpoint, data, peer.peerId, timeoutMs, signal);
+  }
+  // Resolve an optional Studio process plus role to one exact Peer and dispatch.
   async _callSingle(endpoint, data, target, instance_id, timeoutMs, signal) {
-    const r = this.bridge.resolveTarget({ instance_id, target });
-    if (!r.ok)
-      throw new RoutingFailure(r.error);
-    if (r.mode !== "single") {
+    const resolved = this.bridge.resolveTarget({ instance_id, target });
+    if (!resolved.ok)
+      throw new RoutingFailure(resolved.error);
+    if (resolved.mode !== "single") {
       throw new RoutingFailure({
         code: "target_role_not_present_on_instance",
         message: "This tool does not support target=all. Pick a specific role or omit target.",
-        data: {
-          instances: this.bridge.getPublicInstances(),
-          count: this.bridge.getInstances().length
-        }
+        data: this._routingErrorData()
       });
     }
-    if (signal === void 0) {
-      return this.client.request(endpoint, data, r.targetInstanceId, r.targetRole, timeoutMs);
-    }
-    return this.client.request(endpoint, data, r.targetInstanceId, r.targetRole, timeoutMs, signal);
+    return this._requestPeer(endpoint, data, resolved.targetPeerId, timeoutMs, signal);
   }
-  // Resolves which connected place a tool should target and whether a playtest
-  // CLIENT peer is present on it. Used by capture/input to auto-route to the
-  // running client (where the live viewport + input pipeline are) without the
-  // caller having to pass target. Throws RoutingFailure with the standard
-  // instance list if the place is ambiguous (multiple connected, no instance_id).
+  // Prefer the first client role in the selected process/group scope for live
+  // viewport and input operations; otherwise retain the default Peer's Instance.
   _resolveRuntime(instance_id) {
-    const r = this.bridge.resolveTarget({ instance_id, target: void 0 });
-    if (!r.ok)
-      throw new RoutingFailure(r.error);
-    const resolvedId = r.targetInstanceId;
-    const equivalentIds = new Set(this.bridge.getEquivalentInstanceIds(resolvedId));
-    const instances = this.bridge.getInstances().filter((i) => equivalentIds.has(i.instanceId));
-    const client = instances.filter((inst) => inst.role.startsWith("client")).sort((a, b) => a.role.localeCompare(b.role))[0];
-    return { instanceId: client?.instanceId ?? resolvedId, clientRole: client?.role };
+    const resolved = this.bridge.resolveTarget({ instance_id, target: void 0 });
+    if (!resolved.ok)
+      throw new RoutingFailure(resolved.error);
+    if (resolved.mode !== "single") {
+      throw new RoutingFailure({
+        code: "target_role_not_present_on_instance",
+        message: "A single runtime target is required.",
+        data: this._routingErrorData()
+      });
+    }
+    const client = this.bridge.getPeersInScope(resolved.targetInstanceId).filter((peer) => /^client-\d+$/.test(peer.role)).sort((a, b) => a.role.localeCompare(b.role) || a.peerId.localeCompare(b.peerId))[0];
+    return {
+      instanceId: client?.instanceId ?? resolved.targetInstanceId,
+      clientRole: client?.role
+    };
   }
   _resolveInstanceIdOnly(instance_id) {
-    const instances = this.bridge.getInstances();
-    const publicList = this.bridge.getPublicInstances();
-    const errorData = { instances: publicList, count: publicList.length };
     if (instance_id !== void 0) {
-      const resolvedInstanceId = this.bridge.resolveInstanceId(instance_id);
-      if (!instances.some((i) => i.instanceId === resolvedInstanceId)) {
+      const resolvedInstanceId = this.bridge.resolveConnectedInstanceId(instance_id);
+      if (resolvedInstanceId === void 0) {
         throw new RoutingFailure({
           code: "unrecognized_instance_id",
-          message: `instance_id "${instance_id}" is not connected. Pass one from data.instances.`,
-          data: errorData
+          message: `instance_id "${instance_id}" is not connected. Pass a connected top-level or grouped role-suffixed Instance ID.`,
+          data: this._routingErrorData()
         });
       }
       return resolvedInstanceId;
     }
-    const distinct = Array.from(new Set(instances.map((i) => i.instanceId)));
-    if (distinct.length === 0) {
-      throw new RoutingFailure({
-        code: "unrecognized_instance_id",
-        message: "No Studio plugin is connected.",
-        data: errorData
-      });
-    }
-    if (distinct.length > 1) {
+    const resolved = this.bridge.resolveTarget({ target: void 0 });
+    if (!resolved.ok)
+      throw new RoutingFailure(resolved.error);
+    if (resolved.mode !== "single") {
       throw new RoutingFailure({
         code: "multiple_instances_connected",
-        message: "Multiple Studio places are connected. Pass instance_id to disambiguate.",
-        data: errorData
+        message: "Multiple Studio process scopes are connected. Pass instance_id to disambiguate.",
+        data: this._routingErrorData()
       });
     }
-    return distinct[0];
+    return resolved.targetInstanceId;
   }
   _resolveSingleTarget(target, instance_id) {
     const resolved = this.bridge.resolveTarget({ instance_id, target });
@@ -10189,27 +10422,27 @@ var RobloxStudioTools = class {
       throw new RoutingFailure({
         code: "target_role_not_present_on_instance",
         message: "Pick a specific target role for this tool.",
-        data: {
-          instances: this.bridge.getPublicInstances(),
-          count: this.bridge.getInstances().length
-        }
+        data: this._routingErrorData()
       });
     }
-    return { instanceId: resolved.targetInstanceId, role: resolved.targetRole };
-  }
-  _rolesForInstance(instanceId) {
-    return this.bridge.getInstances().filter((i) => i.instanceId === instanceId).map((i) => i.role);
+    return {
+      targetPeerId: resolved.targetPeerId,
+      instanceId: resolved.targetInstanceId,
+      role: resolved.targetRole
+    };
   }
-  _rolesForEquivalentInstances(instanceId) {
-    const instanceIds = new Set(this.bridge.getEquivalentInstanceIds(instanceId));
-    return this.bridge.getInstances().filter((i) => instanceIds.has(i.instanceId)).map((i) => i.role);
+  _rolesForScope(instanceId) {
+    return this.bridge.getPeersInScope(instanceId).map((peer) => peer.role);
   }
-  _clientRolesForInstance(instanceId) {
-    return this._rolesForInstance(instanceId).filter((role) => /^client-\d+$/.test(role)).sort((a, b) => Number(a.slice("client-".length)) - Number(b.slice("client-".length)));
+  _clientRolesForScope(instanceId) {
+    return this._rolesForScope(instanceId).filter((role) => /^client-\d+$/.test(role)).sort((a, b) => Number(a.slice("client-".length)) - Number(b.slice("client-".length)));
   }
-  _runtimeTargetsForEquivalentInstances(instanceId) {
-    const instanceIds = new Set(this.bridge.getEquivalentInstanceIds(instanceId));
-    return this.bridge.getInstances().filter((i) => instanceIds.has(i.instanceId) && (i.role === "server" || /^client-\d+$/.test(i.role))).map((i) => ({ instanceId: i.instanceId, role: i.role }));
+  _runtimeTargetsForScope(instanceId) {
+    return this.bridge.getPeersInScope(instanceId).filter((peer) => peer.role === "server" || /^client-\d+$/.test(peer.role)).map((peer) => ({
+      targetPeerId: peer.peerId,
+      instanceId: peer.instanceId,
+      role: peer.role
+    }));
   }
   _compactSimulationResetResult(result) {
     const compact = {};
@@ -10236,15 +10469,12 @@ var RobloxStudioTools = class {
     const selectedTarget = target ?? "edit";
     if (selectedTarget === "all-clients") {
       const instanceId = this._resolveInstanceIdOnly(instance_id);
-      const roles = this._clientRolesForInstance(instanceId);
+      const roles = this._clientRolesForScope(instanceId);
       if (roles.length === 0) {
         throw new RoutingFailure({
           code: "target_role_not_present_on_instance",
           message: `instance "${instanceId}" has no connected playtest client roles. Start a playtest first.`,
-          data: {
-            instances: this.bridge.getPublicInstances(),
-            count: this.bridge.getInstances().length
-          }
+          data: this._routingErrorData()
         });
       }
       return { instanceId, selectedTarget, roles };
@@ -10265,8 +10495,8 @@ var RobloxStudioTools = class {
       throw new Error(`${toolName} target must be "edit", "client-N", "all-clients", or "edit-and-clients" (got: ${selectedTarget})`);
     }
     const instanceId = this._resolveInstanceIdOnly(instance_id);
-    const connectedRoles = this._rolesForInstance(instanceId);
-    const clientRoles = this._clientRolesForInstance(instanceId);
+    const connectedRoles = this._rolesForScope(instanceId);
+    const clientRoles = this._clientRolesForScope(instanceId);
     const warnings = [];
     let roles;
     if (selectedTarget === "edit") {
@@ -10274,10 +10504,7 @@ var RobloxStudioTools = class {
         throw new RoutingFailure({
           code: "target_role_not_present_on_instance",
           message: `instance "${instanceId}" has no role "edit". Available roles: ${connectedRoles.join(", ") || "none"}.`,
-          data: {
-            instances: this.bridge.getPublicInstances(),
-            count: this.bridge.getInstances().length
-          }
+          data: this._routingErrorData()
         });
       }
       roles = ["edit"];
@@ -10299,10 +10526,7 @@ var RobloxStudioTools = class {
         throw new RoutingFailure({
           code: "target_role_not_present_on_instance",
           message: `instance "${instanceId}" has no role "${selectedTarget}". Available client roles: ${clientRoles.join(", ") || "none"}.`,
-          data: {
-            instances: this.bridge.getPublicInstances(),
-            count: this.bridge.getInstances().length
-          }
+          data: this._routingErrorData()
         });
       }
       roles = [selectedTarget];
@@ -10330,12 +10554,12 @@ var RobloxStudioTools = class {
   }
   async _executeNetworkStateOperation(instanceId, role, operation) {
     const code = buildNetworkStateLuau(operation);
-    const response = await this.client.request("/api/execute-luau", { code }, instanceId, role);
+    const response = await this._request("/api/execute-luau", { code }, instanceId, role);
     return this._parseExecuteLuauJsonResponse(response, `network simulation ${operation}`);
   }
   async _executeDeviceSimulatorOperation(instanceId, role, operation, options) {
     const code = buildDeviceSimulatorLuau(operation, options);
-    const response = await this.client.request("/api/execute-luau", { code }, instanceId, role);
+    const response = await this._request("/api/execute-luau", { code }, instanceId, role);
     return this._parseExecuteLuauJsonResponse(response, `device simulator ${operation}`);
   }
   _settingsFromDeviceSimulatorState(state) {
@@ -10376,11 +10600,11 @@ var RobloxStudioTools = class {
       throw new Error(`capture_device_matrix cannot safely restore active custom device "${s.activeDeviceId}". Switch the simulator to default or a built-in preset first, or pass restoreAfter=false only if you intentionally accept changing the simulator state.`);
     }
   }
-  async _waitForRuntimeRoles(instanceId, opts, timeoutSec = 30, equivalentInstances = false) {
+  async _waitForRuntimeRoles(instanceId, opts, timeoutSec = 30) {
     const deadline = Date.now() + timeoutSec * 1e3;
     while (Date.now() < deadline) {
-      const roles = equivalentInstances ? this._rolesForEquivalentInstances(instanceId) : this._rolesForInstance(instanceId);
-      const clientRoles = equivalentInstances ? roles.filter((role) => /^client-\d+$/.test(role)) : this._clientRolesForInstance(instanceId);
+      const roles = this._rolesForScope(instanceId);
+      const clientRoles = this._clientRolesForScope(instanceId);
       const hasServer = !opts.server || roles.includes("server");
       const hasClients = opts.clientCount === void 0 || clientRoles.length >= opts.clientCount;
       const absent = opts.absentRole === void 0 || !roles.includes(opts.absentRole);
@@ -10392,7 +10616,7 @@ var RobloxStudioTools = class {
     }
     return {
       ok: false,
-      roles: equivalentInstances ? this._rolesForEquivalentInstances(instanceId) : this._rolesForInstance(instanceId),
+      roles: this._rolesForScope(instanceId),
       timedOut: true
     };
   }
@@ -10400,8 +10624,8 @@ var RobloxStudioTools = class {
     const deadline = Date.now() + timeoutSec * 1e3;
     let exactSince;
     while (Date.now() < deadline) {
-      const roles2 = this._rolesForInstance(instanceId);
-      const clientCount2 = this._clientRolesForInstance(instanceId).length;
+      const roles2 = this._rolesForScope(instanceId);
+      const clientCount2 = this._clientRolesForScope(instanceId).length;
       if (clientCount2 > expectedClientCount) {
         return { ok: false, roles: roles2, timedOut: false, extraClients: true, clientCount: clientCount2 };
       }
@@ -10415,17 +10639,16 @@ var RobloxStudioTools = class {
       }
       await sleep(250);
     }
-    const roles = this._rolesForInstance(instanceId);
-    const clientCount = this._clientRolesForInstance(instanceId).length;
+    const roles = this._rolesForScope(instanceId);
+    const clientCount = this._clientRolesForScope(instanceId).length;
     return { ok: false, roles, timedOut: true, extraClients: clientCount > expectedClientCount, clientCount };
   }
-  async _waitForRuntimeRolesFresh(instanceId, connectedAfter, requiredRoles, timeoutSec = 60, equivalentInstances = false) {
+  async _waitForRuntimeRolesFresh(instanceId, connectedAfter, requiredRoles, timeoutSec = 60) {
     const deadline = Date.now() + timeoutSec * 1e3;
     while (Date.now() < deadline) {
-      const instanceIds = equivalentInstances ? new Set(this.bridge.getEquivalentInstanceIds(instanceId)) : /* @__PURE__ */ new Set([instanceId]);
-      const instances = this.bridge.getInstances().filter((i) => instanceIds.has(i.instanceId));
-      const roles = instances.map((i) => i.role);
-      const freshRoles = new Set(instances.filter((i) => i.connectedAt >= connectedAfter).map((i) => i.role));
+      const peers = this.bridge.getPeersInScope(instanceId);
+      const roles = peers.map((peer) => peer.role);
+      const freshRoles = new Set(peers.filter((peer) => peer.connectedAt >= connectedAfter).map((peer) => peer.role));
       if (requiredRoles.every((role) => freshRoles.has(role))) {
         return { ok: true, roles, timedOut: false };
       }
@@ -10433,7 +10656,7 @@ var RobloxStudioTools = class {
     }
     return {
       ok: false,
-      roles: equivalentInstances ? this._rolesForEquivalentInstances(instanceId) : this._rolesForInstance(instanceId),
+      roles: this._rolesForScope(instanceId),
       timedOut: true
     };
   }
@@ -10788,7 +11011,7 @@ var RobloxStudioTools = class {
   async setNetworkProfile(profile, target, overrides, instance_id) {
     const values = normalizeNetworkProfile(profile, overrides);
     const instanceId = this._resolveInstanceIdOnly(instance_id);
-    const clientRoles = this._clientRolesForInstance(instanceId);
+    const clientRoles = this._clientRolesForScope(instanceId);
     const selectedTarget = target ?? "client-1";
     let targetRoles;
     if (selectedTarget === "all-clients") {
@@ -10798,10 +11021,7 @@ var RobloxStudioTools = class {
         throw new RoutingFailure({
           code: "target_role_not_present_on_instance",
           message: `instance "${instanceId}" has no role "${selectedTarget}". Available client roles: ${clientRoles.join(", ") || "none"}.`,
-          data: {
-            instances: this.bridge.getPublicInstances(),
-            count: this.bridge.getInstances().length
-          }
+          data: this._routingErrorData()
         });
       }
       targetRoles = [selectedTarget];
@@ -10812,15 +11032,12 @@ var RobloxStudioTools = class {
       throw new RoutingFailure({
         code: "target_role_not_present_on_instance",
         message: `instance "${instanceId}" has no connected playtest client roles. Start a playtest first.`,
-        data: {
-          instances: this.bridge.getPublicInstances(),
-          count: this.bridge.getInstances().length
-        }
+        data: this._routingErrorData()
       });
     }
     const code = buildNetworkProfileLuau(profile, values);
     const responses = await Promise.allSettled(targetRoles.map(async (role) => {
-      const response = await this.client.request("/api/execute-luau", { code }, instanceId, role);
+      const response = await this._request("/api/execute-luau", { code }, instanceId, role);
       const result = this._parseExecuteLuauJsonResponse(response, "set_network_profile");
       return { role, result };
     }));
@@ -11150,98 +11367,235 @@ var RobloxStudioTools = class {
       ]
     };
   }
-  async getRuntimeLogs(target, since, tail, filter, instance_id) {
-    const tgt = target ?? "all";
-    const data = {};
-    if (since !== void 0)
-      data.since = since;
-    if (tail !== void 0)
-      data.tail = tail;
-    if (filter !== void 0)
-      data.filter = filter;
-    const resolved = this.bridge.resolveTarget({ instance_id, target: tgt });
-    if (!resolved.ok)
-      throw new RoutingFailure(resolved.error);
-    if (resolved.mode === "single") {
-      const originPeerReliable2 = await this._isMultiplayerTestRunning(resolved.targetInstanceId);
-      const response = await this.client.request("/api/get-runtime-logs", data, resolved.targetInstanceId, resolved.targetRole);
-      response.capturedBy = resolved.targetRole;
-      delete response.peer;
-      response.originPeerReliable = originPeerReliable2;
-      response.peerAttribution = originPeerReliable2 ? "guaranteed_multiplayer" : "unavailable_shared_logservice";
-      if (originPeerReliable2)
-        response.peer = resolved.targetRole;
-      if (Array.isArray(response.entries)) {
-        for (const e of response.entries) {
-          e.capturedBy = resolved.targetRole;
-          delete e.peer;
-          if (originPeerReliable2)
-            e.peer = resolved.targetRole;
-        }
-      }
-      return {
-        content: [{ type: "text", text: JSON.stringify(response) }]
-      };
+  async getRuntimeLogs(instance_id, multiplayer_group_id, cursor, cursor_by_instance, tail, filter) {
+    if (instance_id !== void 0 && multiplayer_group_id !== void 0) {
+      throw new Error("get_runtime_logs accepts only one of instance_id or multiplayer_group_id.");
     }
-    const targets = resolved.targets;
-    const originPeerReliable = targets.length > 0 ? await this._isMultiplayerTestRunning(targets[0].targetInstanceId) : false;
-    const responses = await Promise.allSettled(targets.map(async (t) => {
-      const r = await this.client.request("/api/get-runtime-logs", data, t.targetInstanceId, t.targetRole);
-      return { ...r, capturedBy: t.targetRole };
-    }));
-    const merged = [];
-    const perCaptureNextSince = {};
-    const perCaptureErrors = {};
-    let totalDropped = 0;
-    for (const r of responses) {
-      if (r.status !== "fulfilled")
-        continue;
-      const v = r.value;
-      const capturedBy = v.capturedBy ?? "unknown";
-      if (v.error) {
-        perCaptureErrors[capturedBy] = v.error;
-        continue;
+    if (cursor !== void 0 && cursor_by_instance !== void 0) {
+      throw new Error("get_runtime_logs accepts only one of cursor or cursor_by_instance.");
+    }
+    if (tail !== void 0 && (!Number.isInteger(tail) || tail < 0)) {
+      throw new Error("get_runtime_logs tail must be a non-negative integer.");
+    }
+    const instances = this.bridge.getInstances();
+    const groups = this.bridge.getMultiplayerGroups();
+    let selectedGroup = multiplayer_group_id === void 0 ? void 0 : groups.find((group) => group.id === multiplayer_group_id);
+    let selectedInstanceId = instance_id === void 0 ? void 0 : this._resolveInstanceIdOnly(instance_id);
+    if (multiplayer_group_id !== void 0 && !selectedGroup) {
+      throw new RoutingFailure({
+        code: "unrecognized_instance_id",
+        message: `multiplayer_group_id "${multiplayer_group_id}" is not connected.`,
+        data: this._routingErrorData()
+      });
+    }
+    if (selectedInstanceId !== void 0 && !instances.some((instance) => instance.id === selectedInstanceId)) {
+      throw new RoutingFailure({
+        code: "unrecognized_instance_id",
+        message: `instance_id "${selectedInstanceId}" is not connected. Pass a connected top-level or grouped role-suffixed Instance ID.`,
+        data: this._routingErrorData()
+      });
+    }
+    if (selectedGroup === void 0 && selectedInstanceId === void 0) {
+      const groupedInstanceIds = new Set(groups.flatMap((group) => group.instanceIds));
+      const standaloneInstanceIds = instances.map((instance) => instance.id).filter((id) => !groupedInstanceIds.has(id));
+      const scopeCount = groups.length + standaloneInstanceIds.length;
+      if (scopeCount === 0) {
+        throw new RoutingFailure({
+          code: "unrecognized_instance_id",
+          message: "No Studio plugin is connected.",
+          data: this._routingErrorData()
+        });
+      }
+      if (scopeCount > 1) {
+        throw new RoutingFailure({
+          code: "multiple_instances_connected",
+          message: "Multiple Studio process scopes are connected. Pass instance_id or multiplayer_group_id.",
+          data: this._routingErrorData()
+        });
       }
-      if (v.nextSince !== void 0)
-        perCaptureNextSince[capturedBy] = v.nextSince;
-      totalDropped += v.totalDropped ?? 0;
-      for (const e of v.entries ?? []) {
-        const entry = { ...e };
-        delete entry.peer;
-        merged.push({ ...entry, capturedBy });
+      if (groups.length === 1) {
+        selectedGroup = groups[0];
+      } else {
+        selectedInstanceId = standaloneInstanceIds[0];
       }
     }
-    merged.sort((a, b) => a.ts !== b.ts ? a.ts - b.ts : a.seq - b.seq);
-    const DEDUP_WINDOW = 2;
-    const deduped = [];
-    for (const e of merged) {
-      const isDup = deduped.some((d) => d.message === e.message && d.level === e.level && Math.abs(d.ts - e.ts) <= DEDUP_WINDOW && d.capturedBy !== e.capturedBy);
-      if (!isDup)
-        deduped.push(e);
+    if (selectedGroup !== void 0 && cursor !== void 0) {
+      throw new Error("Use cursor_by_instance when reading a multiplayer group.");
     }
-    let final = deduped;
-    if (tail !== void 0 && deduped.length > tail) {
-      final = deduped.slice(deduped.length - tail);
+    if (selectedGroup === void 0 && cursor_by_instance !== void 0) {
+      throw new Error("Use cursor when reading one Instance.");
     }
-    const finalEntries = originPeerReliable ? final.map((e) => ({ ...e, peer: e.capturedBy })) : final;
-    const body = {
-      entries: finalEntries,
-      totalDropped,
-      perCaptureNextSince,
-      originPeerReliable,
-      peerAttribution: originPeerReliable ? "guaranteed_multiplayer" : "unavailable_shared_logservice"
+    const decodeCursor = (value, instanceId) => {
+      if (value === void 0)
+        return {};
+      let decoded;
+      try {
+        decoded = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+      } catch {
+        throw new Error(`get_runtime_logs received an invalid cursor for Instance "${instanceId}".`);
+      }
+      if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) {
+        throw new Error(`get_runtime_logs received an invalid cursor for Instance "${instanceId}".`);
+      }
+      const payload = decoded;
+      if (payload.version !== 1 || payload.instanceId !== instanceId || typeof payload.peers !== "object" || payload.peers === null || Array.isArray(payload.peers)) {
+        throw new Error(`get_runtime_logs cursor does not belong to Instance "${instanceId}".`);
+      }
+      const peers = payload.peers;
+      const parsed = {};
+      for (const [peerId, nextSince] of Object.entries(peers)) {
+        if (typeof nextSince !== "number" || !Number.isInteger(nextSince) || nextSince < 0) {
+          throw new Error(`get_runtime_logs received an invalid cursor for Instance "${instanceId}".`);
+        }
+        parsed[peerId] = nextSince;
+      }
+      return parsed;
+    };
+    const encodeCursor = (instanceId, peers) => {
+      const orderedPeers = {};
+      for (const peerId of Object.keys(peers).sort())
+        orderedPeers[peerId] = peers[peerId];
+      const payload = {
+        version: 1,
+        instanceId,
+        peers: orderedPeers
+      };
+      return Buffer.from(JSON.stringify(payload)).toString("base64url");
+    };
+    const roleRank = (role) => {
+      if (role === "edit")
+        return 0;
+      if (role === "server")
+        return 1;
+      const client = /^client-(\d+)$/.exec(role);
+      return client ? 2 + Number(client[1]) : Number.MAX_SAFE_INTEGER;
+    };
+    const entryTimestamp = (entry) => {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+        return 0;
+      const record = entry;
+      return typeof record.ts === "number" ? record.ts : 0;
+    };
+    const publicEntry = (entry) => {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+        return entry;
+      const record = entry;
+      const copy = { ...record };
+      delete copy.seq;
+      return copy;
+    };
+    const readInstance = async (instanceId, instanceCursor) => {
+      const peers = this.bridge.getPeers().filter((peer) => peer.instanceId === instanceId).sort((a, b) => roleRank(a.role) - roleRank(b.role) || a.peerId.localeCompare(b.peerId));
+      const priorByPeer = decodeCursor(instanceCursor, instanceId);
+      const nextByPeer = {};
+      for (const peer of peers) {
+        const prior = priorByPeer[peer.peerId];
+        if (prior !== void 0)
+          nextByPeer[peer.peerId] = prior;
+      }
+      if (peers.length === 0) {
+        return {
+          instanceId,
+          error: "No connected Peer exists for this Instance.",
+          nextCursor: encodeCursor(instanceId, nextByPeer),
+          peerErrors: []
+        };
+      }
+      const reads = await Promise.all(peers.map(async (peer) => {
+        const data = {};
+        const peerSince = priorByPeer[peer.peerId];
+        if (peerSince !== void 0)
+          data.since = peerSince;
+        if (tail !== void 0)
+          data.tail = tail;
+        if (filter !== void 0)
+          data.filter = filter;
+        try {
+          const responseValue = await this.client.request("/api/get-runtime-logs", data, peer.peerId);
+          if (typeof responseValue !== "object" || responseValue === null || Array.isArray(responseValue)) {
+            return {
+              peerId: peer.peerId,
+              role: peer.role,
+              error: "Studio returned an invalid runtime log response."
+            };
+          }
+          const response = responseValue;
+          if (typeof response.error === "string") {
+            return { peerId: peer.peerId, role: peer.role, error: response.error };
+          }
+          if (!Array.isArray(response.entries) || typeof response.totalDropped !== "number" || typeof response.nextSince !== "number") {
+            return {
+              peerId: peer.peerId,
+              role: peer.role,
+              error: "Studio returned an invalid runtime log response."
+            };
+          }
+          return {
+            peerId: peer.peerId,
+            role: peer.role,
+            entries: response.entries,
+            totalDropped: response.totalDropped,
+            nextSince: response.nextSince
+          };
+        } catch (error) {
+          return { peerId: peer.peerId, role: peer.role, error: errorMessage(error) };
+        }
+      }));
+      const successful = [];
+      const peerErrors = [];
+      for (const read of reads) {
+        if ("error" in read) {
+          peerErrors.push(read);
+        } else {
+          successful.push(read);
+          nextByPeer[read.peerId] = read.nextSince;
+        }
+      }
+      const nextCursor = encodeCursor(instanceId, nextByPeer);
+      if (successful.length === 0) {
+        return {
+          instanceId,
+          error: "Every connected Peer failed to read its runtime log buffer.",
+          nextCursor,
+          peerErrors
+        };
+      }
+      let insertionOrder = 0;
+      const merged = successful.flatMap((read) => read.entries.map((entry) => ({
+        entry: publicEntry(entry),
+        timestamp: entryTimestamp(entry),
+        insertionOrder: insertionOrder++
+      })));
+      merged.sort((a, b) => a.timestamp - b.timestamp || a.insertionOrder - b.insertionOrder);
+      const allEntries = merged.map((item) => item.entry);
+      const entries = tail === void 0 ? allEntries : tail === 0 ? [] : allEntries.slice(-tail);
+      const totalDropped = successful.reduce((total, read) => total + read.totalDropped, 0);
+      return {
+        instanceId,
+        entries,
+        totalDropped,
+        nextCursor,
+        ...peerErrors.length > 0 ? { peerErrors } : {}
+      };
     };
-    if (originPeerReliable) {
-      body.perPeerNextSince = perCaptureNextSince;
+    if (selectedGroup) {
+      const connectedIds = new Set(instances.map((instance) => instance.id));
+      const instanceIds = selectedGroup.instanceIds.filter((id) => connectedIds.has(id));
+      const results = await Promise.all(instanceIds.map((instanceId) => readInstance(instanceId, cursor_by_instance?.[instanceId])));
+      const nextCursorByInstance = {};
+      for (const result2 of results)
+        nextCursorByInstance[result2.instanceId] = result2.nextCursor;
+      return this._textResult({
+        multiplayerGroupId: selectedGroup.id,
+        instances: results,
+        nextCursorByInstance
+      });
     }
-    if (Object.keys(perCaptureErrors).length > 0) {
-      body.perCaptureErrors = perCaptureErrors;
-      if (originPeerReliable)
-        body.perPeerErrors = perCaptureErrors;
+    const result = await readInstance(selectedInstanceId, cursor);
+    if ("error" in result) {
+      throw new Error(`get_runtime_logs failed for Instance "${result.instanceId}": ${result.error}`);
     }
-    return {
-      content: [{ type: "text", text: JSON.stringify(body) }]
-    };
+    return this._textResult(result);
   }
   async captureScriptProfiler(target, request = {}, instance_id) {
     const targetRole = target ?? "server";
@@ -11261,15 +11615,12 @@ var RobloxStudioTools = class {
       throw new RoutingFailure({
         code: "target_role_not_present_on_instance",
         message: 'capture_script_profiler profiles one runtime peer at a time. Pick target="server" or a specific "client-N".',
-        data: {
-          instances: this.bridge.getPublicInstances(),
-          count: this.bridge.getInstances().length
-        }
+        data: this._routingErrorData()
       });
     }
     data.__mcp_instance_id = resolved.targetInstanceId;
     data.__mcp_target_role = resolved.targetRole;
-    const response = await this.client.request("/api/capture-script-profiler", data, resolved.targetInstanceId, resolved.targetRole);
+    const response = await this._requestPeer("/api/capture-script-profiler", data, resolved.targetPeerId);
     const body = response !== null && typeof response === "object" && !Array.isArray(response) ? { ...response, target: resolved.targetRole } : response;
     if (body !== null && typeof body === "object" && !Array.isArray(body)) {
       const mutable = body;
@@ -11324,15 +11675,12 @@ var RobloxStudioTools = class {
       throw new RoutingFailure({
         code: "target_role_not_present_on_instance",
         message: 'capture_micro_profiler profiles one runtime peer at a time. Pick target="server" or a specific "client-N".',
-        data: {
-          instances: this.bridge.getPublicInstances(),
-          count: this.bridge.getInstances().length
-        }
+        data: this._routingErrorData()
       });
     }
     data.__mcp_instance_id = resolved.targetInstanceId;
     data.__mcp_target_role = resolved.targetRole;
-    const response = await this.client.request("/api/capture-micro-profiler", data, resolved.targetInstanceId, resolved.targetRole);
+    const response = await this._requestPeer("/api/capture-micro-profiler", data, resolved.targetPeerId);
     const body = response !== null && typeof response === "object" && !Array.isArray(response) ? { ...response, target: resolved.targetRole } : response;
     if (body !== null && typeof body === "object" && !Array.isArray(body)) {
       const mutable = body;
@@ -11381,15 +11729,11 @@ var RobloxStudioTools = class {
       throw new RoutingFailure({
         code: "target_role_not_present_on_instance",
         message: "This tool does not support target=all. Pick a specific role or omit target.",
-        data: {
-          instances: this.bridge.getPublicInstances(),
-          count: this.bridge.getInstances().length
-        }
+        data: this._routingErrorData()
       });
     }
-    data.__mcp_instance_id = resolved.targetInstanceId;
     data.__mcp_target_role = resolved.targetRole;
-    const response = await this.client.request("/api/breakpoints", data, resolved.targetInstanceId, resolved.targetRole);
+    const response = await this._requestPeer("/api/breakpoints", data, resolved.targetPeerId);
     const body = response !== null && typeof response === "object" && !Array.isArray(response) ? { ...response, target: resolved.targetRole } : response;
     return { content: [{ type: "text", text: JSON.stringify(body) }] };
   }
@@ -11412,12 +11756,8 @@ var RobloxStudioTools = class {
     }
     return value;
   }
-  _publicInstanceKey(instance) {
-    return `${instance.instanceId}:${instance.role}:${instance.connectedAt}`;
-  }
-  async _isLatestPublishedPlaceOpen(placeId) {
-    const publishedInstanceId2 = `place:${placeId}`;
-    return this.bridge.getPublicInstances().some((instance) => instance.placeId === placeId || instance.instanceId === publishedInstanceId2) || (await this.instanceManager.list()).some((record) => record.closedAt === void 0 && record.source === "published_place" && record.placeId === placeId);
+  _publicInstanceKey(peer) {
+    return `${peer.peerId}:${peer.instanceId}:${peer.connectedAt}`;
   }
   _matchesManagedLaunch(record, instance) {
     if (record.source === "published_place") {
@@ -11455,7 +11795,7 @@ var RobloxStudioTools = class {
       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);
+      const candidates = this.bridge.getPublicPeers().filter((peer) => peer.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];
       await sleep(500);
@@ -11463,7 +11803,7 @@ var RobloxStudioTools = class {
     return void 0;
   }
   _managedStatus(record) {
-    const connected = record.instanceId ? this.bridge.getPublicInstances().filter((instance) => instance.instanceId === record.instanceId) : [];
+    const connected = record.instanceId ? this.bridge.getPublicPeers().filter((peer) => peer.instanceId === record.instanceId) : [];
     return {
       launch_id: record.recordId,
       instance_id: record.instanceId,
@@ -11555,7 +11895,7 @@ var RobloxStudioTools = class {
       }
       if (instance_id) {
         const record2 = await this.instanceManager.get(instance_id);
-        const connected2 = this.bridge.getPublicInstances().filter((instance) => instance.instanceId === instance_id);
+        const connected2 = this.bridge.getPublicPeers().filter((peer) => peer.instanceId === instance_id);
         if (!record2 && connected2.length === 0) {
           return this._textResult({ error: "Instance is not connected or managed.", instance_id });
         }
@@ -11573,10 +11913,10 @@ var RobloxStudioTools = class {
       return this._textResult({
         managed: (await this.instanceManager.list()).filter((record2) => record2.closedAt === void 0).map((record2) => this._managedStatus(record2)),
         connected: this.bridge.getPublicInstances().map((instance) => ({
-          instance_id: instance.instanceId,
-          role: instance.role,
+          instance_id: instance.id,
           place_id: instance.placeId,
-          place_name: instance.placeName
+          place_name: instance.placeName,
+          roles: instance.peers.map((peer) => peer.role).sort()
         }))
       });
     }
@@ -11613,8 +11953,8 @@ var RobloxStudioTools = class {
             message: managedClose.status === "already_closed" ? "Studio instance was already closed." : "Studio instance closed."
           });
         }
-        const connected2 = this.bridge.getPublicInstances().filter((instance) => instance.instanceId === instance_id);
-        const edit = connected2.find((instance) => instance.role === "edit");
+        const connected2 = this.bridge.getPublicPeers().filter((peer) => peer.instanceId === instance_id);
+        const edit = connected2.find((peer) => peer.role === "edit");
         if (!edit) {
           return this._textResult({
             error: "Instance is not connected or managed.",
@@ -11679,12 +12019,6 @@ var RobloxStudioTools = class {
     }
     const processEnvironment = parseStudioProcessEnvironmentPatch(request.process_environment);
     const studioWorkingDirectory = parseStudioWorkingDirectory(request.studio_working_directory);
-    if (launchSource === "published_place" && placeId !== void 0 && await this._isLatestPublishedPlaceOpen(placeId)) {
-      return this._textResult({
-        error: "Place is already open.",
-        message: `place_id ${placeId} is already connected. Use the existing instance or launch a specific place_revision.`
-      });
-    }
     const universeId = launchSource === "published_place" || launchSource === "place_revision" ? await this._deriveUniverseId(placeId) : void 0;
     if (request.require_process_identity !== void 0 && typeof request.require_process_identity !== "boolean") {
       throw new Error("require_process_identity must be a boolean when provided.");
@@ -11692,7 +12026,7 @@ var RobloxStudioTools = class {
     const requireProcessIdentity = request.require_process_identity === true;
     const waitForConnection = !requireProcessIdentity && request.wait_for_connection !== false;
     const timeoutMs = this._optionalPositiveInteger(request.timeout_ms, "timeout_ms") ?? 12e4;
-    const beforeKeys = new Set(this.bridge.getPublicInstances().map((instance) => this._publicInstanceKey(instance)));
+    const beforeKeys = new Set(this.bridge.getPublicPeers().map((peer) => this._publicInstanceKey(peer)));
     const record = await this.instanceManager.launch({
       source: launchSource,
       localPlaceFile,
@@ -11739,7 +12073,7 @@ var RobloxStudioTools = class {
     }
     if (action === "status") {
       const instanceId = this._resolveInstanceIdOnly(instance_id);
-      const { roles, runtimeRoles } = this._briefRoles(instanceId, true);
+      const { roles, runtimeRoles } = this._briefRoles(instanceId);
       return this._textResult({
         success: true,
         action,
@@ -11802,22 +12136,19 @@ var RobloxStudioTools = class {
       throw new RoutingFailure({
         code: "target_role_not_present_on_instance",
         message: "This tool does not support target=all. Pick a specific role or omit target.",
-        data: {
-          instances: this.bridge.getPublicInstances(),
-          count: this.bridge.getInstances().length
-        }
+        data: this._routingErrorData()
       });
     }
-    const existingRuntime = this._runtimeTargetsForEquivalentInstances(resolved.targetInstanceId);
+    const existingRuntime = this._runtimeTargetsForScope(resolved.targetInstanceId);
     if (existingRuntime.length > 0) {
-      const roles = this._rolesForEquivalentInstances(resolved.targetInstanceId);
+      const roles = this._rolesForScope(resolved.targetInstanceId);
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
             success: false,
             error: "Playtest already running.",
-            message: "A playtest is already running for this Studio place. Stop the current playtest before starting another.",
+            message: "A playtest is already running for this Studio process scope. Stop the current playtest before starting another.",
             runtimeReady: true,
             timedOut: false,
             roles,
@@ -11826,11 +12157,11 @@ var RobloxStudioTools = class {
         }]
       };
     }
-    const response = await this.client.request("/api/start-playtest", data, resolved.targetInstanceId, resolved.targetRole);
+    const response = await this._requestPeer("/api/start-playtest", data, resolved.targetPeerId);
     let wait;
     if (response?.success === true) {
       const requiredRoles = mode === "play" ? ["server", "client-1"] : ["server"];
-      wait = await this._waitForRuntimeRolesFresh(resolved.targetInstanceId, startedAt, requiredRoles, timeout, true);
+      wait = await this._waitForRuntimeRolesFresh(resolved.targetInstanceId, startedAt, requiredRoles, timeout);
     }
     const body = wait ? {
       ...response,
@@ -11852,7 +12183,7 @@ var RobloxStudioTools = class {
     let response;
     let stopRequestError;
     try {
-      response = await this.client.request("/api/stop-playtest", {}, instanceId, "edit");
+      response = await this._request("/api/stop-playtest", {}, instanceId, "edit");
     } catch (error) {
       stopRequestError = errorMessage(error);
       response = {
@@ -11863,11 +12194,11 @@ var RobloxStudioTools = class {
     }
     let wait;
     if (response?.success === true) {
-      wait = await this._waitForRuntimeRoles(instanceId, { noRuntime: true }, timeout, true);
-    } else if (this._runtimeTargetsForEquivalentInstances(instanceId).length > 0) {
+      wait = await this._waitForRuntimeRoles(instanceId, { noRuntime: true }, timeout);
+    } else if (this._runtimeTargetsForScope(instanceId).length > 0) {
       wait = {
         ok: false,
-        roles: this._rolesForEquivalentInstances(instanceId),
+        roles: this._rolesForScope(instanceId),
         timedOut: false
       };
     }
@@ -11898,9 +12229,11 @@ var RobloxStudioTools = class {
     };
   }
   async _buildMultiplayerState(instanceId) {
-    const peers = this.bridge.getPublicInstances().filter((i) => i.instanceId === instanceId).sort((a, b) => a.role.localeCompare(b.role));
+    const peers = this.bridge.getPublicPeers().filter((peer) => this.bridge.getInstanceIdsInScope(instanceId).includes(peer.instanceId)).sort((a, b) => a.role.localeCompare(b.role));
+    const multiplayerGroup = this.bridge.getMultiplayerGroups().find((group) => group.instanceIds.includes(instanceId));
     const body = {
       instanceId,
+      multiplayerGroupId: multiplayerGroup?.id,
       peers,
       peerCount: peers.length
     };
@@ -11910,7 +12243,7 @@ var RobloxStudioTools = class {
     let serverState;
     if (edit) {
       try {
-        editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
+        editState = await this._request("/api/multiplayer-test-state", {}, instanceId, "edit");
         body.edit = editState;
       } catch (err2) {
         body.edit = { error: err2 instanceof Error ? err2.message : String(err2) };
@@ -11918,7 +12251,7 @@ var RobloxStudioTools = class {
     }
     if (server) {
       try {
-        serverState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "server");
+        serverState = await this._request("/api/multiplayer-test-state", {}, instanceId, "server");
         body.server = serverState;
       } catch (err2) {
         body.server = { error: err2 instanceof Error ? err2.message : String(err2) };
@@ -11935,16 +12268,16 @@ var RobloxStudioTools = class {
     body.error = session?.error;
     body.players = serverState?.players ?? [];
     body.playerCount = serverState?.playerCount ?? 0;
-    body.clientRoles = this._clientRolesForInstance(instanceId);
+    body.clientRoles = this._clientRolesForScope(instanceId);
     return body;
   }
   async _waitForMultiplayerEditDone(instanceId, timeoutSec = 30) {
     const deadline = Date.now() + timeoutSec * 1e3;
     while (Date.now() < deadline) {
-      if (!this._rolesForInstance(instanceId).includes("edit"))
+      if (!this._rolesForScope(instanceId).includes("edit"))
         return false;
       try {
-        const editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
+        const editState = await this._request("/api/multiplayer-test-state", {}, instanceId, "edit");
         const phase = editState?.session?.phase;
         if (phase === "completed" || phase === "failed")
           return true;
@@ -11955,19 +12288,7 @@ var RobloxStudioTools = class {
     return false;
   }
   async _isMultiplayerTestRunning(instanceId) {
-    const roles = this._rolesForInstance(instanceId);
-    const hasServer = roles.includes("server");
-    const clientCount = roles.filter((role) => role.startsWith("client-")).length;
-    if (roles.includes("edit")) {
-      try {
-        const editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
-        const phase = editState?.session?.phase;
-        if (phase === "starting" || phase === "running")
-          return true;
-      } catch {
-      }
-    }
-    return hasServer && clientCount >= 2;
+    return this.bridge.getMultiplayerGroups().some((group) => group.instanceIds.includes(instanceId));
   }
   async _waitForMultiplayerStart(instanceId, clientCount, timeoutSec = 30, connectedAfter) {
     const deadline = Date.now() + timeoutSec * 1e3;
@@ -11976,8 +12297,8 @@ var RobloxStudioTools = class {
       const exact = await this._waitForExactClientCount(instanceId, clientCount, 0.25, 0);
       if (exact.ok || exact.extraClients) {
         if (exact.ok && connectedAfter !== void 0) {
-          const instances = this.bridge.getInstances().filter((inst) => inst.instanceId === instanceId);
-          const freshRoles = new Set(instances.filter((inst) => inst.connectedAt >= connectedAfter).map((inst) => inst.role));
+          const peers = this.bridge.getPeersInScope(instanceId);
+          const freshRoles = new Set(peers.filter((peer) => peer.connectedAt >= connectedAfter).map((peer) => peer.role));
           const freshClientCount = [...freshRoles].filter((role) => /^client-\d+$/.test(role)).length;
           if (!freshRoles.has("server") || freshClientCount !== clientCount) {
             await sleep(250);
@@ -11988,19 +12309,19 @@ var RobloxStudioTools = class {
       }
       try {
         const remainingMs = Math.max(1, Math.min(1e3, deadline - Date.now()));
-        const editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit", remainingMs);
+        const editState = await this._request("/api/multiplayer-test-state", {}, instanceId, "edit", remainingMs);
         const session = editState?.session;
         if (typeof session?.phase === "string") {
           lastPhase = session.phase;
         }
         if (session?.phase === "failed") {
-          return { ok: false, roles: this._rolesForInstance(instanceId), timedOut: false, phase: session.phase, error: session.error };
+          return { ok: false, roles: this._rolesForScope(instanceId), timedOut: false, phase: session.phase, error: session.error };
         }
       } catch {
       }
       await sleep(250);
     }
-    return { ok: false, roles: this._rolesForInstance(instanceId), timedOut: true, phase: lastPhase };
+    return { ok: false, roles: this._rolesForScope(instanceId), timedOut: true, phase: lastPhase };
   }
   async multiplayerPlaytest(action, numPlayers, target, testArgs, value, timeout, instance_id) {
     if (action !== "start" && action !== "status" && action !== "add_players" && action !== "leave_client" && action !== "end") {
@@ -12008,9 +12329,11 @@ var RobloxStudioTools = class {
     }
     const briefState = async (instanceId) => {
       const state = await this._buildMultiplayerState(this._resolveInstanceIdOnly(instanceId));
+      const roles = Array.isArray(state.peers) ? state.peers.flatMap((peer) => peer !== null && typeof peer === "object" && "role" in peer && typeof peer.role === "string" ? [peer.role] : []) : [];
       return {
         phase: state.phase,
-        roles: Array.isArray(state.peers) ? state.peers.map((peer) => peer.role).filter((role) => typeof role === "string") : [],
+        multiplayerGroupId: typeof state.multiplayerGroupId === "string" ? state.multiplayerGroupId : void 0,
+        roles,
         playerCount: typeof state.playerCount === "number" ? state.playerCount : void 0,
         error: typeof state.error === "string" ? state.error : void 0
       };
@@ -12024,25 +12347,32 @@ var RobloxStudioTools = class {
     }
     if (action === "start") {
       const body2 = this._parseTextResult(await this.multiplayerTestStart(numPlayers, testArgs, timeout, instance_id));
-      const state = body2.state && typeof body2.state === "object" ? body2.state : {};
+      const stateValue = body2.state;
+      const state = stateValue !== null && typeof stateValue === "object" && !Array.isArray(stateValue) ? { ...stateValue } : {};
+      const waitValue = body2.wait;
+      const wait = waitValue !== null && typeof waitValue === "object" && !Array.isArray(waitValue) ? { ...waitValue } : {};
       const launched = body2.success === true && body2.ready === true;
+      const multiplayerGroupId2 = typeof body2.multiplayerGroupId === "string" ? body2.multiplayerGroupId : typeof body2.testId === "string" ? body2.testId : void 0;
       return this._textResult(launched ? {
         success: true,
         action,
         message: "Multiplayer playtest started.",
+        multiplayerGroupId: multiplayerGroupId2,
         roles: Array.isArray(body2.roles) ? body2.roles : void 0,
         playerCount: typeof state.playerCount === "number" ? state.playerCount : void 0
       } : {
         success: false,
         action,
-        error: body2.error ?? body2.wait?.error ?? "multiplayer_start_not_detected",
+        error: body2.error ?? wait.error ?? "multiplayer_start_not_detected",
         message: body2.success === true ? "Multiplayer playtest start was requested, but MCP did not detect the required server/client peers before timeout." : body2.message ?? "Multiplayer playtest did not start.",
+        multiplayerGroupId: multiplayerGroupId2,
         roles: Array.isArray(body2.roles) ? body2.roles : void 0
       });
     }
     if (action === "add_players") {
       const body2 = this._parseTextResult(await this.multiplayerTestAddPlayers(numPlayers, timeout, instance_id));
-      const state = body2.state && typeof body2.state === "object" ? body2.state : {};
+      const stateValue = body2.state;
+      const state = stateValue !== null && typeof stateValue === "object" && !Array.isArray(stateValue) ? { ...stateValue } : {};
       const success = body2.success === true && body2.ready === true;
       return this._textResult(success ? {
         success: true,
@@ -12074,14 +12404,17 @@ var RobloxStudioTools = class {
       });
     }
     const body = this._parseTextResult(await this.multiplayerTestEnd(value, timeout, instance_id));
+    const multiplayerGroupId = typeof body.multiplayerGroupId === "string" ? body.multiplayerGroupId : void 0;
     return this._textResult(body.success === true && body.ended === true ? {
       success: true,
       action,
+      multiplayerGroupId,
       message: body.alreadyEnded === true ? "Multiplayer playtest already ended." : body.teardownConfirmed === false ? 'Multiplayer playtest end requested; teardown still in progress. Use multiplayer_playtest action="status" to confirm.' : "Multiplayer playtest ended.",
       teardownConfirmed: body.teardownConfirmed === true
     } : {
       success: false,
       action,
+      multiplayerGroupId,
       error: body.error ?? "end_failed",
       message: body.message ?? "Multiplayer playtest did not end.",
       roles: Array.isArray(body.roles) ? body.roles : void 0,
@@ -12093,13 +12426,13 @@ var RobloxStudioTools = class {
       throw new Error("numPlayers must be an integer from 1 to 8");
     }
     const editTarget = this._resolveSingleTarget("edit", instance_id);
-    const existingRuntime = this._runtimeTargetsForEquivalentInstances(editTarget.instanceId);
+    const existingRuntime = this._runtimeTargetsForScope(editTarget.instanceId);
     if (existingRuntime.length > 0) {
-      const roles = this._rolesForEquivalentInstances(editTarget.instanceId);
+      const roles = this._rolesForScope(editTarget.instanceId);
       return this._textResult({
         success: false,
         error: "Multiplayer playtest already running.",
-        message: "A Studio runtime is already connected for this place. End the existing playtest before starting another multiplayer playtest.",
+        message: "A Studio runtime is already connected for this process scope. End the existing playtest before starting another multiplayer playtest.",
         ready: true,
         timedOut: false,
         roles,
@@ -12107,23 +12440,35 @@ var RobloxStudioTools = class {
       });
     }
     const startedAt = Date.now();
-    const response = await this.client.request("/api/multiplayer-test-start", { numPlayers, testArgs: testArgs ?? {} }, editTarget.instanceId, editTarget.role);
-    if (response?.error) {
-      return { content: [{ type: "text", text: JSON.stringify(response) }] };
+    const response = await this._requestPeer("/api/multiplayer-test-start", { numPlayers, testArgs: testArgs ?? {} }, editTarget.targetPeerId);
+    const groupId = typeof response?.testId === "string" ? response.testId : void 0;
+    if (response?.error || response?.success !== true || groupId === void 0) {
+      if (groupId !== void 0)
+        await this.bridge.removeMultiplayerGroupEverywhere(groupId);
+      return this._textResult({
+        ...response,
+        error: response?.error ?? "Multiplayer start did not return a testId."
+      });
     }
+    await this.bridge.createMultiplayerGroupEverywhere(groupId, editTarget.instanceId);
     const wait = await this._waitForMultiplayerStart(editTarget.instanceId, numPlayers, timeout ?? 60, startedAt);
     const launched = wait.ok;
     const state = await this._buildMultiplayerState(editTarget.instanceId);
-    const success = response.success === true && wait.ok;
+    const success = wait.ok;
+    const runtimeStillConnected = this._runtimeTargetsForScope(editTarget.instanceId).length > 0;
+    const definitelyFailed = state.phase === "failed" && !runtimeStillConnected;
+    if (definitelyFailed)
+      await this.bridge.removeMultiplayerGroupEverywhere(groupId);
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
           ...response,
+          multiplayerGroupId: groupId,
           success,
           ready: wait.ok,
           launched,
-          startRequested: response.success === true,
+          startRequested: true,
           timedOut: wait.timedOut,
           wait,
           roles: wait.roles,
@@ -12145,13 +12490,15 @@ var RobloxStudioTools = class {
       throw new Error("numPlayers must be an integer from 1 to 8");
     }
     const serverTarget = this._resolveSingleTarget("server", instance_id);
-    const before = this._clientRolesForInstance(serverTarget.instanceId).length;
-    const response = await this.client.request("/api/multiplayer-test-add-players", { numPlayers, timeout: timeout ?? 10 }, serverTarget.instanceId, serverTarget.role);
+    const group = this.bridge.getMultiplayerGroups().find((candidate) => candidate.instanceIds.includes(serverTarget.instanceId));
+    const scopeInstanceId = group?.controllerInstanceId ?? serverTarget.instanceId;
+    const before = this._clientRolesForScope(scopeInstanceId).length;
+    const response = await this._requestPeer("/api/multiplayer-test-add-players", { numPlayers, timeout: timeout ?? 10 }, serverTarget.targetPeerId);
     if (response?.error) {
       return { content: [{ type: "text", text: JSON.stringify(response) }] };
     }
-    const wait = await this._waitForExactClientCount(serverTarget.instanceId, before + numPlayers, timeout ?? 30);
-    const state = await this._buildMultiplayerState(serverTarget.instanceId);
+    const wait = await this._waitForExactClientCount(scopeInstanceId, before + numPlayers, timeout ?? 30);
+    const state = await this._buildMultiplayerState(scopeInstanceId);
     return {
       content: [{
         type: "text",
@@ -12171,12 +12518,14 @@ var RobloxStudioTools = class {
       throw new Error(`multiplayer_test_leave_client requires target=client-N (got: ${target})`);
     }
     const clientTarget = this._resolveSingleTarget(target, instance_id);
-    const response = await this.client.request("/api/multiplayer-test-leave-client", {}, clientTarget.instanceId, clientTarget.role);
+    const group = this.bridge.getMultiplayerGroups().find((candidate) => candidate.instanceIds.includes(clientTarget.instanceId));
+    const scopeInstanceId = group?.controllerInstanceId ?? clientTarget.instanceId;
+    const response = await this._requestPeer("/api/multiplayer-test-leave-client", {}, clientTarget.targetPeerId);
     if (response?.error) {
       return { content: [{ type: "text", text: JSON.stringify(response) }] };
     }
-    const wait = await this._waitForRuntimeRoles(clientTarget.instanceId, { absentRole: clientTarget.role }, timeout ?? 30);
-    const state = await this._buildMultiplayerState(clientTarget.instanceId);
+    const wait = await this._waitForRuntimeRoles(scopeInstanceId, { absentRole: clientTarget.role }, timeout ?? 30);
+    const state = await this._buildMultiplayerState(scopeInstanceId);
     return {
       content: [{
         type: "text",
@@ -12194,29 +12543,39 @@ var RobloxStudioTools = class {
     let serverTarget;
     try {
       serverTarget = this._resolveSingleTarget("server", instance_id);
-    } catch (err2) {
+    } catch (error) {
       const instanceId = this._resolveInstanceIdOnly(instance_id);
-      const hasRuntime = this._rolesForInstance(instanceId).some((role) => role === "server" || /^client-\d+$/.test(role));
+      const group2 = this.bridge.getMultiplayerGroups().find((candidate) => candidate.instanceIds.includes(instanceId));
+      const hasRuntime = this._rolesForScope(instanceId).some((role) => role === "server" || /^client-\d+$/.test(role));
       if (!hasRuntime) {
+        if (group2)
+          await this.bridge.removeMultiplayerGroupEverywhere(group2.id);
         return this._textResult({
           success: true,
+          multiplayerGroupId: group2?.id,
           ended: true,
           alreadyEnded: true,
           teardownConfirmed: true,
           message: "No active multiplayer test to end (already ended)."
         });
       }
-      throw err2;
+      throw error;
     }
-    const response = await this.client.request("/api/multiplayer-test-end", { value: value ?? "ended_by_mcp" }, serverTarget.instanceId, serverTarget.role);
+    const group = this.bridge.getMultiplayerGroups().find((candidate) => candidate.instanceIds.includes(serverTarget.instanceId));
+    const scopeInstanceId = group?.controllerInstanceId ?? serverTarget.instanceId;
+    const response = await this._requestPeer("/api/multiplayer-test-end", { value: value ?? "ended_by_mcp" }, serverTarget.targetPeerId);
     if (response?.error) {
-      return this._textResult(response);
+      return this._textResult({
+        ...response,
+        multiplayerGroupId: group?.id
+      });
     }
-    const editDone = await this._waitForMultiplayerEditDone(serverTarget.instanceId, timeout ?? 30);
-    const wait = await this._waitForRuntimeRoles(serverTarget.instanceId, { noRuntime: true }, timeout ?? 30);
-    const state = await this._buildMultiplayerState(serverTarget.instanceId);
-    return this._textResult({
+    const editDone = await this._waitForMultiplayerEditDone(scopeInstanceId, timeout ?? 30);
+    const wait = await this._waitForRuntimeRoles(scopeInstanceId, { noRuntime: true }, timeout ?? 30);
+    const state = await this._buildMultiplayerState(scopeInstanceId);
+    const result = this._textResult({
       ...response,
+      multiplayerGroupId: group?.id,
       ended: response.success === true,
       teardownConfirmed: wait.ok,
       editDone,
@@ -12224,24 +12583,15 @@ var RobloxStudioTools = class {
       roles: wait.roles,
       state
     });
+    if (wait.ok && group)
+      await this.bridge.removeMultiplayerGroupEverywhere(group.id);
+    return result;
   }
   async getConnectedInstances() {
-    const places = /* @__PURE__ */ new Map();
-    for (const peer of this.bridge.getPublicInstances()) {
-      let place = places.get(peer.instanceId);
-      if (!place) {
-        place = {
-          id: peer.instanceId,
-          name: peer.placeName || peer.dataModelName,
-          roles: []
-        };
-        places.set(peer.instanceId, place);
-      }
-      if (!place.roles.includes(peer.role)) {
-        place.roles.push(peer.role);
-      }
-    }
-    return this._textResult({ instances: [...places.values()] });
+    return this._textResult({
+      instances: this.bridge.getConnectedInstances(),
+      multiplayerGroups: this.bridge.getConnectedMultiplayerGroups()
+    });
   }
   // === Asset Tools ===
   async searchAssets(assetType, query, maxResults, sortBy, robloxCreatedOnly) {
@@ -12825,13 +13175,13 @@ var RobloxStudioTools = class {
     if (!resolved.ok)
       throw new RoutingFailure(resolved.error);
     if (resolved.mode === "single") {
-      const response = await this.client.request("/api/get-memory-breakdown", data, resolved.targetInstanceId, resolved.targetRole);
+      const response = await this._requestPeer("/api/get-memory-breakdown", data, resolved.targetPeerId);
       return { content: [{ type: "text", text: JSON.stringify(response) }] };
     }
     const targets = resolved.targets;
     const responses = await Promise.allSettled(targets.map(async (t) => ({
       peer: t.targetRole,
-      result: await this.client.request("/api/get-memory-breakdown", data, t.targetInstanceId, t.targetRole)
+      result: await this._requestPeer("/api/get-memory-breakdown", data, t.targetPeerId)
     })));
     const body = {};
     for (let i = 0; i < responses.length; i++) {
@@ -12858,13 +13208,13 @@ var RobloxStudioTools = class {
     if (!resolved.ok)
       throw new RoutingFailure(resolved.error);
     if (resolved.mode === "single") {
-      const response = await this.client.request("/api/get-scene-analysis", data, resolved.targetInstanceId, resolved.targetRole);
+      const response = await this._requestPeer("/api/get-scene-analysis", data, resolved.targetPeerId);
       return { content: [{ type: "text", text: JSON.stringify(response) }] };
     }
     const targets = resolved.targets;
     const responses = await Promise.allSettled(targets.map(async (t) => ({
       peer: t.targetRole,
-      result: await this.client.request("/api/get-scene-analysis", data, t.targetInstanceId, t.targetRole)
+      result: await this._requestPeer("/api/get-scene-analysis", data, t.targetPeerId)
     })));
     const body = {};
     for (let i = 0; i < responses.length; i++) {
@@ -13085,12 +13435,17 @@ var RobloxStudioTools = class {
 // ../core/dist/proxy-bridge-service.js
 import { randomUUID as randomUUID4 } from "crypto";
 var PROXY_RESPONSE_GRACE_MS = 5e3;
+function peerPublicationChanged(previous, current) {
+  return previous === void 0 || previous.transportPeerId !== current.transportPeerId || previous.instanceId !== current.instanceId || previous.multiplayerGroupId !== current.multiplayerGroupId || previous.role !== current.role || previous.placeId !== current.placeId || previous.placeName !== current.placeName || previous.placeKey !== current.placeKey || previous.dataModelName !== current.dataModelName || previous.isRunning !== current.isRunning || previous.pluginVersion !== current.pluginVersion || previous.pluginVariant !== current.pluginVariant || previous.serverVersion !== current.serverVersion;
+}
 var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
   primaryBaseUrl;
   authToken;
   proxyInstanceId;
   proxyRequestTimeout = 3e4;
+  cachedPeers = [];
   cachedInstances = [];
+  cachedMultiplayerGroups = [];
   initialRefresh;
   refreshTimer;
   static REFRESH_INTERVAL_MS = 1e3;
@@ -13099,8 +13454,8 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
     this.primaryBaseUrl = primaryBaseUrl;
     this.authToken = authToken;
     this.proxyInstanceId = randomUUID4();
-    this.initialRefresh = this.refreshInstances();
-    this.refreshTimer = setInterval(() => this.refreshInstances(), _ProxyBridgeService.REFRESH_INTERVAL_MS);
+    this.initialRefresh = this.refreshTopology();
+    this.refreshTimer = setInterval(() => this.refreshTopology(), _ProxyBridgeService.REFRESH_INTERVAL_MS);
   }
   waitForInitialRefresh() {
     return this.initialRefresh;
@@ -13111,29 +13466,99 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
       headers["X-MCP-Auth"] = this.authToken;
     return headers;
   }
-  async refreshInstances() {
+  async refreshTopology() {
     try {
-      const res = await fetch(`${this.primaryBaseUrl}/instances`, {
+      const res = await fetch(`${this.primaryBaseUrl}/topology`, {
         headers: this.authHeaders()
       });
       if (!res.ok)
         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));
+      if (!Array.isArray(body.peers) || !Array.isArray(body.instances) || !Array.isArray(body.multiplayerGroups)) {
+        return;
+      }
+      const previousPeers = new Map(this.cachedPeers.map((peer) => [peer.peerId, peer]));
+      this.cachedPeers = body.peers;
+      this.cachedInstances = body.instances;
+      this.cachedMultiplayerGroups = body.multiplayerGroups;
+      for (const peer of body.peers) {
+        if (peerPublicationChanged(previousPeers.get(peer.peerId), peer)) {
+          this.notifyPeerRegistered(toPublicPeer(peer));
         }
       }
     } catch {
     }
   }
+  getPeers() {
+    return this.cachedPeers;
+  }
   getInstances() {
     return this.cachedInstances;
   }
+  getMultiplayerGroups() {
+    return this.cachedMultiplayerGroups;
+  }
+  getTopologySnapshot() {
+    return {
+      peers: this.cachedPeers,
+      instances: this.cachedInstances,
+      multiplayerGroups: this.cachedMultiplayerGroups
+    };
+  }
+  async createMultiplayerGroupEverywhere(groupId, controllerInstanceId) {
+    const response = await fetch(`${this.primaryBaseUrl}/create-multiplayer-group`, {
+      method: "POST",
+      headers: this.authHeaders({ "Content-Type": "application/json" }),
+      body: JSON.stringify({ groupId, controllerInstanceId })
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`Proxy Multiplayer Group creation failed (${response.status}): ${body || response.statusText}`);
+    }
+    const result = await response.json();
+    if (!result.group || result.group.id !== groupId) {
+      throw new Error("Proxy Multiplayer Group creation returned an invalid Group.");
+    }
+    const group = {
+      ...result.group,
+      instanceIds: [...result.group.instanceIds]
+    };
+    this.cachedPeers = this.cachedPeers.map((peer) => peer.instanceId === controllerInstanceId ? { ...peer, multiplayerGroupId: group.id } : peer);
+    this.cachedInstances = this.cachedInstances.map((instance) => instance.id === controllerInstanceId ? {
+      ...instance,
+      multiplayerGroupId: group.id,
+      peers: instance.peers.map((peer) => ({ ...peer, multiplayerGroupId: group.id }))
+    } : instance);
+    this.cachedMultiplayerGroups = [
+      ...this.cachedMultiplayerGroups.filter((candidate) => candidate.id !== group.id),
+      group
+    ];
+    return group;
+  }
+  async removeMultiplayerGroupEverywhere(groupId) {
+    const response = await fetch(`${this.primaryBaseUrl}/remove-multiplayer-group`, {
+      method: "POST",
+      headers: this.authHeaders({ "Content-Type": "application/json" }),
+      body: JSON.stringify({ groupId })
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`Proxy Multiplayer Group removal failed (${response.status}): ${body || response.statusText}`);
+    }
+    const result = await response.json();
+    const removed = result.removed;
+    if (removed !== void 0 && removed.id !== groupId) {
+      throw new Error("Proxy Multiplayer Group removal returned an invalid Group.");
+    }
+    this.cachedPeers = this.cachedPeers.map((peer) => peer.multiplayerGroupId === groupId ? { ...peer, multiplayerGroupId: void 0 } : peer);
+    this.cachedInstances = this.cachedInstances.map((instance) => instance.multiplayerGroupId === groupId ? {
+      ...instance,
+      multiplayerGroupId: void 0,
+      peers: instance.peers.map((peer) => ({ ...peer, multiplayerGroupId: void 0 }))
+    } : instance);
+    this.cachedMultiplayerGroups = this.cachedMultiplayerGroups.filter((candidate) => candidate.id !== groupId);
+    return removed === void 0 ? void 0 : { ...removed, instanceIds: [...removed.instanceIds] };
+  }
   async unregisterInstanceIdEverywhere(instanceId) {
     const response = await fetch(`${this.primaryBaseUrl}/unregister-instance-id`, {
       method: "POST",
@@ -13146,10 +13571,17 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
     }
     const result = await response.json();
     const removed = Array.isArray(result.removed) ? result.removed : [];
-    const removedKeys = new Set(removed.map((inst) => `${inst.instanceId}\0${inst.role}`));
-    if (removedKeys.size > 0) {
-      this.cachedInstances = this.cachedInstances.filter((inst) => !removedKeys.has(`${inst.instanceId}\0${inst.role}`));
-    }
+    const removedPeerIds = new Set(removed.map((peer) => peer.peerId));
+    const removedInstanceIds = /* @__PURE__ */ new Set([
+      instanceId,
+      ...removed.map((peer) => peer.instanceId)
+    ]);
+    this.cachedPeers = this.cachedPeers.filter((peer) => !removedPeerIds.has(peer.peerId));
+    this.cachedInstances = this.cachedInstances.filter((instance) => !removedInstanceIds.has(instance.id));
+    this.cachedMultiplayerGroups = this.cachedMultiplayerGroups.map((group) => ({
+      ...group,
+      instanceIds: group.instanceIds.filter((id) => !removedInstanceIds.has(id))
+    })).filter((group) => group.instanceIds.length > 0);
     return removed;
   }
   /** Called when this proxy is being discarded (e.g. promotion to primary
@@ -13160,7 +13592,7 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
       this.refreshTimer = void 0;
     }
   }
-  async sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs = this.proxyRequestTimeout, signal) {
+  async sendRequest(endpoint, data, targetPeerId, timeoutMs = this.proxyRequestTimeout, signal) {
     if (signal?.aborted)
       throw new Error("Request aborted");
     const controller = new AbortController();
@@ -13181,8 +13613,7 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
         body: JSON.stringify({
           endpoint,
           data,
-          targetInstanceId,
-          targetRole,
+          targetPeerId,
           proxyInstanceId: this.proxyInstanceId,
           timeoutMs: effectiveTimeoutMs
         }),
@@ -13337,7 +13768,7 @@ var RobloxStudioMCPServer = class {
     }, 5e3);
     const cleanupInterval = setInterval(() => {
       this.bridge.cleanupOldRequests();
-      this.bridge.cleanupStaleInstances();
+      this.bridge.cleanupStalePeers();
     }, 5e3);
     const shutdown = async () => {
       console.error("Shutting down MCP server...");
@@ -13379,7 +13810,7 @@ var TOOL_DEFINITIONS = [
       properties: {
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -13406,7 +13837,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["query"]
@@ -13430,7 +13861,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["instancePath"]
@@ -13458,7 +13889,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -13480,7 +13911,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["instancePath", "properties"]
@@ -13505,7 +13936,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["instancePath"]
@@ -13528,7 +13959,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["instancePath", "source"]
@@ -13559,7 +13990,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["instancePath", "old_string", "new_string"]
@@ -13586,7 +14017,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["instancePath", "newContent"]
@@ -13609,7 +14040,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["instancePath", "line_range"]
@@ -13628,7 +14059,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["instancePath"]
@@ -13682,7 +14113,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID if multiple are open."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["action"]
@@ -13705,7 +14136,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["code"]
@@ -13724,7 +14155,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["code"]
@@ -13747,7 +14178,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["code"]
@@ -13807,7 +14238,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["pattern"]
@@ -13898,7 +14329,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected instance for close or status; excludes launch_id."
+          description: "Studio process ID for close or status; excludes launch_id."
         },
         launch_id: {
           type: "string",
@@ -13932,7 +14363,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["action"]
@@ -13995,7 +14426,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["profile"]
@@ -14019,7 +14450,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14045,7 +14476,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14071,7 +14502,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14125,7 +14556,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14207,7 +14638,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["entries"]
@@ -14245,7 +14676,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["action"]
@@ -14254,17 +14685,28 @@ var TOOL_DEFINITIONS = [
   {
     name: "get_runtime_logs",
     category: "read",
-    description: "Use to read recent Studio output from edit, server, or client peers.",
+    description: "Use to read merged logs for one Instance or separate Instance logs for a MultiplayerGroup.",
     inputSchema: {
       type: "object",
       properties: {
-        target: {
+        instance_id: {
           type: "string",
-          description: "Log buffer: edit, server, client-N, or all; all deduplicates."
+          description: "Exact Studio process ID; excludes multiplayer_group_id."
         },
-        since: {
-          type: "number",
-          description: "Sequence floor; reuse returned nextSince values for later reads."
+        multiplayer_group_id: {
+          type: "string",
+          description: "Multiplayer group ID; excludes instance_id."
+        },
+        cursor: {
+          type: "string",
+          description: "Opaque cursor returned by the previous read of one Instance. It remains correct when Peers are added or reloaded."
+        },
+        cursor_by_instance: {
+          type: "object",
+          description: "For a multiplayer group, opaque cursors keyed by Instance ID from nextCursorByInstance.",
+          additionalProperties: {
+            type: "string"
+          }
         },
         tail: {
           type: "number",
@@ -14273,10 +14715,6 @@ var TOOL_DEFINITIONS = [
         filter: {
           type: "string",
           description: "Literal message substring applied before tail."
-        },
-        instance_id: {
-          type: "string",
-          description: "Connected place ID; required with multiple places."
         }
       }
     }
@@ -14338,7 +14776,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14465,7 +14903,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14516,7 +14954,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["action"]
@@ -14526,7 +14964,7 @@ var TOOL_DEFINITIONS = [
   {
     name: "get_connected_instances",
     category: "read",
-    description: "Use to discover connected places and the roles available in each.",
+    description: "Use to discover standalone Studio Instances and role-suffixed temporary Instances nested within multiplayer groups.",
     inputSchema: {
       type: "object",
       properties: {}
@@ -14630,7 +15068,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["assetId"]
@@ -14707,7 +15145,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14747,7 +15185,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["assetId"]
@@ -14807,7 +15245,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14844,7 +15282,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["action", "x", "y"]
@@ -14880,7 +15318,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14904,7 +15342,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14937,7 +15375,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       }
     }
@@ -14966,7 +15404,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["instance_paths", "output_path"]
@@ -15004,7 +15442,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["source", "parent_path"]
@@ -15053,7 +15491,7 @@ var TOOL_DEFINITIONS = [
         },
         instance_id: {
           type: "string",
-          description: "Connected place ID; required with multiple places."
+          description: "Studio process ID when ambiguous."
         }
       },
       required: ["pattern", "replacement"]