story-theme-mcp 1.0.0

package/src/validate/template.js

@@ -0,0 +1,362 @@
+import { checkValue, newResources, resourcesToJson } from './values.js';
+import { closest, templateTypeOf, NON_VALUE_TYPES } from '../theme/catalog.js';
+
+export const LIMITS = {
+  sectionsPerTemplate: 25,
+  sectionsPerGroup: 25,
+  blocksPerSection: 50,
+  blocksPerFile: 1250,
+  nestingDepth: 8,
+  fileBytes: 512 * 1024,
+  settingsDataBytes: 1.5 * 1024 * 1024,
+};
+
+const ID_RE = /^[A-Za-z0-9_-]+$/;
+
+// Ids become object keys: names every JS object inherits (constructor, __proto__…) are refused.
+export const isSafeId = (id) => typeof id === 'string' && ID_RE.test(id) && !Object.hasOwn(Object.prototype, id);
+const has = (object, key) => object !== null && typeof object === 'object' && Object.hasOwn(object, key);
+
+// JSON template types Shopify accepts (gift_card and robots.txt stay Liquid).
+export const TEMPLATE_TYPES = new Set([
+  '404', 'article', 'blog', 'cart', 'collection', 'index', 'list-collections', 'page', 'password', 'product', 'search',
+  'customers/account', 'customers/activate_account', 'customers/addresses', 'customers/login', 'customers/order', 'customers/register', 'customers/reset_password',
+]);
+const SECTION_KEYS = new Set(['type', 'settings', 'blocks', 'block_order', 'disabled', 'custom_css', 'name', 'static']);
+const BLOCK_KEYS = new Set(['type', 'settings', 'blocks', 'block_order', 'disabled', 'static', 'name', 'id']);
+
+// Main sections a template type is expected to hold: without them the page cannot sell or list.
+export const EXPECTED_MAIN = {
+  product: 'main-product-composed',
+  collection: 'main-collection',
+  search: 'main-search',
+  cart: 'main-cart',
+  blog: 'main-blog',
+  article: 'main-article',
+  'list-collections': 'main-list-collections',
+  password: 'main-password',
+};
+
+export function fileKind(file) {
+  if (file === 'config/settings_data.json') return 'settings_data';
+  if (/^templates\/(customers\/|metaobject\/)?[a-z0-9_-]+(\.[a-z0-9_-]+)?\.json$/.test(file)) return 'template';
+  if (/^sections\/[a-z0-9_-]+\.json$/.test(file)) return 'group';
+  return null;
+}
+
+class Report {
+  constructor() {
+    this.errors = [];
+    this.warnings = [];
+    this.resources = newResources();
+    this.counts = { sections: 0, blocks: 0 };
+  }
+
+  add(level, path, message) {
+    (level === 'error' ? this.errors : this.warnings).push({ path, message });
+  }
+
+  toJson() {
+    const links = this.resources.links;
+    for (const link of links) {
+      const match = link.match(/^shopify:\/\/(collections|products|pages|blogs)\/([^/?#]+)/);
+      if (match && match[2] !== 'all') this.resources[match[1]].add(decodeURIComponent(match[2]));
+    }
+    return { ok: this.errors.length === 0, errors: this.errors, warnings: this.warnings, counts: this.counts, resources: resourcesToJson(this.resources) };
+  }
+}
+
+function checkSettings(report, catalog, path, values, settingsList, context) {
+  if (values === undefined) return;
+  if (!values || typeof values !== 'object' || Array.isArray(values)) {
+    report.add('error', path, '"settings" doit être un objet { id: valeur }');
+    return;
+  }
+  const index = new Map((settingsList || []).filter((setting) => setting.id && !NON_VALUE_TYPES.has(setting.type)).map((setting) => [setting.id, setting]));
+  for (const [key, value] of Object.entries(values)) {
+    const setting = index.get(key);
+    if (!setting) {
+      const hint = closest(key, index.keys());
+      report.add('error', `${path}.settings.${key}`, `réglage inconnu${hint.length ? ` (vouliez-vous dire : ${hint.join(', ')} ?)` : ''}`);
+      continue;
+    }
+    for (const problem of checkValue(setting, value, context)) report.add(problem.level, `${path}.settings.${key}`, problem.message);
+  }
+}
+
+function checkChildren(report, catalog, path, node, parent, depth, context) {
+  const { blocks, block_order: order } = node;
+  if (blocks === undefined) {
+    if (order !== undefined && order.length) report.add('error', path, 'block_order sans blocks');
+    return;
+  }
+  if (Array.isArray(blocks)) {
+    report.add('error', path, 'format de preset (tableau) : dans un fichier du thème, "blocks" est un objet { id: bloc } accompagné de "block_order"');
+    return;
+  }
+  if (!blocks || typeof blocks !== 'object') {
+    report.add('error', path, '"blocks" doit être un objet');
+    return;
+  }
+  const entries = Object.entries(blocks);
+  if (entries.length && !parent.schema?.blocks) {
+    report.add('error', path, `« ${parent.type} » n'accepte aucun bloc`);
+    return;
+  }
+  const statics = catalog.staticChildren(parent.kind, parent.type);
+  const dynamicIds = [];
+  for (const [id, block] of entries) {
+    const blockPath = `${path}/${id}`;
+    if (!isSafeId(id)) report.add('error', blockPath, 'identifiant de bloc invalide (lettres, chiffres, - et _ uniquement, hors noms réservés comme constructor)');
+    if (!block || typeof block !== 'object' || Array.isArray(block)) {
+      report.add('error', blockPath, 'un bloc doit être un objet');
+      continue;
+    }
+    for (const key of Object.keys(block)) if (!BLOCK_KEYS.has(key)) report.add('warning', blockPath, `clé « ${key} » ignorée par Shopify`);
+    if (!block.type) {
+      report.add('error', blockPath, 'bloc sans "type"');
+      continue;
+    }
+    if (block.type === '@app' || block.type === '@theme') {
+      report.add('error', blockPath, `« ${block.type} » n'est pas un type de bloc : indiquez le type réel (ex. heading)`);
+      continue;
+    }
+    if (block.static) {
+      if (!statics.some((entry) => entry.type === block.type && entry.id === id)) {
+        const expected = statics.filter((entry) => entry.type === block.type).map((entry) => entry.id);
+        report.add('error', blockPath, expected.length
+          ? `bloc statique « ${block.type} » : son identifiant doit être ${expected.map((value) => `« ${value} »`).join(' ou ')}`
+          : `« ${block.type} » n'est pas un bloc statique de « ${parent.type} » (retirez "static": true)`);
+      }
+    } else {
+      dynamicIds.push(id);
+      report.counts.blocks += 1;
+    }
+    const resolved = catalog.resolveChild(parent.schema, block.type);
+    if (!resolved.ok && !(block.static && catalog.block(block.type))) {
+      const hint = resolved.unknown ? closest(block.type, catalog.blockTypes) : [];
+      report.add('error', blockPath, `« ${block.type} » refusé dans « ${parent.type} » : ${resolved.reason}${hint.length ? ` (vouliez-vous dire : ${hint.join(', ')} ?)` : ''}`);
+      continue;
+    }
+    if (resolved.app) {
+      if (block.blocks && Object.keys(block.blocks).length) report.add('error', blockPath, "un bloc d'application ne contient pas de blocs du thème");
+      continue;
+    }
+    const schema = resolved.schema || catalog.block(block.type)?.schema;
+    if (depth + 1 > LIMITS.nestingDepth) {
+      report.add('error', blockPath, `imbrication trop profonde (${depth + 1} niveaux, ${LIMITS.nestingDepth} maximum sous la section)`);
+      continue;
+    }
+    if (block.disabled !== undefined && typeof block.disabled !== 'boolean') report.add('error', blockPath, '"disabled" doit valoir true ou false');
+    checkSettings(report, catalog, blockPath, block.settings, schema?.settings, context);
+    checkChildren(report, catalog, blockPath, block, { kind: resolved.local ? 'local' : 'block', type: block.type, schema }, depth + 1, context);
+  }
+
+  const policy = catalog.childPolicy(parent.schema);
+  if (dynamicIds.length > policy.maxBlocks) report.add('error', path, `${dynamicIds.length} blocs, ${policy.maxBlocks} maximum ici`);
+
+  if (order === undefined) {
+    if (dynamicIds.length) report.add('error', path, `"block_order" manquant : il doit lister ${dynamicIds.join(', ')}`);
+    return;
+  }
+  if (!Array.isArray(order)) {
+    report.add('error', path, '"block_order" doit être un tableau');
+    return;
+  }
+  const seen = new Set();
+  for (const id of order) {
+    if (seen.has(id)) report.add('error', path, `« ${id} » apparaît deux fois dans block_order`);
+    seen.add(id);
+    if (!has(blocks, id)) report.add('error', path, `block_order cite « ${id} », absent de blocks`);
+    else if (blocks[id]?.static) report.add('warning', path, `le bloc statique « ${id} » n'a pas besoin d'être dans block_order`);
+  }
+  const missing = dynamicIds.filter((id) => !seen.has(id));
+  if (missing.length) report.add('error', path, `blocs absents de block_order (ils ne s'afficheraient pas) : ${missing.join(', ')}`);
+}
+
+function checkSection(report, catalog, path, section, placement, context) {
+  if (!section || typeof section !== 'object' || Array.isArray(section)) {
+    report.add('error', path, 'une section doit être un objet');
+    return null;
+  }
+  for (const key of Object.keys(section)) if (!SECTION_KEYS.has(key)) report.add('warning', path, `clé « ${key} » ignorée par Shopify`);
+  const entry = catalog.section(section.type);
+  if (!entry) {
+    const hint = closest(section.type ?? '', catalog.sectionTypes);
+    report.add('error', path, `section « ${section.type} » inexistante${hint.length ? ` (vouliez-vous dire : ${hint.join(', ')} ?)` : ''}`);
+    return null;
+  }
+  if (!entry.schema) {
+    // A section without {% schema %} can be placed, but has neither settings nor blocks.
+    if (section.settings && Object.keys(section.settings).length) report.add('error', path, `« ${section.type} » n'a pas de réglages`);
+    if (section.blocks && Object.keys(section.blocks).length) report.add('error', path, `« ${section.type} » n'accepte aucun bloc`);
+    report.add('warning', path, `« ${section.type} » est une section sans schéma, rendue telle quelle par le code du thème`);
+    return null;
+  }
+  if (placement && !catalog.sectionAllowedIn(entry.schema, placement)) {
+    report.add('error', path, `« ${section.type} » n'est pas autorisée ici (${catalog.describePlacement(entry.schema)})`);
+  }
+  if (section.disabled !== undefined && typeof section.disabled !== 'boolean') report.add('error', path, '"disabled" doit valoir true ou false');
+  checkSettings(report, catalog, path, section.settings, entry.schema.settings, context);
+  checkChildren(report, catalog, path, section, { kind: 'section', type: section.type, schema: entry.schema }, 0, context);
+  return entry;
+}
+
+function checkSectionMap(report, catalog, data, placement, context, max) {
+  const { sections, order } = data;
+  if (!sections || typeof sections !== 'object' || Array.isArray(sections)) {
+    report.add('error', '', '"sections" doit être un objet { id: section }');
+    return [];
+  }
+  if (!Array.isArray(order)) report.add('error', '', '"order" doit être un tableau des identifiants de sections');
+  const ids = Object.keys(sections);
+  report.counts.sections = ids.length;
+  if (ids.length > max) report.add('error', '', `${ids.length} sections, ${max} maximum par fichier (limite Shopify)`);
+  const seen = new Set();
+  for (const id of order || []) {
+    if (seen.has(id)) report.add('error', 'order', `« ${id} » apparaît deux fois`);
+    seen.add(id);
+    if (!has(sections, id)) report.add('error', 'order', `« ${id} » est dans order mais pas dans sections`);
+  }
+  const notOrdered = ids.filter((id) => !seen.has(id));
+  if (Array.isArray(order) && notOrdered.length) report.add('error', 'order', `sections absentes de order : ${notOrdered.join(', ')}`);
+  const types = [];
+  for (const id of ids) {
+    if (!isSafeId(id)) {
+      report.add('error', id, 'identifiant de section invalide (lettres, chiffres, - et _ uniquement, hors noms réservés comme constructor)');
+      continue;
+    }
+    const entry = checkSection(report, catalog, id, sections[id], placement, context);
+    if (entry) types.push({ id, type: sections[id].type, schema: entry.schema });
+  }
+  const counts = new Map();
+  for (const { type, schema } of types) {
+    counts.set(type, (counts.get(type) || 0) + 1);
+    if (schema.limit && counts.get(type) === schema.limit + 1) report.add('error', '', `« ${type} » est limitée à ${schema.limit} par page`);
+  }
+  if (report.counts.blocks > LIMITS.blocksPerFile) report.add('error', '', `${report.counts.blocks} blocs, ${LIMITS.blocksPerFile} maximum par fichier`);
+  return types;
+}
+
+export function validateTemplateData(catalog, data, { file, schemeIds } = {}) {
+  const report = new Report();
+  const context = { schemeIds: schemeIds || catalog.defaultSchemeIds(), resources: report.resources };
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    report.add('error', '', 'le modèle doit être un objet JSON { sections, order }');
+    return report.toJson();
+  }
+  const templateType = templateTypeOf(file);
+  if (!TEMPLATE_TYPES.has(templateType) && !templateType.startsWith('metaobject/')) {
+    report.add('error', '', `type de modèle « ${templateType} » inconnu de Shopify (types : ${[...TEMPLATE_TYPES].join(', ')}, metaobject/<type>). Pour une page : templates/page.${templateType}.json`);
+  }
+  for (const key of Object.keys(data)) {
+    if (!['sections', 'order', 'layout', 'wrapper'].includes(key)) report.add('warning', '', `clé « ${key} » inconnue dans un modèle`);
+  }
+  if ('layout' in data && data.layout !== false && !['theme', 'password'].includes(data.layout)) {
+    report.add('warning', 'layout', `layout « ${data.layout} » : le thème ne fournit que theme et password`);
+  }
+  const types = checkSectionMap(report, catalog, data, { template: templateType }, context, LIMITS.sectionsPerTemplate);
+  const expected = EXPECTED_MAIN[templateType];
+  if (expected && !types.some(({ type }) => type === expected)) {
+    report.add('warning', '', `un modèle ${templateType} sans section « ${expected} » n'affichera pas l'essentiel de la page`);
+  }
+  return report.toJson();
+}
+
+export function validateGroupData(catalog, data, { file, schemeIds } = {}) {
+  const report = new Report();
+  const context = { schemeIds: schemeIds || catalog.defaultSchemeIds(), resources: report.resources };
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    report.add('error', '', 'le groupe doit être un objet JSON { type, name, sections, order }');
+    return report.toJson();
+  }
+  if (typeof data.type !== 'string' || !/^(header|footer|aside|custom\.[a-z0-9_-]+)$/.test(data.type)) {
+    report.add('error', 'type', 'type de groupe attendu : header, footer, aside ou custom.<nom>');
+  }
+  if (typeof data.name !== 'string' || !data.name) report.add('error', 'name', 'nom du groupe manquant');
+  checkSectionMap(report, catalog, data, { group: data.type }, context, LIMITS.sectionsPerGroup);
+  return report.toJson();
+}
+
+export function validateSettingsData(catalog, data) {
+  const report = new Report();
+  if (!data || typeof data !== 'object') {
+    report.add('error', '', 'settings_data doit être un objet { current, presets }');
+    return report.toJson();
+  }
+  let current = data.current;
+  if (typeof current === 'string') current = data.presets?.[current];
+  if (!current || typeof current !== 'object') {
+    report.add('error', 'current', '"current" doit être un objet de réglages (ou le nom d’un preset existant)');
+    return report.toJson();
+  }
+  const index = catalog.globalSettingIndex();
+  const schemeIds = Object.keys(current.color_schemes || {});
+  const context = { schemeIds: schemeIds.length ? schemeIds : catalog.defaultSchemeIds(), resources: report.resources };
+  for (const [key, value] of Object.entries(current)) {
+    if (key === 'sections') {
+      for (const [id, section] of Object.entries(value || {})) checkSection(report, catalog, `current.sections.${id}`, section, null, context);
+      continue;
+    }
+    if (key === 'content_for_index' || key === 'blocks') continue;
+    const setting = index.get(key);
+    if (!setting) {
+      const hint = closest(key, index.keys());
+      report.add('warning', `current.${key}`, `réglage du thème inconnu, Shopify l'ignorera${hint.length ? ` (vouliez-vous dire : ${hint.join(', ')} ?)` : ''}`);
+      continue;
+    }
+    if (setting.type === 'color_scheme_group') {
+      checkSchemes(report, catalog, value, setting);
+      continue;
+    }
+    if (setting.type === 'color_palette') {
+      checkPalette(report, value, setting);
+      continue;
+    }
+    for (const problem of checkValue(setting, value, context)) report.add(problem.level, `current.${key}`, problem.message);
+  }
+  return report.toJson();
+}
+
+function checkSchemes(report, catalog, value, setting) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    report.add('error', 'current.color_schemes', 'attendu un objet { id_palette: { settings: {…} } }');
+    return;
+  }
+  const definition = setting.definition || [];
+  const ids = Object.keys(value);
+  if (!ids.length) report.add('error', 'current.color_schemes', 'au moins une palette est nécessaire');
+  for (const id of ids) {
+    const path = `current.color_schemes.${id}`;
+    if (!isSafeId(id)) report.add('error', path, 'identifiant de palette invalide');
+    const scheme = value[id];
+    if (!scheme?.settings || typeof scheme.settings !== 'object') {
+      report.add('error', path, 'attendu { settings: { text, background, … } }');
+      continue;
+    }
+    checkSettings(report, catalog, path, scheme.settings, definition, {});
+    for (const role of definition.filter((entry) => entry.type === 'color')) {
+      if (!scheme.settings[role.id] && !role.default) report.add('warning', path, `couleur « ${role.id} » vide`);
+    }
+  }
+}
+
+function checkPalette(report, value, setting) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    report.add('error', 'current.palette', 'attendu un objet { background, surface, text, … }');
+    return;
+  }
+  const keys = Object.keys(setting.default || {});
+  for (const [key, color] of Object.entries(value)) {
+    if (keys.length && !keys.includes(key)) report.add('warning', `current.palette.${key}`, `couleur inconnue de la palette (clés : ${keys.join(', ')})`);
+    for (const problem of checkValue({ type: 'color' }, color)) report.add(problem.level, `current.palette.${key}`, problem.message);
+  }
+}
+
+export function validateFile(catalog, file, data, options = {}) {
+  const kind = fileKind(file);
+  if (kind === 'template') return validateTemplateData(catalog, data, { ...options, file });
+  if (kind === 'group') return validateGroupData(catalog, data, { ...options, file });
+  if (kind === 'settings_data') return validateSettingsData(catalog, data);
+  return { ok: false, errors: [{ path: file, message: 'fichier non géré : seuls templates/*.json, sections/<groupe>.json et config/settings_data.json le sont' }], warnings: [], counts: {}, resources: {} };
+}

