@supericons/mcp 0.4.6

package/material-export.js

@@ -0,0 +1,174 @@
+export const MATERIAL_EXPORT_SOURCE = {
+  ref: 'master',
+  baseUrl: 'https://raw.githubusercontent.com/google/material-design-icons/master/symbols/web',
+  styleDir: 'materialsymbolsoutlined',
+};
+
+export const MATERIAL_EXPORT_STORAGE = {
+  mode: 'owned-static-and-cache',
+  localBasePath: '/material-export',
+  functionBaseUrl: 'https://kcjmkakdhsqplvasgkjv.supabase.co/functions/v1/serve-material-snapshot',
+  bucket: 'material-icons',
+  styleDir: 'materialsymbolsoutlined',
+};
+
+export const MATERIAL_EXPORT_SUPPORTED_AXES = {
+  fill: [0, 1],
+  wght: [100, 200, 300, 400, 500, 600, 700],
+  grad: [-25, 0, 200],
+  opsz: [20, 24, 40, 48],
+};
+
+export const MATERIAL_EXPORT_DEFAULT_AXES = {
+  fill: 0,
+  wght: 300,
+  grad: 0,
+  opsz: 24,
+};
+
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+function nearest(value, supported) {
+  let best = supported[0];
+  let bestDistance = Math.abs(value - best);
+  for (const candidate of supported) {
+    const distance = Math.abs(value - candidate);
+    if (distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+
+export function normalizeMaterialExportAxes(customize = {}) {
+  const raw = {
+    fill: Number.isFinite(customize.materialFill) ? customize.materialFill : MATERIAL_EXPORT_DEFAULT_AXES.fill,
+    wght: Number.isFinite(customize.materialWeight) ? customize.materialWeight : MATERIAL_EXPORT_DEFAULT_AXES.wght,
+    grad: Number.isFinite(customize.materialGrade) ? customize.materialGrade : MATERIAL_EXPORT_DEFAULT_AXES.grad,
+    opsz: Number.isFinite(customize.materialOpticalSize) ? customize.materialOpticalSize : MATERIAL_EXPORT_DEFAULT_AXES.opsz,
+  };
+
+  const normalized = {
+    fill: nearest(clamp(raw.fill, 0, 1), MATERIAL_EXPORT_SUPPORTED_AXES.fill),
+    wght: nearest(clamp(raw.wght, 100, 700), MATERIAL_EXPORT_SUPPORTED_AXES.wght),
+    grad: nearest(clamp(raw.grad, -25, 200), MATERIAL_EXPORT_SUPPORTED_AXES.grad),
+    opsz: nearest(clamp(raw.opsz, 20, 48), MATERIAL_EXPORT_SUPPORTED_AXES.opsz),
+  };
+
+  const snapped =
+    normalized.fill !== raw.fill ||
+    normalized.wght !== raw.wght ||
+    normalized.grad !== raw.grad ||
+    normalized.opsz !== raw.opsz;
+
+  return { ...normalized, snapped };
+}
+
+function formatMaterialGradToken(grad) {
+  if (grad === 200) return 'grad200';
+  if (grad === -25) return 'gradN25';
+  return '';
+}
+
+function formatMaterialOwnedGradSegment(grad) {
+  return grad < 0 ? `grad-neg${Math.abs(grad)}` : `grad-${grad}`;
+}
+
+export function buildMaterialUpstreamSnapshotFilename(iconId, axes) {
+  let suffix = '';
+
+  if (axes.wght !== 400) suffix += `wght${axes.wght}`;
+  const gradToken = formatMaterialGradToken(axes.grad);
+  if (gradToken) suffix += gradToken;
+  if (axes.fill === 1) suffix += 'fill1';
+
+  return `${iconId}${suffix ? `_${suffix}` : ''}_${axes.opsz}px.svg`;
+}
+
+export function buildMaterialUpstreamSnapshotUrl(iconId, axes, source = MATERIAL_EXPORT_SOURCE) {
+  const filename = buildMaterialUpstreamSnapshotFilename(iconId, axes);
+  return `${source.baseUrl}/${encodeURIComponent(iconId)}/${source.styleDir}/${filename}`;
+}
+
+export function buildMaterialCacheKey(iconId, axes) {
+  return `material:${iconId}:f${axes.fill}:w${axes.wght}:g${axes.grad}:o${axes.opsz}`;
+}
+
+export function buildMaterialOwnedStoragePath(iconId, axes, storage = MATERIAL_EXPORT_STORAGE) {
+  return [
+    storage.styleDir || MATERIAL_EXPORT_STORAGE.styleDir,
+    iconId,
+    `fill-${axes.fill}`,
+    `wght-${axes.wght}`,
+    formatMaterialOwnedGradSegment(axes.grad),
+    `opsz-${axes.opsz}.svg`,
+  ].join('/');
+}
+
+export function parseMaterialOwnedStoragePath(path) {
+  const normalized = String(path || '').replace(/\\/g, '/').replace(/^\/+/, '');
+  const match = normalized.match(
+    /^([^/]+)\/([^/]+)\/fill-(0|1)\/wght-(100|200|300|400|500|600|700)\/(grad-(?:0|200)|grad-neg25)\/opsz-(20|24|40|48)\.svg$/
+  );
+
+  if (!match) return null;
+
+  const [, styleDir, iconId, fill, wght, gradSegment, opsz] = match;
+  const grad = gradSegment === 'grad-neg25' ? -25 : Number(gradSegment.replace('grad-', ''));
+
+  return {
+    styleDir,
+    iconId,
+    axes: {
+      fill: Number(fill),
+      wght: Number(wght),
+      grad,
+      opsz: Number(opsz),
+      snapped: false,
+    },
+  };
+}
+
+export function normalizeMaterialSnapshotSvg(rawSvg) {
+  if (!rawSvg) return null;
+  if (/\bfill="/.test(rawSvg)) return rawSvg;
+  return rawSvg.replace(/<svg([^>]*)>/, '<svg$1 fill="currentColor">');
+}
+
+export function resolveMaterialExportStorage(manifest = {}) {
+  return {
+    ...MATERIAL_EXPORT_STORAGE,
+    ...(manifest?.storage || {}),
+  };
+}
+
+export function getMaterialManifestEntry(manifest, iconId, axes) {
+  if (!manifest?.entries) return null;
+  return manifest.entries[buildMaterialCacheKey(iconId, axes)] || null;
+}
+
+export function buildMaterialOwnedSnapshotUrl(iconId, axes, manifest = {}) {
+  const storage = resolveMaterialExportStorage(manifest);
+  const entry = getMaterialManifestEntry(manifest, iconId, axes);
+
+  if (entry?.url) return entry.url;
+
+  if (entry?.path) {
+    const basePath = String(storage.localBasePath || '/material-export').replace(/\/$/, '');
+    const path = String(entry.path).replace(/^\/+/, '');
+    return `${basePath}/${path}`;
+  }
+
+  const params = new URLSearchParams({
+    icon: iconId,
+    fill: String(axes.fill),
+    wght: String(axes.wght),
+    grad: String(axes.grad),
+    opsz: String(axes.opsz),
+  });
+
+  return `${storage.functionBaseUrl}?${params.toString()}`;
+}

package/mcp-output-localization.js

@@ -0,0 +1,132 @@
+import { readFileSync } from 'node:fs';
+
+const localeDataUrl = new URL('./generated/mcp-output-locales.json', import.meta.url);
+const localeDataset = JSON.parse(readFileSync(localeDataUrl, 'utf8'));
+
+export const SUPPORTED_MCP_OUTPUT_LOCALES = Object.freeze(Object.keys(localeDataset.locales || {}));
+
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+export function normalizeMcpOutputLocale(locale) {
+  return SUPPORTED_MCP_OUTPUT_LOCALES.includes(locale) ? locale : null;
+}
+
+function getLocale(locale) {
+  const normalized = normalizeMcpOutputLocale(locale);
+  return normalized ? localeDataset.locales[normalized] : null;
+}
+
+function formatMessage(template, replacements = {}) {
+  if (typeof template !== 'string') return null;
+  return template.replace(/\{([a-zA-Z0-9_]+)\}/g, (match, key) =>
+    Object.hasOwn(replacements, key) ? String(replacements[key]) : match
+  );
+}
+
+function localizeTriggerLabels(triggers = [], localeRecord) {
+  return triggers.map((trigger) => ({
+    id: trigger,
+    label: localeRecord.motionLab.triggers[trigger] || trigger,
+  }));
+}
+
+export function localizeMotionPresetSummary(record, locale) {
+  const localeRecord = getLocale(locale);
+  if (!localeRecord) return record;
+
+  const preset = localeRecord.motionLab.presets[record.preset];
+  if (!preset) return record;
+
+  return {
+    ...record,
+    localized: {
+      locale: normalizeMcpOutputLocale(locale),
+      label: preset.label,
+      group: preset.group,
+      description: preset.description,
+      supported_triggers: localizeTriggerLabels(record.supported_triggers || [], localeRecord),
+    },
+  };
+}
+
+export function localizeMotionRecipe(recipe, locale) {
+  const localeRecord = getLocale(locale);
+  if (!localeRecord || !recipe) return recipe;
+
+  const presetId = recipe.preset_id || recipe.preset;
+  const preset = localeRecord.motionLab.presets[presetId];
+  if (!preset) return recipe;
+
+  return {
+    ...recipe,
+    localized: {
+      locale: normalizeMcpOutputLocale(locale),
+      preset: preset.label,
+      group: preset.group,
+      description: preset.description,
+      ...(preset.visual_character ? { visual_character: preset.visual_character } : {}),
+      ...(preset.emotional_tone ? { emotional_tone: [...preset.emotional_tone] } : {}),
+      ...(preset.recommended_contexts ? { recommended_contexts: [...preset.recommended_contexts] } : {}),
+      ...(preset.avoid_for ? { avoid_for: [...preset.avoid_for] } : {}),
+      ...(recipe.trigger ? { trigger: localeRecord.motionLab.triggers[recipe.trigger] || recipe.trigger } : {}),
+    },
+  };
+}
+
+export function localizeSelectorInstructions(selectorMode, selectorToken, locale) {
+  const localeRecord = getLocale(locale);
+  if (!localeRecord) return null;
+
+  const selectorMessages = localeRecord.messages?.selector || {};
+  if (selectorMode === 'literal') return selectorMessages.literal || null;
+  if (selectorToken) {
+    return formatMessage(selectorMessages.placeholder, { selectorToken });
+  }
+  return selectorMessages.fallback || null;
+}
+
+export function localizeSearchNoResultsHint(locale, hasLocale) {
+  const localeRecord = getLocale(locale);
+  if (!localeRecord) return null;
+  return hasLocale
+    ? localeRecord.messages?.hints?.noResultsWithLocale || null
+    : localeRecord.messages?.hints?.noResultsNoLocale || null;
+}
+
+export function localizeIconNotFoundHint(locale) {
+  const localeRecord = getLocale(locale);
+  return localeRecord?.messages?.hints?.iconNotFound || null;
+}
+
+export function localizeWorkflowAccessPayload(payload, locale) {
+  const localeRecord = getLocale(locale);
+  if (!localeRecord || !payload || typeof payload !== 'object') return payload;
+
+  const proKeyHint = localeRecord.messages?.hints?.proKey;
+  if (!proKeyHint) return payload;
+
+  return {
+    ...payload,
+    localized: {
+      locale: normalizeMcpOutputLocale(locale),
+      hint: proKeyHint,
+    },
+  };
+}
+
+export function localizeConverterOptions(options, locale) {
+  const localeRecord = getLocale(locale);
+  if (!localeRecord) return options;
+
+  const localizedConverter = localeRecord.converter || {};
+  return {
+    ...options,
+    localized: {
+      locale: normalizeMcpOutputLocale(locale),
+      guidance: cloneJson(localizedConverter.guidance || {}),
+      traceClasses: cloneJson(localizedConverter.traceClasses || {}),
+    },
+  };
+}

package/motion-lab-client.js

@@ -0,0 +1,347 @@
+import { hashApiKey, getConfiguredApiKey, SUPABASE_ANON, SUPABASE_URL } from './auth.js';
+
+const HOSTED_FUNCTIONS_BASE_URL = (process.env.SUPERICONS_MOTION_LAB_BASE_URL || `${SUPABASE_URL}/functions/v1`).replace(/\/+$/, '');
+const SESSION_ENDPOINT = `${HOSTED_FUNCTIONS_BASE_URL}/motion-lab-session`;
+const RECIPE_ENDPOINT = `${HOSTED_FUNCTIONS_BASE_URL}/motion-lab-recipe`;
+const CSS_ENDPOINT = `${HOSTED_FUNCTIONS_BASE_URL}/motion-lab-render-css`;
+const ANIMATED_SVG_ENDPOINT = `${HOSTED_FUNCTIONS_BASE_URL}/motion-lab-render-animated-svg`;
+const LOCAL_WORKFLOW_MODULE_URL = new URL('../lib/motion-lab-workflow.js', import.meta.url);
+const PLACEHOLDER_SELECTOR = '{{ICON_SELECTOR}}';
+const MCP_CLIENT_VERSION = '0.3.0';
+
+class MotionLabClientError extends Error {
+  constructor(message, {
+    code = 'motion_lab_service_unavailable',
+    status = 503,
+    hint = 'Retry when the Motion Lab service is available.',
+    retryable = true,
+    retryAfterSeconds = null,
+    limitScope = null,
+    cause = null,
+  } = {}) {
+    super(message);
+    this.name = 'MotionLabClientError';
+    this.code = code;
+    this.status = status;
+    this.hint = hint;
+    this.retryable = retryable;
+    this.retry_after_seconds = typeof retryAfterSeconds === 'number' ? retryAfterSeconds : null;
+    this.limit_scope = typeof limitScope === 'string' ? limitScope : null;
+    this.cause = cause;
+  }
+}
+
+let cachedSession = null;
+let localFallbackWarningShown = false;
+
+function normalizeErrorFromBody(body, status) {
+  if (status === 404) {
+    return new MotionLabClientError('Motion Lab hosted endpoint is not available.', {
+      code: 'motion_lab_service_unavailable',
+      status,
+      hint: 'Deploy the Motion Lab hosted functions or use the repo-local fallback during development.',
+      retryable: true,
+    });
+  }
+
+  if (body && typeof body === 'object' && !Array.isArray(body)) {
+    return new MotionLabClientError(
+      typeof body.message === 'string' ? body.message : `Motion Lab request failed (${status}).`,
+      {
+        code: typeof body.error === 'string' ? body.error : 'motion_lab_service_unavailable',
+        status,
+        hint: typeof body.hint === 'string' ? body.hint : 'Retry when the Motion Lab service is available.',
+        retryable: typeof body.retryable === 'boolean' ? body.retryable : status >= 500,
+        retryAfterSeconds: typeof body.retry_after_seconds === 'number' ? body.retry_after_seconds : null,
+        limitScope: typeof body.limit_scope === 'string' ? body.limit_scope : null,
+      }
+    );
+  }
+
+  return new MotionLabClientError(`Motion Lab request failed (${status}).`, {
+    status,
+    retryable: status >= 500,
+  });
+}
+
+async function readJsonResponse(response) {
+  const text = await response.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { message: text };
+  }
+}
+
+function getExpiryTimestamp(expiresAt) {
+  const expiry = Date.parse(expiresAt || '');
+  return Number.isFinite(expiry) ? expiry : 0;
+}
+
+function isSessionFresh(session) {
+  if (!session?.sessionToken || !session?.expiresAtMs) return false;
+  return session.expiresAtMs - Date.now() > 30_000;
+}
+
+async function exchangeSessionToken() {
+  const apiKey = getConfiguredApiKey();
+  if (!apiKey) {
+    throw new MotionLabClientError('Motion Lab MCP requires SUPERICONS_API_KEY for premium calls.', {
+      code: 'motion_lab_auth_required',
+      status: 401,
+      hint: 'Set SUPERICONS_API_KEY before using Motion Lab MCP premium tools.',
+      retryable: false,
+    });
+  }
+
+  const api_key_hash = await hashApiKey(apiKey);
+
+  let response;
+  try {
+    response = await fetch(SESSION_ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'apikey': SUPABASE_ANON,
+      },
+      body: JSON.stringify({
+        api_key_hash,
+        client: {
+          surface: 'mcp',
+          version: MCP_CLIENT_VERSION,
+        },
+      }),
+    });
+  } catch (error) {
+    throw new MotionLabClientError('Motion Lab session exchange failed.', {
+      cause: error,
+      retryable: true,
+    });
+  }
+
+  const body = await readJsonResponse(response);
+  if (!response.ok) {
+    throw normalizeErrorFromBody(body, response.status);
+  }
+
+  const sessionToken = body?.session_token;
+  const expiresAt = body?.expires_at;
+  if (typeof sessionToken !== 'string' || typeof expiresAt !== 'string') {
+    throw new MotionLabClientError('Motion Lab session exchange returned an invalid payload.', {
+      retryable: false,
+    });
+  }
+
+  cachedSession = {
+    sessionToken,
+    expiresAtMs: getExpiryTimestamp(expiresAt),
+  };
+  return cachedSession.sessionToken;
+}
+
+async function getSessionToken(forceRefresh = false) {
+  if (!forceRefresh && isSessionFresh(cachedSession)) {
+    return cachedSession.sessionToken;
+  }
+  return exchangeSessionToken();
+}
+
+async function callHostedMotionLab(endpoint, body) {
+  let token = await getSessionToken();
+
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    let response;
+    try {
+      response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'apikey': SUPABASE_ANON,
+          'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify(body),
+      });
+    } catch (error) {
+      throw new MotionLabClientError('Motion Lab hosted call failed.', {
+        cause: error,
+        retryable: true,
+      });
+    }
+
+    const responseBody = await readJsonResponse(response);
+    if (response.ok) {
+      return responseBody;
+    }
+
+    if (response.status === 401 && attempt === 0) {
+      token = await getSessionToken(true);
+      continue;
+    }
+
+    throw normalizeErrorFromBody(responseBody, response.status);
+  }
+
+  throw new MotionLabClientError('Motion Lab hosted call failed after token refresh.', {
+    retryable: true,
+  });
+}
+
+async function loadLocalFallbackModule() {
+  try {
+    return await import(LOCAL_WORKFLOW_MODULE_URL.href);
+  } catch {
+    return null;
+  }
+}
+
+function shouldFallbackToLocal(error) {
+  if (process.env.SUPERICONS_MOTION_LAB_LOCAL_FALLBACK === '0') {
+    return false;
+  }
+  return Boolean(error?.retryable);
+}
+
+async function withOptionalLocalFallback(hostedCall, localResolver) {
+  try {
+    return await hostedCall();
+  } catch (error) {
+    if (!shouldFallbackToLocal(error)) {
+      throw error;
+    }
+    const localWorkflow = await loadLocalFallbackModule();
+    if (!localWorkflow) {
+      throw error;
+    }
+    if (!localFallbackWarningShown) {
+      console.error('[Motion Lab MCP] Hosted premium path unavailable, using local workflow fallback in this repo checkout.');
+      localFallbackWarningShown = true;
+    }
+    return localResolver(localWorkflow);
+  }
+}
+
+function replaceLegacyCssSelector(css, selector) {
+  return css.replace(/#icon-container svg/g, selector);
+}
+
+function buildLocalCssResponse(localWorkflow, { preset, trigger, duration_ms, intensity_percent, selector = null }) {
+  const recipe = localWorkflow.buildMotionLabRecipe({
+    presetId: preset,
+    trigger,
+    durationMs: duration_ms,
+    intensityPercent: intensity_percent,
+  });
+  const cssSelector = selector || PLACEHOLDER_SELECTOR;
+  return {
+    recipe: {
+      preset_id: recipe.preset_id,
+      preset: recipe.preset,
+      group: recipe.group,
+    },
+    css: replaceLegacyCssSelector(
+      localWorkflow.buildMotionLabExternalCss({
+        presetId: preset,
+        trigger,
+        durationMs: duration_ms,
+        intensityPercent: intensity_percent,
+      }),
+      cssSelector
+    ),
+    selector_mode: selector ? 'literal' : 'placeholder',
+    ...(selector ? {} : { selector_token: PLACEHOLDER_SELECTOR }),
+  };
+}
+
+export async function getMotionLabRecipeHosted({ preset, trigger = 'loop', duration_ms = 500, intensity_percent = 100 }) {
+  return withOptionalLocalFallback(
+    async () => {
+      const response = await callHostedMotionLab(RECIPE_ENDPOINT, {
+        preset,
+        trigger,
+        duration_ms,
+        intensity_percent,
+      });
+      return response.recipe;
+    },
+    async (localWorkflow) => localWorkflow.buildMotionLabRecipe({
+      presetId: preset,
+      trigger,
+      durationMs: duration_ms,
+      intensityPercent: intensity_percent,
+    })
+  );
+}
+
+export async function renderMotionLabCssHosted({ preset, trigger = 'loop', duration_ms = 500, intensity_percent = 100, selector = null }) {
+  return withOptionalLocalFallback(
+    async () => callHostedMotionLab(CSS_ENDPOINT, {
+      preset,
+      trigger,
+      duration_ms,
+      intensity_percent,
+      ...(selector ? { selector } : {}),
+    }),
+    async (localWorkflow) => buildLocalCssResponse(localWorkflow, {
+      preset,
+      trigger,
+      duration_ms,
+      intensity_percent,
+      selector,
+    })
+  );
+}
+
+export async function renderMotionLabAnimatedSvgHosted({ svg, preset, trigger = 'loop', duration_ms = 500, intensity_percent = 100, color = null }) {
+  return withOptionalLocalFallback(
+    async () => callHostedMotionLab(ANIMATED_SVG_ENDPOINT, {
+      svg,
+      preset,
+      trigger,
+      duration_ms,
+      intensity_percent,
+      ...(color ? { color } : {}),
+    }),
+    async (localWorkflow) => {
+      const recipe = localWorkflow.buildMotionLabRecipe({
+        presetId: preset,
+        trigger,
+        durationMs: duration_ms,
+        intensityPercent: intensity_percent,
+      });
+      return {
+        recipe: {
+          preset_id: recipe.preset_id,
+          preset: recipe.preset,
+          group: recipe.group,
+        },
+        animated_svg: localWorkflow.buildMotionLabAnimatedSvg({
+          svg,
+          presetId: preset,
+          trigger,
+          durationMs: duration_ms,
+          intensityPercent: intensity_percent,
+          color,
+        }),
+        applied_color: color || null,
+      };
+    }
+  );
+}
+
+export async function animateMotionLabIconHosted({ svg, preset, trigger = 'loop', duration_ms = 500, intensity_percent = 100, color = null }) {
+  const [recipe, cssResponse, animatedSvgResponse] = await Promise.all([
+    getMotionLabRecipeHosted({ preset, trigger, duration_ms, intensity_percent }),
+    renderMotionLabCssHosted({ preset, trigger, duration_ms, intensity_percent }),
+    renderMotionLabAnimatedSvgHosted({ svg, preset, trigger, duration_ms, intensity_percent, color }),
+  ]);
+
+  return {
+    recipe,
+    css: cssResponse.css,
+    animated_svg: animatedSvgResponse.animated_svg,
+    selector_mode: cssResponse.selector_mode,
+    ...(cssResponse.selector_token ? { selector_token: cssResponse.selector_token } : {}),
+    ...(animatedSvgResponse.applied_color ? { applied_color: animatedSvgResponse.applied_color } : {}),
+  };
+}

package/motion-lab.js

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+import { localizeMotionPresetSummary } from './mcp-output-localization.js';
+
+const baselineUrl = new URL('./generated/motion-lab-baseline.json', import.meta.url);
+const baselineDataset = JSON.parse(readFileSync(baselineUrl, 'utf8'));
+const baselinePresets = Object.freeze(
+  (baselineDataset.presets || []).map((record) => Object.freeze({
+    ...record,
+    supported_triggers: Object.freeze([...(record.supported_triggers || [])]),
+  }))
+);
+
+export function listMotionLabPresets(locale = null) {
+  return baselinePresets.map((record) => ({
+    preset: record.preset,
+    label: record.label,
+    group: record.group,
+    description: record.description,
+    supported_triggers: [...record.supported_triggers],
+  })).map((record) => localizeMotionPresetSummary(record, locale));
+}