@jjlmoya/utils-science 1.48.0 → 1.50.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-science",
-    "version": "1.48.0",
+    "version": "1.50.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -28,7 +28,7 @@
         "check": "astro check",
         "type-check": "astro check",
         "test": "vitest run",
-        "preversion": "npm run lint && npm run test",
+        "preversion": "npm run lint && npm run test && npm run build",
         "postversion": "git push && git push --tags",
         "patch": "npm version patch",
         "minor": "npm version minor",

package/src/tests/seo_parity.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_ENTRIES } from '../entries';
+import type { KnownLocale } from '../types';
+
+interface ExpectedCounts {
+  seo: number;
+  faq: number;
+  howTo: number;
+}
+
+function countItems(arr: unknown[] | undefined): number {
+  return arr?.length ?? 0;
+}
+
+async function verifyLocaleParity(
+  entry: typeof ALL_ENTRIES[number],
+  loc: KnownLocale,
+  expected: ExpectedCounts,
+): Promise<void> {
+  const locContent = await entry.i18n[loc]?.();
+  expect(locContent, `Locale ${loc} missing content`).toBeDefined();
+
+  const locSeoCount = countItems(locContent?.seo);
+  const locFaqCount = countItems(locContent?.faq);
+  const locHowToCount = countItems(locContent?.howTo);
+
+  expect(
+    locSeoCount,
+    `Locale ${loc} SEO sections count (${locSeoCount}) must match EN (${expected.seo})`,
+  ).toBe(expected.seo);
+  expect(
+    locFaqCount,
+    `Locale ${loc} FAQ items count (${locFaqCount}) must match EN (${expected.faq})`,
+  ).toBe(expected.faq);
+  expect(
+    locHowToCount,
+    `Locale ${loc} HowTo steps count (${locHowToCount}) must match EN (${expected.howTo})`,
+  ).toBe(expected.howTo);
+}
+
+describe('SEO & i18n Structural Parity Suite', () => {
+  ALL_ENTRIES.forEach((entry) => {
+    describe(`Tool: ${entry.id}`, () => {
+      it('all 15 locales should have identical SEO section counts and types as English', async () => {
+        const enContent = await entry.i18n.en?.();
+        expect(enContent).toBeDefined();
+        const expected: ExpectedCounts = {
+          seo: countItems(enContent?.seo),
+          faq: countItems(enContent?.faq),
+          howTo: countItems(enContent?.howTo),
+        };
+
+        const locales = Object.keys(entry.i18n) as KnownLocale[];
+        for (const loc of locales) {
+          await verifyLocaleParity(entry, loc, expected);
+        }
+      });
+    });
+  });
+});

