figma-prototype-mcp 0.30.0

package/dist/figma-plugin/code.js

@@ -0,0 +1,1203 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __defProps = Object.defineProperties;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
+          __defNormalProp(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/figma-plugin/reaction-builder.ts
+  function resolveEasing(input) {
+    if (input === void 0) return { type: "EASE_OUT" };
+    if (typeof input === "string") return { type: input };
+    if (input.type === "CUSTOM_CUBIC_BEZIER") {
+      return {
+        type: "CUSTOM_CUBIC_BEZIER",
+        easingFunctionCubicBezier: { x1: input.x1, y1: input.y1, x2: input.x2, y2: input.y2 }
+      };
+    }
+    return {
+      type: "CUSTOM_SPRING",
+      easingFunctionSpring: {
+        mass: input.mass,
+        stiffness: input.stiffness,
+        damping: input.damping
+      }
+    };
+  }
+  function buildTransition(input) {
+    var _a, _b, _c;
+    if (input === "INSTANT") return null;
+    if (input === "DISSOLVE" || input === "SMART_ANIMATE") {
+      return {
+        type: input,
+        duration: 0.3,
+        easing: { type: "EASE_OUT" }
+      };
+    }
+    if (input.type === "MOVE_IN" || input.type === "MOVE_OUT" || input.type === "PUSH" || input.type === "SLIDE_IN" || input.type === "SLIDE_OUT") {
+      return {
+        type: input.type,
+        direction: input.direction,
+        matchLayers: (_a = input.matchLayers) != null ? _a : false,
+        duration: (_b = input.duration) != null ? _b : 0.3,
+        easing: resolveEasing(input.easing)
+      };
+    }
+    return {
+      type: input.type,
+      duration: (_c = input.duration) != null ? _c : 0.3,
+      easing: resolveEasing(input.easing)
+    };
+  }
+  function isSmartAnimate(input) {
+    if (input === "SMART_ANIMATE") return true;
+    return typeof input !== "string" && input.type === "SMART_ANIMATE";
+  }
+  function degradeTransition(input, degradeTo) {
+    if (!isSmartAnimate(input)) return input;
+    if (degradeTo === "INSTANT") return "INSTANT";
+    if (typeof input === "string") return "DISSOLVE";
+    const obj = input;
+    return { type: "DISSOLVE", duration: obj.duration, easing: obj.easing };
+  }
+  function buildTrigger(input, legacyAfterTimeoutSeconds) {
+    var _a, _b;
+    if (typeof input === "string") {
+      if (input === "AFTER_TIMEOUT") {
+        if (legacyAfterTimeoutSeconds === void 0) {
+          throw new Error("buildTrigger: afterTimeoutSeconds is required when name is AFTER_TIMEOUT");
+        }
+        return { type: "AFTER_TIMEOUT", timeout: legacyAfterTimeoutSeconds };
+      }
+      return { type: input };
+    }
+    switch (input.type) {
+      case "ON_CLICK":
+      case "ON_HOVER":
+      case "ON_PRESS":
+      case "ON_DRAG":
+      case "ON_MEDIA_END":
+        return { type: input.type };
+      case "AFTER_TIMEOUT":
+        return { type: "AFTER_TIMEOUT", timeout: input.timeout };
+      case "MOUSE_UP":
+      case "MOUSE_DOWN":
+        return { type: input.type, delay: (_a = input.delay) != null ? _a : 0 };
+      case "MOUSE_ENTER":
+      case "MOUSE_LEAVE":
+        return {
+          type: input.type,
+          delay: (_b = input.delay) != null ? _b : 0
+        };
+      case "ON_KEY_DOWN":
+        return { type: "ON_KEY_DOWN", device: input.device, keyCodes: input.keyCodes };
+      case "ON_MEDIA_HIT":
+        return { type: "ON_MEDIA_HIT", mediaHitTime: input.mediaHitTime };
+    }
+  }
+  function buildNavigateReaction(input) {
+    const action = __spreadValues({
+      type: "NODE",
+      destinationId: input.targetFrameId,
+      navigation: "NAVIGATE",
+      transition: buildTransition(input.transition)
+    }, input.resetScrollPosition !== void 0 && { resetScrollPosition: input.resetScrollPosition });
+    return {
+      trigger: buildTrigger(input.trigger, input.afterTimeoutSeconds),
+      actions: [action]
+    };
+  }
+  function buildChangeToReaction(input) {
+    const action = {
+      type: "NODE",
+      destinationId: input.targetVariantId,
+      navigation: "CHANGE_TO",
+      transition: buildTransition(input.transition)
+    };
+    return {
+      trigger: buildTrigger(input.trigger, input.afterTimeoutSeconds),
+      actions: [action]
+    };
+  }
+  function changeToCurrentVariantError(currentVariantId, targetVariantId) {
+    if (currentVariantId !== null && currentVariantId === targetVariantId) {
+      return `Change-to target ${targetVariantId} is already the instance's current variant; nothing would change`;
+    }
+    return void 0;
+  }
+  function buildScrollReaction(input) {
+    const action = __spreadValues({
+      type: "NODE",
+      destinationId: input.targetNodeId,
+      navigation: "SCROLL_TO",
+      transition: buildTransition(input.transition)
+    }, input.resetScrollPosition !== void 0 && { resetScrollPosition: input.resetScrollPosition });
+    return {
+      trigger: buildTrigger(input.trigger, input.afterTimeoutSeconds),
+      actions: [action]
+    };
+  }
+  function buildOverlayReaction(input) {
+    const action = __spreadValues({
+      type: "NODE",
+      destinationId: input.targetFrameId,
+      navigation: "OVERLAY",
+      transition: buildTransition(input.transition)
+    }, input.resetScrollPosition !== void 0 && { resetScrollPosition: input.resetScrollPosition });
+    return {
+      trigger: buildTrigger(input.trigger, input.afterTimeoutSeconds),
+      actions: [action]
+    };
+  }
+  function buildCloseReaction(input) {
+    return {
+      trigger: buildTrigger(input.trigger, input.afterTimeoutSeconds),
+      actions: [{ type: "CLOSE" }]
+    };
+  }
+  function buildBackReaction(input) {
+    return {
+      trigger: buildTrigger(input.trigger, input.afterTimeoutSeconds),
+      actions: [{ type: "BACK" }]
+    };
+  }
+  function buildUrlReaction(input) {
+    var _a;
+    return {
+      trigger: buildTrigger(input.trigger, input.afterTimeoutSeconds),
+      actions: [{ type: "URL", url: input.url, openInNewTab: (_a = input.openInNewTab) != null ? _a : false }]
+    };
+  }
+  function buildSwapOverlayReaction(input) {
+    const action = __spreadValues({
+      type: "NODE",
+      destinationId: input.targetFrameId,
+      navigation: "SWAP",
+      transition: buildTransition(input.transition)
+    }, input.resetScrollPosition !== void 0 && { resetScrollPosition: input.resetScrollPosition });
+    return {
+      trigger: buildTrigger(input.trigger, input.afterTimeoutSeconds),
+      actions: [action]
+    };
+  }
+  function buildConditionalReaction(input) {
+    const blocks = [
+      { condition: input.condition, actions: input.thenActions }
+    ];
+    if (input.elseActions && input.elseActions.length > 0) {
+      blocks.push({ actions: input.elseActions });
+    }
+    return {
+      trigger: buildTrigger(input.trigger, input.afterTimeoutSeconds),
+      actions: [{ type: "CONDITIONAL", conditionalBlocks: blocks }]
+    };
+  }
+
+  // src/figma-plugin/command-queue.ts
+  var CommandQueue = class {
+    constructor() {
+      __publicField(this, "tail", Promise.resolve());
+    }
+    enqueue(fn) {
+      const result = this.tail.then(() => fn(), () => fn());
+      this.tail = result.then(
+        () => void 0,
+        () => void 0
+      );
+      return result;
+    }
+  };
+
+  // src/figma-plugin/variable-literal.ts
+  var HEX_REGEX = /^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/;
+  function hexToRgb(hex) {
+    const clean = hex.slice(1);
+    const r = parseInt(clean.slice(0, 2), 16) / 255;
+    const g = parseInt(clean.slice(2, 4), 16) / 255;
+    const b = parseInt(clean.slice(4, 6), 16) / 255;
+    const a = clean.length === 8 ? parseInt(clean.slice(6, 8), 16) / 255 : 1;
+    return { r, g, b, a };
+  }
+  function rgbToHex(rgb) {
+    const toHex = (n) => Math.max(0, Math.min(255, Math.round(n * 255))).toString(16).padStart(2, "0").toUpperCase();
+    const base = `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`;
+    if (rgb.a === void 0 || Math.round(rgb.a * 255) === 255) return base;
+    return base + toHex(rgb.a);
+  }
+  function validateVariableLiteralCompat(variable, value, context) {
+    const valueType = typeof value;
+    if (variable.resolvedType === "COLOR") {
+      if (context === "comparison") {
+        throw new Error(`Variable "${variable.name}" is COLOR; conditional comparison against COLOR variables is not supported in v1.18 (use BOOLEAN/FLOAT/STRING for condition.value)`);
+      }
+      if (valueType !== "string") {
+        throw new Error(`Variable "${variable.name}" is COLOR; cannot assign ${valueType} literal (expected hex string)`);
+      }
+      if (!HEX_REGEX.test(value)) {
+        throw new Error(`Variable "${variable.name}" is COLOR; value must be a hex string like #RRGGBB or #RRGGBBAA (got "${value}")`);
+      }
+      return { type: "COLOR", resolvedType: "COLOR", value: hexToRgb(value) };
+    }
+    const expected = variable.resolvedType === "BOOLEAN" ? "boolean" : variable.resolvedType === "FLOAT" ? "number" : variable.resolvedType === "STRING" ? "string" : "unknown";
+    if (expected === "unknown") {
+      throw new Error(`Variable "${variable.name}" has unsupported type ${variable.resolvedType} for ${context} (supported: BOOLEAN, FLOAT, STRING, COLOR)`);
+    }
+    if (valueType !== expected) {
+      const action = context === "comparison" ? "compare against" : "assign";
+      throw new Error(`Variable "${variable.name}" is ${variable.resolvedType}; cannot ${action} ${valueType} literal (expected ${expected})`);
+    }
+    if (expected === "boolean") {
+      return { type: "BOOLEAN", resolvedType: "BOOLEAN", value };
+    }
+    if (expected === "number") {
+      return { type: "FLOAT", resolvedType: "FLOAT", value };
+    }
+    return { type: "STRING", resolvedType: "STRING", value };
+  }
+
+  // src/figma-plugin/variable-catalog.ts
+  function filterVariables(items, filters) {
+    var _a;
+    const q = (_a = filters.nameQuery) == null ? void 0 : _a.toLowerCase();
+    return items.filter((v) => {
+      if (filters.resolvedType && v.resolvedType !== filters.resolvedType) return false;
+      if (q && !v.name.toLowerCase().includes(q)) return false;
+      return true;
+    });
+  }
+  function formatVariableNotFoundError(name, localNames, libraryNames) {
+    const render = (names) => names.length ? `[${names.join(", ")}]` : "(none)";
+    return `Variable "${name}" not found. Available \u2014 local: ${render(localNames)}; library: ${render(libraryNames)}. Use list_variables to inspect.`;
+  }
+  function selectVariableMatch(name, collection, candidates) {
+    const byName = candidates.filter((c) => c.name === name);
+    if (byName.length === 0) return { kind: "none" };
+    const pool = collection === void 0 ? byName : byName.filter((c) => c.collection === collection);
+    if (pool.length === 0) return { kind: "none" };
+    if (pool.length === 1) return { kind: "match", item: pool[0] };
+    return { kind: "ambiguous", collections: pool.map((c) => c.collection) };
+  }
+  function formatAmbiguousVariableError(name, collections, scope) {
+    return `Variable "${name}" is ambiguous \u2014 it exists in multiple ${scope} collections: [${collections.join(", ")}]. Specify the \`collection\` field to disambiguate (use list_variables to see collection names).`;
+  }
+
+  // src/figma-plugin/node-tree.ts
+  function findEnclosingFrameId(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "FRAME") return cur.id;
+      cur = cur.parent;
+    }
+    return null;
+  }
+  function hasReactions(node) {
+    return Array.isArray(node.reactions) && node.reactions.length > 0;
+  }
+  function findScrollableAncestor(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.overflowDirection !== void 0 && cur.overflowDirection !== "NONE") {
+        return cur;
+      }
+      cur = cur.parent;
+    }
+    return null;
+  }
+  function pathOf(node) {
+    const parts = [];
+    let cur = node;
+    while (cur && cur.type !== "DOCUMENT") {
+      parts.unshift(cur.name);
+      cur = cur.parent;
+    }
+    return parts.join(" > ");
+  }
+  function findTopLevelFrameNode(node) {
+    let cur = node;
+    let top = null;
+    while (cur) {
+      if (cur.type === "FRAME") {
+        const p = cur.parent;
+        if (!p || p.type === "PAGE" || p.type === "SECTION") top = cur;
+      }
+      cur = cur.parent;
+    }
+    return top;
+  }
+  function collectDescendantLayerPaths(node) {
+    const paths = /* @__PURE__ */ new Set();
+    const visit = (n, prefix) => {
+      var _a;
+      for (const child of (_a = n.children) != null ? _a : []) {
+        const path = prefix ? `${prefix}/${child.name}` : child.name;
+        paths.add(path);
+        visit(child, path);
+      }
+    };
+    visit(node, "");
+    return paths;
+  }
+  function framesShareLayer(a, b) {
+    const pathsA = collectDescendantLayerPaths(a);
+    for (const path of collectDescendantLayerPaths(b)) {
+      if (pathsA.has(path)) return true;
+    }
+    return false;
+  }
+
+  // src/figma-plugin/condition-codec.ts
+  var COMPARISON_OPERATOR_MAP = {
+    "==": "EQUALS",
+    "!=": "NOT_EQUAL",
+    "<": "LESS_THAN",
+    "<=": "LESS_THAN_OR_EQUAL",
+    ">": "GREATER_THAN",
+    ">=": "GREATER_THAN_OR_EQUAL"
+  };
+  var OPERATOR_INVERSE = Object.fromEntries(
+    Object.entries(COMPARISON_OPERATOR_MAP).map(([k, v]) => [v, k])
+  );
+  function buildConditionExpression(input) {
+    return {
+      type: "EXPRESSION",
+      resolvedType: "BOOLEAN",
+      value: {
+        expressionFunction: COMPARISON_OPERATOR_MAP[input.operator],
+        expressionArguments: [
+          {
+            type: "VARIABLE_ALIAS",
+            resolvedType: input.resolvedType,
+            value: { type: "VARIABLE_ALIAS", id: input.variableId }
+          },
+          input.literal
+        ]
+      }
+    };
+  }
+  function buildCompoundConditionExpression(input) {
+    return {
+      type: "EXPRESSION",
+      resolvedType: "BOOLEAN",
+      value: {
+        expressionFunction: input.join,
+        expressionArguments: input.operands
+      }
+    };
+  }
+  function decodeComparison(condition) {
+    var _a, _b;
+    if (!condition || condition.type !== "EXPRESSION" || !condition.value) return null;
+    const expr = condition.value;
+    const operator = OPERATOR_INVERSE[expr.expressionFunction];
+    if (!operator) return null;
+    const args = (_a = expr.expressionArguments) != null ? _a : [];
+    if (args.length !== 2) return null;
+    const aliasArg = args[0];
+    const literalArg = args[1];
+    if ((aliasArg == null ? void 0 : aliasArg.type) !== "VARIABLE_ALIAS") return null;
+    const variableId = (_b = aliasArg.value) == null ? void 0 : _b.id;
+    let value;
+    if ((literalArg == null ? void 0 : literalArg.type) === "BOOLEAN" || (literalArg == null ? void 0 : literalArg.type) === "FLOAT" || (literalArg == null ? void 0 : literalArg.type) === "STRING") {
+      value = literalArg.value;
+    }
+    return { variableId, operator, value };
+  }
+  var JOIN_INVERSE = { AND: "all", OR: "any" };
+  function decodeConditionExpression(condition) {
+    var _a, _b;
+    const join = (condition == null ? void 0 : condition.type) === "EXPRESSION" ? JOIN_INVERSE[(_a = condition.value) == null ? void 0 : _a.expressionFunction] : void 0;
+    if (join) {
+      const operands = (_b = condition.value.expressionArguments) != null ? _b : [];
+      const conditions = [];
+      for (const op of operands) {
+        const c = decodeComparison(op);
+        if (!c) return { raw: condition };
+        conditions.push(c);
+      }
+      return { join, conditions };
+    }
+    const single = decodeComparison(condition);
+    return single != null ? single : { raw: condition };
+  }
+  function detectTogglePattern(blocks) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    if (!Array.isArray(blocks) || blocks.length !== 2) return null;
+    const [b0, b1] = blocks;
+    if ((b1 == null ? void 0 : b1.condition) !== void 0) return null;
+    const cond = b0 == null ? void 0 : b0.condition;
+    if (!cond || cond.type !== "EXPRESSION" || !cond.value) return null;
+    if (cond.value.expressionFunction !== "EQUALS") return null;
+    const args = cond.value.expressionArguments;
+    if (!Array.isArray(args) || args.length !== 2) return null;
+    const aliasArg = args[0], boolArg = args[1];
+    if ((aliasArg == null ? void 0 : aliasArg.type) !== "VARIABLE_ALIAS") return null;
+    if ((boolArg == null ? void 0 : boolArg.type) !== "BOOLEAN" || boolArg.value !== true) return null;
+    const varId = (_a = aliasArg == null ? void 0 : aliasArg.value) == null ? void 0 : _a.id;
+    if (!varId) return null;
+    const a0 = b0 == null ? void 0 : b0.actions;
+    if (!Array.isArray(a0) || a0.length !== 1) return null;
+    if (((_b = a0[0]) == null ? void 0 : _b.type) !== "SET_VARIABLE") return null;
+    if (((_c = a0[0]) == null ? void 0 : _c.variableId) !== varId) return null;
+    if (((_e = (_d = a0[0]) == null ? void 0 : _d.variableValue) == null ? void 0 : _e.type) !== "BOOLEAN" || ((_g = (_f = a0[0]) == null ? void 0 : _f.variableValue) == null ? void 0 : _g.value) !== false) return null;
+    const a1 = b1 == null ? void 0 : b1.actions;
+    if (!Array.isArray(a1) || a1.length !== 1) return null;
+    if (((_h = a1[0]) == null ? void 0 : _h.type) !== "SET_VARIABLE") return null;
+    if (((_i = a1[0]) == null ? void 0 : _i.variableId) !== varId) return null;
+    if (((_k = (_j = a1[0]) == null ? void 0 : _j.variableValue) == null ? void 0 : _k.type) !== "BOOLEAN" || ((_m = (_l = a1[0]) == null ? void 0 : _l.variableValue) == null ? void 0 : _m.value) !== true) return null;
+    return varId;
+  }
+
+  // src/figma-plugin/action-echo.ts
+  async function encodeActionForListEcho(action, resolvers) {
+    var _a, _b, _c;
+    if (!action || typeof action !== "object") return { type: "UNKNOWN" };
+    if (action.type === "CONDITIONAL") {
+      const blocks = Array.isArray(action.conditionalBlocks) ? action.conditionalBlocks : [];
+      const toggleVarId = detectTogglePattern(blocks);
+      if (toggleVarId) {
+        const varName = await resolvers.variableName(toggleVarId);
+        return { type: "toggle_variable", variable: varName != null ? varName : `<id:${toggleVarId}>` };
+      }
+      const standardPattern = blocks.length >= 1 && blocks.length <= 2 && blocks[0].condition !== void 0 && (blocks.length === 1 || blocks[1].condition === void 0);
+      if (!standardPattern) {
+        return { type: "CONDITIONAL", raw: blocks };
+      }
+      const decodedCondition = await decodeConditionForEcho(blocks[0].condition, resolvers);
+      const thenActions = await Promise.all(
+        ((_a = blocks[0].actions) != null ? _a : []).map((a) => encodeActionForListEcho(a, resolvers))
+      );
+      const elseActions = blocks.length === 2 ? await Promise.all(((_b = blocks[1].actions) != null ? _b : []).map((a) => encodeActionForListEcho(a, resolvers))) : void 0;
+      return { type: "CONDITIONAL", condition: decodedCondition, then: thenActions, else: elseActions };
+    }
+    if (action.type === "SET_VARIABLE") {
+      let varName;
+      if (action.variableId) varName = await resolvers.variableName(action.variableId);
+      const vd = action.variableValue;
+      let value;
+      if ((vd == null ? void 0 : vd.type) === "COLOR" && (vd == null ? void 0 : vd.value) && typeof vd.value === "object" && "r" in vd.value && "g" in vd.value && "b" in vd.value) {
+        value = rgbToHex(vd.value);
+      } else {
+        value = vd == null ? void 0 : vd.value;
+      }
+      return { type: "set_variable", variable: varName != null ? varName : `<id:${action.variableId}>`, value };
+    }
+    const destId = action.destinationId;
+    const destName = destId ? resolvers.nodeName(destId) : void 0;
+    return {
+      type: (_c = action.type) != null ? _c : "UNKNOWN",
+      navigation: action.navigation,
+      url: action.url,
+      openInNewTab: action.openInNewTab,
+      destinationId: destId,
+      destinationName: destName,
+      transition: action.transition,
+      resetScrollPosition: action.resetScrollPosition
+    };
+  }
+  async function decodeConditionForEcho(condition, resolvers) {
+    const decoded = decodeConditionExpression(condition);
+    if ("raw" in decoded) return { raw: decoded.raw };
+    const echoLeaf = async (c) => {
+      const name = c.variableId ? await resolvers.variableName(c.variableId) : void 0;
+      return { variable: name != null ? name : `<id:${c.variableId}>`, operator: c.operator, value: c.value };
+    };
+    if ("join" in decoded) {
+      const conditions = [];
+      for (const c of decoded.conditions) conditions.push(await echoLeaf(c));
+      return decoded.join === "all" ? { all: conditions } : { any: conditions };
+    }
+    const leaf = await echoLeaf(decoded);
+    return __spreadProps(__spreadValues({}, leaf), {
+      raw: leaf.variable.startsWith("<id:") ? condition : void 0
+      // keep raw if we lost the name
+    });
+  }
+
+  // src/figma-plugin/motion-degrade.ts
+  function resolveNavigateTransition(args) {
+    const { source, destFrame, transition, degradeTo } = args;
+    if (!isSmartAnimate(transition)) return { transition };
+    const srcTop = findTopLevelFrameNode(source);
+    if (!srcTop) return { transition };
+    if (framesShareLayer(srcTop, destFrame)) return { transition };
+    const to = degradeTo != null ? degradeTo : "DISSOLVE";
+    return {
+      transition: degradeTransition(transition, to),
+      warning: `SMART_ANIMATE has no matching layers between "${srcTop.name}" and "${destFrame.name}"; degraded to ${to}`
+    };
+  }
+
+  // src/figma-plugin/flow-graph.ts
+  function assembleFlowGraph(input) {
+    const nameById = new Map(input.frames.map((f) => [f.id, f.name]));
+    const limited = input.interactions.slice(0, input.limit);
+    const interactions = limited.map((i) => {
+      var _a;
+      return __spreadProps(__spreadValues({}, i), {
+        frameName: i.frameId !== null ? (_a = nameById.get(i.frameId)) != null ? _a : null : null
+      });
+    });
+    return {
+      page: input.page,
+      frames: input.frames,
+      interactions,
+      truncated: input.interactions.length > input.limit
+    };
+  }
+
+  // src/figma-plugin/code.ts
+  figma.showUI(__html__, { width: 320, height: 220 });
+  var commandQueue = new CommandQueue();
+  figma.ui.onmessage = (msg) => {
+    if ((msg == null ? void 0 : msg.type) === "load-channel") {
+      figma.clientStorage.getAsync("channel").then((value) => {
+        figma.ui.postMessage({
+          type: "channel-loaded",
+          channel: typeof value === "string" && value.length > 0 ? value : null
+        });
+      });
+      return;
+    }
+    if ((msg == null ? void 0 : msg.type) === "save-channel" && typeof msg.channel === "string" && msg.channel.length > 0) {
+      figma.clientStorage.setAsync("channel", msg.channel).catch(() => {
+      });
+      return;
+    }
+    if ((msg == null ? void 0 : msg.type) === "command" && msg.envelope) {
+      const envelope = msg.envelope;
+      void commandQueue.enqueue(async () => {
+        const response = await dispatch(envelope.command, envelope.params);
+        figma.ui.postMessage({
+          type: "response",
+          envelope: __spreadValues({ id: envelope.id, type: "response" }, response)
+        });
+      });
+    }
+  };
+  async function dispatch(command, params) {
+    var _a;
+    try {
+      switch (command) {
+        case "GET_CANVAS_OVERVIEW":
+          return { status: "ok", result: await handleGetCanvasOverview(params) };
+        case "GET_PROTOTYPE_FLOW":
+          return { status: "ok", result: await handleGetPrototypeFlow(params) };
+        case "FIND_NODES":
+          return { status: "ok", result: await handleFindNodes(params) };
+        case "LIST_VARIABLES":
+          return { status: "ok", result: await handleListVariables(params) };
+        case "CREATE_REACTIONS":
+          return { status: "ok", result: await handleCreateReactions(params) };
+        case "LIST_REACTIONS":
+          return { status: "ok", result: await handleListReactions(params) };
+        case "CLEAR_REACTIONS":
+          return { status: "ok", result: await handleClearReactions(params) };
+        case "SET_FRAME_SCROLL":
+          return { status: "ok", result: await handleSetFrameScroll(params) };
+        default:
+          return { status: "error", error: { code: "UNKNOWN_COMMAND", message: `Unknown command: ${command}` } };
+      }
+    } catch (err) {
+      return { status: "error", error: { code: "PLUGIN_EXCEPTION", message: (_a = err == null ? void 0 : err.message) != null ? _a : String(err) } };
+    }
+  }
+  async function loadPage(pageId) {
+    if (!pageId) {
+      await figma.loadAllPagesAsync();
+      return figma.currentPage;
+    }
+    await figma.loadAllPagesAsync();
+    const page = figma.getNodeById(pageId);
+    if (!page || page.type !== "PAGE") throw new Error(`Page not found: ${pageId}`);
+    return page;
+  }
+  async function buildNonConditionalAction(action, trigger, afterTimeoutSeconds, transition, sourceNode, degradeTo) {
+    var _a;
+    if (action.type === "navigate") {
+      const target = figma.getNodeById(action.targetFrameId);
+      if (!target) throw new Error(`Target frame not found: ${action.targetFrameId}`);
+      if (target.type !== "FRAME") {
+        throw new Error(`Target must be a frame: ${action.targetFrameId} (got ${target.type})`);
+      }
+      const { transition: effectiveTransition, warning } = resolveNavigateTransition({
+        source: sourceNode,
+        destFrame: target,
+        transition,
+        degradeTo
+      });
+      const reaction = buildNavigateReaction({
+        targetFrameId: action.targetFrameId,
+        trigger,
+        afterTimeoutSeconds,
+        transition: effectiveTransition,
+        resetScrollPosition: action.resetScrollPosition
+      });
+      return { built: reaction.actions[0], warning };
+    }
+    if (action.type === "scroll") {
+      const target = figma.getNodeById(action.targetNodeId);
+      if (!target) throw new Error(`Scroll target node not found: ${action.targetNodeId}`);
+      const scrollable = findScrollableAncestor(target);
+      let warning;
+      if (!scrollable) {
+        warning = `Scroll target ${action.targetNodeId} (${target.name}) has no scrollable ancestor frame; the prototype scroll will not animate at runtime`;
+      }
+      const reaction = buildScrollReaction({
+        targetNodeId: action.targetNodeId,
+        trigger,
+        afterTimeoutSeconds,
+        transition,
+        resetScrollPosition: action.resetScrollPosition
+      });
+      return { built: reaction.actions[0], warning };
+    }
+    if (action.type === "overlay") {
+      const target = figma.getNodeById(action.targetFrameId);
+      if (!target) throw new Error(`Overlay target frame not found: ${action.targetFrameId}`);
+      if (target.type !== "FRAME") {
+        throw new Error(`Overlay target must be a frame: ${action.targetFrameId} (got ${target.type})`);
+      }
+      const reaction = buildOverlayReaction({
+        targetFrameId: action.targetFrameId,
+        trigger,
+        afterTimeoutSeconds,
+        transition,
+        resetScrollPosition: action.resetScrollPosition
+      });
+      return { built: reaction.actions[0] };
+    }
+    if (action.type === "close") {
+      const reaction = buildCloseReaction({ trigger, afterTimeoutSeconds });
+      return { built: reaction.actions[0] };
+    }
+    if (action.type === "back") {
+      const reaction = buildBackReaction({ trigger, afterTimeoutSeconds });
+      return { built: reaction.actions[0] };
+    }
+    if (action.type === "url") {
+      const reaction = buildUrlReaction({
+        trigger,
+        afterTimeoutSeconds,
+        url: action.url,
+        openInNewTab: action.openInNewTab
+      });
+      return { built: reaction.actions[0] };
+    }
+    if (action.type === "set_variable") {
+      const { variable, warning } = await resolveVariableByName(action.variable, action.collection);
+      const variableValue = buildSetVariableData(variable, action.value);
+      const built = {
+        type: "SET_VARIABLE",
+        variableId: variable.id,
+        variableValue
+      };
+      return { built, warning };
+    }
+    if (action.type === "swap_overlay") {
+      const target = figma.getNodeById(action.targetFrameId);
+      if (!target) throw new Error(`Swap overlay target frame not found: ${action.targetFrameId}`);
+      if (target.type !== "FRAME") {
+        throw new Error(`Swap overlay target must be a frame: ${action.targetFrameId} (got ${target.type})`);
+      }
+      const reaction = buildSwapOverlayReaction({
+        trigger,
+        afterTimeoutSeconds,
+        transition,
+        targetFrameId: action.targetFrameId,
+        resetScrollPosition: action.resetScrollPosition
+      });
+      return { built: reaction.actions[0] };
+    }
+    if (action.type === "change_to") {
+      const target = figma.getNodeById(action.targetVariantId);
+      if (!target) throw new Error(`Change-to target not found: ${action.targetVariantId}`);
+      if (target.type !== "COMPONENT") {
+        throw new Error(`Change-to target must be a component variant: ${action.targetVariantId} (got ${target.type})`);
+      }
+      let cur = sourceNode;
+      let instance = null;
+      while (cur) {
+        if (cur.type === "INSTANCE") {
+          instance = cur;
+          break;
+        }
+        cur = cur.parent;
+      }
+      const hasInstance = instance !== null;
+      if (instance) {
+        const mainComponent = await instance.getMainComponentAsync();
+        const sameVariantError = changeToCurrentVariantError(
+          (_a = mainComponent == null ? void 0 : mainComponent.id) != null ? _a : null,
+          action.targetVariantId
+        );
+        if (sameVariantError) throw new Error(sameVariantError);
+      }
+      const reaction = buildChangeToReaction({
+        targetVariantId: action.targetVariantId,
+        trigger,
+        afterTimeoutSeconds,
+        transition
+      });
+      const warning = hasInstance ? void 0 : `Change-to source ${sourceNode.id} is not (and is not inside) a component instance; the reaction will not animate at runtime`;
+      return { built: reaction.actions[0], warning };
+    }
+    throw new Error(`Unhandled action type: ${action.type}`);
+  }
+  async function resolveVariableByName(name, collection) {
+    var _a;
+    const all = await figma.variables.getLocalVariablesAsync();
+    const localDescriptors = await Promise.all(
+      all.map(async (v) => {
+        var _a2;
+        const col = await figma.variables.getVariableCollectionByIdAsync(v.variableCollectionId);
+        return {
+          name: v.name,
+          id: v.id,
+          resolvedType: v.resolvedType,
+          collection: (_a2 = col == null ? void 0 : col.name) != null ? _a2 : "",
+          ref: v
+        };
+      })
+    );
+    const localPick = selectVariableMatch(name, collection, localDescriptors);
+    if (localPick.kind === "match") {
+      return { variable: localPick.item.ref };
+    }
+    if (localPick.kind === "ambiguous") {
+      throw new Error(formatAmbiguousVariableError(name, localPick.collections, "local"));
+    }
+    const libraryDescriptors = [];
+    try {
+      const collections = await figma.teamLibrary.getAvailableLibraryVariableCollectionsAsync();
+      for (const col of collections) {
+        const vars = await figma.teamLibrary.getVariablesInLibraryCollectionAsync(col.key);
+        for (const v of vars) {
+          libraryDescriptors.push({
+            name: v.name,
+            key: v.key,
+            resolvedType: v.resolvedType,
+            collection: col.name,
+            libraryName: col.libraryName
+          });
+        }
+      }
+    } catch (e) {
+    }
+    const libPick = selectVariableMatch(name, collection, libraryDescriptors);
+    if (libPick.kind === "ambiguous") {
+      throw new Error(formatAmbiguousVariableError(name, libPick.collections, "library"));
+    }
+    if (libPick.kind === "match") {
+      try {
+        const imported = await figma.variables.importVariableByKeyAsync(libPick.item.key);
+        return {
+          variable: imported,
+          warning: `Imported library variable "${name}" from "${libPick.item.libraryName}".`
+        };
+      } catch (err) {
+        throw new Error(
+          `Found library variable "${name}" in "${libPick.item.libraryName}" but failed to import it: ${(_a = err == null ? void 0 : err.message) != null ? _a : String(err)}`
+        );
+      }
+    }
+    throw new Error(
+      formatVariableNotFoundError(name, all.map((v) => v.name), libraryDescriptors.map((v) => v.name))
+    );
+  }
+  async function buildCondition(input) {
+    let firstWarning;
+    const buildLeaf = async (leaf) => {
+      const { variable, warning } = await resolveVariableByName(leaf.variable, leaf.collection);
+      if (warning && !firstWarning) firstWarning = warning;
+      const literalVD = validateVariableLiteralCompat(
+        { name: variable.name, resolvedType: variable.resolvedType },
+        leaf.value,
+        "comparison"
+      );
+      return buildConditionExpression({
+        variableId: variable.id,
+        resolvedType: variable.resolvedType,
+        operator: leaf.operator,
+        literal: literalVD
+      });
+    };
+    if ("all" in input || "any" in input) {
+      const join = "all" in input ? "AND" : "OR";
+      const leaves = "all" in input ? input.all : input.any;
+      const operands = await Promise.all(leaves.map(buildLeaf));
+      return { condition: buildCompoundConditionExpression({ join, operands }), warning: firstWarning };
+    }
+    const condition = await buildLeaf(input);
+    return { condition, warning: firstWarning };
+  }
+  function buildSetVariableData(variable, value) {
+    return validateVariableLiteralCompat(
+      { name: variable.name, resolvedType: variable.resolvedType },
+      value,
+      "assignment"
+    );
+  }
+  async function handleGetCanvasOverview(params) {
+    const page = await loadPage(params.pageId);
+    const frames = page.children.filter((n) => n.type === "FRAME").map((f) => {
+      var _a, _b;
+      return {
+        id: f.id,
+        name: f.name,
+        width: f.width,
+        height: f.height,
+        isStartFrame: (_b = (_a = page.flowStartingPoints) == null ? void 0 : _a.some((p) => p.nodeId === f.id)) != null ? _b : false
+      };
+    });
+    const selection = figma.currentPage.selection.map((n) => ({
+      id: n.id,
+      name: n.name,
+      type: n.type,
+      parentFrameId: findEnclosingFrameId(n),
+      hasExistingReactions: hasReactions(n)
+    }));
+    return { page: { id: page.id, name: page.name }, frames, selection };
+  }
+  async function handleGetPrototypeFlow(params) {
+    var _a, _b, _c, _d, _e, _f;
+    const page = await loadPage(params.pageId);
+    const limit = (_a = params.limit) != null ? _a : 500;
+    const frames = page.findAll((n) => n.type === "FRAME").map((f) => {
+      var _a2, _b2;
+      return {
+        id: f.id,
+        name: f.name,
+        isStartFrame: (_b2 = (_a2 = page.flowStartingPoints) == null ? void 0 : _a2.some((p) => p.nodeId === f.id)) != null ? _b2 : false
+      };
+    });
+    const reactiveNodes = page.findAll(
+      (n) => {
+        var _a2, _b2;
+        return "reactions" in n && ((_b2 = (_a2 = n.reactions) == null ? void 0 : _a2.length) != null ? _b2 : 0) > 0;
+      }
+    );
+    const interactions = [];
+    for (const node of reactiveNodes) {
+      const frameId = node.type === "FRAME" ? node.id : findEnclosingFrameId(node);
+      const reactions = (_b = node.reactions) != null ? _b : [];
+      for (const r of reactions) {
+        const firstAction = (_e = (_d = (_c = r.actions) == null ? void 0 : _c[0]) != null ? _d : r.action) != null ? _e : {};
+        interactions.push({
+          frameId,
+          sourceNodeId: node.id,
+          sourceNodeName: node.name,
+          trigger: (_f = r.trigger) != null ? _f : { type: "UNKNOWN" },
+          action: await encodeActionForListEcho(firstAction, echoResolvers)
+        });
+      }
+    }
+    return assembleFlowGraph({ page: { id: page.id, name: page.name }, frames, interactions, limit });
+  }
+  async function handleFindNodes(params) {
+    var _a, _b;
+    const scope = (_a = params.scope) != null ? _a : "page";
+    const limit = (_b = params.limit) != null ? _b : 50;
+    const q = params.query.toLowerCase();
+    let root;
+    if (scope === "document") {
+      await figma.loadAllPagesAsync();
+      root = figma.root;
+    } else {
+      root = figma.currentPage;
+    }
+    const matches = root.findAll((n) => {
+      if (!n.name.toLowerCase().includes(q)) return false;
+      if (params.nodeTypes && params.nodeTypes.length && !params.nodeTypes.includes(n.type)) return false;
+      return true;
+    });
+    const truncated = matches.length > limit;
+    const sliced = matches.slice(0, limit);
+    return {
+      nodes: sliced.map((n) => ({
+        id: n.id,
+        name: n.name,
+        type: n.type,
+        parentFrameId: findEnclosingFrameId(n),
+        path: pathOf(n)
+      })),
+      truncated
+    };
+  }
+  async function handleListVariables(params) {
+    var _a;
+    const includeRemote = (_a = params.includeRemote) != null ? _a : true;
+    const filters = { resolvedType: params.resolvedType, nameQuery: params.nameQuery };
+    const localVars = await figma.variables.getLocalVariablesAsync();
+    const localDescriptors = await Promise.all(
+      localVars.map(async (v) => {
+        var _a2;
+        const col = await figma.variables.getVariableCollectionByIdAsync(v.variableCollectionId);
+        return {
+          name: v.name,
+          id: v.id,
+          resolvedType: v.resolvedType,
+          collection: (_a2 = col == null ? void 0 : col.name) != null ? _a2 : ""
+        };
+      })
+    );
+    const local = filterVariables(localDescriptors, filters);
+    let library = [];
+    let remoteEnumerated = false;
+    if (includeRemote) {
+      try {
+        const collections = await figma.teamLibrary.getAvailableLibraryVariableCollectionsAsync();
+        const all = [];
+        for (const col of collections) {
+          const vars = await figma.teamLibrary.getVariablesInLibraryCollectionAsync(col.key);
+          for (const v of vars) {
+            all.push({
+              name: v.name,
+              key: v.key,
+              resolvedType: v.resolvedType,
+              collection: col.name,
+              libraryName: col.libraryName
+            });
+          }
+        }
+        library = filterVariables(all, filters);
+        remoteEnumerated = true;
+      } catch (e) {
+        library = [];
+        remoteEnumerated = false;
+      }
+    }
+    return { local, library, remoteEnumerated };
+  }
+  async function handleCreateReactions(params) {
+    var _a;
+    await figma.loadAllPagesAsync();
+    const results = [];
+    let successCount = 0;
+    let errorCount = 0;
+    let warningCount = 0;
+    for (const conn of params.connections) {
+      try {
+        const source = figma.getNodeById(conn.sourceNodeId);
+        if (!source) throw new Error(`Source node not found: ${conn.sourceNodeId}`);
+        if (!("setReactionsAsync" in source) || typeof source.setReactionsAsync !== "function") {
+          throw new Error(`Node cannot have reactions: ${source.name} (type: ${source.type})`);
+        }
+        let newReaction;
+        let warning;
+        if (conn.action.type === "conditional") {
+          const { condition, warning: condWarning } = await buildCondition(conn.action.condition);
+          if (condWarning) warning = condWarning;
+          const thenBuilt = [];
+          for (const a of conn.action.then) {
+            const r = await buildNonConditionalAction(a, conn.trigger, conn.afterTimeoutSeconds, conn.transition, source, conn.degradeTo);
+            thenBuilt.push(r.built);
+            if (r.warning && !warning) warning = r.warning;
+          }
+          let elseBuilt;
+          if (conn.action.else) {
+            elseBuilt = [];
+            for (const a of conn.action.else) {
+              const r = await buildNonConditionalAction(a, conn.trigger, conn.afterTimeoutSeconds, conn.transition, source, conn.degradeTo);
+              elseBuilt.push(r.built);
+              if (r.warning && !warning) warning = r.warning;
+            }
+          }
+          newReaction = buildConditionalReaction({
+            trigger: conn.trigger,
+            afterTimeoutSeconds: conn.afterTimeoutSeconds,
+            condition,
+            thenActions: thenBuilt,
+            elseActions: elseBuilt
+          });
+        } else if (conn.action.type === "toggle_variable") {
+          const { variable, warning: resolveWarning } = await resolveVariableByName(
+            conn.action.variable,
+            conn.action.collection
+          );
+          if (variable.resolvedType !== "BOOLEAN") {
+            throw new Error(`Cannot toggle non-BOOLEAN variable "${conn.action.variable}" (type: ${variable.resolvedType}); toggle_variable requires BOOLEAN`);
+          }
+          if (resolveWarning) warning = resolveWarning;
+          const condition = {
+            type: "EXPRESSION",
+            resolvedType: "BOOLEAN",
+            value: {
+              expressionFunction: "EQUALS",
+              expressionArguments: [
+                {
+                  type: "VARIABLE_ALIAS",
+                  resolvedType: "BOOLEAN",
+                  value: { type: "VARIABLE_ALIAS", id: variable.id }
+                },
+                { type: "BOOLEAN", resolvedType: "BOOLEAN", value: true }
+              ]
+            }
+          };
+          const setFalseAction = {
+            type: "SET_VARIABLE",
+            variableId: variable.id,
+            variableValue: { type: "BOOLEAN", resolvedType: "BOOLEAN", value: false }
+          };
+          const setTrueAction = {
+            type: "SET_VARIABLE",
+            variableId: variable.id,
+            variableValue: { type: "BOOLEAN", resolvedType: "BOOLEAN", value: true }
+          };
+          newReaction = buildConditionalReaction({
+            trigger: conn.trigger,
+            afterTimeoutSeconds: conn.afterTimeoutSeconds,
+            condition,
+            thenActions: [setFalseAction],
+            elseActions: [setTrueAction]
+          });
+        } else {
+          const { built, warning: branchWarning } = await buildNonConditionalAction(
+            conn.action,
+            conn.trigger,
+            conn.afterTimeoutSeconds,
+            conn.transition,
+            source,
+            conn.degradeTo
+          );
+          if (branchWarning) warning = branchWarning;
+          newReaction = {
+            trigger: buildTrigger(conn.trigger, conn.afterTimeoutSeconds),
+            actions: [built]
+          };
+        }
+        const existing = "reactions" in source ? source.reactions : [];
+        const next = params.replaceExisting ? [newReaction] : [...existing, newReaction];
+        await source.setReactionsAsync(next);
+        const result = {
+          sourceNodeId: conn.sourceNodeId,
+          status: "success",
+          reactionIndex: next.length - 1
+        };
+        if (warning) {
+          result.warning = warning;
+          warningCount++;
+        }
+        results.push(result);
+        successCount++;
+      } catch (err) {
+        results.push({
+          sourceNodeId: conn.sourceNodeId,
+          status: "error",
+          error: (_a = err == null ? void 0 : err.message) != null ? _a : String(err)
+        });
+        errorCount++;
+      }
+    }
+    return { results, successCount, errorCount, warningCount };
+  }
+  var echoResolvers = {
+    variableName: async (id) => {
+      var _a;
+      try {
+        return (_a = await figma.variables.getVariableByIdAsync(id)) == null ? void 0 : _a.name;
+      } catch (e) {
+        return void 0;
+      }
+    },
+    nodeName: (id) => {
+      var _a, _b;
+      return (_b = (_a = figma.getNodeById(id)) == null ? void 0 : _a.name) != null ? _b : void 0;
+    }
+  };
+  async function handleListReactions(params) {
+    var _a;
+    await figma.loadAllPagesAsync();
+    const node = figma.getNodeById(params.nodeId);
+    if (!node) throw new Error(`Node not found: ${params.nodeId}`);
+    if (!("reactions" in node)) throw new Error(`Node has no reactions field: ${node.name}`);
+    const reactions = (_a = node.reactions) != null ? _a : [];
+    return {
+      nodeId: node.id,
+      nodeName: node.name,
+      reactions: await Promise.all(reactions.map(async (r, i) => {
+        var _a2, _b, _c, _d;
+        const firstAction = (_c = (_b = (_a2 = r.actions) == null ? void 0 : _a2[0]) != null ? _b : r.action) != null ? _c : {};
+        return {
+          index: i,
+          trigger: (_d = r.trigger) != null ? _d : { type: "UNKNOWN" },
+          action: await encodeActionForListEcho(firstAction, echoResolvers)
+        };
+      }))
+    };
+  }
+  async function handleClearReactions(params) {
+    var _a, _b;
+    await figma.loadAllPagesAsync();
+    const results = [];
+    for (const nodeId of params.nodeIds) {
+      try {
+        const node = figma.getNodeById(nodeId);
+        if (!node) throw new Error(`Node not found: ${nodeId}`);
+        if (!("setReactionsAsync" in node)) throw new Error(`Node cannot have reactions: ${node.name}`);
+        const existing = (_a = node.reactions) != null ? _a : [];
+        let next;
+        let removedCount;
+        if (params.indices && params.indices.length > 0) {
+          const toRemove = new Set(params.indices);
+          next = existing.filter((_, i) => !toRemove.has(i));
+          removedCount = existing.length - next.length;
+        } else {
+          next = [];
+          removedCount = existing.length;
+        }
+        await node.setReactionsAsync(next);
+        results.push({ nodeId, removedCount, status: "success" });
+      } catch (err) {
+        results.push({ nodeId, removedCount: 0, status: "error", error: (_b = err == null ? void 0 : err.message) != null ? _b : String(err) });
+      }
+    }
+    return { results };
+  }
+  async function handleSetFrameScroll(params) {
+    var _a;
+    await figma.loadAllPagesAsync();
+    const results = [];
+    let successCount = 0;
+    let errorCount = 0;
+    for (const { frameId, direction, fixedChildren } of params.frames) {
+      const applied = [];
+      try {
+        const node = figma.getNodeById(frameId);
+        if (!node) throw new Error(`Frame not found: ${frameId}`);
+        if (node.type !== "FRAME") {
+          throw new Error(`Node is not a FRAME: ${node.name} (type: ${node.type})`);
+        }
+        if (direction !== void 0) {
+          node.overflowDirection = direction;
+          applied.push("direction");
+        }
+        if (fixedChildren !== void 0) {
+          node.numberOfFixedChildren = fixedChildren;
+          applied.push("fixedChildren");
+        }
+        results.push({ frameId, status: "success", applied });
+        successCount++;
+      } catch (e) {
+        results.push({ frameId, status: "error", applied, error: (_a = e == null ? void 0 : e.message) != null ? _a : String(e) });
+        errorCount++;
+      }
+    }
+    return { results, successCount, errorCount };
+  }
+})();