@jjlmoya/utils-science 1.42.0 → 1.43.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-science",
-    "version": "1.42.0",
+    "version": "1.43.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -22,10 +22,12 @@ import { dysonSphereEnergyCapture } from '../tool/dyson-sphere-energy-capture/in
 import { globalAlbedoSnowballSimulator } from '../tool/global-albedo-snowball-simulator/index';
 import { conwayLifeRuleLab } from '../tool/conway-life-rule-lab/index';
 import { crystalLatticeStructureFinder } from '../tool/crystal-lattice-structure-finder/index';
+import { fermiParadoxFilterLab } from '../tool/fermi-paradox-filter-lab/index';
+import { epidemicSirSimulator } from '../tool/epidemic-sir-simulator/index';
 
 export const scienceCategory: ScienceCategoryEntry = {
   icon: 'mdi:flask',
-  tools: [colonyCounter, asteroidImpact, microwaveDetector, simulationProbability, cellularRenewal, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone, radioactiveDecay, naturalSelectionDrift, entropySecondLaw, doubleSlitDecoherence, phaseDiagramCriticalPoints, twinParadoxVisualizer, mandelbrotFractal, planetAtmosphereSurvival, threeBodyProblem, rocheLimitSatelliteDisruption, dysonSphereEnergyCapture, globalAlbedoSnowballSimulator, conwayLifeRuleLab, crystalLatticeStructureFinder],
+  tools: [colonyCounter, asteroidImpact, microwaveDetector, simulationProbability, cellularRenewal, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone, radioactiveDecay, naturalSelectionDrift, entropySecondLaw, doubleSlitDecoherence, phaseDiagramCriticalPoints, twinParadoxVisualizer, mandelbrotFractal, planetAtmosphereSurvival, threeBodyProblem, rocheLimitSatelliteDisruption, dysonSphereEnergyCapture, globalAlbedoSnowballSimulator, conwayLifeRuleLab, crystalLatticeStructureFinder, fermiParadoxFilterLab, epidemicSirSimulator],
   i18n: {
     es: () => import('./i18n/es').then((m) => m.content),
     en: () => import('./i18n/en').then((m) => m.content),

package/src/entries.ts

@@ -22,6 +22,8 @@ export { dysonSphereEnergyCapture } from './tool/dyson-sphere-energy-capture/ent
 export { globalAlbedoSnowballSimulator } from './tool/global-albedo-snowball-simulator/entry';
 export { conwayLifeRuleLab } from './tool/conway-life-rule-lab/entry';
 export { crystalLatticeStructureFinder } from './tool/crystal-lattice-structure-finder/entry';
+export { fermiParadoxFilterLab } from './tool/fermi-paradox-filter-lab/entry';
+export { epidemicSirSimulator } from './tool/epidemic-sir-simulator/entry';
 export { scienceCategory } from './category';
 import { asteroidImpact } from './tool/asteroid-impact/entry';
 import { cellularRenewal } from './tool/cellular-renewal/entry';
@@ -46,4 +48,6 @@ import { dysonSphereEnergyCapture } from './tool/dyson-sphere-energy-capture/ent
 import { globalAlbedoSnowballSimulator } from './tool/global-albedo-snowball-simulator/entry';
 import { conwayLifeRuleLab } from './tool/conway-life-rule-lab/entry';
 import { crystalLatticeStructureFinder } from './tool/crystal-lattice-structure-finder/entry';
-export const ALL_ENTRIES = [asteroidImpact, cellularRenewal, colonyCounter, microwaveDetector, simulationProbability, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone, radioactiveDecay, naturalSelectionDrift, entropySecondLaw, doubleSlitDecoherence, phaseDiagramCriticalPoints, twinParadoxVisualizer, mandelbrotFractal, planetAtmosphereSurvival, threeBodyProblem, rocheLimitSatelliteDisruption, dysonSphereEnergyCapture, globalAlbedoSnowballSimulator, conwayLifeRuleLab, crystalLatticeStructureFinder];
+import { fermiParadoxFilterLab } from './tool/fermi-paradox-filter-lab/entry';
+import { epidemicSirSimulator } from './tool/epidemic-sir-simulator/entry';
+export const ALL_ENTRIES = [asteroidImpact, cellularRenewal, colonyCounter, microwaveDetector, simulationProbability, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone, radioactiveDecay, naturalSelectionDrift, entropySecondLaw, doubleSlitDecoherence, phaseDiagramCriticalPoints, twinParadoxVisualizer, mandelbrotFractal, planetAtmosphereSurvival, threeBodyProblem, rocheLimitSatelliteDisruption, dysonSphereEnergyCapture, globalAlbedoSnowballSimulator, conwayLifeRuleLab, crystalLatticeStructureFinder, fermiParadoxFilterLab, epidemicSirSimulator];

package/src/index.ts

@@ -23,6 +23,8 @@ export { DYSON_SPHERE_ENERGY_CAPTURE_TOOL } from './tool/dyson-sphere-energy-cap
 export { GLOBAL_ALBEDO_SNOWBALL_SIMULATOR_TOOL } from './tool/global-albedo-snowball-simulator/index';
 export { CONWAY_LIFE_RULE_LAB_TOOL } from './tool/conway-life-rule-lab/index';
 export { CRYSTAL_LATTICE_STRUCTURE_FINDER_TOOL } from './tool/crystal-lattice-structure-finder/index';
+export { FERMI_PARADOX_FILTER_LAB_TOOL } from './tool/fermi-paradox-filter-lab/index';
+export { EPIDEMIC_SIR_SIMULATOR_TOOL } from './tool/epidemic-sir-simulator/index';
 
 export type {
   KnownLocale,

package/src/tests/diacritics_density.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it, afterAll } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const failures: Map<string, string[]> = new Map();
+
+type LocaleWithDiacritics = keyof typeof DIACRITIC_RULES;
+
+const DIACRITIC_RULES = {
+  de: {
+    language: 'German',
+    expectedCharacters: 'ä ö ü ß',
+    characters: /[äöüÄÖÜß]/g,
+    minPerThousandLetters: 0.1,
+  },
+  es: {
+    language: 'Spanish',
+    expectedCharacters: 'á é í ó ú ü ñ',
+    characters: /[áéíóúüñÁÉÍÓÚÜÑ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  fr: {
+    language: 'French',
+    expectedCharacters: 'à â æ ç é è ê ë î ï ô œ ù û ü ÿ',
+    characters: /[àâæçéèêëîïôœùûüÿÀÂÆÇÉÈÊËÎÏÔŒÙÛÜŸ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  it: {
+    language: 'Italian',
+    expectedCharacters: 'à è é ì í î ò ó ù ú',
+    characters: /[àèéìíîòóùúÀÈÉÌÍÎÒÓÙÚ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  pl: {
+    language: 'Polish',
+    expectedCharacters: 'ą ć ę ł ń ó ś ź ż',
+    characters: /[ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  pt: {
+    language: 'Portuguese',
+    expectedCharacters: 'á â ã à ç é ê í ó ô õ ú ü',
+    characters: /[áâãàçéêíóôõúüÁÂÃÀÇÉÊÍÓÔÕÚÜ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  sv: {
+    language: 'Swedish',
+    expectedCharacters: 'å ä ö',
+    characters: /[åäöÅÄÖ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  tr: {
+    language: 'Turkish',
+    expectedCharacters: 'ç ğ ı İ ö ş ü',
+    characters: /[çğıöşüÇĞİÖŞÜ]/g,
+    minPerThousandLetters: 0.1,
+  },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function normalizeText(value: unknown): string {
+  return collectStrings(value).join(' ').normalize('NFC');
+}
+
+function translatableContent(content: Record<string, unknown>) {
+  return TRANSLATABLE_KEYS.map((key) => content[key]);
+}
+
+function letterCount(text: string): number {
+  return text.match(LETTERS)?.length ?? 0;
+}
+
+function diacriticCount(text: string, locale: LocaleWithDiacritics): number {
+  return text.match(DIACRITIC_RULES[locale].characters)?.length ?? 0;
+}
+
+function diacriticsPerThousandLetters(text: string, locale: LocaleWithDiacritics): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return diacriticCount(text, locale) / letters * 1000;
+}
+
+describe('Diacritics density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(DIACRITIC_RULES).forEach((locale) => {
+        it(`${locale} keeps the expected accent and special-letter set`, async () => {
+          const typedLocale = locale as LocaleWithDiacritics;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const rule = DIACRITIC_RULES[typedLocale];
+          const letters = letterCount(text);
+          const matches = diacriticCount(text, typedLocale);
+          const density = diacriticsPerThousandLetters(text, typedLocale);
+
+          expect(
+            density,
+            [
+              `Possible spelling or encoding issue detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} special characters (${density.toFixed(2)} per 1000 letters, ${letters} letters analyzed).`,
+              `This locale should include some of these characters: ${rule.expectedCharacters}.`,
+              'If the count is 0 or near 0, accents, tildes, or special letters were probably stripped by encoding or normalization.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minPerThousandLetters);
+
+          if (density < rule.minPerThousandLetters) {
+            const existing = failures.get(tool.entry.id) ?? [];
+            existing.push(typedLocale);
+            failures.set(tool.entry.id, existing);
+          }
+        });
+      });
+    });
+  });
+});
+
+afterAll(() => {
+  if (failures.size > 0) {
+    const sorted = [...failures.entries()].sort(([a], [b]) => a.localeCompare(b));
+    console.log('\n=== DIACRITICS DENSITY FAILURES (grouped by tool) ===');
+    let total = 0;
+    for (const [tool, locales] of sorted) {
+      locales.sort();
+      console.log(`  ${tool}: ${locales.join(', ')}`);
+      total += locales.length;
+    }
+    console.log(`  Total: ${total} failures across ${failures.size} tools\n`);
+  }
+});

package/src/tests/inverted_punctuation.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const INVERTED_PUNCTUATION_LOCALES = {
+  es: {
+    language: 'Spanish',
+    questionStart: '¿',
+    questionEnd: '?',
+    exclamationStart: '¡',
+    exclamationEnd: '!',
+  },
+} as const;
+
+type InvertedPunctuationLocale = keyof typeof INVERTED_PUNCTUATION_LOCALES;
+
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function translatableStrings(content: Record<string, unknown>): string[] {
+  return TRANSLATABLE_KEYS.flatMap((key) => collectStrings(content[key]));
+}
+
+function sentenceStart(text: string, endIndex: number): string {
+  const beforeMark = text.slice(0, endIndex).trimEnd();
+  const boundary = Math.max(
+    beforeMark.lastIndexOf('.'),
+    beforeMark.lastIndexOf(':'),
+    beforeMark.lastIndexOf(';'),
+    beforeMark.lastIndexOf('\n'),
+  );
+
+  return beforeMark.slice(boundary + 1).trimStart();
+}
+
+function findMissingInvertedMarks(
+  text: string,
+  startMark: string,
+  endMark: string,
+): string[] {
+  return [...text.matchAll(new RegExp(`\\${endMark}`, 'g'))]
+    .map((match) => sentenceStart(text, match.index ?? 0))
+    .filter((segment) => segment.length > 0 && !segment.includes(startMark))
+    .map((segment) => `${segment}${endMark}`);
+}
+
+describe('Inverted punctuation validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(INVERTED_PUNCTUATION_LOCALES).forEach((locale) => {
+        it(`${locale} uses opening punctuation marks for questions and exclamations`, async () => {
+          const typedLocale = locale as InvertedPunctuationLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const rule = INVERTED_PUNCTUATION_LOCALES[typedLocale];
+          const content = await loader();
+          const strings = translatableStrings(content as Record<string, unknown>);
+          const missingQuestions = strings.flatMap((text) =>
+            findMissingInvertedMarks(text, rule.questionStart, rule.questionEnd)
+          );
+          const missingExclamations = strings.flatMap((text) =>
+            findMissingInvertedMarks(text, rule.exclamationStart, rule.exclamationEnd)
+          );
+          const failures = [...missingQuestions, ...missingExclamations];
+
+          expect(
+            failures,
+            [
+              `Missing opening punctuation marks in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `Questions must use ${rule.questionStart}...${rule.questionEnd} and exclamations must use ${rule.exclamationStart}...${rule.exclamationEnd}.`,
+              `Examples: ${failures.slice(0, 5).join(' | ')}`,
+            ].join(' '),
+          ).toHaveLength(0);
+        });
+      });
+    });
+  });
+});

package/src/tests/locale_completeness.test.ts

@@ -18,7 +18,7 @@ describe('Locale Completeness Validation', () => {
     });
   });
 
-    it('all 23 tools registered', () => {
-      expect(ALL_TOOLS.length).toBe(23);
+    it('all 25 tools registered', () => {
+      expect(ALL_TOOLS.length).toBe(25);
   });
 });

package/src/tests/script_density.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+type ScriptLocale = keyof typeof SCRIPT_RULES;
+
+const SCRIPT_RULES = {
+  ja: {
+    language: 'Japanese',
+    scriptName: 'kana/kanji',
+    scriptCharacters: /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/gu,
+    minScriptRatio: 0.45,
+  },
+  ko: {
+    language: 'Korean',
+    scriptName: 'hangul',
+    scriptCharacters: /\p{Script=Hangul}/gu,
+    minScriptRatio: 0.55,
+  },
+  ru: {
+    language: 'Russian',
+    scriptName: 'cyrillic',
+    scriptCharacters: /\p{Script=Cyrillic}/gu,
+    minScriptRatio: 0.65,
+  },
+  zh: {
+    language: 'Chinese',
+    scriptName: 'han',
+    scriptCharacters: /\p{Script=Han}/gu,
+    minScriptRatio: 0.45,
+  },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function normalizeText(value: unknown): string {
+  return collectStrings(value).join(' ').normalize('NFC');
+}
+
+function translatableContent(content: Record<string, unknown>) {
+  return TRANSLATABLE_KEYS.map((key) => content[key]);
+}
+
+function letterCount(text: string): number {
+  return text.match(LETTERS)?.length ?? 0;
+}
+
+function scriptCount(text: string, locale: ScriptLocale): number {
+  return text.match(SCRIPT_RULES[locale].scriptCharacters)?.length ?? 0;
+}
+
+function scriptRatio(text: string, locale: ScriptLocale): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return scriptCount(text, locale) / letters;
+}
+
+describe('Native script density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(SCRIPT_RULES).forEach((locale) => {
+        it(`${locale} keeps most translated text in its native script`, async () => {
+          const typedLocale = locale as ScriptLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const rule = SCRIPT_RULES[typedLocale];
+          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const letters = letterCount(text);
+          const matches = scriptCount(text, typedLocale);
+          const ratio = scriptRatio(text, typedLocale);
+
+          expect(
+            ratio,
+            [
+              `Possible broken translation detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} ${rule.scriptName} characters out of ${letters} analyzed letters (${(ratio * 100).toFixed(1)}%).`,
+              `Most translatable content should be written in ${rule.scriptName} script.`,
+              'Non-translatable fields such as slug, bibliography, and schemas are ignored to avoid false positives.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minScriptRatio);
+        });
+      });
+    });
+  });
+});

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { scienceCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 23 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(23);
+    it('should have 25 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(25);
     });
 
     it('scienceCategory should be defined', () => {
@@ -14,4 +14,3 @@ describe('Tool Validation Suite', () => {
     });
   });
 });
-

package/src/tool/conway-life-rule-lab/i18n/de.ts

@@ -1,11 +1,52 @@
-import { content as enContent } from './en';
+import { bibliography } from '../bibliography';
 import type { ToolLocaleContent } from '../../../types';
 
+const slug = 'conway-spiel-des-lebens-regellabor';
+const title = 'Conway Spiel des Lebens Regellabor';
+const description = 'Spiele, bearbeite und vergleiche Conway-artige zelluläre Automaten mit B/S-Regeln, Mustersaaten, Live-Metriken und responsivem Simulationsfeld.';
+
+const howTo = [
+  {
+    name: 'Feld besäen',
+    text: 'Wähle ein Muster wie einen Gleiter, Pulsar oder Gosper-Kanone, platziere es auf dem Gitter oder erzeuge eine zufällige Population.',
+  },
+  {
+    name: 'Simulation starten',
+    text: 'Nutze Start, Pause, Schritt und Tempo-Steuerung, um Geburten, Tode, Dichte und Stabilität über Zeit zu beobachten.',
+  },
+  {
+    name: 'Regel ändern',
+    text: 'Wechsle Voreinstellungen oder gib eine B/S-Regel wie B3/S23, B36/S23 oder B3678/S34678 ein, um verschiedene Automaten zu vergleichen.',
+  },
+];
+
+const faq = [
+  {
+    question: 'Was ist B/S-Notation im Spiel des Lebens?',
+    answer: 'Die B/S-Notation listet die Nachbarzahlen, die eine neue lebende Zelle erzeugen, und die Zahlen, die eine bestehende lebende Zelle überleben lassen. Conways Spiel des Lebens ist B3/S23: tote Zellen werden mit genau drei Nachbarn geboren, lebende Zellen überleben mit zwei oder drei Nachbarn.',
+  },
+  {
+    question: 'Warum heißt dieses Werkzeug Regellabor statt nur Simulator?',
+    answer: 'Die klassische Conway-Regel ist enthalten, aber der Simulator ist dafür gebaut, Familien von Life-artigen zellulären Automaten zu vergleichen. Das Bearbeiten der Geburts- und Überlebenszahlen ändert das Langzeitverhalten und erzeugt Replikatoren, Wellen, Inselgruppen oder unkontrolliertes Wachstum.',
+  },
+  {
+    question: 'Was bedeutet Stabilität im Simulator?',
+    answer: 'Stabilität schätzt, wie stark sich die Kolonie in der letzten Generation verändert hat. Hohe Stabilität bedeutet wenige Geburten und Tode relativ zur Population; niedrige Stabilität bedeutet turbulentes oder schnell reorganisierendes Feld.',
+  },
+  {
+    question: 'Hat das Feld Ränder?',
+    answer: 'Die Simulation verwendet toroidales Wickeln: der linke Rand verbindet sich mit dem rechten, und oben verbindet sich mit unten. So bewegen sich Muster natürlich weiter, ohne an harten Grenzen zu verschwinden.',
+  },
+  {
+    question: 'Kann ich ein eigenes Startmuster zeichnen?',
+    answer: 'Ja. Pausiere die Simulation und klicke oder tippe auf Zellen, um sie umzuschalten. Du kannst handgezeichnete Zellen mit eingebauten Mustern kombinieren und das Ergebnis dann unter beliebiger Regelvoreinstellung ausführen.',
+  },
+];
+
 export const content: ToolLocaleContent = {
-  ...enContent,
-  slug: 'conway-spiel-des-lebens-regellabor',
-  title: 'Conway Spiel des Lebens Regellabor',
-  description: 'Spiele, bearbeite und vergleiche Conway-artige zelluläre Automaten mit B/S-Regeln, Mustersaaten, Live-Metriken und responsivem Simulationsfeld.',
+  slug,
+  title,
+  description,
   ui: {
     boardLabel: 'Feld für Life-artige zelluläre Automaten',
     play: 'Start',
@@ -47,4 +88,20 @@ export const content: ToolLocaleContent = {
     statusChaotic: 'volatil',
     invalidRule: 'Verwende B/S-Notation wie B3/S23.',
   },
+  seo: [
+    { type: 'title', text: 'Conway Spiel des Lebens Simulator mit bearbeitbaren Regeln', level: 2 },
+    { type: 'paragraph', html: 'Dieses Regellabor lässt dich den klassischen zellulären Automaten ausführen und seine Regeln gezielt verändern und vergleichen. Das Feld unterstützt direktes Zeichnen, Musterpositionen, Zufallssaaten, schrittweise Inspektion, variables Tempo und Live-Messungen für Population, Dichte, Geburten, Tode und Stabilität.' },
+    { type: 'title', text: 'Wie B/S-Regeln das Spiel verändern', level: 3 },
+    { type: 'paragraph', html: 'Life-artige zelluläre Automaten werden oft in <strong>B/S-Notation</strong> geschrieben. Die B-Seite definiert, wie viele lebende Nachbarn eine tote Zelle braucht, um zu entstehen; die S-Seite definiert, wie viele Nachbarn eine lebende Zelle zum Überleben braucht. Conways ursprüngliche Regel <strong>B3/S23</strong> ist berühmt, weil sie in einem schmalen Bereich zwischen Aussterben und unkontrolliertem Wachstum liegt.' },
+    { type: 'title', text: 'Live-Metriken lesen', level: 3 },
+    { type: 'paragraph', html: 'Population und Dichte zeigen, wie viele Zellen am Leben sind, aber sie erzählen nicht die ganze Geschichte. Geburten und Tode zeigen das aktuelle Aktivitätsniveau, während Stabilität abschätzt, ob die Kolonie sich in einen Oszillator einpendelt, in Stilleben einfriert oder turbulent bleibt.' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [
+    { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'EducationalApplication', operatingSystem: 'Any' },
+    { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+    { '@context': 'https://schema.org', '@type': 'HowTo', name: title, step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })) },
+  ],
 };

package/src/tool/conway-life-rule-lab/i18n/es.ts

@@ -1,11 +1,52 @@
-import { content as enContent } from './en';
+import { bibliography } from '../bibliography';
 import type { ToolLocaleContent } from '../../../types';
 
+const slug = 'laboratorio-reglas-juego-vida-conway';
+const title = 'Laboratorio de Reglas del Juego de la Vida de Conway';
+const description = 'Juega, edita y compara autómatas celulares tipo Conway con reglas B/S, semillas de patrones, métricas en vivo y un tablero de simulación adaptable.';
+
+const howTo = [
+  {
+    name: 'Sembrar el tablero',
+    text: 'Elige un patrón como un planeador, pulsar o cañón de Gosper, colócalo en la cuadrícula o aleatoriza una población inicial.',
+  },
+  {
+    name: 'Ejecutar la simulación',
+    text: 'Usa los controles de reproducción, pausa, paso y velocidad para observar cómo evolucionan los nacimientos, muertes, densidad y estabilidad.',
+  },
+  {
+    name: 'Cambiar la regla',
+    text: 'Cambia entre preajustes o escribe una regla B/S como B3/S23, B36/S23 o B3678/S34678 para comparar diferentes autómatas.',
+  },
+];
+
+const faq = [
+  {
+    question: '¿Qué es la notación B/S en el Juego de la Vida?',
+    answer: 'La notación B/S lista los conteos de vecinos que crean una nueva célula viva y los conteos que permiten a una célula viva existente sobrevivir. El Juego de la Vida de Conway es B3/S23: las células muertas nacen con exactamente tres vecinos, y las células vivas sobreviven con dos o tres vecinos.',
+  },
+  {
+    question: '¿Por qué se llama laboratorio de reglas en lugar de solo simulador?',
+    answer: 'La regla clásica de Conway está incluida, pero el simulador está diseñado para comparar familias de autómatas celulares tipo Life. Editar los conteos de nacimiento y supervivencia cambia el comportamiento a largo plazo, produciendo replicadores, ondas, islas congeladas, crecimiento caótico o extinción.',
+  },
+  {
+    question: '¿Qué significa estabilidad en el simulador?',
+    answer: 'La estabilidad estima cuánto cambió la colonia durante la última generación. Alta estabilidad significa pocas células nacidas o muertas relativas a la población; baja estabilidad significa que el tablero es turbulento o se reorganiza rápidamente.',
+  },
+  {
+    question: '¿El tablero tiene bordes?',
+    answer: 'La simulación usa envoltura toroidal, por lo que el borde izquierdo se conecta con el derecho y la parte superior con la inferior. Esto mantiene los patrones moviéndose naturalmente sin desaparecer en bordes duros.',
+  },
+  {
+    question: '¿Puedo dibujar mi propio patrón inicial?',
+    answer: 'Sí. Pausa la simulación y haz clic o toca las células del tablero para activarlas o desactivarlas. Puedes combinar células dibujadas a mano con patrones integrados y ejecutar el resultado bajo cualquier preajuste de regla.',
+  },
+];
+
 export const content: ToolLocaleContent = {
-  ...enContent,
-  slug: 'laboratorio-reglas-juego-vida-conway',
-  title: 'Laboratorio de Reglas del Juego de la Vida de Conway',
-  description: 'Juega, edita y compara autómatas celulares tipo Conway con reglas B/S, semillas de patrones, métricas en vivo y un tablero de simulación adaptable.',
+  slug,
+  title,
+  description,
   ui: {
     boardLabel: 'Tablero de autómatas celulares tipo Life',
     play: 'Reproducir',
@@ -47,4 +88,20 @@ export const content: ToolLocaleContent = {
     statusChaotic: 'volátil',
     invalidRule: 'Usa notación B/S como B3/S23.',
   },
+  seo: [
+    { type: 'title', text: 'Simulador del Juego de la Vida de Conway con reglas editables', level: 2 },
+    { type: 'paragraph', html: 'Este laboratorio de reglas del Juego de la Vida de Conway te permite ejecutar el autómata celular clásico y luego cambiar y comparar sus reglas. El tablero admite dibujo directo, colocación de patrones, semillas aleatorias, inspección paso a paso, tempo variable y mediciones en vivo de población, densidad, nacimientos, muertes y estabilidad.' },
+    { type: 'title', text: 'Cómo las reglas B/S cambian el juego', level: 3 },
+    { type: 'paragraph', html: 'Los autómatas celulares tipo Life se escriben a menudo en <strong>notación B/S</strong>. El lado B define cuántos vecinos vivos necesita una célula muerta para nacer; el lado S define cuántos vecinos necesita una célula viva para sobrevivir. La regla original de Conway, <strong>B3/S23</strong>, es famosa porque se sitúa en una región estrecha entre la extinción y el crecimiento descontrolado.' },
+    { type: 'title', text: 'Leer las métricas en vivo', level: 3 },
+    { type: 'paragraph', html: 'La población y la densidad muestran cuántas células están vivas, pero no cuentan la historia completa. Los nacimientos y las muertes exponen el nivel de actividad actual, mientras que la estabilidad estima si la colonia está asentándose en un oscilador, congelándose en figuras estáticas o permaneciendo turbulenta.' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [
+    { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'EducationalApplication', operatingSystem: 'Any' },
+    { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+    { '@context': 'https://schema.org', '@type': 'HowTo', name: title, step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })) },
+  ],
 };

package/src/tool/conway-life-rule-lab/i18n/fr.ts

@@ -1,11 +1,52 @@
-import { content as enContent } from './en';
+import { bibliography } from '../bibliography';
 import type { ToolLocaleContent } from '../../../types';
 
+const slug = 'laboratoire-regles-jeu-vie-conway';
+const title = 'Laboratoire de règles du Jeu de la Vie de Conway';
+const description = 'Jouez, modifiez et comparez des automates cellulaires de type Conway avec règles B/S, motifs de départ, métriques en direct et grille responsive.';
+
+const howTo = [
+  {
+    name: 'Ensemencer le plateau',
+    text: 'Choisissez un motif comme un planeur, un pulsar ou le canon de Gosper, placez-le sur la grille ou générez une population aléatoire.',
+  },
+  {
+    name: 'Lancer la simulation',
+    text: 'Utilisez les contrôles de lecture, pause, pas et tempo pour observer l\'évolution des naissances, morts, densité et stabilité.',
+  },
+  {
+    name: 'Changer la règle',
+    text: 'Changez les préréglages ou tapez une règle B/S comme B3/S23, B36/S23 ou B3678/S34678 pour comparer différents automates.',
+  },
+];
+
+const faq = [
+  {
+    question: 'Qu\'est-ce que la notation B/S dans le Jeu de la Vie ?',
+    answer: 'La notation B/S liste les nombres de voisins qui creent une nouvelle cellule vivante et les nombres qui permettent a une cellule vivante existante de survivre. Le Jeu de la Vie de Conway est B3/S23: les cellules mortes naissent avec exactement trois voisins, et les cellules vivantes survivent avec deux ou trois voisins.',
+  },
+  {
+    question: 'Pourquoi cet outil s\'appelle laboratoire de règles plutôt que simulateur ?',
+    answer: 'La règle classique de Conway est incluse, mais le simulateur est conçu pour comparer des familles d\'automates cellulaires de type Life. Modifier les comptes de naissance et de survie change le comportement à long terme, produisant des réplicateurs, des vagues, des îles gelées, une croissance chaotique ou l\'extinction.',
+  },
+  {
+    question: 'Que signifie la stabilité dans le simulateur ?',
+    answer: 'La stabilité estime combien la colonie a changé lors de la dernière génération. Une stabilité élevée signifie peu de cellules nées ou mortes par rapport à la population ; une faible stabilité signifie que le plateau est turbulent ou se réorganise rapidement.',
+  },
+  {
+    question: 'Le plateau a-t-il des bords ?',
+    answer: 'La simulation utilise un enroulement toroidal: le bord gauche se connecte au bord droit et le haut se connecte au bas. Cela maintient les motifs se deplacant naturellement sans disparaitre aux bords.',
+  },
+  {
+    question: 'Puis-je dessiner mon propre motif de départ ?',
+    answer: 'Oui. Mettez la simulation en pause et cliquez ou tapez sur les cellules du plateau pour les basculer. Vous pouvez combiner des cellules dessinées à la main avec des motifs intégrés et lancer le résultat sous n\'importe quel préréglage de règle.',
+  },
+];
+
 export const content: ToolLocaleContent = {
-  ...enContent,
-  slug: 'laboratoire-regles-jeu-vie-conway',
-  title: 'Laboratoire de règles du Jeu de la Vie de Conway',
-  description: 'Jouez, modifiez et comparez des automates cellulaires de type Conway avec règles B/S, motifs de départ, métriques en direct et grille responsive.',
+  slug,
+  title,
+  description,
   ui: {
     boardLabel: 'Grille d\'automates cellulaires de type Life',
     play: 'Lire',
@@ -47,4 +88,20 @@ export const content: ToolLocaleContent = {
     statusChaotic: 'volatile',
     invalidRule: 'Utilisez une notation B/S comme B3/S23.',
   },
+  seo: [
+    { type: 'title', text: 'Simulateur du Jeu de la Vie de Conway avec règles modifiables', level: 2 },
+    { type: 'paragraph', html: 'Ce laboratoire de règles vous permet d\'exécuter l\'automate cellulaire classique et de modifier et comparer ses règles. Le plateau prend en charge le dessin direct, le placement de motifs, les graines aléatoires, l\'inspection pas à pas, le tempo variable et les mesures en direct pour la population, la densité, les naissances, les morts et la stabilité.' },
+    { type: 'title', text: 'Comment les règles B/S changent le jeu', level: 3 },
+    { type: 'paragraph', html: 'Les automates cellulaires de type Life sont souvent écrits en <strong>notation B/S</strong>. Le côté B définit combien de voisins vivants une cellule morte a besoin pour naître ; le côté S définit combien de voisins une cellule vivante a besoin pour survivre. La règle originale de Conway, <strong>B3/S23</strong>, est célèbre car elle se situe dans une région étroite entre extinction et croissance incontrôlée.' },
+    { type: 'title', text: 'Lire les métriques en direct', level: 3 },
+    { type: 'paragraph', html: 'La population et la densité montrent combien de cellules sont vivantes, mais elles ne racontent pas toute l\'histoire. Les naissances et les morts exposent le niveau d\'activité actuel, tandis que la stabilité estime si la colonie se stabilise dans un oscillateur, se fige dans des structures statiques ou reste turbulente.' },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [
+    { '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: title, description, applicationCategory: 'EducationalApplication', operatingSystem: 'Any' },
+    { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })) },
+    { '@context': 'https://schema.org', '@type': 'HowTo', name: title, step: howTo.map((step) => ({ '@type': 'HowToStep', name: step.name, text: step.text })) },
+  ],
 };