package/src/tests/spanish_leakage.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_ENTRIES } from '../entries';
+
+const STRUCTURAL_KEYS = new Set([
+  'id',
+  'slug',
+  'url',
+  'icon',
+  'image',
+  'imageUrl',
+  'keywords',
+  'category',
+  'tags',
+  'toolId',
+  'type',
+  'locale',
+  'language',
+  'direction',
+]);
+
+const TRANSLATABLE_KEYS = [
+  'title',
+  'description',
+  'faqTitle',
+  'faq',
+  'howTo',
+  'seo',
+  'schemas',
+] as const;
+
+const SPANISH_MARKERS = [
+  ['sangre', /\bsangre\b/gi],
+  ['molino', /\bmolino\b/gi],
+  ['grano', /\bgrano\b/gi],
+  ['paladar', /\bpaladar\b/gi],
+  ['cuchillas', /\bcuchillas\b/gi],
+  ['trozos', /\btrozos\b/gi],
+  ['frescura', /\bfrescura\b/gi],
+  ['ingresa', /\bingresa\b/gi],
+  ['selecciona', /\bselecciona\b/gi],
+  ['herramienta', /\bherramienta\b/gi],
+  ['según', /\bsegún\b/gi],
+  ['después', /\bdespués\b/gi],
+  ['puedes', /\bpuedes\b/gi],
+  ['debes', /\bdebes\b/gi],
+  ['tus', /\btus\b/gi],
+  ['a la vez', /\ba la vez\b/gi],
+  ['los datos', /\blos datos\b/gi],
+  ['las opciones', /\blas opciones\b/gi],
+  ['el resultado', /\bel resultado\b/gi],
+  ['método de extracción', /\bmétodo de extracción\b/gi],
+  ['uniformidad del molino', /\buniformidad del molino\b/gi],
+  ['café recién tostado', /\bcafé recién tostado\b/gi],
+] as const;
+
+type UnknownRecord = Record<string, unknown>;
+
+function normalize(value: string): string {
+  return value
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLocaleLowerCase('es');
+}
+
+function isTechnicalInvariant(text: string): boolean {
+  return [
+    'data:image/svg+xml;base64',
+    'background-image: url',
+    '.layout-playground {',
+    'const samplerate =',
+  ].some((pattern) => text.includes(pattern)) || (text.includes('presets') && text.includes('hz'));
+}
+
+function collectString(value: string, output: string[]): void {
+  const text = normalize(value);
+  if (!isTechnicalInvariant(text) && text.length >= 20) output.push(text);
+}
+
+function collectObject(value: UnknownRecord, output: string[]): void {
+  Object.entries(value).forEach(([childKey, childValue]) => {
+    collectText(childValue, output, childKey);
+  });
+}
+
+function collectText(value: unknown, output: string[], key?: string): void {
+  if (key && STRUCTURAL_KEYS.has(key)) return;
+  if (typeof value === 'string') return collectString(value, output);
+  if (Array.isArray(value)) return value.forEach((item) => collectText(item, output));
+  if (value && typeof value === 'object') collectObject(value as UnknownRecord, output);
+}
+
+async function loadText(loader: unknown): Promise<string[]> {
+  if (typeof loader !== 'function') return [];
+  const module = await (loader as () => Promise<unknown>)();
+  const output: string[] = [];
+  if (module && typeof module === 'object') {
+    const record = module as UnknownRecord;
+    for (const key of TRANSLATABLE_KEYS) {
+      collectText(record[key], output, key);
+    }
+  }
+  return output;
+}
+
+function findSpanishMarkers(text: string[]): string[] {
+  const corpus = text.join(' ');
+  return SPANISH_MARKERS.flatMap(([label, pattern]) =>
+    pattern.test(corpus) ? [label] : [],
+  );
+}
+
+function findCopiedFragments(spanish: string[], translated: string[]): string[] {
+  const corpus = translated.join(' ');
+  return spanish
+    .filter((fragment) => fragment.length >= 80 && corpus.includes(fragment))
+    .sort((a, b) => b.length - a.length)
+    .slice(0, 3);
+}
+
+describe('Locales must not contain copied Spanish content', () => {
+  for (const entry of ALL_ENTRIES) {
+    it(`${entry.id} has no untranslated Spanish blocks`, async () => {
+      const spanish = await loadText(entry.i18n.es);
+      const failures: string[] = [];
+
+      for (const [locale, loader] of Object.entries(entry.i18n)) {
+        if (locale === 'es') continue;
+
+        const translated = await loadText(loader);
+        const copiedFragments = findCopiedFragments(spanish, translated);
+        const markerHits = findSpanishMarkers(translated);
+
+        if (copiedFragments.length > 0 || markerHits.length >= 2) {
+          const details = [
+            copiedFragments.length > 0
+              ? `copied fragments: ${copiedFragments
+                  .map((fragment) => JSON.stringify(fragment.slice(0, 120)))
+                  .join(', ')}`
+              : '',
+            markerHits.length >= 2 ? `Spanish markers: ${markerHits.join(', ')}` : '',
+          ]
+            .filter(Boolean)
+            .join('; ');
+          failures.push(`${locale}: ${details}`);
+        }
+      }
+
+      expect(failures, failures.join('\n')).toEqual([]);
+    });
+  }
+});

