project-graph-mcp 2.3.2 → 2.4.1

package/vendor/symbiote-node/engine/packs/transform/riopla-adapt.handler.js

@@ -1,432 +0,0 @@
-/**
- * transform/riopla-adapt — Rioplatense text adaptation for TTS
- *
- * Pure text transforms: Spanish→Cyrillic transliteration for TTS guidance,
- * Rioplatense pronunciation adaptation, number→word conversion,
- * and voice style instruct generation.
- *
- * Ported from Mr-Computer/automations/argentine-spanish-bot/src/utils/transliteration/riopla.js
- * and instruct-generator.js
- *
- * @module agi-graph/packs/transform/riopla-adapt
- */
-
-// ─── Transliteration Engine ────────────────────────────────────────────
-
-/**
- * Lightweight word segmenter; uses Intl.Segmenter when available
- * @param {string} text
- * @returns {Array<{type: string, value: string}>}
- */
-function segmentWords(text) {
-  try {
-    if (typeof Intl !== 'undefined' && Intl.Segmenter) {
-      const seg = new Intl.Segmenter('es', { granularity: 'word' });
-      return Array.from(seg.segment(text)).map(s => ({
-        type: /\p{L}/u.test(s.segment) ? 'word' : 'sep',
-        value: s.segment,
-      }));
-    }
-  } catch { /* fallback */ }
-  const parts = text.split(/(\p{L}+(?:[\p{Mn}\p{Pd}]?\p{L}+)*)/u);
-  return parts.filter(Boolean).map(p => ({ type: /\p{L}/u.test(p) ? 'word' : 'sep', value: p }));
-}
-
-/**
- * Apply ordered regex rules to a single token
- * @param {string} word
- * @param {Array<{re: RegExp, to: Function|string}>} rules
- * @returns {string}
- */
-function applyRules(word, rules) {
-  let w = word;
-  for (const { re, to } of rules) {
-    w = w.replace(re, (...args) => typeof to === 'function' ? to(...args) : to);
-  }
-  return w;
-}
-
-/**
- * Find which vowel (by index, 0-based) should be stressed in a Spanish word.
- * @param {string} word
- * @returns {number} Index of stressed vowel, or -1
- */
-function findSpanishStressVowelIndex(word) {
-  const vowels = [];
-  for (let i = 0; i < word.length; i++) {
-    const char = word[i];
-    if (char.toLowerCase() === 'u') {
-      const prev = word[i - 1]?.toLowerCase();
-      const next = word[i + 1]?.toLowerCase();
-      if (prev === 'q' && (next === 'e' || next === 'i')) continue;
-      if (prev === 'g' && (next === 'e' || next === 'i')) continue;
-    }
-    if (/[aeiouüáéíóú]/i.test(char)) {
-      vowels.push({ index: i, char });
-    }
-  }
-  if (vowels.length <= 1) return -1;
-  const accentedIndex = vowels.findIndex(v => /[áéíóú]/i.test(v.char));
-  if (accentedIndex >= 0) return accentedIndex;
-  const cleanWord = word.replace(/[.,:;!?¡¿]+$/, '');
-  const lastChar = cleanWord.slice(-1).toLowerCase();
-  if (/[aeiouüns]/.test(lastChar)) return Math.max(0, vowels.length - 2);
-  return vowels.length - 1;
-}
-
-/**
- * Add stress mark to the Nth vowel in Cyrillic text.
- * @param {string} cyrillic
- * @param {number} vowelIndex
- * @returns {string}
- */
-function addCyrillicStressByVowelIndex(cyrillic, vowelIndex) {
-  const normalized = cyrillic.normalize('NFD');
-  const vowelPattern = /[аеиоуяёюыэАЕИОУЯЁЮЫЭ]/g;
-  const vowels = [];
-  let match;
-  while ((match = vowelPattern.exec(normalized)) !== null) {
-    const nextChar = normalized[match.index + 1];
-    const hasStress = nextChar === '\u0301';
-    vowels.push({ index: match.index, char: match[0], hasStress });
-  }
-  if (vowels.length === 0 || vowelIndex >= vowels.length) return cyrillic;
-  const targetVowel = vowels[vowelIndex];
-  if (targetVowel.hasStress) return cyrillic;
-  const result = normalized.substring(0, targetVowel.index + 1) + '\u0301' + normalized.substring(targetVowel.index + 1);
-  return result.normalize('NFC');
-}
-
-/**
- * Transliterate Spanish (Rioplatense) to Cyrillic for TTS guidance
- * @param {string} input
- * @param {Object} [opts]
- * @returns {string}
- */
-function transliterateSpanishToCyrillic(input, opts = {}) {
-  const options = {
-    yConj: 'и',
-    keepAccents: true,
-    autoStress: true,
-    normalize: 'NFC',
-    ...opts,
-  };
-  if (!input) return '';
-
-  const textWithNumbers = convertNumbersToSpanish(String(input));
-  const text = options.normalize ? textWithNumbers.normalize(options.normalize) : textWithNumbers;
-
-  function matchCase(src, dst) {
-    if (src.toUpperCase() === src) return dst.toUpperCase();
-    if (src[0] && src[0] === src[0].toUpperCase()) return dst[0].toUpperCase() + dst.slice(1);
-    return dst;
-  }
-
-  function mapVowel(v) {
-    const lower = v.toLowerCase();
-    const table = { a: 'а', e: 'е', i: 'и', o: 'о', u: 'у', á: 'а́', é: 'е́', í: 'и́', ó: 'о́', ú: 'у́', ü: 'у' };
-    const base = table[lower] || v;
-    if (!options.keepAccents) return base.replace('\u0301', '');
-    return matchCase(v, base);
-  }
-
-  const CONS_LOWER = { n: 'н', m: 'м', p: 'п', t: 'т', d: 'д', l: 'л', r: 'р', s: 'с', f: 'ф', g: 'г', k: 'к' };
-  const LL = 'щ';
-
-  const rules = [
-    { re: /\bel\b/gi, to: m => matchCase(m, 'эль') },
-    { re: /\bdel\b/gi, to: m => matchCase(m, 'дель') },
-    { re: /\bal\b/gi, to: m => matchCase(m, 'аль') },
-    { re: /\byo\b/gi, to: m => matchCase(m, 'що') },
-    { re: /(?<![a-záéíóúüñ])e/gi, to: m => matchCase(m, 'э') },
-    { re: /(?<![a-záéíóúüñ])é/gi, to: m => matchCase(m, 'э́') },
-    { re: /ch/gi, to: m => matchCase(m, 'ч') },
-    { re: /rr/gi, to: m => matchCase(m, 'рр') },
-    { re: /ll/gi, to: m => matchCase(m, LL) },
-    { re: /l(?=[^aeiouáéíóú\s]|$)/gi, to: m => matchCase(m, 'ль') },
-    { re: /qu([eiéí])/gi, to: (m, v) => matchCase(m, 'к') + mapVowel(v) },
-    { re: /qu([aouáóú])/gi, to: (m, v) => matchCase(m, 'к') + mapVowel(v) },
-    { re: /gü([ei])/gi, to: (m, v) => matchCase(m, 'гв') + mapVowel(v) },
-    { re: /gu([eiéí])/gi, to: (m, v) => matchCase(m[0], 'г') + mapVowel(v) },
-    { re: /g([eiéí])/gi, to: (m, v) => matchCase(m[0], 'х') + mapVowel(v) },
-    { re: /c([eiéí])/gi, to: (m, v) => matchCase(m[0], 'с') + mapVowel(v) },
-    { re: /c([aouáóú])/gi, to: (m, v) => matchCase(m[0], 'к') + mapVowel(v) },
-    { re: /c/gi, to: m => matchCase(m, 'к') },
-    { re: /\b[yY]\b/g, to: () => options.yConj },
-    { re: /y(?=[aeiouáéíóú])/gi, to: m => matchCase(m, LL) },
-    { re: /j/gi, to: m => matchCase(m, 'х') },
-    { re: /z/gi, to: m => matchCase(m, 'с') },
-    { re: /q/gi, to: m => matchCase(m, 'к') },
-    { re: /h/gi, to: () => '' },
-    { re: /x/gi, to: m => matchCase(m, 'кс') },
-    { re: /ñ/g, to: 'нь' },
-    { re: /Ñ/g, to: 'НЬ' },
-    { re: /[vb]/g, to: 'б' },
-    { re: /[VB]/g, to: 'Б' },
-    { re: /ay\b/gi, to: m => matchCase(m, 'ай') },
-    { re: /ey\b/gi, to: m => matchCase(m, 'эй') },
-    { re: /oy\b/gi, to: m => matchCase(m, 'ой') },
-    { re: /uy\b/gi, to: m => matchCase(m, 'уй') },
-    { re: /iy\b/gi, to: m => matchCase(m, 'ий') },
-    { re: /[aeiouáéíóúüAEIOUÁÉÍÓÚÜ]/g, to: m => mapVowel(m) },
-    { re: /[nmp tdlrsfgk]/g, to: m => CONS_LOWER[m] || m },
-    { re: /[NMP TDLRSFGK]/g, to: m => (CONS_LOWER[m.toLowerCase()] || m.toLowerCase()).toUpperCase() },
-    { re: /l\b/gi, to: m => matchCase(m, 'ль') },
-  ];
-
-  const segments = segmentWords(text);
-  const out = segments.map(seg => {
-    if (seg.type !== 'word') return seg.value;
-    const spanishVowelIndex = options.autoStress ? findSpanishStressVowelIndex(seg.value) : -1;
-    const transliterated = applyRules(seg.value, rules);
-    if (spanishVowelIndex >= 0) return addCyrillicStressByVowelIndex(transliterated, spanishVowelIndex);
-    return transliterated;
-  }).join('');
-
-  return out;
-}
-
-/**
- * Convert numbers 0-999 to Spanish words
- * @param {string} text
- * @returns {string}
- */
-function convertNumbersToSpanish(text) {
-  const ones = ['', 'uno', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve'];
-  const teens = ['diez', 'once', 'doce', 'trece', 'catorce', 'quince', 'dieciséis', 'diecisiete', 'dieciocho', 'diecinueve'];
-  const tens = ['', '', 'veinte', 'treinta', 'cuarenta', 'cincuenta', 'sesenta', 'setenta', 'ochenta', 'noventa'];
-  const hundreds = ['', 'ciento', 'doscientos', 'trescientos', 'cuatrocientos', 'quinientos', 'seiscientos', 'setecientos', 'ochocientos', 'novecientos'];
-
-  function numberToSpanish(n) {
-    if (n === 0) return 'cero';
-    if (n < 10) return ones[n];
-    if (n < 20) return teens[n - 10];
-    if (n === 20) return 'veinte';
-    if (n < 30) return 'veinti' + ones[n - 20];
-    if (n < 100) {
-      const ten = Math.floor(n / 10);
-      const one = n % 10;
-      return tens[ten] + (one ? ' y ' + ones[one] : '');
-    }
-    if (n === 100) return 'cien';
-    if (n < 1000) {
-      const hundred = Math.floor(n / 100);
-      const rest = n % 100;
-      return hundreds[hundred] + (rest ? ' ' + numberToSpanish(rest) : '');
-    }
-    return String(n);
-  }
-
-  return text.replace(/\b\d+\b/g, match => {
-    const num = parseInt(match, 10);
-    if (isNaN(num) || num > 999) return match;
-    return numberToSpanish(num);
-  });
-}
-
-/**
- * Adapt Spanish text for Rioplatense pronunciation
- * @param {string} text
- * @returns {string}
- */
-function adaptSpanishToRioplatense(text) {
-  if (!text) return '';
-  return text
-    .replace(/ll/gi, 'sh')
-    .replace(/\by\b/gi, 'i')
-    .replace(/y(?=[aeiouáéíóú])/gi, 'sh')
-    .replace(/([^cs]|^)h/gi, '$1');
-}
-
-// ─── Voice Instruct Templates ──────────────────────────────────────────
-
-const INSTRUCT_TEMPLATES = {
-  ru: {
-    neutral: ['', 'Говори спокойно и уверенно', 'Четко и разборчиво', 'В нейтральном тоне'],
-    friendly: ['В дружелюбном тоне', 'Тепло и приветливо', 'С улыбкой в голосе', 'Доброжелательно и открыто'],
-    enthusiastic: ['С энтузиазмом', 'Увлеченно и живо', 'С воодушевлением', 'Энергично и позитивно'],
-    teaching: ['Как опытный преподаватель', 'Терпеливо и понятно', 'Объясняя как ученику', 'Четко и методично'],
-    encouraging: ['Одобрительно и поддерживающе', 'С теплотой и заботой', 'Мотивирующим тоном', 'Вдохновляюще'],
-  },
-  es: {
-    neutral: ['', 'Habla con calma y claridad', 'De manera natural', 'Con tono neutro'],
-    friendly: ['Con tono amigable', 'De manera cálida y acogedora', 'Con simpatía', 'Amablemente'],
-    enthusiastic: ['Con entusiasmo', 'De manera animada', 'Con energía positiva', 'Alegremente'],
-    teaching: ['Como un profesor paciente', 'Explicando claramente', 'De forma didáctica', 'Con paciencia'],
-    encouraging: ['De manera alentadora', 'Con apoyo y calidez', 'Motivando al estudiante', 'Con palabras de ánimo'],
-  },
-  en: {
-    neutral: ['', 'Speak calmly and clearly', 'In a natural tone', 'Neutrally'],
-    friendly: ['In a friendly tone', 'Warm and welcoming', 'With a smile in your voice', 'Kindly'],
-    enthusiastic: ['With enthusiasm', 'Energetically and lively', 'With excitement', 'Positively and upbeat'],
-    teaching: ['Like a patient teacher', 'Explaining clearly', 'In a didactic manner', 'With patience'],
-    encouraging: ['Encouragingly', 'With warmth and support', 'Motivatingly', 'Inspiringly'],
-  },
-};
-
-const CONTEXT_PATTERNS = {
-  question: /[?¿]/,
-  exclamation: /[!¡]/,
-  greeting: /^(привет|hola|hello|hey|buenos|добрый|доброе)/i,
-  farewell: /\b(пока|adiós|chau|bye|hasta|до свидания)\b/i,
-  encouragement: /\b(молодец|отлично|bien|great|excellent|genial|excelente)\b/i,
-  correction: /\b(внимание|ошибка|error|cuidado|attention|mistake)\b/i,
-};
-
-/**
- * Detect context from text content
- * @param {string} text
- * @returns {string}
- */
-function detectContext(text) {
-  if (CONTEXT_PATTERNS.encouragement.test(text)) return 'encouraging';
-  if (CONTEXT_PATTERNS.greeting.test(text)) return 'friendly';
-  if (CONTEXT_PATTERNS.correction.test(text)) return 'teaching';
-  if (CONTEXT_PATTERNS.exclamation.test(text)) return 'enthusiastic';
-  if (CONTEXT_PATTERNS.question.test(text)) return 'friendly';
-  return 'neutral';
-}
-
-/**
- * @param {Array} arr
- * @returns {*}
- */
-function randomChoice(arr) {
-  return arr[Math.floor(Math.random() * arr.length)];
-}
-
-/**
- * Generate a voice instruct prompt for TTS
- * @param {Object} options
- * @param {string} options.text
- * @param {string} options.lang
- * @param {string} [options.context]
- * @param {boolean} [options.randomize]
- * @returns {string}
- */
-function generateVoiceInstruct({ text, lang, context = null, randomize = true }) {
-  const langTemplates = INSTRUCT_TEMPLATES[lang] || INSTRUCT_TEMPLATES.ru;
-  const effectiveContext = context || detectContext(text);
-  const templates = langTemplates[effectiveContext] || langTemplates.neutral;
-  return randomize ? randomChoice(templates) : templates[0];
-}
-
-/**
- * Generate varied instructs for a batch of segments
- * @param {Array<{text: string, lang: string}>} segments
- * @returns {Array<string>}
- */
-function generateBatchInstructs(segments) {
-  const recentlyUsed = new Set();
-  const results = [];
-  for (const seg of segments) {
-    let instruct = '';
-    let attempts = 0;
-    while (attempts < 3) {
-      instruct = generateVoiceInstruct({ text: seg.text, lang: seg.lang });
-      if (!recentlyUsed.has(instruct) || instruct === '') break;
-      attempts++;
-    }
-    results.push(instruct);
-    if (instruct) {
-      recentlyUsed.add(instruct);
-      if (recentlyUsed.size > 3) {
-        const first = recentlyUsed.values().next().value;
-        recentlyUsed.delete(first);
-      }
-    }
-  }
-  return results;
-}
-
-// ─── Handler Definition ────────────────────────────────────────────────
-
-export default {
-  type: 'transform/riopla-adapt',
-  category: 'transform',
-  icon: 'translate',
-
-  driver: {
-    description: 'Rioplatense text adaptation: transliteration, pronunciation, number conversion, voice instructs',
-    inputs: [
-      { name: 'text', type: 'string' },
-    ],
-    outputs: [
-      { name: 'result', type: 'any' },
-      { name: 'error', type: 'string' },
-    ],
-    params: {
-      operation: { type: 'string', default: 'transliterate', description: 'Operation: transliterate | adapt-rioplatense | numbers-to-spanish | voice-instruct | batch-instructs' },
-      // transliterate options
-      keepAccents: { type: 'boolean', default: true, description: 'Preserve acute accents in Cyrillic output' },
-      autoStress: { type: 'boolean', default: true, description: 'Auto-add stress marks based on Spanish rules' },
-      // voice-instruct options
-      lang: { type: 'string', default: 'es', description: 'Language code for voice instruct (ru/es/en)' },
-      context: { type: 'string', default: null, description: 'Voice instruct context hint (neutral/friendly/enthusiastic/teaching/encouraging)' },
-      // batch-instructs
-      segments: { type: 'any', default: null, description: 'Array of {text, lang} for batch instruct generation' },
-    },
-  },
-
-  lifecycle: {
-    validate: (inputs, params) => {
-      const op = params.operation;
-      if (op === 'batch-instructs') {
-        return Array.isArray(params.segments) && params.segments.length > 0;
-      }
-      return typeof inputs.text === 'string' && inputs.text.length > 0;
-    },
-
-    cacheKey: (inputs, params) => {
-      if (params.operation === 'batch-instructs') return null; // random, no cache
-      if (params.operation === 'voice-instruct') return null; // random, no cache
-      return `riopla:${params.operation}:${inputs.text?.slice(0, 100)}`;
-    },
-
-    execute: async (inputs, params) => {
-      const { text } = inputs;
-      const { operation } = params;
-
-      try {
-        switch (operation) {
-          case 'transliterate': {
-            const result = transliterateSpanishToCyrillic(text, {
-              keepAccents: params.keepAccents,
-              autoStress: params.autoStress,
-            });
-            return { result: { original: text, cyrillic: result } };
-          }
-
-          case 'adapt-rioplatense': {
-            const result = adaptSpanishToRioplatense(text);
-            return { result: { original: text, adapted: result } };
-          }
-
-          case 'numbers-to-spanish': {
-            const result = convertNumbersToSpanish(text);
-            return { result: { original: text, converted: result } };
-          }
-
-          case 'voice-instruct': {
-            const instruct = generateVoiceInstruct({
-              text,
-              lang: params.lang,
-              context: params.context,
-            });
-            return { result: { text, instruct, lang: params.lang } };
-          }
-
-          case 'batch-instructs': {
-            const instructs = generateBatchInstructs(params.segments);
-            return { result: { segments: params.segments, instructs } };
-          }
-
-          default:
-            return { error: `Unknown operation: ${operation}` };
-        }
-      } catch (err) {
-        return { error: `riopla-adapt ${operation} failed: ${err.message}` };
-      }
-    },
-  },
-};

package/vendor/symbiote-node/engine/packs/transform/set.handler.js

@@ -1,57 +0,0 @@
-/**
- * transform/set — Field mapping and value assignment
- *
- * Sets fields on the output data object. Values can be:
- * - Static values: "hello"
- * - References to input fields: "={{fieldName}}"
- * - Simple expressions: "={{items.length}}"
- *
- * Like n8n's "Set" node — reshapes data between nodes.
- *
- * @module symbiote-node/packs/transform/set
- */
-
-export default {
-  type: 'transform/set',
-  category: 'transform',
-  icon: 'edit_note',
-
-  driver: {
-    description: 'Set or map fields on the data object',
-    inputs: [
-      { name: 'data', type: 'any' },
-    ],
-    outputs: [
-      { name: 'data', type: 'any' },
-    ],
-    params: {
-      fields: { type: 'object', default: {}, description: 'Map of fieldName → value or ={{expression}}' },
-      keepOriginal: { type: 'boolean', default: true, description: 'Keep original input fields' },
-    },
-  },
-
-  lifecycle: {
-    execute: async (inputs, params) => {
-      const inputData = inputs.data || {};
-      const base = params.keepOriginal ? { ...inputData } : {};
-
-      for (const [key, rawValue] of Object.entries(params.fields || {})) {
-        if (typeof rawValue === 'string' && rawValue.startsWith('={{') && rawValue.endsWith('}}')) {
-          // Expression: resolve from input data
-          const expr = rawValue.slice(3, -2).trim();
-          // Simple dot-path resolution
-          const value = expr.split('.').reduce((obj, k) => {
-            if (obj === null || obj === undefined) return undefined;
-            return obj[k];
-          }, inputData);
-          base[key] = value;
-        } else {
-          // Static value
-          base[key] = rawValue;
-        }
-      }
-
-      return { data: base };
-    },
-  },
-};

package/vendor/symbiote-node/engine/packs/transform/template-builder.handler.js

@@ -1,134 +0,0 @@
-/**
- * transform/template-builder — Visual template builder with dynamic field discovery
- *
- * Combines UE Blueprint "Format Text" pattern (auto-pin from {placeholders})
- * with n8n live preview and ComfyUI inline editing.
- *
- * Parses {placeholder} syntax in template string, resolves values from
- * upstream data, and produces interpolated text output.
- *
- * @module symbiote-node/packs/transform/template-builder */
-
-/**
- * Extract placeholder names from template string.
- * Supports both {var} and {{var}} syntax.
- *
- * @param {string} template
- * @returns {string[]} Unique placeholder names
- */
-function extractPlaceholders(template) {
-  if (!template) return [];
-  const matches = new Set();
-  // Match both {var} and {{var}} — normalize to single-brace names
-  const regex = /\{\{?([^{}]+)\}?\}/g;
-  let m;
-  while ((m = regex.exec(template)) !== null) {
-    matches.add(m[1].trim());
-  }
-  return [...matches];
-}
-
-/**
- * Resolve a dot-notation path in an object.
- *
- * @param {Object} obj - Data object
- * @param {string} path - Dot-separated path (e.g., 'user.name')
- * @returns {*} Resolved value or undefined
- */
-function resolvePath(obj, path) {
-  return path.split('.').reduce((o, k) => {
-    if (o === null || o === undefined) return undefined;
-    return o[k];
-  }, obj);
-}
-
-export default {
-  type: 'transform/template-builder',
-  category: 'transform',
-  icon: 'edit_note',
-
-  driver: {
-    description: 'Visual template builder — write text with {placeholders}, auto-discovers input fields',
-    inputs: [
-      { name: 'data', type: 'any', description: 'Input data object with fields to interpolate' },
-    ],
-    outputs: [
-      { name: 'text', type: 'string', description: 'Interpolated text result' },
-      { name: 'data', type: 'any', description: 'Full data context with text field added' },
-    ],
-    params: {
-      template: {
-        type: 'textarea',
-        default: '',
-        description: 'Template with {placeholder} syntax. Fields auto-create input pins.',
-      },
-      outputField: {
-        type: 'string',
-        default: 'text',
-        description: 'Field name for the interpolated text in output data',
-      },
-    },
-
-    /**
-     * Dynamic outputs metadata — called by Inspector to show available placeholders.
-     *
-     * @param {Object} params - Current node params
-     * @returns {{ placeholders: string[] }}
-     */
-    meta: (params) => ({
-      placeholders: extractPlaceholders(params?.template),
-    }),
-  },
-
-  lifecycle: {
-    cacheKey: (inputs, params) =>
-      `tpl-builder:${params?.template}:${JSON.stringify(inputs.data)}`,
-
-    /**
-     * Execute template interpolation.
-     *
-     * @param {{ data: Object }} inputs - Upstream data
-     * @param {{ template: string, outputField: string }} params - Node params
-     * @returns {{ text: string, data: Object }}
-     */
-    execute: async (inputs, params) => {
-      const template = params?.template;
-      if (!template) {
-        console.warn('[template-builder] Empty template');
-        return { text: '', data: inputs.data ?? {} };
-      }
-
-      const data = inputs.data ?? {};
-      const placeholders = extractPlaceholders(template);
-
-      // Interpolate — replace both {var} and {{var}} with resolved values
-      const text = template.replace(/\{\{?([^{}]+)\}?\}/g, (match, key) => {
-        const trimmed = key.trim();
-        const value = resolvePath(data, trimmed);
-
-        if (value === undefined) {
-          console.warn(`[template-builder] ⚠️ Missing field "${trimmed}" — available: [${Object.keys(data).join(', ')}]`);
-          return match;
-        }
-        if (typeof value === 'object') return JSON.stringify(value);
-        return String(value);
-      });
-
-      // Log discovered vs resolved
-      const resolved = placeholders.filter(p => resolvePath(data, p) !== undefined);
-      const missing = placeholders.filter(p => resolvePath(data, p) === undefined);
-      if (missing.length) {
-        console.warn(`[template-builder] ${resolved.length}/${placeholders.length} fields resolved, missing: [${missing.join(', ')}]`);
-      }
-
-      const outputField = params?.outputField ?? 'text';
-      return {
-        text,
-        data: { ...(typeof data === 'object' ? data : {}), [outputField]: text },
-      };
-    },
-  },
-};
-
-// Re-export utility for Inspector use
-export { extractPlaceholders };