¿Qué hace Crear Especificación de Movimiento?
Genera una especificación de movimiento directamente en Figma: barras de tiempo y tablas de detalle que documentan todas las propiedades animadas de una composición de After Effects.
Fuera del alcance del contrato de consumo del Componente Markdown (
.md). Los otros skillscreate-*requieren el.mddel componente (generado por {{skill:create-component-md}}) y renderizan a partir de surender-meta.create-motiones la excepción deliberada: su entrada es una exportación de la línea de tiempo de After Effects ({{ref:motion/export-timeline.jsx}}), no un recorrido de componente de Figma — no hay_base.json, no hayextract-motiony no hay sección de Movimiento en el.md. Este skill NO requiere un.mdy NO participa en la refactorización de require-.md/fail-fast/lecturas permitidas.
Contrato de ejecución (léase primero).
- Este archivo son instrucciones para EJECUTAR, no un documento para editar. Invocar el skill = renderizar la especificación de movimiento en Figma a partir del JSON de la línea de tiempo de After Effects.
- Nunca edite este
SKILL.mdni ningún otro archivo de skill en respuesta, incluso si uno está abierto o enfocado en el editor. Modifique un skill solo cuando el usuario solicite explícitamente cambiar el skill. - El JSON de la línea de tiempo de entrada es una fuente de verdad de SOLO LECTURA. Nunca lo edite. El único artefacto que produce este skill es la anotación de Figma; realice solicitudes de renderizado en Figma, nunca como una edición de archivo.
- Nunca llame a
AskQuestion, solicite confirmación, o pause para entrada (incluyendo antes de escrituras en Figma, la salida esperada). En caso de ambigüedad, elija la opción más defendible y continúe. - Solo dos paradas legales: (a) JSON de línea de tiempo de AE faltante o inválido (la puerta de reunir + validar del Paso 4/5); (b) aborto de una línea si la conexión MCP de Figma está muerta.
Adaptador MCP
Lea uspecs.config.json → mcpProvider. Siga la columna correspondiente para cada llamada MCP en este skill.
| Operación | figma-console | figma-mcp |
|---|---|---|
| Verificar conexión | figma_get_status | Omitir — implícito. Si la primera llamada a use_figma falla, guíe al usuario para que verifique la configuración de MCP. |
| Navegar a archivo | figma_navigate con URL | Extraer fileKey de la URL (figma.com/design/:fileKey/...). No se necesita navegación. |
| Tomar captura de pantalla | figma_take_screenshot | get_screenshot con fileKey + nodeId |
| Ejecutar Plugin JS | figma_execute con code | use_figma con fileKey, code, description. El código JS es idéntico — sin cambios de envoltorio. |
| Buscar componentes | figma_search_components | search_design_system con query + fileKey + includeComponents: true |
| Obtener datos de archivo/componente | figma_get_file_data / figma_get_component | get_metadata o get_design_context con fileKey + nodeId |
| Obtener variables (de todo el archivo) | figma_get_variables | Script use_figma: return await figma.variables.getLocalVariableCollectionsAsync(); |
| Obtener valores de tokens | figma_get_token_values | Script use_figma que lee valores de variables por modo/colección |
| Obtener estilos | figma_get_styles | search_design_system con includeStyles: true, o use_figma: return figma.getLocalPaintStyles(); |
| Obtener selección | figma_get_selection | Script use_figma: return figma.currentPage.selection.map(n => ({id: n.id, name: n.name, type: n.type})); |
figma-mcp requiere fileKey en cada llamada. Extráigalo una vez de la URL de Figma del usuario al inicio del flujo de trabajo. Para URL de ramas (figma.com/design/:fileKey/branch/:branchKey/:fileName), use :branchKey como fileKey.
Contexto de página de figma-mcp: use_figma restablece figma.currentPage a la primera página en cada llamada. Cuando un script accede a un nodo de un paso anterior mediante getNodeByIdAsync(ID), es posible que el contenido de la página no esté cargado — findAll, findOne y characters fallarán con TypeError hasta que se active la página. Inserte este bloque de carga de página inmediatamente después de getNodeByIdAsync:
let _p = node; while (_p.parent && _p.parent.type !== 'DOCUMENT') _p = _p.parent;
if (_p.type === 'PAGE') await figma.setCurrentPageAsync(_p);
Esto sube hasta el ancestro PAGE y carga su contenido. Console MCP no necesita esto — figma_execute hereda el contexto de página de la aplicación de escritorio.
Entradas Esperadas
El usuario activa este skill con uno de estos patrones:
- {{skill:create-motion}} + JSON pegado (desde el portapapeles, exportado a través de
{{ref:motion/export-timeline.jsx}}) - {{skill:create-motion}} + una referencia de archivo (por ejemplo,
@motion-ex.jsono una ruta a un archivo.json) - {{skill:create-motion}} + un enlace de Figma (página/archivo de destino donde se debe colocar la anotación)
Requerido: Los datos JSON exportados — ya sea pegados en línea o referenciados como un archivo.
Opcional:
- Enlace de Figma a la página de destino (si no se proporciona, colocar en la página actual en el centro de la vista)
- Captura de pantalla o grabación de la animación
- Descripción del propósito de la animación
Flujo de Trabajo
Copie esta lista de verificación y actualícela a medida que avanza:
Task Progress:
- [ ] Paso 1: Leer archivo de instrucciones
- [ ] Paso 2: Verificar conexión MCP
- [ ] Paso 3: Leer clave de plantilla de uspecs.config.json
- [ ] Paso 4: Reunir contexto (JSON de pegado, referencia de archivo o solicitar al usuario)
- [ ] Paso 5: Analizar y validar JSON (incluyendo segments[] y hasAnimatedSegments)
- [ ] Paso 6: Transformar datos (leer segmentos precalculados, calcular ancho de pista, posiciones de línea de tiempo)
- [ ] Paso 7: Releer archivo de instrucciones (Errores y Anti-Patrones, Lista de Verificación de Validación) y auditar
- [ ] Paso 8: Importar y desvincular la plantilla de Movimiento
- [ ] Paso 9: Rellenar campos de encabezado
- [ ] Paso 10: Generar regla de tiempo
- [ ] Paso 11: Renderizar capas de línea de tiempo (un figma_execute por capa)
- [ ] Paso 12: Ocultar plantillas
- [ ] Paso 13: Renderizar filas de tabla
- [ ] Paso 14: Validación visual
Paso 1: Leer Instrucciones
Lea agent-motion-instruction.md
Paso 2: Verificar Conexión MCP
Lea mcpProvider de uspecs.config.json para determinar qué Figma MCP usar.
Si figma-console:
figma_get_status— Confirme que el plugin Desktop Bridge esté activo- Si la conexión falla: "Por favor, abra Figma Desktop y ejecute el plugin Desktop Bridge. Luego intente de nuevo."
Si figma-mcp:
- La conexión se verifica implícitamente en la primera llamada a
use_figma. No se necesita una verificación explícita. - Si la primera llamada falla: "Por favor, verifique que su FIGMA_API_KEY esté configurada correctamente en su configuración MCP."
Paso 3: Leer Clave de Plantilla
Lea el archivo uspecs.config.json y extraiga:
- El valor
motionSpecdel objetotemplateKeys→ guardar comoMOTION_TEMPLATE_KEY
Si la clave de plantilla está vacía, dígale al usuario:
La clave de plantilla de especificación de movimiento no está configurada. Ejecute {{skill:firstrun}} con su enlace de biblioteca de plantillas de Figma primero.
Paso 4: Reunir Contexto
Verifique qué proporcionó el usuario:
- JSON ya proporcionado (pegado en línea o como referencia de archivo como
@motion-ex.json) → léalo y continúe directamente al Paso 5. No lo solicite de nuevo. - Solo un enlace de Figma (destino) pero sin JSON → solicite:
Por favor, pegue el JSON exportado o haga referencia al archivo
.json(por ejemplo,@motion-ex.json). - Nada proporcionado → solicite:
Por favor, pegue el JSON exportado de
export-timeline.jsx, o haga referencia al archivo.json.
Si se proporcionó un enlace de destino de Figma, use figma_navigate para abrirlo antes de renderizar (Paso 8).
También acepte cualquier captura de pantalla, grabación o descripción opcional que el usuario proporcione para contexto adicional.
Paso 5: Analizar y Validar JSON
Valide el JSON del portapapeles contra el esquema y las reglas de validación en el archivo de instrucciones (secciones Esquema JSON y Reglas de Validación JSON). Si la validación falla, dígale al usuario exactamente qué campo falta o está mal formado y pídale que reexporte.
Paso 6: Transformar Datos
El script de exportación precalcula segmentos, formato de valores, etiquetas de barras, etiquetas de easing y filtrado de cambios. El agente lee estos directamente y solo calcula valores dependientes del diseño.
6a. Saltar capas no animadas — Verifique layer.hasAnimatedSegments. Si es false, omita la capa de la línea de tiempo y la tabla.
6b. Leer segmentos precalculados — Cada propiedad tiene un array segments[] con startMs, endMs, durationMs, fromValue, toValue, barLabel, easing y easingType. Use estos valores directamente — no se necesita cálculo manual.
6c. Calcular ancho de pista y pxPerMs — pxPerMs es una tasa fija; trackWidth es dinámico con relleno derecho para etiquetas de ticks:
compDurationMs = composition.durationMs // leer directamente del JSON
pxPerMs = 0.64 // tasa fija — ~320px por tick de 500ms
trackWidth = max(compDurationMs * pxPerMs + 50, 1600) // área de datos + 50px de relleno de etiqueta, mínimo 1600
Pase trackWidth y pxPerMs al código de renderizado de Figma. pxPerMs es una tasa fija (0.64), no derivada de trackWidth / compDurationMs. Las posiciones de las barras (barX, barWidth) se calculan dentro del código de Figma en el momento del renderizado — el agente no calcula posiciones por segmento.
En el momento del renderizado, redimensione tanto #track-area como #ruler-track a este trackWidth calculado. Los contenedores padres usan dimensionamiento HUG y se expanden automáticamente.
6d. Formatear metadatos de composición según las reglas de Metadatos de Composición del archivo de instrucciones. Guardar como COMPOSITION_META.
Paso 7: Auditar
Vuelva a leer el archivo de instrucciones, enfocándose en:
- Sección Errores y Anti-Patrones
- Lista de Verificación de Validación Pre-Salida
Verifique sus datos transformados contra cada regla. Corrija cualquier violación.
Paso 8: Importar y Desvincular Plantilla
Ejecute a través de figma_execute (reemplace __MOTION_TEMPLATE_KEY__ y __COMPONENT_NAME__):
const TEMPLATE_KEY = '__MOTION_TEMPLATE_KEY__';
const templateComponent = await figma.importComponentByKeyAsync(TEMPLATE_KEY);
const instance = templateComponent.createInstance();
const { x, y } = figma.viewport.center;
instance.x = x - instance.width / 2;
instance.y = y - instance.height / 2;
const frame = instance.detachInstance();
frame.name = '__COMPONENT_NAME__ Motion';
figma.currentPage.selection = [frame];
figma.viewport.scrollAndZoomIntoView([frame]);
return { frameId: frame.id };
Guarde el frameId devuelto — lo necesita para todos los pasos siguientes.
Paso 9: Rellenar Campos de Encabezado
Ejecute a través de figma_execute (reemplace __FRAME_ID__, __COMPONENT_NAME__, __COMPOSITION_META__):
const FRAME_ID = '__FRAME_ID__';
const frame = await figma.getNodeByIdAsync(FRAME_ID);
const textNodes = frame.findAll(n => n.type === 'TEXT');
const fontSet = new Set();
const fontsToLoad = [];
for (const tn of textNodes) {
try {
const fn = tn.fontName;
if (fn && fn !== figma.mixed && fn.family) {
const key = fn.family + '|' + fn.style;
if (!fontSet.has(key)) { fontSet.add(key); fontsToLoad.push(fn); }
}
} catch {}
}
await Promise.all(fontsToLoad.map(f => figma.loadFontAsync(f).catch(() => {})));
const compName = frame.findOne(n => n.name === '#component-name');
if (compName) {
const t = compName.type === 'TEXT' ? compName : compName.findOne(n => n.type === 'TEXT');
if (t) t.characters = '__COMPONENT_NAME__';
}
const compDesc = frame.findOne(n => n.name === '#component-description');
if (compDesc) {
const t = compDesc.type === 'TEXT' ? compDesc : compDesc.findOne(n => n.type === 'TEXT');
if (t) t.characters = 'Motion Specification';
}
const compMeta = frame.findOne(n => n.name === '#composition-meta');
if (compMeta) {
const t = compMeta.type === 'TEXT' ? compMeta : compMeta.findOne(n => n.type === 'TEXT');
if (t) t.characters = '__COMPOSITION_META__';
}
return { success: true };
Paso 10: Generar Regla de Tiempo
Ejecute a través de figma_execute. Calcule el ancho de pista ideal, redimensione #ruler-track y todos los nodos #track-area, luego clone #tick para cada intervalo.
Reemplace __FRAME_ID__, __COMP_DURATION_MS__ (leído de composition.durationMs), __TRACK_WIDTH__ (calculado en el Paso 6c) y __PX_PER_MS__ (fijo en 0.64):
const FRAME_ID = '__FRAME_ID__';
const COMP_DURATION_MS = __COMP_DURATION_MS__;
const TRACK_WIDTH = __TRACK_WIDTH__;
const PX_PER_MS = __PX_PER_MS__;
const frame = await figma.getNodeByIdAsync(FRAME_ID);
const rulerTrack = frame.findOne(n => n.name === '#ruler-track');
if (!rulerTrack) return { error: '#ruler-track not found' };
// Redimensionar pista de regla al ancho calculado
rulerTrack.resize(TRACK_WIDTH, rulerTrack.height);
// Redimensionar todos los nodos #track-area (en la plantilla de capa y cualquier capa clonada)
const trackAreas = frame.findAll(n => n.name === '#track-area');
for (const ta of trackAreas) {
ta.resize(TRACK_WIDTH, ta.height);
}
// Encontrar la plantilla #tick dentro de la pista de regla
const tickTemplate = rulerTrack.findOne(n => n.name === '#tick');
if (!tickTemplate) return { error: '#tick template not found in #ruler-track' };
// Cargar fuentes de los nodos de texto de la plantilla tick
const tickTextNodes = tickTemplate.findAll(n => n.type === 'TEXT');
for (const tn of tickTextNodes) {
if (tn.characters.length > 0) {
try { await figma.loadFontAsync(tn.fontName); } catch {}
}
}
// Intervalo de ticks: apuntar a 6–12 ticks
const tickInterval = COMP_DURATION_MS <= 300 ? 50
: COMP_DURATION_MS <= 600 ? 100
: COMP_DURATION_MS <= 1500 ? 250
: COMP_DURATION_MS <= 4000 ? 500
: COMP_DURATION_MS <= 10000 ? 1000
: 2000;
for (let ms = 0; ms <= COMP_DURATION_MS; ms += tickInterval) {
const xPos = ms * PX_PER_MS;
const tick = tickTemplate.clone();
rulerTrack.appendChild(tick);
tick.name = ms + 'ms';
tick.visible = true;
tick.x = xPos;
const label = tick.findOne(n => n.type === 'TEXT');
if (label) {
try { await figma.loadFontAsync(label.fontName); } catch {}
label.characters = ms + 'ms';
}
}
tickTemplate.visible = false;
return { success: true, trackWidth: TRACK_WIDTH, tickInterval: tickInterval };
Paso 11: Renderizar Capas de Línea de Tiempo
Ejecute una llamada figma_execute por capa para evitar tiempos de espera. Para cada capa (donde hasAnimatedSegments es true), clone la #layer-template, configure el nombre de la capa, luego para cada propiedad animada clone #property-template y posicione las barras.
Reemplace todos los valores __PLACEHOLDER__.
… [truncado para traducción]