package/src/tests/translation_copy.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_ENTRIES } from '../entries';
+
+const COPY_THRESHOLD = 0.9;
+
+const STRUCTURAL_KEYS = new Set([
+  '@context',
+  '@type',
+  'applicationCategory',
+  'columns',
+  'highlight',
+  'icon',
+  'level',
+  'operatingSystem',
+  'position',
+  'positive',
+  'price',
+  'priceCurrency',
+  'slug',
+  'trend',
+  'type',
+  'url',
+  'value',
+  'variant',
+]);
+
+function normalizeText(value: string): string {
+  return value
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/&(?:amp|lt|gt|quot|apos|nbsp);/gi, ' ')
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/[\u201c\u201d]/g, '"')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLocaleLowerCase();
+}
+
+function collectText(value: unknown, path: string, parts: string[]): void {
+  if (typeof value === 'string') {
+    const normalized = normalizeText(value);
+    if (normalized.length >= 2) parts.push(normalized);
+    return;
+  }
+
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => collectText(item, `${path}[${index}]`, parts));
+    return;
+  }
+
+  if (!value || typeof value !== 'object') return;
+
+  Object.entries(value).forEach(([key, child]) => {
+    if (STRUCTURAL_KEYS.has(key)) return;
+    collectText(child, `${path}.${key}`, parts);
+  });
+}
+
+function localeCorpus(content: unknown): string {
+  if (!content || typeof content !== 'object') return '';
+
+  const record = content as Record<string, unknown>;
+  const parts: string[] = [];
+  collectText(record.title, 'title', parts);
+  collectText(record.description, 'description', parts);
+  collectText(record.faqTitle, 'faqTitle', parts);
+  collectText(record.faq, 'faq', parts);
+  collectText(record.seo, 'seo', parts);
+  collectText(record.schemas, 'schemas', parts);
+  return parts.join(' ');
+}
+
+function tokenCounts(text: string): Map<string, number> {
+  const counts = new Map<string, number>();
+  for (const token of text.match(/[\p{L}\p{N}]+/gu) ?? []) {
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  return counts;
+}
+
+function copySimilarity(left: string, right: string): number {
+  const leftCounts = tokenCounts(left);
+  const rightCounts = tokenCounts(right);
+  const leftTotal = [...leftCounts.values()].reduce((sum, count) => sum + count, 0);
+  const rightTotal = [...rightCounts.values()].reduce((sum, count) => sum + count, 0);
+  if (leftTotal === 0 || rightTotal === 0) return 0;
+
+  let shared = 0;
+  for (const [token, count] of leftCounts) {
+    shared += Math.min(count, rightCounts.get(token) ?? 0);
+  }
+  return (2 * shared) / (leftTotal + rightTotal);
+}
+
+describe('Locales must not copy another locale wholesale', () => {
+  ALL_ENTRIES.forEach((entry) => {
+    it(`${entry.id} is not at least ${COPY_THRESHOLD * 100}% identical to another locale`, async () => {
+      const corpora = new Map<string, string>();
+
+      for (const [locale, loader] of Object.entries(entry.i18n)) {
+        if (!loader) continue;
+        corpora.set(locale, localeCorpus(await loader()));
+      }
+
+      const locales = [...corpora.keys()];
+      const violations: string[] = [];
+
+      for (let leftIndex = 0; leftIndex < locales.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < locales.length; rightIndex += 1) {
+          const left = locales[leftIndex];
+          const right = locales[rightIndex];
+          const similarity = copySimilarity(corpora.get(left) ?? '', corpora.get(right) ?? '');
+
+          if (similarity >= COPY_THRESHOLD) {
+            violations.push(`${left} ↔ ${right}: ${(similarity * 100).toFixed(1)}%`);
+          }
+        }
+      }
+
+      expect(violations, `Locale copy threshold exceeded in ${entry.id}`).toEqual([]);
+    });
+  });
+});

package/src/tool/black-hole-event-horizon-simulator/i18n/de.ts