package/src/validate/values.js

@@ -0,0 +1,173 @@
+import { checkRichtext, checkInlineRichtext } from './richtext.js';
+import { checkFontHandle } from '../knowledge/fonts.js';
+
+const DYNAMIC_RE = /^\s*\{\{[\s\S]+\}\}\s*$/;
+const HANDLE_RE = /^[\p{Ll}\p{N}][\p{Ll}\p{N}_-]*$/u;
+const HEX_RE = /^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+const RGB_RE = /^rgba?\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}\s*(,\s*(0|1|1\.0+|0?\.\d+)\s*)?\)$/i;
+const ARTICLE_RE = /^[\p{Ll}\p{N}][\p{Ll}\p{N}_-]*\/[\p{Ll}\p{N}][\p{Ll}\p{N}_-]*$/u;
+const NO_DYNAMIC = new Set(['select', 'radio', 'color_scheme', 'font_picker', 'text_alignment']);
+
+export const isDynamic = (value) => typeof value === 'string' && DYNAMIC_RE.test(value);
+
+const fail = (message) => [{ level: 'error', message }];
+const warn = (message) => [{ level: 'warning', message }];
+
+function checkUrl(value) {
+  if (value === '') return [];
+  if (typeof value !== 'string') return fail('un lien doit être une chaîne');
+  if (/\s/.test(value.trim())) return fail(`lien « ${value} » : contient des espaces`);
+  if (/^shopify:\/\/(collections|products|pages|blogs|policies|search|customer|account|cart)(\/|$)/.test(value)) return [];
+  if (/^shopify:\/\//.test(value)) return warn(`lien « ${value} » : format shopify:// inhabituel (attendu : shopify://collections/<handle>, shopify://products/<handle>, shopify://pages/<handle>, shopify://blogs/<handle>)`);
+  if (/^(https?:\/\/|\/|#|mailto:|tel:|sms:)/.test(value)) return [];
+  return fail(`lien « ${value} » invalide : utilisez shopify://collections/<handle>, /chemin, https://…, mailto:, tel: ou #ancre`);
+}
+
+function checkHandle(value, what) {
+  if (value === '' || value == null) return [];
+  if (typeof value !== 'string') return fail(`${what} : attendu l'identifiant (handle) sous forme de texte`);
+  if (!HANDLE_RE.test(value)) return fail(`${what} « ${value} » : un handle Shopify est en minuscules, sans espace ni accent (ex. robes-ete)`);
+  return [];
+}
+
+function checkList(value, setting, what) {
+  if (value === '' || value == null) return [];
+  if (!Array.isArray(value)) return fail(`${what} : attendu une liste de handles`);
+  const problems = value.flatMap((item) => checkHandle(item, what));
+  if (setting.limit && value.length > setting.limit) problems.push({ level: 'error', message: `${what} : ${value.length} éléments, ${setting.limit} maximum` });
+  return problems;
+}
+
+function onStep(value, min, step) {
+  const ratio = (value - min) / step;
+  return Math.abs(ratio - Math.round(ratio)) < 1e-9;
+}
+
+// Validates one setting value against its schema entry. `context` carries the colour scheme ids
+// and collects the resources the value points to.
+export function checkValue(setting, value, context = {}) {
+  const type = setting.type;
+  if (value === null || value === undefined) return [];
+  if (typeof value === 'string' && value.startsWith('t:')) {
+    return fail(`« ${value} » est une clé de traduction : dans un modèle, écrivez le texte lui-même`);
+  }
+  if (isDynamic(value) && !NO_DYNAMIC.has(type)) return [];
+
+  switch (type) {
+    case 'text':
+    case 'textarea':
+      if (typeof value !== 'string') return fail('attendu du texte');
+      if (type === 'text' && /<(p|div|h[1-6])\b/i.test(value)) return warn('HTML dans un champ texte simple : il sera affiché tel quel');
+      return [];
+    case 'html':
+    case 'liquid':
+      if (typeof value !== 'string') return fail('attendu du texte');
+      if (value.length > 50000) return fail('plus de 50 Ko dans un seul réglage (limite Shopify)');
+      return [];
+    case 'richtext':
+      if (typeof value !== 'string') return fail('attendu du texte riche (HTML)');
+      return checkRichtext(value);
+    case 'inline_richtext':
+      if (typeof value !== 'string') return fail('attendu du texte riche en ligne');
+      return checkInlineRichtext(value);
+    case 'number':
+      if (value === '') return [];
+      return typeof value === 'number' && Number.isFinite(value) ? [] : fail('attendu un nombre');
+    case 'range': {
+      if (typeof value !== 'number' || !Number.isFinite(value)) return fail(`attendu un nombre entre ${setting.min} et ${setting.max}`);
+      if (value < setting.min || value > setting.max) return fail(`${value} hors limites (${setting.min} à ${setting.max}${setting.unit ? ' ' + setting.unit : ''})`);
+      if (!onStep(value, setting.min, setting.step ?? 1)) return fail(`${value} n'est pas sur un pas de ${setting.step ?? 1} depuis ${setting.min}`);
+      return [];
+    }
+    case 'checkbox':
+      return typeof value === 'boolean' ? [] : fail('attendu true ou false (sans guillemets)');
+    case 'select':
+    case 'radio': {
+      const values = (setting.options || []).map((option) => option.value);
+      return values.includes(value) ? [] : fail(`« ${value} » n'est pas une option (options : ${values.join(', ')})`);
+    }
+    case 'text_alignment':
+      return ['left', 'center', 'right'].includes(value) ? [] : fail('attendu left, center ou right');
+    case 'color':
+      if (value === '') return [];
+      if (typeof value !== 'string' || !(HEX_RE.test(value) || RGB_RE.test(value))) return fail(`couleur « ${value} » invalide : utilisez #RRGGBB`);
+      return [];
+    case 'color_background':
+      if (value === '') return [];
+      if (typeof value !== 'string' || !/gradient\(/.test(value)) return fail('attendu un dégradé CSS (linear-gradient(…), radial-gradient(…)) ou une chaîne vide');
+      return [];
+    case 'color_scheme': {
+      // An empty value falls back to the setting's default scheme.
+      if (value === '') return [];
+      const ids = context.schemeIds || [];
+      if (ids.length && !ids.includes(value)) return fail(`palette « ${value} » inexistante (palettes : ${ids.join(', ')})`);
+      return [];
+    }
+    case 'font_picker':
+      return checkFontHandle(value);
+    case 'url':
+      if (typeof value === 'string' && value.startsWith('shopify://')) context.resources?.links.add(value);
+      return checkUrl(value);
+    case 'image_picker':
+      if (value === '') return [];
+      if (typeof value !== 'string' || !/^shopify:\/\/shop_images\/[^/\s]+$/.test(value)) {
+        return fail(`image « ${value} » : une image se désigne par shopify://shop_images/<nom-du-fichier> (fichier déjà présent dans Contenu > Fichiers), sinon laissez vide`);
+      }
+      context.resources?.images.add(value);
+      return [];
+    case 'video':
+      if (value === '') return [];
+      if (typeof value !== 'string' || !/^shopify:\/\/files\/videos\/[^/\s]+$/.test(value)) return fail('une vidéo se désigne par shopify://files/videos/<nom-du-fichier>, sinon laissez vide');
+      context.resources?.videos.add(value);
+      return [];
+    case 'video_url': {
+      if (value === '') return [];
+      if (typeof value !== 'string') return fail('attendu une adresse YouTube ou Vimeo');
+      const youtube = /^https?:\/\/(www\.)?(youtube\.com|youtu\.be)\//.test(value);
+      const vimeo = /^https?:\/\/(www\.|player\.)?vimeo\.com\//.test(value);
+      const accept = setting.accept || ['youtube', 'vimeo'];
+      if ((youtube && accept.includes('youtube')) || (vimeo && accept.includes('vimeo'))) return [];
+      return fail(`vidéo « ${value} » : adresse ${accept.join(' ou ')} attendue`);
+    }
+    case 'product':
+    case 'collection':
+    case 'page':
+    case 'blog':
+    case 'link_list':
+    case 'metaobject': {
+      const problems = checkHandle(value, type);
+      if (!problems.length && value) context.resources?.[type === 'link_list' ? 'menus' : `${type}s`]?.add(value);
+      return problems;
+    }
+    case 'article':
+      if (value === '') return [];
+      return typeof value === 'string' && ARTICLE_RE.test(value) ? [] : fail(`article « ${value} » : attendu handle-du-blog/handle-de-l-article`);
+    case 'article_list': {
+      if (value === '' || value == null) return [];
+      if (!Array.isArray(value)) return fail('article_list : attendu une liste « blog/article »');
+      const problems = value.filter((item) => typeof item !== 'string' || !ARTICLE_RE.test(item)).map((item) => ({ level: 'error', message: `article « ${item} » : attendu handle-du-blog/handle-de-l-article` }));
+      if (setting.limit && value.length > setting.limit) problems.push({ level: 'error', message: `article_list : ${value.length} éléments, ${setting.limit} maximum` });
+      return problems;
+    }
+    case 'product_list':
+    case 'collection_list':
+    case 'metaobject_list': {
+      const problems = checkList(value, setting, type);
+      if (!problems.length && Array.isArray(value)) {
+        const bucket = type === 'product_list' ? 'products' : type === 'collection_list' ? 'collections' : null;
+        if (bucket) value.forEach((item) => context.resources?.[bucket].add(item));
+      }
+      return problems;
+    }
+    default:
+      return [];
+  }
+}
+
+export function newResources() {
+  return { links: new Set(), images: new Set(), videos: new Set(), products: new Set(), collections: new Set(), pages: new Set(), blogs: new Set(), menus: new Set(), metaobjects: new Set() };
+}
+
+export function resourcesToJson(resources) {
+  return Object.fromEntries(Object.entries(resources).filter(([, set]) => set.size).map(([key, set]) => [key, [...set].sort()]));
+}

package/src/version.js

@@ -0,0 +1,3 @@
+// Version du serveur MCP. Ici et dans package.json — les deux doivent être identiques
+// (npm test le vérifie), et rien d'autre ne la redéclare.
+export const VERSION = '1.0.0';