story-theme-mcp 1.4.0 → 1.6.0

package/README.md

@@ -59,6 +59,7 @@ Le MCP ne contient pas le thème : au démarrage, il demande à l'espace membre
 | Construire | `create_project`, `update_brief`, `apply_recipe`, `localize_template`, `list_texts`, `edit_template`, `write_file`, `update_theme_settings`, `read_file`, `exclude_template` |
 | Contrôler | `validate_json`, `review_project`, `undo`, `revert_file` |
 | Livrer | `export_theme` (zip à importer + check-list), `import_theme` (auditer un thème téléchargé d'une boutique) |
+| Passer en 4.x | `migrate_v3` : une boutique en Story Thème 3.7 ou avant, reconstruite en 4.x avec son contenu (textes, photos, avis, FAQ, produits, couleurs, polices, logo, menus), section par section — ce que la mise à jour de l'espace membre ne sait pas faire |
 | Vos boutiques | `list_shops`, `shops_overview`, `shop_graphql` (Admin GraphQL sur une, plusieurs ou toutes les boutiques), `push_to_shop` (écrire le projet dans un thème non publié, sans zip) — via l'appli Shopify Story Apps, sans aucune clé Shopify |
 
 Prompts prêts à l'emploi : `creer-boutique`, `refaire-une-page`, `auditer-un-theme`. Les guides sont aussi exposés en ressources (`storytheme://guides/<sujet>`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "story-theme-mcp",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Serveur MCP du Story Thème : votre assistant IA connaît le thème Shopify Story par cœur et construit des boutiques propres et professionnelles.",
   "type": "module",
   "main": "src/index.js",

package/src/build/compose.js

@@ -1,22 +1,49 @@
 import { sectionFromPreset, blockFromPreset, createIdFactory, collectIds } from './scaffold.js';
 import { imageRef } from './quick-shared.js';
 import { closest } from '../theme/catalog.js';
+import { plainText } from '../validate/richtext.js';
 
 const clone = (value) => JSON.parse(JSON.stringify(value));
 const escapeHtml = (text) => String(text ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 
+// Text that is already theme HTML — a merchant's own rich text read from another theme — travels
+// as { html } and is placed as it is, instead of being escaped like the assistant's plain text.
+export const isHtml = (value) => Boolean(value) && typeof value === 'object' && typeof value.html === 'string';
+const RICH_ALLOWED = /^(p|ul|ol|li|h[1-6]|br|strong|b|em|i|u|span|a|s|sub|sup)$/i;
+const INLINE_ALLOWED = /^(strong|b|em|i|u|span|a|s|sub|sup)$/i;
+// Tags Shopify refuses in rich text go, their text stays.
+const keepTags = (html, allowed) => String(html).replace(/<\/?([a-zA-Z][a-zA-Z0-9]*)\b[^>]*>/g, (tag, name) => (allowed.test(name) ? tag : ''));
+const htmlInline = (html) =>
+  keepTags(
+    String(html)
+      .replace(/<li\b[^>]*>/gi, ' · ')
+      .replace(/<br\s*\/?>/gi, ' ')
+      .replace(/<\/(p|h[1-6]|li|ul|ol)>\s*<(p|h[1-6]|ul|ol)\b[^>]*>/gi, ' '),
+    INLINE_ALLOWED,
+  )
+    .replace(/\s+/g, ' ')
+    .trim();
+const htmlBlocks = (html) => {
+  const kept = keepTags(html, RICH_ALLOWED).trim();
+  if (!kept) return '';
+  // Every top-level node of a rich text must be a block tag.
+  return /^<(p|ul|ol|h[1-6])\b/i.test(kept) ? kept : `<p>${kept}</p>`;
+};
+
 // Plain text in, theme rich text out: **word** becomes bold (the theme's heading styles colour
 // bold words), blank lines split paragraphs.
-export const inline = (text) => escapeHtml(text).replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+export const inline = (text) => (isHtml(text) ? htmlInline(text.html) : escapeHtml(text).replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>'));
 // Plain text settings (labels, accordion titles, eyebrows) cannot hold bold: the stars go.
-export const plain = (text) => escapeHtml(String(text ?? '').replace(/\*\*(.+?)\*\*/g, '$1'));
+export const plain = (text) => (isHtml(text) ? escapeHtml(plainText(text.html)) : escapeHtml(String(text ?? '').replace(/\*\*(.+?)\*\*/g, '$1')));
 export const paragraphs = (text) =>
-  String(text ?? '')
-    .split(/\n\s*\n/)
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((part) => `<p>${inline(part).replace(/\n/g, '<br>')}</p>`)
-    .join('');
+  isHtml(text)
+    ? htmlBlocks(text.html)
+    : String(text ?? '')
+        .split(/\n\s*\n/)
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => `<p>${inline(part).replace(/\n/g, '<br>')}</p>`)
+        .join('');
 
 // Blocks that repeat inside a section and carry one item of content each.
 const ITEM_TYPES = ['_timeline-step', '_scroll-card', '_story-step', '_slide', 'accordion', 'testimonial', 'counter', 'progress-bar', '_spec-row', '_comparison-row', '_hotspot', '_gallery-item', '_story', '_logo', '_marquee-image', '_trust-badge', '_ugc-item'];
@@ -95,14 +122,20 @@ function largestSiblings(entries, keyOf) {
 
 // The repeated items of a section: its most frequent item block type, else groups holding a
 // heading (columns, benefits), else alike groups of an image and a caption (horizontal gallery).
-function findItems(section) {
+export function findItems(section) {
   const entries = [...walk(section)];
   const counts = new Map();
   for (const { block } of entries) if (ITEM_TYPES.includes(block.type)) counts.set(block.type, (counts.get(block.type) || 0) + 1);
   const type = [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
   if (type) return entries.filter(({ block }) => block.type === type);
-  const titled = largestSiblings(entries.filter(({ block }) => block.type === 'group' && holds(block, 'heading') && ![...walk(block)].slice(1).some((entry) => entry.block.type === 'group')), () => '');
+  const titledAll = entries.filter(({ block }) => block.type === 'group' && holds(block, 'heading') && ![...walk(block)].slice(1).some((entry) => entry.block.type === 'group'));
+  const titled = largestSiblings(titledAll, () => '');
   if (titled.length) return titled;
+  // Columns whose title sits in a nested group next to the photo (« Features with images »):
+  // the items are the outer groups, alike siblings each holding one titled group.
+  const outer = titledAll.map(({ parent }) => entries.find((entry) => entry.block === parent)).filter((entry) => entry && entry.block.type === 'group');
+  const columns = largestSiblings(outer.filter((entry, index) => outer.indexOf(entry) === index), signature);
+  if (columns.length) return columns;
   return largestSiblings(entries.filter(({ block }) => leafGroup(block) && (holds(block, 'image') || holds(block, 'text'))), signature);
 }
 
@@ -134,6 +167,7 @@ function setOption(catalog, block, key, value, notes) {
 }
 
 const firstOf = (node, type) => [...walk(node)].find((entry) => entry.block.type === type);
+const blockHas = (catalog, block, id) => (catalog.block(block.type)?.schema?.settings || []).some((setting) => setting.id === id);
 
 // One item of content into one item block, whatever its kind.
 function fillItem(catalog, entry, item, notes) {
@@ -146,7 +180,8 @@ function fillItem(catalog, entry, item, notes) {
     case '_timeline-step':
       if (content.label !== undefined) block.settings.label = plain(content.label);
       if (content.title) block.settings.title = inline(content.title);
-      if (text) block.settings.text = paragraphs(text);
+      // A step given without text keeps no sample text under the brand's title.
+      block.settings.text = text ? paragraphs(text) : '';
       if (content.image) block.settings.image = imageRef(content.image);
       setOption(catalog, block, 'icon', content.icon, notes);
       return;
@@ -196,13 +231,21 @@ function fillItem(catalog, entry, item, notes) {
     case '_logo':
     case '_ugc-item':
       if (content.image) block.settings.image = imageRef(content.image);
+      if (content.video && blockHas(catalog, block, 'video')) block.settings.video = content.video;
       if (content.title && block.type === '_gallery-item') block.settings.caption = inline(content.title);
       if (content.title && block.type === '_logo') block.settings.name = plain(content.title);
+      if (block.type === '_ugc-item') {
+        if (content.name) block.settings.author = plain(content.name);
+        if (content.text || (content.title && content.name)) block.settings.caption = inline(content.text || content.title);
+        if (content.product) block.settings.product = content.product;
+      }
       if (content.link) block.settings.link = content.link;
       return;
     case '_story':
       if (content.image) block.settings.image = imageRef(content.image);
+      if (content.video) block.settings.video = content.video;
       if (content.title) block.settings.title = plain(content.title);
+      if (content.product) block.settings.product = content.product;
       if (content.link) block.settings.link = content.link;
       return;
     default: {
@@ -210,11 +253,19 @@ function fillItem(catalog, entry, item, notes) {
       // icon and image blocks.
       const heading = firstOf(block, 'heading');
       if (heading && title) heading.block.settings = { ...(heading.block.settings || {}), title: `<p>${inline(title)}</p>` };
+      // An item given without a title keeps no sample one.
+      else if (heading) remove(heading.parent, heading.id);
       const body = firstOf(block, 'text');
       // No heading (a captioned photo): the title opens the text, in bold.
-      const caption = !heading && title ? `**${String(title).replace(/\*\*/g, '')}**${text ? `\n${text}` : ''}` : text;
+      const caption =
+        !heading && title
+          ? isHtml(title) || isHtml(text)
+            ? { html: `<p><strong>${plain(title)}</strong></p>${text ? paragraphs(text) : ''}` }
+            : `**${String(title).replace(/\*\*/g, '')}**${text ? `\n${text}` : ''}`
+          : text;
       if (body && caption) body.block.settings = { ...(body.block.settings || {}), description: paragraphs(caption) };
-      else if (body && !caption && content.title) remove(body.parent, body.id);
+      // No text for this item: the preset's sample sentence would read as the brand's.
+      else if (body && !caption) remove(body.parent, body.id);
       const button = firstOf(block, 'button');
       if (button) {
         if (content.button?.label) button.block.settings = { ...(button.block.settings || {}), button_text: inline(content.button.label), button_link: content.button.link || button.block.settings?.button_link || '' };
@@ -287,6 +338,8 @@ export function fillSection(catalog, section, spec, { nextId, h1 = false } = {})
     if (content.title) heading.block.settings.title = `<${tag}>${inline(content.title)}</${tag}>`;
     if (content.eyebrow !== undefined) heading.block.settings.subheading = plain(content.eyebrow);
     if (content.rotating_words?.length) heading.block.settings.rotating_words = content.rotating_words.map(plain).join('\n');
+    // title: "" removes the sample title, as text: "" removes the sample text.
+    if (content.title === '' && !content.eyebrow && !content.rotating_words?.length) remove(heading.parent, heading.id);
   }
   const text = outside.find(({ block }) => block.type === 'text');
   if (text && content.text) text.block.settings.description = paragraphs(content.text);
@@ -305,7 +358,11 @@ export function fillSection(catalog, section, spec, { nextId, h1 = false } = {})
   if (content.lines?.length) {
     for (const { block } of outside) {
       if (block.type === 'marquee-text') block.settings.text_items = content.lines.map(plain).join('\n');
-      if (block.type === 'checklist') block.settings.items_rich = content.lines.map((line) => `<p>${inline(line)}</p>`).join('');
+      if (block.type === 'checklist') {
+        block.settings.items_rich = content.lines.map((line) => `<p>${inline(line)}</p>`).join('');
+        // The plain list (older setting) keeps the preset's instructions otherwise.
+        if (block.settings.items !== undefined) block.settings.items = content.lines.map(plain).join('\n');
+      }
     }
   }
 

package/src/migrate/extract.js

@@ -0,0 +1,256 @@
+// =====================================================================
+// Ce qu'une section 3.x DIT, sans la façon dont elle le montre
+// =====================================================================
+// Une section 3.x mêle le contenu saisi par le marchand (titres, textes, boutons, photos,
+// vidéos, produits, éléments répétés) et sa présentation (alignements, couleurs, polices,
+// animations, espacements). Seul le contenu passe en 4.0 : les presets 4.0 apportent leur
+// propre présentation, réglée par le designer pour les nouvelles sections.
+//
+// Avec le schéma de la section (lu dans les `.liquid` du thème exporté), le type de chaque
+// réglage est connu. Sans lui, on devine d'après la valeur : une référence shopify://shop_images
+// est une photo, une chaîne en minuscules sans espace (« left », « fade-up ») un choix de
+// présentation, une phrase un texte.
+
+import { isHtml } from '../build/compose.js';
+import { plainText } from '../validate/richtext.js';
+
+// Blocs qui ne portent que de la décoration ou une fonction du thème, rien que le marchand ait écrit.
+const DECOR = new Set(['picto', 'custom_typo', 'divider', 'spacer', 'email_form', 'trust', 'share', 'media', 'featured_image']);
+// Blocs qui portent le titre, le texte ou les boutons de la section elle-même, quand ils sont seuls.
+const TETE = new Set(['heading', 'subheading', 'text', 'paragraph', 'button', 'more_image', 'icons', 'timer', 'image_heading', 'collapsible_subheading']);
+// Blocs dont chaque occurrence est une ligne d'une liste (puces, badges, bandeau défilant).
+const LIGNES = new Set(['badge', 'marquee', 'announcement-marquee', '_marquee-text-item']);
+
+const SCHEMA_GENRE = {
+  image_picker: 'image',
+  video: 'video',
+  video_url: 'video',
+  url: 'link',
+  richtext: 'html',
+  inline_richtext: 'html',
+  text: 'text',
+  textarea: 'text',
+  html: 'code',
+  liquid: 'code',
+  product: 'product',
+  collection: 'collection',
+  product_list: 'products',
+  collection_list: 'collections',
+  blog: 'blog',
+  page: 'page',
+  link_list: 'menu',
+  article: 'article',
+  color_scheme: 'palette',
+};
+
+const ROLES = [
+  ['link', /^(button_link|button_url|link|url|shop_link|link_url|cta_link|button_link_url)$/],
+  ['label', /^(button_text|button|button_label|link_label|link_title|cta|cta_text)$/],
+  ['name', /^(name|customer_name|author_name|author)$/],
+  ['role', /^(role|author_age|verified_text|job|position)$/],
+  ['rating', /^(rating|rate_text|rating_text)$/],
+  ['title', /^(heading|title|image_heading|review_title|tab_label|headline|heading_text|question|slides)$/],
+  ['eyebrow', /^(subheading|image_subheading|subtitle|label|tagline|eyebrow|caption|announcment)$/],
+  ['text', /^(description|text|row_content|content|text_footer|caption_text|form_text|text_above|message|body|paragraph|info|tooltip|answer|text_before|text_after|helper_text)$/],
+  ['image', /^(image|image_custom|custom_icon|icon_custom|icon_image|avatar|cover_image|background_image|image_before|image_after|logo|photo)$/],
+  ['image_mobile', /^(image_mobile|background_image_mobile)$/],
+  ['video', /^(video|video_url|video_link|video_mobile|video_link_mobile)$/],
+];
+
+const roleDe = (base) => ROLES.find(([, motif]) => motif.test(base))?.[0] || null;
+
+// « icon_1_text » → icon, 1, text ; « heading1 » → heading, 1 ; « image0 » → image, 0.
+const NUMERO = /^([a-z][a-z_]*?)_?(\d+)(?:_([a-z_]+))?$/;
+// Réglages numérotés qui ne sont PAS des éléments répétés.
+const PAS_NUMEROTE = /^(accent|heading_\d+_font_size|h\d)$/;
+
+function genreDeviné(cle, valeur) {
+  if (typeof valeur !== 'string') return null;
+  const v = valeur.trim();
+  if (!v) return null;
+  if (/^shopify:\/\/shop_images\//.test(v)) return 'image';
+  if (/^shopify:\/\/files\/videos\//.test(v) || /youtube\.com|youtu\.be|vimeo\.com/.test(v)) return 'video';
+  if (/(^|_)(collection)$/.test(cle)) return 'collection';
+  if (/(^|_)(product)$/.test(cle)) return 'product';
+  if (/(^|_)(blog)$/.test(cle)) return 'blog';
+  if (/(^|_)(page)$/.test(cle)) return 'page';
+  if (/(^|_)(menu)$/.test(cle)) return 'menu';
+  if (/^#[0-9a-f]{3,8}$/i.test(v) || /^rgba?\(/.test(v)) return null;
+  if (/^(shopify:\/\/|\/|https?:|mailto:|tel:|#[a-z])/i.test(v) && !/\s/.test(v)) return 'link';
+  if (/_[nib]\d$/.test(v)) return null; // police de la bibliothèque Shopify
+  if (/^(background-\d|inverse|scheme(-\d+)?|accent-\d)$/.test(v) && /palette|scheme/.test(cle)) return 'palette';
+  if (/<[a-z][^>]*>/i.test(v)) return 'html';
+  // Un choix de présentation : minuscules, chiffres, tirets, sans espace.
+  if (/^[a-z0-9_\-.:%]+$/.test(v)) return null;
+  return 'text';
+}
+
+const texteVide = (valeur) => !plainText(isHtml(valeur) ? valeur.html : valeur).replace(/ /g, '').trim();
+
+// Réglages qui ne sont pas du contenu : un ancre technique, ou un libellé d'interface du thème
+// (« Écrire un avis », « Voir plus », jours/heures du compte à rebours…), que la 4.0 traduit elle-même.
+const INTERFACE = /^(section_id|custom_class|anchor|write_review_\w+|success_message|plus|less|button_show_all_text|placeholder|error_message|default_value|days|hours|mins|secs|free_label|reviews_based_on_text|reviews_suffix_text|reviews_count|cart_\w+|sale_badge|share_label|size_guide_trigger|product_trigger|trigger|final_message|track)$/;
+
+/** Un réglage lu : sa clé, son rôle (titre, texte, lien…), son genre et sa valeur. */
+function lireReglage(cle, valeur, type) {
+  if (INTERFACE.test(cle)) return null;
+  const genre = type ? SCHEMA_GENRE[type] ?? null : genreDeviné(cle, valeur);
+  if (!genre || valeur === '' || valeur == null) return null;
+  if (genre === 'html' || genre === 'text') {
+    const v = genre === 'html' ? { html: String(valeur) } : String(valeur);
+    if (texteVide(v)) return null;
+    return { cle, genre, valeur: v };
+  }
+  return { cle, genre, valeur };
+}
+
+/**
+ * Range des réglages lus dans un contenu : titre, sur-titre, texte, boutons, médias, produits.
+ * Ce qui n'a pas de place est gardé dans `autres`, pour que rien ne se perde en silence.
+ */
+function ranger(contenu, reglages) {
+  const bouton = {};
+  const second = {};
+  for (const reglage of reglages) {
+    const secondaire = /_secondary$|_2$/.test(reglage.cle) && /button|link/.test(reglage.cle);
+    const base = reglage.cle.replace(/_secondary$/, '');
+    const role = roleDe(base);
+    const { genre, valeur } = reglage;
+
+    if (genre === 'palette') contenu.palette ??= valeur;
+    else if (genre === 'code') contenu.code.push(valeur);
+    else if (['product', 'collection', 'blog', 'page', 'menu', 'article'].includes(genre)) contenu[genre] ??= valeur;
+    else if (genre === 'products' || genre === 'collections') contenu[genre] = [...(contenu[genre] || []), ...(Array.isArray(valeur) ? valeur : [valeur])];
+    else if (genre === 'image') {
+      if (role === 'image_mobile') contenu.image_mobile ??= valeur;
+      else if (/after/.test(base)) contenu.image_after ??= valeur;
+      else if (/before/.test(base)) contenu.image_before ??= valeur;
+      else if (!contenu.image) contenu.image = valeur;
+      else contenu.images.push(valeur);
+    } else if (genre === 'video') contenu.video ??= valeur;
+    else if (genre === 'link') (secondaire ? second : bouton).link ??= valeur;
+    else if (role === 'label') (secondaire ? second : bouton).label ??= valeur;
+    else if (role && ['title', 'eyebrow', 'text', 'name', 'role', 'rating'].includes(role) && contenu[role] === undefined) contenu[role] = valeur;
+    else if (role === 'text' && contenu.text !== undefined) contenu.text = concat(contenu.text, valeur);
+    else contenu.autres.push({ cle: reglage.cle, valeur });
+  }
+  for (const b of [bouton, second]) if (b.label && !texteVide(b.label)) contenu.buttons.push({ label: b.label, link: b.link || '' });
+  // Un lien seul (bloc image cliquable, logo) reste au contenu.
+  if (bouton.link && !bouton.label) contenu.link ??= bouton.link;
+  return contenu;
+}
+
+const enHtml = (v) => (isHtml(v) ? v.html : `<p>${String(v).replace(/&/g, '&amp;').replace(/</g, '&lt;')}</p>`);
+const concat = (a, b) => ({ html: `${enHtml(a)}${enHtml(b)}` });
+
+export const contenuVide = () => ({ buttons: [], images: [], items: [], lines: [], apps: [], code: [], autres: [], ignores: [] });
+
+/**
+ * Sépare les réglages simples des réglages numérotés (icon_1_text, heading2, image0…),
+ * qui décrivent des éléments répétés dans un seul bloc ou une seule section.
+ */
+function lire(settings, schemaSettings) {
+  const types = new Map((schemaSettings || []).filter((s) => s.id).map((s) => [s.id, s.type]));
+  const simples = [];
+  const numerotes = new Map();
+  for (const [cle, valeur] of Object.entries(settings || {})) {
+    const reglage = lireReglage(cle, valeur, types.get(cle));
+    if (!reglage) continue;
+    const match = PAS_NUMEROTE.test(cle) ? null : NUMERO.exec(cle);
+    if (match && !/secondary/.test(cle)) {
+      const n = Number(match[2]);
+      const base = (match[3] ? `${match[1]}_${match[3]}` : match[1]).replace(/^(icon|item|slot|gift_slot|brand|spec|stat|step|review|tab|feature)_/, '');
+      if (!numerotes.has(n)) numerotes.set(n, []);
+      numerotes.get(n).push({ ...reglage, cle: base });
+    } else simples.push(reglage);
+  }
+  const elements = [...numerotes.entries()]
+    .sort((a, b) => a[0] - b[0])
+    .map(([, reglages]) => element(reglages))
+    .filter(utile);
+  return { simples, elements };
+}
+
+/** Un élément répété (une colonne, un avis, une question…) à partir de ses réglages. */
+function element(reglages, genre = null) {
+  const item = ranger(contenuVide(), reglages);
+  // Une ligne d'icône n'a qu'un texte : c'est son titre.
+  if (item.title === undefined && item.text !== undefined && item.name === undefined) {
+    item.title = item.text;
+    delete item.text;
+  }
+  if (genre) item.kind = genre;
+  return item;
+}
+
+const utile = (item) =>
+  item.title !== undefined || item.text !== undefined || item.name !== undefined || item.image || item.video || item.product || item.collection || item.buttons.length || item.eyebrow !== undefined;
+
+/**
+ * Le contenu d'une section 3.x.
+ * @param {object} section la section telle qu'elle est dans le JSON du thème
+ * @param {object|null} schema son schéma 3.x (null : lecture par devinette)
+ * @param {{ elements?: string[], schemasBlocs?: Map }} options `elements` : types de blocs à lire
+ *   comme des éléments répétés même seuls (un avis unique reste un avis)
+ */
+export function extraireSection(section, schema, { elements: typesElements = null, schemasBlocs = new Map() } = {}) {
+  const contenu = contenuVide();
+  contenu.type = section.type;
+  contenu.disabled = Boolean(section.disabled);
+
+  const { simples, elements } = lire(section.settings, schema?.settings);
+  ranger(contenu, simples);
+  contenu.items.push(...elements);
+
+  const ordre = (section.block_order || Object.keys(section.blocks || {})).filter((id) => section.blocks?.[id]);
+  const compte = new Map();
+  for (const id of ordre) compte.set(section.blocks[id].type, (compte.get(section.blocks[id].type) || 0) + 1);
+
+  for (const id of ordre) {
+    const bloc = section.blocks[id];
+    if (String(bloc.type).startsWith('shopify://apps/')) {
+      contenu.apps.push({ id, bloc });
+      continue;
+    }
+    if (bloc.disabled) {
+      contenu.ignores.push(`bloc ${bloc.type} masqué`);
+      continue;
+    }
+    if (DECOR.has(bloc.type)) continue;
+    const schemaBloc = schema?.blocks?.find((b) => b.type === bloc.type) || schemasBlocs.get(bloc.type) || null;
+    const lu = lire(bloc.settings, schemaBloc?.settings);
+
+    if (LIGNES.has(bloc.type)) {
+      const ligne = lu.simples.find((r) => r.genre === 'text' || r.genre === 'html');
+      if (ligne) contenu.lines.push(...decouperLigne(ligne.valeur));
+      continue;
+    }
+    const tete = typesElements ? !typesElements.includes(bloc.type) : TETE.has(bloc.type) && compte.get(bloc.type) === 1;
+    if (tete) {
+      ranger(contenu, lu.simples);
+      // Une liste d'icônes dans la section (puces sous le texte) : des lignes.
+      for (const el of lu.elements) if (el.title !== undefined) contenu.lines.push(el.title);
+      continue;
+    }
+    if (lu.elements.length && !lu.simples.some((r) => ['text', 'html'].includes(r.genre) && /^(heading|title|name|description|text)$/.test(r.cle))) {
+      // Un bloc qui porte plusieurs éléments numérotés (icônes, questions, avis).
+      contenu.items.push(...lu.elements.map((el) => ({ ...el, kind: bloc.type })));
+      continue;
+    }
+    const item = element(lu.simples, bloc.type);
+    if (lu.elements.length) item.sous = lu.elements;
+    if (bloc.blocks) item.enfants = bloc;
+    if (utile(item) || item.enfants) contenu.items.push(item);
+  }
+  return contenu;
+}
+
+// Un bandeau défilant 3.x tient parfois toute sa liste dans un seul texte (« ✓ A ✓ B ✓ C »).
+function decouperLigne(valeur) {
+  const texte = plainText(isHtml(valeur) ? valeur.html : valeur);
+  const morceaux = texte.split(/\s*(?:✓|✔|•|\||·)\s*/).map((m) => m.trim()).filter(Boolean);
+  return morceaux.length > 1 ? morceaux : [texte];
+}
+
+/** Le texte lisible d'une valeur, pour le rapport. */
+export const lisible = (valeur) => plainText(isHtml(valeur) ? valeur.html : valeur);

package/src/migrate/source.js

@@ -0,0 +1,125 @@
+// =====================================================================
+// Lire une boutique en Story Thème 3.x
+// =====================================================================
+// La 4.0 a refait le schéma des sections : 39 sections de la 3.7 n'existent plus, 32 sont
+// nouvelles. La mise à jour de l'espace membre, qui recopie les réglages d'une version à
+// l'autre, rendrait donc une boutique vide. La migration lit plutôt ce que le marchand a
+// SAISI (textes, photos, liens, produits, couleurs) pour le reposer dans les sections 4.0.
+//
+// La source est un thème exporté de la boutique (dossier, ou zip de Boutique en ligne >
+// Thèmes > Télécharger). Ses `.liquid` donnent le schéma de chaque section 3.x, y compris
+// celles qu'une agence ou une appli a ajoutées : on sait alors sans deviner quel réglage est
+// un texte, une image ou un lien. Sans eux (seulement les JSON), la lecture devine d'après
+// la valeur et le nom du réglage.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { unzipSync, strFromU8 } from 'fflate';
+import { parseThemeJson } from '../theme/loader.js';
+import { fileKind } from '../validate/template.js';
+
+const SCHEMA_RE = /\{%-?\s*schema\s*-?%\}([\s\S]*?)\{%-?\s*endschema\s*-?%\}/;
+
+function lireSchema(liquid) {
+  const match = SCHEMA_RE.exec(liquid);
+  if (!match) return null;
+  try {
+    return JSON.parse(match[1]);
+  } catch {
+    return null;
+  }
+}
+
+/** Les fichiers utiles d'un thème : chemin relatif → texte. */
+function lireFichiers(source) {
+  const fichiers = new Map();
+  // La langue par défaut de la boutique se lit au nom du fichier de traductions (fr.default.json) :
+  // on garde ce nom, pas son contenu.
+  const garder = (rel) => fileKind(rel) || rel === 'config/settings_schema.json' || /^(sections|blocks)\/[^/]+\.liquid$/.test(rel) || /^locales\/[a-z-]+\.default\.json$/i.test(rel);
+
+  if (fs.statSync(source).isDirectory()) {
+    const parcourir = (dossier) => {
+      const complet = path.join(source, dossier);
+      if (!fs.existsSync(complet)) return;
+      for (const nom of fs.readdirSync(complet)) {
+        const rel = `${dossier}/${nom}`;
+        if (fs.statSync(path.join(source, rel)).isDirectory()) parcourir(rel);
+        else if (garder(rel)) fichiers.set(rel, fs.readFileSync(path.join(source, rel), 'utf8'));
+      }
+    };
+    for (const dossier of ['templates', 'sections', 'blocks', 'config']) parcourir(dossier);
+    return fichiers;
+  }
+
+  if (!source.endsWith('.zip')) throw new Error('source attendue : le dossier ou le .zip d’un thème exporté de Shopify');
+  const archive = unzipSync(new Uint8Array(fs.readFileSync(source)));
+  const noms = Object.keys(archive);
+  // Les exports Shopify rangent parfois tout sous un dossier racine.
+  const racine = noms.find((nom) => nom.endsWith('config/settings_schema.json'))?.replace('config/settings_schema.json', '') ?? '';
+  for (const nom of noms) {
+    if (!nom.startsWith(racine)) continue;
+    const rel = nom.slice(racine.length);
+    if (garder(rel)) fichiers.set(rel, strFromU8(archive[nom]));
+  }
+  return fichiers;
+}
+
+/**
+ * Le thème 3.x d'une boutique : ses modèles, groupes et réglages en JSON, les schémas de ses
+ * sections et blocs, et sa version.
+ * @param {string} source dossier ou .zip
+ */
+export function lireThemeV3(source) {
+  const chemin = path.resolve(String(source).replace(/^~/, process.env.HOME || ''));
+  if (!fs.existsSync(chemin)) throw new Error(`« ${source} » introuvable`);
+  return lireThemeV3DepuisFichiers(lireFichiers(chemin), chemin);
+}
+
+/** Même lecture, à partir de fichiers déjà en mémoire (thème relu dans la boutique). */
+export function lireThemeV3DepuisFichiers(fichiers, origine = 'boutique') {
+  const fichiersJson = new Map();
+  const erreurs = [];
+  const schemas = { sections: new Map(), blocks: new Map() };
+  let version = null;
+  let nom = null;
+  let langue = null;
+
+  for (const [rel, texte] of fichiers) {
+    const locale = /^locales\/([a-z-]+)\.default\.json$/i.exec(rel);
+    if (locale) {
+      langue = locale[1].toLowerCase().split('-')[0];
+      continue;
+    }
+    const liquid = /^(sections|blocks)\/([^/]+)\.liquid$/.exec(rel);
+    if (liquid) {
+      const schema = lireSchema(texte);
+      if (schema) schemas[liquid[1]].set(liquid[2], schema);
+      continue;
+    }
+    if (rel === 'config/settings_schema.json') {
+      try {
+        const info = parseThemeJson(texte).find((groupe) => groupe.name === 'theme_info');
+        version = info?.theme_version || null;
+        nom = info?.theme_name || null;
+      } catch {
+        /* version inconnue */
+      }
+      continue;
+    }
+    try {
+      fichiersJson.set(rel, parseThemeJson(texte));
+    } catch (error) {
+      erreurs.push(`${rel} : JSON illisible (${error.message})`);
+    }
+  }
+
+  const reglages = fichiersJson.get('config/settings_data.json');
+  const courant = typeof reglages?.current === 'string' ? reglages.presets?.[reglages.current] : reglages?.current;
+  return { origine, version, nom, langue, fichiers: fichiersJson, schemas, reglages: courant || {}, erreurs };
+}
+
+/** La version majeure d'un numéro « 3.7.0 », ou null. */
+export const majeure = (version) => {
+  const match = /^(\d+)\./.exec(String(version || ''));
+  return match ? Number(match[1]) : null;
+};