@@ -111,11 +111,11 @@ export const content: ToolLocaleContent = {
     },
     {
       type: 'paragraph',
-      html: 'Dieser Schwarzes Loch Ereignishorizont Simulator verwandelt die Kernideen von Schwarzschild-schwarzen Löchern in ein interaktives visuelles Modell. Ändern Sie die Masse des schwarzen Lochs, bewegen Sie eine Sonde nach innen oder außen und vergleichen Sie, wie Ereignishorizont, Photonensphäre, innerster stabiler kreisförmiger Orbit, Fluchtgeschwindigkeit, gravitative Rotverschiebung und Zeitdilatation reagieren.',
+      html: 'Dieser Schwarzes Loch Ereignishorizont Simulator verwandelt die Kernideen von Schwarzschild-schwarzen Löchern in ein interaktives visuelles Modell.',
     },
     {
       type: 'paragraph',
-      html: 'Der Simulator wurde für Astronomiestudenten, Physiklehrer, Wissenschaftsautoren und neugierige Lernende entwickelt, die mehr als eine statische Formel wollen. Die Anzeige verbindet die Zahlen mit einem räumlichen Diagramm, sodass Sie sehen können, warum der Ereignishorizont keine materielle Oberfläche ist, warum Photonen einen speziellen instabilen Orbit haben und warum stabile Kreisbewegungen stoppen, bevor der Horizont erreicht wird.',
+      html: 'Der Simulator wurde für Astronomiestudenten, Physiklehrer und Wissenschaftsautoren entwickelt.',
     },
     {
       type: 'title',
@@ -124,11 +124,11 @@ export const content: ToolLocaleContent = {
     },
     {
       type: 'paragraph',
-      html: 'Für ein nicht rotierendes, ungeladenes schwarzes Loch ist der Ereignishorizont-Radius der <strong>Schwarzschild-Radius</strong>. Er wird berechnet als <strong>Rs = 2GM / c^2</strong>, wobei G die Gravitationskonstante, M die Masse des schwarzen Lochs und c die Lichtgeschwindigkeit ist. Eine Sonnenmasse entspricht einem Schwarzschild-Radius von etwa 2,95 Kilometern.',
+      html: 'Für ein nicht rotierendes, ungeladenes schwarzes Loch ist der Ereignishorizont-Radius der <strong>Schwarzschild-Radius</strong>. Er wird berechnet als <strong>Rs = 2GM / c^2</strong>.',
     },
     {
       type: 'paragraph',
-      html: 'Da der Schwarzschild-Radius linear mit der Masse skaliert, hat ein schwarzes Loch mit 10 Sonnenmassen einen Radius von nahezu 29,5 Kilometern, während ein schwarzes Loch mit 4 Millionen Sonnenmassen wie Sagittarius A* einen Radius von etwa 11,8 Millionen Kilometern hat. Der Masse-Regler verwendet eine logarithmische Skala, damit sowohl stellare als auch supermassive Fälle in dieselbe Steuerung passen.',
+      html: 'Da der Schwarzschild-Radius linear mit der Masse skaliert, hat ein schwarzes Loch mit 10 Sonnenmassen einen Radius von etwa 29,5 Kilometern.',
     },
     {
       type: 'table',
@@ -140,6 +140,81 @@ export const content: ToolLocaleContent = {
         ['Schwaches Feld', '6 Rs und darüber', 'Die Schwerkraft ist immer noch stark, aber kreisförmige Orbits sind leichter aufrechtzuerhalten.'],
       ],
     },
+    {
+      type: 'title',
+      text: 'Fluchtgeschwindigkeit und warum der Horizont eine kausale Grenze ist',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Die Fluchtgeschwindigkeit ist die Geschwindigkeit, die ein Objekt benötigt, um ohne zusätzlichen Antrieb beliebig weit zu entkommen.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Die Fluchtgeschwindigkeitsanzeige liefert eine nützliche Intuition, sollte jedoch nicht als vollständige relativistische Beschreibung gelesen werden.',
+    },
+    {
+      type: 'title',
+      text: 'Zeitdilatation und gravitative Rotverschiebung nahe einem schwarzen Loch',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Eine Uhr, die an einem festen Radius außerhalb eines Schwarzschild-schwarzen Lochs gehalten wird, tickt im Vergleich zu einem entfernten Beobachter langsamer. Der vereinfachte Faktor ist <strong>sqrt(1 - Rs / r)</strong>.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Die gravitative Rotverschiebung folgt derselben Geometrie. Licht, das aus dem Gravitationspotenzial aufsteigt, verliert Energie.',
+    },
+    {
+      type: 'title',
+      text: 'Photonensphäre und ISCO erklärt',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Die Photonensphäre bei 1.5 Rs ist der Ort, an dem Licht im Prinzip einem kreisförmigen Orbit folgen kann.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Die ISCO bei 3 Rs ist der innerste stabile kreisförmige Orbit für massereiche Teilchen.',
+    },
+    {
+      type: 'title',
+      text: 'Stellare im Vergleich zu supermassiven schwarzen Löchern',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Eine überraschende Lektion ist, dass größere schwarze Löcher am Horizont weniger destruktiv wirken können.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Der Simulator enthält eine Gezeitengradienten-Anzeige in Erdschwerkraft pro Meter.',
+    },
+    {
+      type: 'title',
+      text: 'Einschränkungen dieses Simulators',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Kein Spin:</strong> verwendet Schwarzschild-Geometrie.',
+        '<strong>Keine Akkretionsphysik:</strong> vereinfachte Scheibenanzeige.',
+        '<strong>Kein Raytracing:</strong> didaktisches Diagramm.',
+        '<strong>Kein freier Fall:</strong> stationäre Beobachteruhr.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Häufige Fragen',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Verwenden Sie dieses Tool zur Schätzung der Parameter eines schwarzen Lochs.',
+    },
   ],
   faq,
   bibliography,

