@sarjallab09/figma-intelligence 1.1.0 → 1.2.0

package/figma-bridge-plugin/code.js

@@ -1,1534 +0,0 @@
-/**
- * Figma Intelligence Bridge Plugin — Plugin Sandbox (code.js)
- *
- * This runs inside Figma's plugin sandbox. It cannot do network I/O directly.
- * It communicates with the UI iframe (ui.html) via figma.ui.postMessage / onmessage.
- *
- * Flow:
- *   MCP Server → WebSocket → ui.html → postMessage → this code → Figma Plugin API
- *   result  ←   WebSocket ← ui.html ← postMessage ← this code
- */
-
-var UI_WIDTH = 320;
-var UI_HEIGHT = 480;
-var UI_MIN_HEIGHT = 480;
-var UI_MAX_HEIGHT = 960;
-
-figma.showUI(__html__, { visible: true, width: UI_WIDTH, height: UI_HEIGHT });
-
-function normalizeExecuteCode(code) {
-  var trimmed = typeof code === "string" ? code.trim() : "";
-  if (!trimmed) return "";
-
-  // Many callers already pass an async IIFE. Preserve compatibility by
-  // returning its resolved value instead of letting the outer wrapper finish
-  // early with `undefined`.
-  if (/^\(async\s*\(\)\s*=>\s*\{[\s\S]*\}\)\(\);?$/.test(trimmed)) {
-    return "return await " + trimmed;
-  }
-
-  return code;
-}
-
-function getSelectionSummary() {
-  return figma.currentPage.selection.map(function(node) {
-    return { id: node.id, name: node.name, type: node.type };
-  });
-}
-
-function getCurrentPageSummary() {
-  return {
-    id: figma.currentPage.id,
-    name: figma.currentPage.name,
-  };
-}
-
-function summarizeDocumentChange(change) {
-  var summary = { type: change.type || "UNKNOWN" };
-
-  if (change.id) summary.id = change.id;
-  if (change.node && change.node.id) {
-    summary.nodeId = change.node.id;
-    summary.nodeType = change.node.type;
-  } else if (change.nodeId) {
-    summary.nodeId = change.nodeId;
-  }
-
-  return summary;
-}
-
-function postBridgeEvent(eventType, payload) {
-  figma.ui.postMessage({
-    type: "bridge-event",
-    eventType: eventType,
-    payload: payload,
-    timestamp: Date.now(),
-  });
-}
-
-function emitReadyEvent() {
-  postBridgeEvent("bridge.ready", {
-    fileName: figma.root.name,
-    currentPage: getCurrentPageSummary(),
-    pageCount: figma.root.children.length,
-    selection: getSelectionSummary(),
-    capabilities: getBridgeCapabilities(),
-  });
-}
-
-function getBridgeCapabilities() {
-  return {
-    editorType: figma.editorType,
-    mode: figma.mode || null,
-    variablesApi: !!figma.variables,
-    localVariablesApi: !!(figma.variables && figma.variables.getLocalVariableCollectionsAsync),
-    localPaintStylesApi: !!figma.getLocalPaintStylesAsync,
-    localTextStylesApi: !!figma.getLocalTextStylesAsync,
-    localEffectStylesApi: !!figma.getLocalEffectStylesAsync,
-    fileName: figma.root.name,
-  };
-}
-
-function emitSelectionChange() {
-  postBridgeEvent("selectionchange", {
-    selection: getSelectionSummary(),
-  });
-}
-
-function emitCurrentPageChange() {
-  postBridgeEvent("currentpagechange", {
-    currentPage: getCurrentPageSummary(),
-    selection: getSelectionSummary(),
-  });
-}
-
-var documentChangeFlushTimer = null;
-var pendingDocumentChanges = [];
-
-function flushDocumentChanges() {
-  if (!pendingDocumentChanges.length) return;
-  var batch = pendingDocumentChanges.splice(0, 50).map(summarizeDocumentChange);
-  postBridgeEvent("documentchange", {
-    documentChanges: batch,
-  });
-}
-
-function scheduleDocumentChangeFlush() {
-  if (documentChangeFlushTimer) return;
-  // Coalesce noisy document changes so the UI bridge socket stays stable.
-  documentChangeFlushTimer = setTimeout(function() {
-    documentChangeFlushTimer = null;
-    flushDocumentChanges();
-  }, 120);
-}
-
-function emitDocumentChange(event) {
-  var changes = Array.isArray(event && event.documentChanges) ? event.documentChanges : [];
-  if (!changes.length) return;
-  pendingDocumentChanges = pendingDocumentChanges.concat(changes);
-  if (pendingDocumentChanges.length > 200) {
-    pendingDocumentChanges = pendingDocumentChanges.slice(-200);
-  }
-  scheduleDocumentChangeFlush();
-
-  // Detect variable/token changes for taxonomy docs auto-sync
-  var hasVariableChange = changes.some(function(c) {
-    var t = (c.type || "").toUpperCase();
-    return t === "VARIABLE_CHANGE" || t === "VARIABLE_COLLECTION_CHANGE"
-      || t === "CREATE" || t === "PROPERTY_CHANGE" || t === "DELETE";
-  });
-  if (hasVariableChange) {
-    postBridgeEvent("variable-change", { timestamp: Date.now() });
-  }
-}
-
-figma.on("selectionchange", emitSelectionChange);
-figma.on("currentpagechange", emitCurrentPageChange);
-
-async function initializeBridgeEvents() {
-  try {
-    await figma.loadAllPagesAsync();
-    figma.on("documentchange", emitDocumentChange);
-  } catch (error) {
-    console.warn("Failed to enable documentchange events:", error);
-  } finally {
-    emitReadyEvent();
-  }
-}
-
-initializeBridgeEvents();
-
-// ─── Operation Cursor System ──────────────────────────────────────────────────
-// Single honest cursor that tracks real operations. Moves to the actual target
-// node, shows real operation names, and stays invisible when idle.
-
-// Pre-load font for cursor label
-figma.loadFontAsync({ family: "Inter", style: "Bold" }).catch(function() {
-  figma.loadFontAsync({ family: "Inter", style: "Semi Bold" }).catch(function() {
-    figma.loadFontAsync({ family: "Inter", style: "Regular" }).catch(function() {});
-  });
-});
-
-// ── Cursor Configuration ──────────────────────────────────────────────────────
-var CURSOR_NAME = "MCP Power";
-var CURSOR_COLOR = { r: 0.43, g: 0.37, b: 0.85 }; // #6E5FD8
-var CURSOR_TEXT_COLOR = { r: 1, g: 1, b: 1 };
-var CURSOR_ANIM_DURATION = 250; // ms — perceptible but snappy
-var SESSION_IDLE_TIMEOUT = 8000;
-
-// ── Methods that skip cursor entirely (they manage their own frames) ──
-var THEATRE_SKIP_METHODS = { execute: 1 };
-
-// ── Shared State ──────────────────────────────────────────────────────────────
-var opCursor = null;          // { pointer, label, text, x, y, fontStyle }
-var operationCount = 0;
-var cursorCleanupTimer = null;
-var cursorActive = false;
-
-// ── Operation Classification ──────────────────────────────────────────────────
-var READ_OPERATIONS = {
-  getNode:1, getSelection:1, getStatus:1, getPages:1,
-  getStyles:1, getVariables:1, getComponentSets:1,
-  searchComponents:1, screenshot:1, getCapabilities:1, ping:1,
-};
-
-// ── Human-readable operation labels (shown on cursor) ─────────────────────────
-var METHOD_LABELS = {
-  createChild: "Creating", createPage: "Creating page",
-  moveNode: "Positioning", resizeNode: "Resizing",
-  cloneNode: "Duplicating", deleteNode: "Removing",
-  setFills: "Styling", setStrokes: "Styling",
-  createVariable: "Creating token", updateVariable: "Updating token",
-  createVariableCollection: "New collection",
-  batchCreateVariables: "Creating tokens", batchUpdateVariables: "Updating tokens",
-  deleteVariable: "Removing token",
-  setText: "Writing text", renameNode: "Naming",
-  setDescription: "Documenting",
-  instantiateComponent: "Placing component",
-};
-
-// ── Utility ───────────────────────────────────────────────────────────────────
-function theatreDelay(ms) {
-  return new Promise(function(resolve) { setTimeout(resolve, ms); });
-}
-
-// ── Absolute Position Helper ───────────────────────────────────────────────────
-function getAbsolutePosition(node) {
-  try {
-    if (node.absoluteTransform) {
-      return {
-        x: node.absoluteTransform[0][2],
-        y: node.absoluteTransform[1][2],
-        width: node.width || 0,
-        height: node.height || 0,
-      };
-    }
-  } catch (e) {}
-  return { x: node.x || 0, y: node.y || 0, width: node.width || 0, height: node.height || 0 };
-}
-
-// ── Get Real Target Position ──────────────────────────────────────────────────
-async function getTargetPosition(method, params) {
-  try {
-    var targetNode = null;
-    if (params.nodeId) targetNode = await figma.getNodeByIdAsync(params.nodeId);
-    if (!targetNode && params.parentId) targetNode = await figma.getNodeByIdAsync(params.parentId);
-
-    if (targetNode && targetNode.absoluteTransform) {
-      var abs = getAbsolutePosition(targetNode);
-      // Position cursor just outside the top-left of the target node
-      return { x: abs.x - 20, y: abs.y - 6 };
-    }
-
-    // Fall back to explicit coordinates if provided
-    if (typeof params.x === "number" && typeof params.y === "number") {
-      return { x: params.x - 20, y: params.y - 6 };
-    }
-  } catch (e) {}
-
-  // Last resort: viewport center
-  try {
-    var vc = figma.viewport.center;
-    return { x: vc.x, y: vc.y };
-  } catch (e) {
-    return { x: 400, y: 300 };
-  }
-}
-
-// ── Build Operation Label ─────────────────────────────────────────────────────
-function buildOperationLabel(method, params) {
-  var prefix = METHOD_LABELS[method] || method;
-  // Append the element name when available for context
-  var name = params && params.name;
-  if (!name && params && params.characters) {
-    name = params.characters.length > 20 ? params.characters.substring(0, 20) + "…" : params.characters;
-  }
-  return name ? prefix + ": " + name : prefix;
-}
-
-// ── Cursor Creation ─────────────────────────────────────────────────────────
-async function createCursorNode(x, y) {
-  var POINTER_W = 14;
-  var POINTER_H = 21;
-
-  var pointer;
-  try {
-    pointer = figma.createVector();
-    pointer.vectorPaths = [{
-      windingRule: "NONZERO",
-      data: "M 0 0 L 0 18 L 5 13 L 9 21 L 12 19.5 L 8 11 L 14 11 Z"
-    }];
-    pointer.fills = [{ type: "SOLID", color: { r: 1, g: 1, b: 1 } }];
-    pointer.strokes = [{ type: "SOLID", color: CURSOR_COLOR }];
-    pointer.strokeWeight = 1.5;
-    pointer.resize(POINTER_W, POINTER_H);
-  } catch (e) {
-    pointer = figma.createRectangle();
-    pointer.resize(10, 14);
-    pointer.cornerRadius = 1;
-    pointer.fills = [{ type: "SOLID", color: { r: 1, g: 1, b: 1 } }];
-    pointer.strokes = [{ type: "SOLID", color: CURSOR_COLOR }];
-    pointer.strokeWeight = 1;
-  }
-  pointer.name = "__agent_ptr_op";
-  pointer.locked = true;
-  pointer.x = x;
-  pointer.y = y;
-  figma.currentPage.appendChild(pointer);
-
-  var label = figma.createFrame();
-  label.name = "__agent_label_op";
-  label.locked = true;
-  label.fills = [{ type: "SOLID", color: CURSOR_COLOR }];
-  label.cornerRadius = 4;
-  label.layoutMode = "HORIZONTAL";
-  label.primaryAxisSizingMode = "AUTO";
-  label.counterAxisSizingMode = "AUTO";
-  label.paddingLeft = 6;
-  label.paddingRight = 6;
-  label.paddingTop = 2;
-  label.paddingBottom = 2;
-  label.effects = [{
-    type: "DROP_SHADOW",
-    color: { r: 0, g: 0, b: 0, a: 0.3 },
-    offset: { x: 0, y: 2 },
-    radius: 4,
-    visible: true,
-    blendMode: "NORMAL",
-    spread: 0,
-  }];
-  label.x = x + POINTER_W + 2;
-  label.y = y + POINTER_H - 4;
-  figma.currentPage.appendChild(label);
-
-  var fontStyle = "Regular";
-  var textNode = null;
-  try {
-    try {
-      await figma.loadFontAsync({ family: "Inter", style: "Bold" });
-      fontStyle = "Bold";
-    } catch (e) {
-      try {
-        await figma.loadFontAsync({ family: "Inter", style: "Semi Bold" });
-        fontStyle = "Semi Bold";
-      } catch (e2) {
-        await figma.loadFontAsync({ family: "Inter", style: "Regular" });
-      }
-    }
-    textNode = figma.createText();
-    textNode.fontName = { family: "Inter", style: fontStyle };
-    textNode.characters = CURSOR_NAME;
-    textNode.fontSize = 10;
-    textNode.fills = [{ type: "SOLID", color: CURSOR_TEXT_COLOR }];
-    textNode.locked = true;
-    label.appendChild(textNode);
-  } catch (fontErr) {
-    label.resize(50, 18);
-  }
-
-  opCursor = {
-    pointer: pointer, label: label, text: textNode,
-    x: x, y: y, fontStyle: fontStyle,
-  };
-}
-
-// ── Cursor Label Update ────────────────────────────────────────────────────────
-function updateCursorLabel(text) {
-  if (!opCursor || !opCursor.text) return;
-  try { opCursor.text.characters = text; } catch (e) {}
-}
-
-// ── Cursor Movement (instant) ──────────────────────────────────────────────────
-function moveCursorTo(x, y) {
-  if (!opCursor) return;
-  try {
-    opCursor.pointer.x = x;
-    opCursor.pointer.y = y;
-    opCursor.label.x = x + 16;
-    opCursor.label.y = y + 17;
-    opCursor.x = x;
-    opCursor.y = y;
-  } catch (e) {}
-}
-
-// ── Animated Cursor Movement ───────────────────────────────────────────────────
-async function animateCursorTo(targetX, targetY, durationMs) {
-  if (!opCursor) return;
-
-  var dur = (typeof durationMs === "number") ? durationMs : CURSOR_ANIM_DURATION;
-  var startX = opCursor.x;
-  var startY = opCursor.y;
-  var dx = targetX - startX;
-  var dy = targetY - startY;
-  var dist = Math.sqrt(dx * dx + dy * dy);
-
-  if (dist < 15) {
-    moveCursorTo(targetX, targetY);
-    return;
-  }
-
-  var steps = Math.max(6, Math.min(18, Math.floor(dist / 18)));
-  var stepDelay = Math.floor(dur / steps);
-
-  for (var i = 1; i <= steps; i++) {
-    var t = i / steps;
-    var ease = t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
-    moveCursorTo(startX + dx * ease, startY + dy * ease);
-    if (i < steps) await theatreDelay(stepDelay);
-  }
-}
-
-// ── Fade Out Cursor ───────────────────────────────────────────────────────────
-async function fadeOutCursor(durationMs) {
-  if (!opCursor) return;
-  var stepDelay = Math.floor((durationMs || 400) / 5);
-  for (var step = 4; step >= 0; step--) {
-    var opacity = step / 4;
-    try { opCursor.pointer.opacity = opacity; } catch (e) {}
-    try { opCursor.label.opacity = opacity; } catch (e) {}
-    if (step > 0) await theatreDelay(stepDelay);
-  }
-  removeCursorNodes();
-}
-
-// ── Ensure Cursor Exists ──────────────────────────────────────────────────────
-async function ensureCursor(x, y) {
-  if (opCursor) return;
-  cleanupOrphanedCursors();
-  await createCursorNode(x, y);
-  cursorActive = true;
-}
-
-// ── Cleanup ────────────────────────────────────────────────────────────────────
-function removeCursorNodes() {
-  if (!opCursor) return;
-  try { opCursor.pointer.remove(); } catch (e) {}
-  try { opCursor.label.remove(); } catch (e) {}
-  opCursor = null;
-  cursorActive = false;
-}
-
-function cleanupOrphanedCursors() {
-  try {
-    var orphans = figma.currentPage.findAll(function(n) {
-      return n.name && (
-        n.name.indexOf("__agent_ptr_") === 0 ||
-        n.name.indexOf("__agent_label_") === 0 ||
-        n.name.indexOf("__agent_cursor_") === 0 ||
-        n.name.indexOf("__cursor_") === 0
-      );
-    });
-    for (var i = 0; i < orphans.length; i++) {
-      try { orphans[i].remove(); } catch (e) {}
-    }
-  } catch (e) {}
-}
-
-// ── Bring Cursor to Front ─────────────────────────────────────────────────────
-function bringCursorToFront() {
-  if (!opCursor) return;
-  try {
-    if (opCursor.pointer && opCursor.pointer.parent === figma.currentPage) {
-      figma.currentPage.appendChild(opCursor.pointer);
-    }
-    if (opCursor.label && opCursor.label.parent === figma.currentPage) {
-      figma.currentPage.appendChild(opCursor.label);
-    }
-  } catch (e) {}
-}
-
-// ── Idle Cleanup Timer ────────────────────────────────────────────────────────
-function resetCursorCleanupTimer() {
-  if (cursorCleanupTimer) clearTimeout(cursorCleanupTimer);
-  cursorCleanupTimer = setTimeout(function() {
-    if (opCursor) {
-      (async function() { await fadeOutCursor(400); })();
-      figma.ui.postMessage({ type: "agent-session-end", timestamp: Date.now() });
-    }
-    operationCount = 0;
-  }, SESSION_IDLE_TIMEOUT);
-}
-
-// ── Main Operation Cursor ─────────────────────────────────────────────────────
-async function activateAgentForOperation(method, params) {
-  if (READ_OPERATIONS[method]) return;
-
-  operationCount++;
-  var pos = await getTargetPosition(method, params || {});
-  await ensureCursor(pos.x, pos.y);
-
-  // Build label from real operation + element name
-  var label = buildOperationLabel(method, params || {});
-  updateCursorLabel(label);
-
-  // Animate to actual target position
-  await animateCursorTo(pos.x, pos.y);
-  bringCursorToFront();
-
-  // Report real activity to UI
-  figma.ui.postMessage({
-    type: "agent-activity",
-    agent: CURSOR_NAME,
-    method: method,
-    status: label,
-    phase: "WORKING",
-    timestamp: Date.now(),
-  });
-
-  resetCursorCleanupTimer();
-}
-
-// ── Post-Operation Effect ──────────────────────────────────────────────────────
-async function postOperationEffect(method, params, result) {
-  if (READ_OPERATIONS[method]) return;
-  if (!opCursor) return;
-
-  // Move cursor to the newly created node's actual position
-  if (result && result.id) {
-    try {
-      var newNode = await figma.getNodeByIdAsync(result.id);
-      if (newNode && newNode.absoluteTransform) {
-        var abs = getAbsolutePosition(newNode);
-        await animateCursorTo(abs.x - 20, abs.y - 6, 150);
-      }
-    } catch (e) {}
-  }
-
-  resetCursorCleanupTimer();
-}
-
-// ─── End Operation Cursor System ──────────────────────────────────────────────
-
-// ─── Multi-Agent Cursor System (Swarm Mode) ─────────────────────────────────
-// Multiple named agent cursors with unique colors for parallel visual theatre.
-// Each agent gets its own pointer + label that can move independently.
-
-var AGENT_COLORS = {
-  Layouter:   { r: 0.26, g: 0.52, b: 0.96 },  // #4285F4 blue
-  Styler:     { r: 0.60, g: 0.33, b: 0.86 },  // #9955DB purple
-  Copywriter: { r: 0.13, g: 0.72, b: 0.45 },  // #22B873 green
-  Matcher:    { r: 0.96, g: 0.50, b: 0.14 },  // #F58024 orange
-  Reviewer:   { r: 0.90, g: 0.22, b: 0.35 },  // #E63959 red
-  Builder:    { r: 0.18, g: 0.73, b: 0.82 },  // #2EBAD1 teal
-};
-
-var agentCursors = {};  // { agentId: { pointer, label, text, x, y } }
-
-async function createAgentCursorNode(agentId, x, y) {
-  var color = AGENT_COLORS[agentId] || AGENT_COLORS.Builder;
-
-  var pointer;
-  try {
-    pointer = figma.createVector();
-    pointer.vectorPaths = [{
-      windingRule: "NONZERO",
-      data: "M 0 0 L 0 18 L 5 13 L 9 21 L 12 19.5 L 8 11 L 14 11 Z"
-    }];
-    pointer.fills = [{ type: "SOLID", color: { r: 1, g: 1, b: 1 } }];
-    pointer.strokes = [{ type: "SOLID", color: color }];
-    pointer.strokeWeight = 1.5;
-    pointer.resize(14, 21);
-  } catch (e) {
-    pointer = figma.createRectangle();
-    pointer.resize(10, 14);
-    pointer.cornerRadius = 1;
-    pointer.fills = [{ type: "SOLID", color: { r: 1, g: 1, b: 1 } }];
-    pointer.strokes = [{ type: "SOLID", color: color }];
-    pointer.strokeWeight = 1;
-  }
-  pointer.name = "__agent_ptr_" + agentId;
-  pointer.locked = true;
-  pointer.x = x;
-  pointer.y = y;
-  figma.currentPage.appendChild(pointer);
-
-  var label = figma.createFrame();
-  label.name = "__agent_label_" + agentId;
-  label.locked = true;
-  label.fills = [{ type: "SOLID", color: color }];
-  label.cornerRadius = 4;
-  label.layoutMode = "HORIZONTAL";
-  label.primaryAxisSizingMode = "AUTO";
-  label.counterAxisSizingMode = "AUTO";
-  label.paddingLeft = 6;
-  label.paddingRight = 6;
-  label.paddingTop = 2;
-  label.paddingBottom = 2;
-  label.effects = [{
-    type: "DROP_SHADOW",
-    color: { r: 0, g: 0, b: 0, a: 0.3 },
-    offset: { x: 0, y: 2 },
-    radius: 4,
-    visible: true,
-    blendMode: "NORMAL",
-    spread: 0,
-  }];
-  label.x = x + 16;
-  label.y = y + 17;
-  figma.currentPage.appendChild(label);
-
-  var textNode = null;
-  try {
-    await figma.loadFontAsync({ family: "Inter", style: "Bold" });
-    textNode = figma.createText();
-    textNode.fontName = { family: "Inter", style: "Bold" };
-    textNode.characters = agentId;
-    textNode.fontSize = 10;
-    textNode.fills = [{ type: "SOLID", color: { r: 1, g: 1, b: 1 } }];
-    textNode.locked = true;
-    label.appendChild(textNode);
-  } catch (e) {
-    try {
-      await figma.loadFontAsync({ family: "Inter", style: "Regular" });
-      textNode = figma.createText();
-      textNode.fontName = { family: "Inter", style: "Regular" };
-      textNode.characters = agentId;
-      textNode.fontSize = 10;
-      textNode.fills = [{ type: "SOLID", color: { r: 1, g: 1, b: 1 } }];
-      textNode.locked = true;
-      label.appendChild(textNode);
-    } catch (e2) {
-      label.resize(60, 18);
-    }
-  }
-
-  agentCursors[agentId] = { pointer: pointer, label: label, text: textNode, x: x, y: y };
-}
-
-function moveAgentCursorTo(agentId, x, y) {
-  var cursor = agentCursors[agentId];
-  if (!cursor) return;
-  try {
-    cursor.pointer.x = x;
-    cursor.pointer.y = y;
-    cursor.label.x = x + 16;
-    cursor.label.y = y + 17;
-    cursor.x = x;
-    cursor.y = y;
-  } catch (e) {}
-}
-
-async function animateAgentCursorTo(agentId, targetX, targetY, durationMs) {
-  var cursor = agentCursors[agentId];
-  if (!cursor) return;
-
-  var dur = (typeof durationMs === "number") ? durationMs : 250;
-  var startX = cursor.x;
-  var startY = cursor.y;
-  var dx = targetX - startX;
-  var dy = targetY - startY;
-  var dist = Math.sqrt(dx * dx + dy * dy);
-
-  if (dist < 15) {
-    moveAgentCursorTo(agentId, targetX, targetY);
-    return;
-  }
-
-  var steps = Math.max(6, Math.min(14, Math.floor(dist / 20)));
-  var stepDelay = Math.floor(dur / steps);
-
-  for (var i = 1; i <= steps; i++) {
-    var t = i / steps;
-    var ease = t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
-    moveAgentCursorTo(agentId, startX + dx * ease, startY + dy * ease);
-    if (i < steps) await theatreDelay(stepDelay);
-  }
-}
-
-function updateAgentCursorLabel(agentId, text) {
-  var cursor = agentCursors[agentId];
-  if (!cursor || !cursor.text) return;
-  try { cursor.text.characters = text; } catch (e) {}
-}
-
-function removeAgentCursorNode(agentId) {
-  var cursor = agentCursors[agentId];
-  if (!cursor) return;
-  try { cursor.pointer.remove(); } catch (e) {}
-  try { cursor.label.remove(); } catch (e) {}
-  delete agentCursors[agentId];
-}
-
-function removeAllAgentCursorNodes() {
-  var ids = Object.keys(agentCursors);
-  for (var i = 0; i < ids.length; i++) {
-    removeAgentCursorNode(ids[i]);
-  }
-}
-
-async function createAgentChatNote(agentId, message, x, y) {
-  var color = AGENT_COLORS[agentId] || AGENT_COLORS.Builder;
-
-  var note = figma.createFrame();
-  note.name = "__agent_chat_" + agentId;
-  note.locked = true;
-  note.layoutMode = "VERTICAL";
-  note.primaryAxisSizingMode = "AUTO";
-  note.counterAxisSizingMode = "AUTO";
-  note.paddingLeft = 10;
-  note.paddingRight = 10;
-  note.paddingTop = 6;
-  note.paddingBottom = 6;
-  note.itemSpacing = 2;
-  note.cornerRadius = 8;
-  note.fills = [{ type: "SOLID", color: { r: 1, g: 1, b: 1 } }];
-  note.strokes = [{ type: "SOLID", color: color }];
-  note.strokeWeight = 1.5;
-  note.effects = [{
-    type: "DROP_SHADOW",
-    color: { r: 0, g: 0, b: 0, a: 0.12 },
-    offset: { x: 0, y: 2 },
-    radius: 6,
-    visible: true,
-    blendMode: "NORMAL",
-    spread: 0,
-  }];
-  note.x = x;
-  note.y = y;
-
-  try {
-    await figma.loadFontAsync({ family: "Inter", style: "Bold" });
-    await figma.loadFontAsync({ family: "Inter", style: "Regular" });
-
-    var nameText = figma.createText();
-    nameText.fontName = { family: "Inter", style: "Bold" };
-    nameText.characters = agentId;
-    nameText.fontSize = 10;
-    nameText.fills = [{ type: "SOLID", color: color }];
-    nameText.locked = true;
-    note.appendChild(nameText);
-
-    var msgText = figma.createText();
-    msgText.fontName = { family: "Inter", style: "Regular" };
-    msgText.characters = message;
-    msgText.fontSize = 10;
-    msgText.fills = [{ type: "SOLID", color: { r: 0.3, g: 0.3, b: 0.3 } }];
-    msgText.locked = true;
-    note.appendChild(msgText);
-  } catch (e) {
-    note.resize(140, 36);
-  }
-
-  figma.currentPage.appendChild(note);
-  return note.id;
-}
-
-function cleanupAgentChatNotes() {
-  try {
-    var notes = figma.currentPage.findAll(function(n) {
-      return n.name && n.name.indexOf("__agent_chat_") === 0;
-    });
-    for (var i = 0; i < notes.length; i++) {
-      try { notes[i].remove(); } catch (e) {}
-    }
-  } catch (e) {}
-}
-
-// ─── End Multi-Agent Cursor System ───────────────────────────────────────────
-
-async function normalizeVariableValue(resolvedType, value) {
-  if (value === undefined || value === null) return value;
-
-  if (
-    typeof value === "object" &&
-    value &&
-    value.type === "VARIABLE_ALIAS" &&
-    typeof value.variableId === "string"
-  ) {
-    if (!figma.variables || !figma.variables.getVariableByIdAsync || !figma.variables.createVariableAlias) {
-      throw new Error("Variable aliasing is unavailable in this plugin runtime");
-    }
-    const aliasTarget = await figma.variables.getVariableByIdAsync(value.variableId);
-    if (!aliasTarget) {
-      throw new Error("Alias target variable not found: " + value.variableId);
-    }
-    return figma.variables.createVariableAlias(aliasTarget);
-  }
-
-  if (resolvedType === "COLOR") {
-    if (typeof value === "string") {
-      var hex = value.trim().replace(/^#/, "");
-      if (hex.length === 6 || hex.length === 8) {
-        return {
-          r: parseInt(hex.slice(0, 2), 16) / 255,
-          g: parseInt(hex.slice(2, 4), 16) / 255,
-          b: parseInt(hex.slice(4, 6), 16) / 255,
-          a: hex.length === 8 ? parseInt(hex.slice(6, 8), 16) / 255 : 1,
-        };
-      }
-    }
-    if (
-      typeof value === "object" &&
-      typeof value.r === "number" &&
-      typeof value.g === "number" &&
-      typeof value.b === "number"
-    ) {
-      return {
-        r: value.r,
-        g: value.g,
-        b: value.b,
-        a: typeof value.a === "number" ? value.a : 1,
-      };
-    }
-    throw new Error("Invalid COLOR value: expected #RRGGBB, #RRGGBBAA, or {r,g,b,a}");
-  }
-
-  if (resolvedType === "FLOAT") {
-    if (typeof value === "number") return value;
-    if (typeof value === "string" && value.trim() !== "") {
-      var parsed = Number(value);
-      if (!Number.isNaN(parsed)) return parsed;
-    }
-    throw new Error("Invalid FLOAT value: expected number");
-  }
-
-  if (resolvedType === "BOOLEAN") {
-    if (typeof value === "boolean") return value;
-    if (value === "true") return true;
-    if (value === "false") return false;
-    throw new Error("Invalid BOOLEAN value: expected true/false");
-  }
-
-  if (resolvedType === "STRING") {
-    return String(value);
-  }
-
-  return value;
-}
-
-// ─── Handle messages from the UI (which receives them from the WebSocket) ────
-
-figma.ui.onmessage = async (msg) => {
-  if (msg.type === "resize-ui") {
-    var width = typeof msg.width === "number" ? Math.max(280, Math.round(msg.width)) : UI_WIDTH;
-    var height = typeof msg.height === "number"
-      ? Math.max(UI_MIN_HEIGHT, Math.min(UI_MAX_HEIGHT, Math.round(msg.height)))
-      : UI_HEIGHT;
-    UI_WIDTH = width;
-    UI_HEIGHT = height;
-    figma.ui.resize(UI_WIDTH, UI_HEIGHT);
-    return;
-  }
-
-  // Handle agent cursor commands from UI
-  if (msg.type === "agent-command") {
-    if (msg.command === "cleanup") {
-      removeAllAgentCursorNodes();
-      cleanupOrphanedCursors();
-    }
-    return;
-  }
-
-  // msg: { type: "bridge-request", id: string, method: string, params: object }
-  if (msg.type !== "bridge-request") return;
-
-  const { id, method, params } = msg;
-
-  // Activate agent cursor for this operation (errors must not block the real work)
-  try { if (!THEATRE_SKIP_METHODS[method]) await activateAgentForOperation(method, params); } catch (e) {}
-
-  try {
-    let result;
-
-    switch (method) {
-
-      // ── Core: execute arbitrary plugin code ────────────────────────────
-      case "execute": {
-        // params.code is a string of Figma Plugin API code
-        // We wrap it in an async function so `return` works
-        const normalizedCode = normalizeExecuteCode(params.code);
-        const fn = new Function("figma", `return (async () => { ${normalizedCode} })();`);
-        result = await fn(figma);
-        break;
-      }
-
-      // ── Convenience: get node by ID ────────────────────────────────────
-      case "getNode": {
-        const node = await figma.getNodeByIdAsync(params.nodeId);
-        if (!node) throw new Error("Node not found: " + params.nodeId);
-        result = await serializeNode(node);
-        break;
-      }
-
-      // ── Convenience: take screenshot ───────────────────────────────────
-      case "screenshot": {
-        const node = await figma.getNodeByIdAsync(params.nodeId);
-        if (!node) throw new Error("Node not found: " + params.nodeId);
-        if (!('exportAsync' in node)) throw new Error('Node does not support export');
-        const bytes = await node.exportAsync({
-          format: "PNG",
-          constraint: { type: "SCALE", value: params.scale || 2 },
-        });
-        // Send bytes as Uint8Array; UI layer will convert to base64
-        figma.ui.postMessage({
-          type: "bridge-response",
-          id,
-          resultBytes: Array.from(bytes),
-        });
-        return; // early return — we sent the response directly
-      }
-
-      // ── Convenience: import image from a data URI and return image hash ──
-      case "importImage": {
-        if (typeof params.imageDataUri !== "string" || !params.imageDataUri.startsWith("data:image")) {
-          throw new Error("importImage requires imageDataUri");
-        }
-        const response = await fetch(params.imageDataUri);
-        const bytes = new Uint8Array(await response.arrayBuffer());
-        const image = figma.createImage(bytes);
-        result = {
-          imageHash: image.hash,
-          byteLength: bytes.length,
-        };
-        break;
-      }
-
-      // ── Convenience: list pages ────────────────────────────────────────
-      case "getPages": {
-        result = figma.root.children.map((p) => ({
-          id: p.id,
-          name: p.name,
-        }));
-        break;
-      }
-
-      // ── Convenience: list component sets ───────────────────────────────
-      case "getComponentSets": {
-        var sets = figma.currentPage.findAll(function(n) { return n.type === "COMPONENT_SET"; });
-        result = sets.map((s) => ({
-          id: s.id,
-          name: s.name,
-          description: s.description || "",
-          children: s.children.map((c) => ({
-            id: c.id,
-            name: c.name,
-            type: c.type,
-          })),
-        }));
-        break;
-      }
-
-      // ── Convenience: get tokens / variables ────────────────────────────
-      case "getTokens": {
-        const collections = await figma.variables.getLocalVariableCollectionsAsync();
-        const filtered = params.collectionId
-          ? collections.filter((c) => c.id === params.collectionId)
-          : collections;
-        const tokens = [];
-        for (const col of filtered) {
-          for (const varId of col.variableIds) {
-            const v = await figma.variables.getVariableByIdAsync(varId);
-            if (!v) continue;
-            const modeValues = {};
-            for (const [modeId, val] of Object.entries(v.valuesByMode)) {
-              const mode = col.modes.find((m) => m.modeId === modeId);
-              modeValues[mode ? mode.name : modeId] = val;
-            }
-            var firstVal = Object.values(modeValues)[0];
-            tokens.push({
-              id: v.id,
-              name: v.name,
-              type: v.resolvedType,
-              value: firstVal !== undefined ? firstVal : null,
-              collectionId: col.id,
-              modeValues,
-              description: v.description || "",
-            });
-          }
-        }
-        result = tokens;
-        break;
-      }
-
-      // ── Ping / health check ────────────────────────────────────────────
-      case "ping": {
-        result = {
-          status: "ok",
-          fileName: figma.root.name,
-          pageCount: figma.root.children.length,
-          timestamp: Date.now(),
-        };
-        break;
-      }
-
-      // ── Navigation & Status ─────────────────────────────────────────────
-      case "getStatus": {
-        var connStatus = "connected";
-        var currentPage = figma.currentPage;
-        result = {
-          status: connStatus,
-          fileName: figma.root.name,
-          currentPage: { id: currentPage.id, name: currentPage.name },
-          pageCount: figma.root.children.length,
-          timestamp: Date.now(),
-        };
-        break;
-      }
-
-      case "getCapabilities": {
-        result = getBridgeCapabilities();
-        break;
-      }
-
-      case "navigate": {
-        if (params.nodeId) {
-          var navNode = await figma.getNodeByIdAsync(params.nodeId);
-          if (navNode) figma.viewport.scrollAndZoomIntoView([navNode]);
-          result = { navigated: true, nodeId: params.nodeId };
-        } else {
-          result = { navigated: false, error: "No nodeId provided" };
-        }
-        break;
-      }
-
-      case "getSelection": {
-        var sel = figma.currentPage.selection;
-        result = sel.map(function(n) {
-          return { id: n.id, name: n.name, type: n.type };
-        });
-        break;
-      }
-
-      // ── Variable CRUD ──────────────────────────────────────────────────
-      case "createVariableCollection": {
-        var col = figma.variables.createVariableCollection(params.name);
-        if (params.initialModeName && col.modes.length > 0) {
-          col.renameMode(col.modes[0].modeId, params.initialModeName);
-        }
-        result = {
-          id: col.id,
-          name: col.name,
-          modes: col.modes.map(function(m) { return { modeId: m.modeId, name: m.name }; }),
-        };
-        break;
-      }
-
-      case "createVariable": {
-        var targetCollection = await figma.variables.getVariableCollectionByIdAsync(params.collectionId);
-        if (!targetCollection) throw new Error("Collection not found: " + params.collectionId);
-        var newVar = figma.variables.createVariable(
-          params.name,
-          targetCollection,
-          params.resolvedType
-        );
-        if (params.description) newVar.description = params.description;
-        if (params.valuesByMode) {
-          var entries = Object.entries(params.valuesByMode);
-          for (var vi = 0; vi < entries.length; vi++) {
-            newVar.setValueForMode(entries[vi][0], await normalizeVariableValue(params.resolvedType, entries[vi][1]));
-          }
-        }
-        result = { id: newVar.id, name: newVar.name, resolvedType: newVar.resolvedType };
-        break;
-      }
-
-      case "updateVariable": {
-        var updVar = await figma.variables.getVariableByIdAsync(params.variableId);
-        if (!updVar) throw new Error("Variable not found: " + params.variableId);
-        updVar.setValueForMode(params.modeId, await normalizeVariableValue(updVar.resolvedType, params.value));
-        result = { id: updVar.id, name: updVar.name, updated: true };
-        break;
-      }
-
-      case "deleteVariable": {
-        var delVar = await figma.variables.getVariableByIdAsync(params.variableId);
-        if (!delVar) throw new Error("Variable not found: " + params.variableId);
-        delVar.remove();
-        result = { deleted: true, variableId: params.variableId };
-        break;
-      }
-
-      case "renameVariable": {
-        var renVar = await figma.variables.getVariableByIdAsync(params.variableId);
-        if (!renVar) throw new Error("Variable not found: " + params.variableId);
-        renVar.name = params.newName;
-        result = { id: renVar.id, name: renVar.name, renamed: true };
-        break;
-      }
-
-      case "deleteVariableCollection": {
-        var delCol = await figma.variables.getVariableCollectionByIdAsync(params.collectionId);
-        if (!delCol) throw new Error("Collection not found: " + params.collectionId);
-        delCol.remove();
-        result = { deleted: true, collectionId: params.collectionId };
-        break;
-      }
-
-      case "addMode": {
-        var modeCol = await figma.variables.getVariableCollectionByIdAsync(params.collectionId);
-        if (!modeCol) throw new Error("Collection not found: " + params.collectionId);
-        var newMode = modeCol.addMode(params.modeName);
-        result = { collectionId: params.collectionId, modeId: newMode, modeName: params.modeName };
-        break;
-      }
-
-      case "renameMode": {
-        var rmCol = await figma.variables.getVariableCollectionByIdAsync(params.collectionId);
-        if (!rmCol) throw new Error("Collection not found: " + params.collectionId);
-        rmCol.renameMode(params.modeId, params.newName);
-        result = { collectionId: params.collectionId, modeId: params.modeId, newName: params.newName };
-        break;
-      }
-
-      case "batchCreateVariables": {
-        var batchResults = [];
-        for (var bi = 0; bi < params.variables.length; bi++) {
-          var spec = params.variables[bi];
-          var batchCollection = await figma.variables.getVariableCollectionByIdAsync(spec.collectionId);
-          if (!batchCollection) throw new Error("Collection not found: " + spec.collectionId);
-          var bVar = figma.variables.createVariable(spec.name, batchCollection, spec.resolvedType);
-          if (spec.description) bVar.description = spec.description;
-          if (spec.valuesByMode) {
-            var bEntries = Object.entries(spec.valuesByMode);
-            for (var bj = 0; bj < bEntries.length; bj++) {
-              bVar.setValueForMode(bEntries[bj][0], await normalizeVariableValue(spec.resolvedType, bEntries[bj][1]));
-            }
-          }
-          batchResults.push({ id: bVar.id, name: bVar.name, resolvedType: bVar.resolvedType });
-        }
-        result = { created: batchResults.length, variables: batchResults };
-        break;
-      }
-
-      case "batchUpdateVariables": {
-        var batchUpdated = 0;
-        for (var ui = 0; ui < params.updates.length; ui++) {
-          var upd = params.updates[ui];
-          var buVar = await figma.variables.getVariableByIdAsync(upd.variableId);
-          if (buVar) {
-            buVar.setValueForMode(upd.modeId, await normalizeVariableValue(buVar.resolvedType, upd.value));
-            batchUpdated++;
-          }
-        }
-        result = { updated: batchUpdated, total: params.updates.length };
-        break;
-      }
-
-      // ── Node Operations ────────────────────────────────────────────────
-      case "cloneNode": {
-        var srcNode = await figma.getNodeByIdAsync(params.nodeId);
-        if (!srcNode) throw new Error("Node not found: " + params.nodeId);
-        var cloned = srcNode.clone();
-        if (params.x !== undefined) cloned.x = params.x;
-        if (params.y !== undefined) cloned.y = params.y;
-        result = { id: cloned.id, name: cloned.name, type: cloned.type };
-        break;
-      }
-
-      case "deleteNode": {
-        var delNode = await figma.getNodeByIdAsync(params.nodeId);
-        if (!delNode) throw new Error("Node not found: " + params.nodeId);
-        delNode.remove();
-        result = { deleted: true, nodeId: params.nodeId };
-        break;
-      }
-
-      case "moveNode": {
-        var mvNode = await figma.getNodeByIdAsync(params.nodeId);
-        if (!mvNode) throw new Error("Node not found: " + params.nodeId);
-        if (params.x !== undefined) mvNode.x = params.x;
-        if (params.y !== undefined) mvNode.y = params.y;
-        if (params.parentId) {
-          var newParent = await figma.getNodeByIdAsync(params.parentId);
-          if (newParent && "appendChild" in newParent) {
-            newParent.appendChild(mvNode);
-          }
-        }
-        result = { id: mvNode.id, x: mvNode.x, y: mvNode.y };
-        break;
-      }
-
-      case "resizeNode": {
-        var rsNode = await figma.getNodeByIdAsync(params.nodeId);
-        if (!rsNode) throw new Error("Node not found: " + params.nodeId);
-        if ("resize" in rsNode) {
-          rsNode.resize(params.width, params.height);
-        }
-        result = { id: rsNode.id, width: params.width, height: params.height };
-        break;
-      }
-
-      case "renameNode": {
-        var rnNode = await figma.getNodeByIdAsync(params.nodeId);
-        if (!rnNode) throw new Error("Node not found: " + params.nodeId);
-        rnNode.name = params.newName;
-        result = { id: rnNode.id, name: rnNode.name };
-        break;
-      }
-
-      case "setFills": {
-        var fillNode = await figma.getNodeByIdAsync(params.nodeId);
-        if (!fillNode) throw new Error("Node not found: " + params.nodeId);
-        if ("fills" in fillNode) {
-          fillNode.fills = params.fills;
-        }
-        result = { id: fillNode.id, fills: params.fills };
-        break;
-      }
-
-      case "setStrokes": {
-        var strokeNode = await figma.getNodeByIdAsync(params.nodeId);
-        if (!strokeNode) throw new Error("Node not found: " + params.nodeId);
-        if ("strokes" in strokeNode) {
-          strokeNode.strokes = params.strokes;
-          if (params.strokeWeight !== undefined) strokeNode.strokeWeight = params.strokeWeight;
-        }
-        result = { id: strokeNode.id, strokes: params.strokes };
-        break;
-      }
-
-      case "setText": {
-        var textNode = await figma.getNodeByIdAsync(params.nodeId);
-        if (!textNode) throw new Error("Node not found: " + params.nodeId);
-        if (textNode.type !== "TEXT") throw new Error("Node is not a text node");
-        await figma.loadFontAsync(textNode.fontName);
-        textNode.characters = params.characters;
-        if (params.fontSize) textNode.fontSize = params.fontSize;
-        result = { id: textNode.id, characters: textNode.characters };
-        break;
-      }
-
-      // ── Component Operations ───────────────────────────────────────────
-      case "searchComponents": {
-        var query = (params.query || "").toLowerCase();
-        var limit = params.limit || 20;
-        var allComponents = figma.currentPage.findAll(function(n) {
-          return n.type === "COMPONENT" || n.type === "COMPONENT_SET";
-        });
-        var matched = [];
-        for (var ci = 0; ci < allComponents.length; ci++) {
-          if (allComponents[ci].name.toLowerCase().indexOf(query) !== -1) {
-            matched.push({
-              id: allComponents[ci].id,
-              name: allComponents[ci].name,
-              type: allComponents[ci].type,
-              description: allComponents[ci].description || "",
-            });
-          }
-          if (matched.length >= limit) break;
-        }
-        result = matched;
-        break;
-      }
-
-      case "instantiateComponent": {
-        var comp = null;
-        if (params.nodeId) {
-          comp = await figma.getNodeByIdAsync(params.nodeId);
-        }
-        if (!comp) throw new Error("Component not found");
-        if (comp.type === "COMPONENT_SET") {
-          // Find matching variant
-          var targetVariant = null;
-          if (params.variant) {
-            var variantStr = Object.entries(params.variant).map(function(e) {
-              return e[0] + "=" + e[1];
-            }).join(", ");
-            for (var vi2 = 0; vi2 < comp.children.length; vi2++) {
-              if (comp.children[vi2].name === variantStr) {
-                targetVariant = comp.children[vi2];
-                break;
-              }
-            }
-          }
-          if (!targetVariant) targetVariant = comp.children[0];
-          comp = targetVariant;
-        }
-        if (comp.type !== "COMPONENT") throw new Error("Node is not a component: " + comp.type);
-        var instance = comp.createInstance();
-        if (params.x !== undefined) instance.x = params.x;
-        if (params.y !== undefined) instance.y = params.y;
-        if (params.parentId) {
-          var instParent = await figma.getNodeByIdAsync(params.parentId);
-          if (instParent && "appendChild" in instParent) {
-            instParent.appendChild(instance);
-          }
-        }
-        result = { id: instance.id, name: instance.name, type: instance.type, componentId: comp.id };
-        break;
-      }
-
-      case "setDescription": {
-        var descNode = await figma.getNodeByIdAsync(params.nodeId);
-        if (!descNode) throw new Error("Node not found: " + params.nodeId);
-        if ("description" in descNode) {
-          descNode.description = params.description;
-        }
-        result = { id: descNode.id, description: params.description };
-        break;
-      }
-
-      case "getVariables": {
-        if (!figma.variables || !figma.variables.getLocalVariableCollectionsAsync) {
-          throw new Error("Variables API unavailable in this plugin runtime");
-        }
-        var verbosity = params.verbosity || "summary";
-        var gvCollections = await figma.variables.getLocalVariableCollectionsAsync();
-        if (params.collectionId) {
-          gvCollections = gvCollections.filter(function(c) { return c.id === params.collectionId; });
-        }
-        var gvResult = [];
-        for (var gci = 0; gci < gvCollections.length; gci++) {
-          var gCol = gvCollections[gci];
-          var gVars = [];
-          for (var gvi = 0; gvi < gCol.variableIds.length; gvi++) {
-            var gv = await figma.variables.getVariableByIdAsync(gCol.variableIds[gvi]);
-            if (!gv) continue;
-            var gvEntry = { id: gv.id, name: gv.name, type: gv.resolvedType };
-            if (verbosity !== "inventory") {
-              var gvModes = {};
-              var gvModeEntries = Object.entries(gv.valuesByMode);
-              for (var gmi = 0; gmi < gvModeEntries.length; gmi++) {
-                var mode = gCol.modes.find(function(m) { return m.modeId === gvModeEntries[gmi][0]; });
-                gvModes[mode ? mode.name : gvModeEntries[gmi][0]] = gvModeEntries[gmi][1];
-              }
-              gvEntry.valuesByMode = gvModes;
-              if (verbosity === "full") {
-                gvEntry.description = gv.description || "";
-                gvEntry.collectionId = gCol.id;
-                gvEntry.collectionName = gCol.name;
-              }
-            }
-            gVars.push(gvEntry);
-          }
-          gvResult.push({
-            id: gCol.id,
-            name: gCol.name,
-            modes: gCol.modes.map(function(m) { return { modeId: m.modeId, name: m.name }; }),
-            variables: gVars,
-          });
-        }
-        result = gvResult;
-        break;
-      }
-
-      case "getStyles": {
-        if (!figma.getLocalPaintStylesAsync || !figma.getLocalTextStylesAsync || !figma.getLocalEffectStylesAsync) {
-          throw new Error("Local styles APIs unavailable in this plugin runtime");
-        }
-        var paintStyles = await figma.getLocalPaintStylesAsync();
-        var textStyles = await figma.getLocalTextStylesAsync();
-        var effectStyles = await figma.getLocalEffectStylesAsync();
-        result = {
-          paint: paintStyles.map(function(s) {
-            return { id: s.id, name: s.name, paints: s.paints, description: s.description || "" };
-          }),
-          text: textStyles.map(function(s) {
-            return {
-              id: s.id, name: s.name,
-              fontName: s.fontName, fontSize: s.fontSize,
-              lineHeight: s.lineHeight, letterSpacing: s.letterSpacing,
-              description: s.description || "",
-            };
-          }),
-          effect: effectStyles.map(function(s) {
-            return { id: s.id, name: s.name, effects: s.effects, description: s.description || "" };
-          }),
-        };
-        break;
-      }
-
-      case "createChild": {
-        var parentNode = params.parentId
-          ? await figma.getNodeByIdAsync(params.parentId)
-          : figma.currentPage;
-        if (!parentNode || !("appendChild" in parentNode))
-          throw new Error("Invalid parent node");
-        var child;
-        switch (params.childType) {
-          case "FRAME":
-            child = figma.createFrame();
-            break;
-          case "TEXT":
-            child = figma.createText();
-            await figma.loadFontAsync({ family: "Inter", style: "Regular" });
-            if (params.characters) child.characters = params.characters;
-            break;
-          case "RECTANGLE":
-            child = figma.createRectangle();
-            break;
-          case "ELLIPSE":
-            child = figma.createEllipse();
-            break;
-          case "LINE":
-            child = figma.createLine();
-            break;
-          case "COMPONENT":
-            child = figma.createComponent();
-            break;
-          case "SECTION":
-            child = figma.createSection();
-            break;
-          default:
-            child = figma.createFrame();
-        }
-        if (params.name) child.name = params.name;
-        if (params.width && params.height && "resize" in child) child.resize(params.width, params.height);
-        if (params.x !== undefined) child.x = params.x;
-        if (params.y !== undefined) child.y = params.y;
-        parentNode.appendChild(child);
-        result = { id: child.id, name: child.name, type: child.type };
-        break;
-      }
-
-      case "cleanupAgentCursors": {
-        removeAllAgentCursorNodes();
-        cleanupAgentChatNotes();
-        cleanupOrphanedCursors();
-        result = { cleaned: true };
-        break;
-      }
-
-      // ── Swarm Agent Cursor Operations ─────────────────────────────────
-      case "spawnAgentCursor": {
-        await createAgentCursorNode(params.agentId, params.x || 0, params.y || 0);
-        result = { agentId: params.agentId, spawned: true };
-        break;
-      }
-
-      case "moveAgentCursor": {
-        if (params.animate) {
-          await animateAgentCursorTo(params.agentId, params.x, params.y, params.durationMs);
-        } else {
-          moveAgentCursorTo(params.agentId, params.x, params.y);
-        }
-        result = { agentId: params.agentId, x: params.x, y: params.y };
-        break;
-      }
-
-      case "updateAgentLabel": {
-        updateAgentCursorLabel(params.agentId, params.label);
-        result = { agentId: params.agentId, label: params.label };
-        break;
-      }
-
-      case "removeAgentCursor": {
-        removeAgentCursorNode(params.agentId);
-        result = { agentId: params.agentId, removed: true };
-        break;
-      }
-
-      case "agentChat": {
-        var noteId = await createAgentChatNote(params.agentId, params.message, params.x || 0, params.y || 0);
-        result = { agentId: params.agentId, noteId: noteId };
-        break;
-      }
-
-      case "cleanupAgentChats": {
-        cleanupAgentChatNotes();
-        result = { cleaned: true };
-        break;
-      }
-
-      default:
-        throw new Error(`Unknown bridge method: ${method}`);
-    }
-
-    // Post-operation: cursor inspects the result (visual operations only)
-    try { if (!THEATRE_SKIP_METHODS[method]) await postOperationEffect(method, params, result); } catch (e) {}
-
-    figma.ui.postMessage({ type: "bridge-response", id, result });
-  } catch (err) {
-    figma.ui.postMessage({
-      type: "bridge-response",
-      id,
-      error: err instanceof Error ? err.message : String(err),
-    });
-  }
-};
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-async function serializeNode(node) {
-  const base = {
-    id: node.id,
-    name: node.name,
-    type: node.type,
-    visible: node.visible,
-  };
-
-  if ("x" in node) {
-    Object.assign(base, {
-      x: node.x,
-      y: node.y,
-      width: node.width,
-      height: node.height,
-    });
-  }
-  if ("fills" in node) base.fills = node.fills;
-  if ("strokes" in node) base.strokes = node.strokes;
-  if ("effects" in node) base.effects = node.effects;
-  if ("opacity" in node) base.opacity = node.opacity;
-  if ("cornerRadius" in node) base.cornerRadius = node.cornerRadius;
-  if ("layoutMode" in node) {
-    Object.assign(base, {
-      layoutMode: node.layoutMode,
-      primaryAxisSizingMode: node.primaryAxisSizingMode,
-      counterAxisSizingMode: node.counterAxisSizingMode,
-      paddingTop: node.paddingTop,
-      paddingBottom: node.paddingBottom,
-      paddingLeft: node.paddingLeft,
-      paddingRight: node.paddingRight,
-      itemSpacing: node.itemSpacing,
-    });
-  }
-  if ("characters" in node) {
-    Object.assign(base, {
-      characters: node.characters,
-      fontSize: node.fontSize,
-      fontName: node.fontName,
-      lineHeight: node.lineHeight,
-      letterSpacing: node.letterSpacing,
-      textAlignHorizontal: node.textAlignHorizontal,
-      textAlignVertical: node.textAlignVertical,
-    });
-  }
-  if ("children" in node) {
-    base.childCount = node.children.length;
-    base.children = node.children.map((c) => ({
-      id: c.id,
-      name: c.name,
-      type: c.type,
-    }));
-  }
-  if (node.type === "INSTANCE") {
-    try {
-      const main = await node.getMainComponentAsync();
-      base.mainComponentId = main ? main.id : undefined;
-      base.mainComponentName = main ? main.name : undefined;
-    } catch (e) {
-      base.mainComponentId = undefined;
-      base.mainComponentName = undefined;
-    }
-  }
-
-  return base;
-}
-
-// Keep plugin running
-figma.on("close", () => {
-  removeAllAgentCursorNodes();
-  cleanupOrphanedCursors();
-});
-
-console.log("✅ Figma Intelligence Bridge Plugin loaded");