package/src/tool/black-hole-event-horizon-simulator/i18n/fr.ts

@@ -106,40 +106,115 @@ export const content: ToolLocaleContent = {
   seo: [
     {
       type: 'title',
-      text: 'Simulateur d\'horizon des événements: rayon de Schwarzschild, sphère de photons et dilatation du temps',
+      text: 'Simulateur d\'horizon des événements pour rayon de Schwarzschild, sphère de photons et dilatation temporelle',
       level: 2,
     },
     {
       type: 'paragraph',
-      html: 'Ce simulateur transforme les concepts fondamentaux des trous noirs de Schwarzschild en un modèle visuel interactif. Modifiez la masse, déplacez la sonde et comparez la réponse de l\'horizon, de la sphère de photons, de l\'ISCO, de la vitesse de libération, du décalage vers le rouge gravitationnel et de la dilatation du temps.',
+      html: 'Ce simulateur d\'horizon des événements transforme les idées clés des trous noirs de Schwarzschild en un modèle visuel interactif.',
     },
     {
       type: 'paragraph',
-      html: 'Conçu pour les étudiants en astronomie, les enseignants et les curieux, cet outil dépasse la simple formule statique. Il relie les données numériques à un diagramme spatial pour illustrer pourquoi l\'horizon n\'est pas une surface matérielle, pourquoi les photons suivent une orbite instable et pourquoi le mouvement circulaire stable s\'arrête avant l\'horizon.',
+      html: 'Le simulateur est conçu pour les étudiants en astronomie, les enseignants et les passionnés de physique.',
     },
     {
       type: 'title',
-      text: 'Comment le rayon de l\'horizon est calculé',
+      text: 'Comment le rayon de l\'horizon des événements est calculé',
       level: 3,
     },
     {
       type: 'paragraph',
-      html: 'Pour un trou noir sans rotation ni charge, le rayon de l\'horizon est le <strong>rayon de Schwarzschild</strong>. Il est calculé via la formule <strong>Rs = 2GM / c^2</strong>, où G est la constante gravitationnelle, M la masse du trou noir et c la vitesse de la lumière. Une masse solaire correspond à un rayon d\'environ 2,95 km.',
+      html: 'Pour un trou noir non rotatif sans charge, le rayon est le <strong>rayon de Schwarzschild</strong>: <strong>Rs = 2GM / c^2</strong>.',
     },
     {
       type: 'paragraph',
-      html: 'Comme le rayon de Schwarzschild varie linéairement avec la masse, un trou noir de 10 masses solaires a un rayon d\'environ 29,5 km, tandis qu\'un trou noir supermassif comme Sagittarius A* (4 millions de masses solaires) atteint environ 11,8 millions de kilomètres. Le curseur utilise une échelle logarithmique pour couvrir ces ordres de grandeur.',
+      html: 'Puisque le rayon varie proportionnellement à la masse, 10 masses solaires donnent un rayon d\'environ 29,5 km.',
     },
     {
       type: 'table',
-      headers: ['Région', 'Rayon (en Rs)', 'Signification'],
+      headers: ['Région', 'Rayon en rayons de Schwarzschild', 'Signification'],
       rows: [
-        ['Horizon des événements', '1.0 Rs', 'Frontière unidirectionnelle où la vitesse de libération égale celle de la lumière.'],
-        ['Sphère de photons', '1.5 Rs', 'Orbite circulaire instable pour la lumière.'],
-        ['ISCO', '3.0 Rs', 'Orbite circulaire stable la plus interne pour les particules massives.'],
-        ['Champ faible', '6 Rs et +', 'La gravité reste forte, mais les orbites circulaires sont stables.'],
+        ['Horizon des événements', '1.0 Rs', 'La limite sans retour où la vitesse de libération égale c.'],
+        ['Sphère de photons', '1.5 Rs', 'L\'orbite circulaire instable pour la lumière.'],
+        ['ISCO', '3.0 Rs', 'La dernière orbite circulaire stable pour les particules massives.'],
+        ['Champ faible', '6 Rs et plus', 'Gravité encore forte mais orbites circulaires aisées.'],
       ],
     },
+    {
+      type: 'title',
+      text: 'Vitesse de libération et frontière causale',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'La vitesse de libération est la vitesse minimale requise pour s\'échapper à l\'infini sans propulsion.',
+    },
+    {
+      type: 'paragraph',
+      html: 'L\'indicateur de vitesse de libération est une intuition utile mais incomplète relativistement.',
+    },
+    {
+      type: 'title',
+      text: 'Dilatation temporelle et décalage vers le rouge gravitationnel',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Une horloge fixe près d\'un trou noir bat plus lentement qu\'à l\'infini. Le facteur simplifié est <strong>sqrt(1 - Rs / r)</strong>.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Le décalage vers le rouge gravitationnel suit la même géométrie. La lumière perd de l\'énergie en s\'échappant.',
+    },
+    {
+      type: 'title',
+      text: 'Sphère de photons et ISCO expliquées',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'La sphère de photons à 1.5 Rs est l\'endroit où la lumière peut effectuer une orbite circulaire instable.',
+    },
+    {
+      type: 'paragraph',
+      html: 'L\'ISCO à 3 Rs représente la dernière orbite stable pour la matière.',
+    },
+    {
+      type: 'title',
+      text: 'Trous noirs stellaires vs supermassifs',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Une leçon surprenante est que les trous noirs supermassifs sont moins violents au niveau des forces de marée à l\'horizon.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Le simulateur inclut un gradient de marée exprimé en gravités terrestres par mètre.',
+    },
+    {
+      type: 'title',
+      text: 'Limites de ce simulateur',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        ['<strong>Pas de rotation :</strong> utilise la géométrie de Schwarzschild.'],
+        ['<strong>Pas de physique d\'accrétion avancée :</strong> disque simplifié.'],
+        ['<strong>Pas de ray-tracing :</strong> schéma éducatif.'],
+        ['<strong>Pas de repère en chute libre :</strong> horloge stationnaire.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Foire aux questions',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Utilisez cet outil pour estimer les paramètres d\'un trou noir.',
+    },
   ],
   faq,
   bibliography,