@jjlmoya/utils-science 1.25.0 → 1.27.0

package/package.json

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

package/src/category/index.ts

@@ -8,10 +8,12 @@ import { cosmicInflation } from '../tool/cosmic-inflation/index';
 import { temperatureTimeline } from '../tool/temperature-timeline/index';
 import { lorenzAttractor } from '../tool/lorenz-attractor/index';
 import { stellarHabitabilityZone } from '../tool/stellar-habitability-zone/index';
+import { radioactiveDecay } from '../tool/radioactive-decay/index';
+import { naturalSelectionDrift } from '../tool/natural-selection-drift/index';
 
 export const scienceCategory: ScienceCategoryEntry = {
   icon: 'mdi:flask',
-  tools: [colonyCounter, asteroidImpact, microwaveDetector, simulationProbability, cellularRenewal, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone],
+  tools: [colonyCounter, asteroidImpact, microwaveDetector, simulationProbability, cellularRenewal, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone, radioactiveDecay, naturalSelectionDrift],
   i18n: {
     es: () => import('./i18n/es').then((m) => m.content),
     en: () => import('./i18n/en').then((m) => m.content),

package/src/entries.ts

@@ -8,6 +8,8 @@ export { cosmicInflation } from './tool/cosmic-inflation/entry';
 export { temperatureTimeline } from './tool/temperature-timeline/entry';
 export { lorenzAttractor } from './tool/lorenz-attractor/entry';
 export { stellarHabitabilityZone } from './tool/stellar-habitability-zone/entry';
+export { radioactiveDecay } from './tool/radioactive-decay/entry';
+export { naturalSelectionDrift } from './tool/natural-selection-drift/entry';
 export { scienceCategory } from './category';
 import { asteroidImpact } from './tool/asteroid-impact/entry';
 import { cellularRenewal } from './tool/cellular-renewal/entry';
@@ -18,4 +20,6 @@ import { cosmicInflation } from './tool/cosmic-inflation/entry';
 import { temperatureTimeline } from './tool/temperature-timeline/entry';
 import { lorenzAttractor } from './tool/lorenz-attractor/entry';
 import { stellarHabitabilityZone } from './tool/stellar-habitability-zone/entry';
-export const ALL_ENTRIES = [asteroidImpact, cellularRenewal, colonyCounter, microwaveDetector, simulationProbability, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone];
+import { radioactiveDecay } from './tool/radioactive-decay/entry';
+import { naturalSelectionDrift } from './tool/natural-selection-drift/entry';
+export const ALL_ENTRIES = [asteroidImpact, cellularRenewal, colonyCounter, microwaveDetector, simulationProbability, cosmicInflation, temperatureTimeline, lorenzAttractor, stellarHabitabilityZone, radioactiveDecay, naturalSelectionDrift];

package/src/index.ts

@@ -9,6 +9,8 @@ export { COSMIC_INFLATION_TOOL } from './tool/cosmic-inflation/index';
 export { TEMPERATURE_TIMELINE_TOOL } from './tool/temperature-timeline/index';
 export { LORENZ_ATTRACTOR_TOOL } from './tool/lorenz-attractor/index';
 export { STELLAR_HABITABILITY_ZONE_TOOL } from './tool/stellar-habitability-zone/index';
+export { RADIOACTIVE_DECAY_TOOL } from './tool/radioactive-decay/index';
+export { NATURAL_SELECTION_DRIFT_TOOL } from './tool/natural-selection-drift/index';
 
 export type {
   KnownLocale,
@@ -25,4 +27,3 @@ export type {
 } from './types';
 
 export { ALL_ENTRIES, ALL_TOOLS } from './tools';
-

package/src/tests/locale_completeness.test.ts

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

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 9 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(9);
+    it('should have 11 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(11);
     });
 
     it('scienceCategory should be defined', () => {

package/src/tool/natural-selection-drift/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { naturalSelectionDrift } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await naturalSelectionDrift.i18n[locale]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/natural-selection-drift/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Darwin, C. (1859). On the Origin of Species.',
+    url: 'https://www.gutenberg.org/ebooks/1228',
+  },
+  {
+    name: 'Futuyma, D. J. (2017). Evolution.',
+    url: 'https://www.scirp.org/reference/referencespapers?referenceid=2347977',
+  },
+  {
+    name: 'Nature Education - Genetic drift',
+    url: 'https://www.nature.com/scitable/definition/genetic-drift-201/',
+  },
+];

package/src/tool/natural-selection-drift/component.astro

@@ -0,0 +1,104 @@
+---
+import "./natural-selection-drift.css";
+
+interface Props {
+  ui: Record<string, string>;
+}
+
+const { ui } = Astro.props;
+---
+
+<div class="ns-app">
+  <section class="ns-card">
+    <canvas id="simulation-canvas" class="ns-canvas"></canvas>
+    <div class="ns-canvas-badge" id="alive-badge">0 {ui.aliveLabel}</div>
+    <header class="ns-top-hud">
+      <div class="ns-top-hud-item">
+        <span>{ui.dominantTrait}</span>
+        <strong id="dominant-trait">{ui.alleleDefault}</strong>
+      </div>
+      <div class="ns-top-hud-item">
+        <span>{ui.diversity}</span>
+        <strong id="diversity-score">0%</strong>
+      </div>
+    </header>
+
+    <section class="ns-alleles" id="allele-ranking" aria-label={ui.alleleCountsLabel}></section>
+
+    <aside class="ns-console" aria-label="Simulation controls">
+      <div class="ns-console-header">
+        <span class="ns-console-kicker">{ui.evolutionConsole}</span>
+        <h3>{ui.title}</h3>
+      </div>
+
+      <div class="ns-slider-row">
+        <label for="population"><span>{ui.population}</span><span id="population-value" class="ns-slider-value">120</span></label>
+        <input id="population" type="range" min="20" max="500" value="120" />
+      </div>
+      <div class="ns-slider-row">
+        <label for="generations"><span>{ui.generations}</span><span id="generations-value" class="ns-slider-value">60</span></label>
+        <input id="generations" type="range" min="10" max="200" value="60" />
+      </div>
+      <div class="ns-slider-row">
+        <label for="mutation"><span>{ui.mutationRate}</span><span id="mutation-value" class="ns-slider-value">12%</span></label>
+        <input id="mutation" type="range" min="0" max="100" value="12" />
+      </div>
+      <div class="ns-slider-row">
+        <label for="pressure"><span>{ui.selectionPressure}</span><span id="pressure-value" class="ns-slider-value">55%</span></label>
+        <input id="pressure" type="range" min="0" max="100" value="55" />
+      </div>
+      <div class="ns-slider-row">
+        <label for="drift"><span>{ui.driftIntensity}</span><span id="drift-value" class="ns-slider-value">28%</span></label>
+        <input id="drift" type="range" min="0" max="100" value="28" />
+      </div>
+      <div class="ns-slider-row">
+        <label for="alleles"><span>{ui.alleleCount}</span><span id="alleles-value" class="ns-slider-value">3</span></label>
+        <input id="alleles" type="range" min="2" max="8" value="3" />
+      </div>
+      <div class="ns-slider-row">
+        <label for="innovation"><span>{ui.innovationRate}</span><span id="innovation-value" class="ns-slider-value">2%</span></label>
+        <input id="innovation" type="range" min="0" max="20" value="2" />
+      </div>
+    </aside>
+
+    <footer class="ns-hud">
+      <div class="ns-hud-item">
+        <span>{ui.fitness}</span>
+        <strong id="fitness-score">0%</strong>
+      </div>
+      <div class="ns-hud-item">
+        <span>{ui.populationLabel}</span>
+        <strong id="population-score">0</strong>
+      </div>
+    </footer>
+  </section>
+</div>
+
+<script type="module" define:vars={{ ui }}>
+  import { createNaturalSelectionRuntime } from '/src/tool/natural-selection-drift/runtime';
+
+  createNaturalSelectionRuntime({
+    populationInput: document.getElementById('population'),
+    generationsInput: document.getElementById('generations'),
+    mutationInput: document.getElementById('mutation'),
+    pressureInput: document.getElementById('pressure'),
+    driftInput: document.getElementById('drift'),
+    allelesInput: document.getElementById('alleles'),
+    innovationInput: document.getElementById('innovation'),
+    populationValue: document.getElementById('population-value'),
+    generationsValue: document.getElementById('generations-value'),
+    mutationValue: document.getElementById('mutation-value'),
+    pressureValue: document.getElementById('pressure-value'),
+    driftValue: document.getElementById('drift-value'),
+    allelesValue: document.getElementById('alleles-value'),
+    innovationValue: document.getElementById('innovation-value'),
+    canvas: document.getElementById('simulation-canvas'),
+    aliveBadge: document.getElementById('alive-badge'),
+    dominantTrait: document.getElementById('dominant-trait'),
+    fitnessScore: document.getElementById('fitness-score'),
+    diversityScore: document.getElementById('diversity-score'),
+    populationScore: document.getElementById('population-score'),
+    alleleRanking: document.getElementById('allele-ranking'),
+    ui: { ...ui },
+  });
+</script>

package/src/tool/natural-selection-drift/entry.ts

@@ -0,0 +1,29 @@
+import type { ScienceToolEntry, ToolLocaleContent } from '../../types';
+
+export interface NaturalSelectionUI {
+  [key: string]: string;
+}
+
+export type NaturalSelectionLocaleContent = ToolLocaleContent<NaturalSelectionUI>;
+
+export const naturalSelectionDrift: ScienceToolEntry<NaturalSelectionUI> = {
+  id: 'natural-selection-drift',
+  icons: { bg: 'mdi:alpha-n-box-outline', fg: 'mdi:leaf' },
+  i18n: {
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    de: () => import('./i18n/de').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/natural-selection-drift/i18n/de.ts

@@ -0,0 +1,65 @@
+import { bibliography } from '../bibliography';
+import type { NaturalSelectionLocaleContent } from '../entry';
+
+const slug = 'simulator-natuerliche-selektion-genetische-drift';
+const title = 'Simulator fur naturliche Selektion und genetische Drift';
+const description =
+  'Beobachte in Echtzeit, wie Selektionsdruck, Mutation, Drift und Fortpflanzung die Allelfrequenzen verandern.';
+
+const howTo = [
+  { name: 'Population festlegen', text: 'Wahle eine kleine oder große Population, um den Einfluss der Stichprobe zu sehen.' },
+  { name: 'Selektion und Drift einstellen', text: 'Erhohe den Selektionsdruck oder die Drift, um andere Evolutionsverlaufe zu sehen.' },
+  { name: 'Generationen beobachten', text: 'Starte die Simulation und vergleiche dominantes Merkmal, Fitness und Vielfalt uber die Zeit.' },
+  { name: 'Ergebnisse deuten', text: 'Nutze die Metriken, um zu verstehen, wann Anpassung gewinnt und wann Zufall dominiert.' },
+];
+
+const faq = [
+  { question: 'Was ist der Unterschied zwischen naturlicher Selektion und genetischer Drift?', answer: 'Naturliche Selektion ist nicht zufallig. Vorteilhafte Merkmale werden haufiger. Genetische Drift ist eine zufallige Veranderung der Allelfrequenzen, besonders stark in kleinen Populationen.' },
+  { question: 'Warum verandern sich kleine Populationen schneller?', answer: 'Bei wenigen Individuen hat Zufall einen großeren Einfluss auf die nachste Generation.' },
+  { question: 'Kann Drift Selektion ubertreffen?', answer: 'Ja. Ein vorteilhaftes Merkmal kann durch Zufall verschwinden, wenn die Drift stark genug ist.' },
+  { question: 'Was bedeutet Fitness in diesem Simulator?', answer: 'Fitness ist eine vereinfachte Kennzahl dafur, wie gut die Population an die Umgebung angepasst ist.' },
+  { question: 'Warum ist die Populationsgroße so wichtig?', answer: 'Sie bestimmt, wie stark Zufall die Allelfrequenzen beeinflusst.' },
+  { question: 'Wann sollte ich diesen Simulator benutzen?', answer: 'Wenn du die Intuition hinter Evolution verstehen willst, besonders den Unterschied zwischen Selektion und Drift.' },
+];
+
+export const content: NaturalSelectionLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    population: 'Populationsgroße',
+    generations: 'Generationen',
+    mutationRate: 'Mutationsrate',
+    selectionPressure: 'Selektionsdruck',
+    driftIntensity: 'Driftintensitat',
+    alleleCount: 'Startallele',
+    innovationRate: 'Innovationsrate',
+    run: 'Simulation starten',
+    dominantTrait: 'Dominantes Merkmal',
+    fitness: 'Endfitness',
+    diversity: 'Genetische Vielfalt',
+    evolutionConsole: 'Evolution-Konsole',
+    populationLabel: 'Population',
+    aliveLabel: 'lebend',
+    alleleCountsLabel: 'Allelzahlen',
+    alleleDefault: 'Allel 1',
+    populationValueLabel: 'Population',
+  },
+  seo: [
+    { type: 'title', text: 'Naturliche Selektion vs genetische Drift: Evolution mit einer lebenden Population verstehen', level: 2 },
+    { type: 'paragraph', html: 'Wenn du naturliche Selektion vs genetische Drift verstehen willst, liefert dir dieser Simulator die fehlende visuelle Ebene.' },
+    { type: 'title', text: 'Was die Regler bedeuten', level: 3 },
+    { type: 'paragraph', html: 'Naturliche Selektion erhoht die Haufigkeit vorteilhafter Merkmale. Genetische Drift verandert Allelfrequenzen zufallig.' },
+    { type: 'paragraph', html: 'Beide Krafte wirken gleichzeitig. In großen Populationen dominiert oft Selektion; in kleinen kann Zufall nutzliche Merkmale auslosen.' },
+    { type: 'title', text: 'Wie man die Ergebnisse liest', level: 3 },
+    { type: 'paragraph', html: 'Die Live-Metriken zeigen das dominante Allel, die genetische Vielfalt, die Endfitness und ob die Population wachst oder kollabiert.' },
+  ],
+  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/natural-selection-drift/i18n/en.ts

@@ -0,0 +1,180 @@
+import { bibliography } from '../bibliography';
+import type { NaturalSelectionLocaleContent } from '../entry';
+
+const slug = 'natural-selection-drift';
+const title = 'Natural Selection and Genetic Drift Simulator';
+const description = 'See how selection pressure, mutation, drift, and reproduction change allele frequencies over time with an interactive evolution simulator that explains why populations adapt, diversify, or collapse.';
+const howTo = [
+  {
+    name: 'Set the population',
+    text: 'Choose a small or large population to see how sample size changes evolutionary stability and how easily chance can dominate the outcome.',
+  },
+  {
+    name: 'Tune selection and drift',
+    text: 'Increase selection pressure to favor one trait, or raise drift intensity to make chance dominate the outcome when populations are small or fluctuating.',
+  },
+  {
+    name: 'Watch generations unfold',
+    text: 'Run the simulation and compare dominant traits, fitness, and diversity across time so you can see whether adaptation or randomness wins.',
+  },
+  {
+    name: 'Interpret the balance',
+    text: 'Use the final metrics to understand when adaptation wins, when random fluctuation takes over, and why the same starting point can lead to different outcomes.',
+  },
+];
+const faq = [
+  {
+    question: 'What is the difference between natural selection and genetic drift?',
+    answer: 'Natural selection is a non-random process where traits that improve survival or reproduction become more common. Genetic drift is random change in allele frequencies, and it is strongest in small populations.',
+  },
+  {
+    question: 'Why do small populations change faster?',
+    answer: 'With fewer individuals, random sampling has a larger effect. That means chance events can move trait frequencies more dramatically from one generation to the next.',
+  },
+  {
+    question: 'Can drift overpower selection?',
+    answer: 'Yes. If drift is strong enough, a beneficial trait may still disappear by chance, especially when the population is small or selection pressure is weak.',
+  },
+  {
+    question: 'What does fitness mean in this simulator?',
+    answer: 'Fitness is a simplified score representing how well the current population is adapted to the chosen environment. It is a teaching metric, not a laboratory measurement.',
+  },
+  {
+    question: 'Why does population size matter so much?',
+    answer: 'Population size determines how strongly random sampling affects allele frequencies. In large populations, selection is easier to see because random noise averages out. In small populations, chance can overpower a seemingly beneficial trait.',
+  },
+  {
+    question: 'When should I use this simulator instead of a textbook explanation?',
+    answer: 'Use it when you want to understand the intuition behind evolution, especially the difference between a directional force like selection and a stochastic force like drift. It is useful for students, teachers, and anyone trying to connect the concept to real population behavior.',
+  },
+];
+
+export const content: NaturalSelectionLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    population: 'Population size',
+    generations: 'Generations',
+    mutationRate: 'Mutation rate',
+    selectionPressure: 'Selection pressure',
+    driftIntensity: 'Drift intensity',
+    alleleCount: 'Initial alleles',
+    innovationRate: 'Innovation rate',
+    run: 'Run simulation',
+    dominantTrait: 'Dominant trait',
+    fitness: 'Final fitness',
+    diversity: 'Genetic diversity',
+    evolutionConsole: 'Evolution console',
+    populationLabel: 'Population',
+    aliveLabel: 'alive',
+    alleleCountsLabel: 'Allele counts',
+    alleleDefault: 'Allele 1',
+    populationValueLabel: 'Population',
+  },
+  seo: [
+    {
+      type: 'title',
+      text: 'Natural Selection vs Genetic Drift: Understand Evolution Through a Live Population Simulator',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'If you are trying to understand natural selection vs genetic drift, this simulator gives you the missing visual layer. Instead of reading a static definition, you can watch a population change in real time as selection pressure, mutation rate, drift intensity, and reproduction interact. That makes it much easier to connect the textbook idea of evolution with the actual behavior of alleles inside a living system.',
+    },
+    {
+      type: 'title',
+      text: 'What the Controls Mean and Why They Matter',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Natural selection is the non-random part of evolution. It increases the frequency of traits that improve survival or reproduction in a given environment. Genetic drift is the random part. It changes allele frequencies because not every individual contributes equally to the next generation, and those fluctuations become especially important when the population is small.',
+    },
+    {
+      type: 'paragraph',
+      html: 'The key idea is that both forces are always present. Selection tries to push the population in one direction, while drift can pull it somewhere else entirely. In a large population, selection usually has the stronger voice. In a small population, randomness can erase a useful trait, fix a neutral trait, or completely change the evolutionary outcome.',
+    },
+    {
+      type: 'title',
+      text: 'How to Read the Simulation Results',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'The live metrics help you read the system as it changes. Dominant trait tells you which allele currently leads. Genetic diversity shows how much variation is still present. Final fitness gives a quick summary of how well the population is adapted to the selected environment. Alive and population show whether the lineage is expanding or collapsing.',
+    },
+    {
+      type: 'title',
+      text: 'Why Population Size Changes the Story',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Selection pressure:</strong> How strongly the environment rewards one trait over another and how quickly that advantage can spread.',
+        '<strong>Drift intensity:</strong> How much random sampling noise changes the population each generation, even when no trait is objectively better.',
+        '<strong>Mutation rate:</strong> How often new variation enters the system and prevents the population from becoming completely static.',
+        '<strong>Allele count:</strong> How many explicit alleles are present at the start and how quickly new variants appear once innovation is enabled.',
+        '<strong>Genetic diversity:</strong> Why variation is the raw material of evolution and why losing it makes populations more vulnerable.',
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'The result is a fast, practical way to understand evolution without needing to guess how the abstract terms interact. If you want a simulator that explains natural selection, genetic drift, mutation, reproduction, and why the same starting conditions can end in different outcomes, this tool is built for that exact search intent.',
+    },
+    {
+      type: 'title',
+      text: 'Quick Examples of What to Try',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Goal', 'What to change', 'What you should see'],
+      rows: [
+        ['Show selection winning', 'Raise selection pressure and keep drift low', 'One allele should dominate over time and diversity should drop more slowly'],
+        ['Show randomness taking over', 'Lower population size and increase drift', 'Allele counts should swing unpredictably, even without a clear fitness advantage'],
+        ['Show mutation creating new variation', 'Increase mutation and innovation rate', 'New alleles should appear and the ranking should reshuffle more often'],
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'That combination of live visuals, explicit allele ranking, and real-time metrics makes the simulator useful both as a teaching tool and as a quick way to explain evolutionary tradeoffs without hand-waving.',
+    },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: title,
+      description: 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/natural-selection-drift/i18n/es.ts

@@ -0,0 +1,64 @@
+import { bibliography } from '../bibliography';
+import type { NaturalSelectionLocaleContent } from '../entry';
+
+const slug = 'simulador-seleccion-natural-deriva-genetica';
+const title = 'Simulador de Selección Natural y Deriva Genética';
+const description = 'Observa cómo la presión de selección, la mutación, la deriva y la reproducción cambian las frecuencias alélicas en tiempo real con un simulador evolutivo interactivo.';
+const howTo = [
+  { name: 'Ajusta la población', text: 'Elige una población pequeña o grande para ver cómo el tamaño muestral cambia la estabilidad evolutiva y cuánto puede dominar el azar.' },
+  { name: 'Regula selección y deriva', text: 'Sube la presión de selección para favorecer un rasgo o aumenta la deriva para que el azar domine cuando la población es pequeña o fluctúa.' },
+  { name: 'Observa las generaciones', text: 'Ejecuta la simulación y compara rasgos dominantes, aptitud y diversidad a lo largo del tiempo para ver si gana la adaptación o la aleatoriedad.' },
+  { name: 'Interpreta el balance', text: 'Usa las métricas finales para entender cuándo gana la adaptación, cuándo toma el control la fluctuación aleatoria y por qué un mismo inicio puede acabar distinto.' },
+];
+const faq = [
+  { question: '¿Cuál es la diferencia entre selección natural y deriva genética?', answer: 'La selección natural es un proceso no aleatorio en el que los rasgos que mejoran la supervivencia o la reproducción se vuelven más comunes. La deriva genética es un cambio aleatorio en las frecuencias alélicas y se nota más en poblaciones pequeñas.' },
+  { question: '¿Por qué las poblaciones pequeñas cambian más rápido?', answer: 'Con menos individuos, el muestreo aleatorio tiene un efecto mayor. Eso hace que los eventos fortuitos muevan las frecuencias de rasgos con mucha más intensidad de una generación a la siguiente.' },
+  { question: '¿Puede la deriva imponerse a la selección?', answer: 'Sí. Si la deriva es lo bastante fuerte, un rasgo beneficioso puede desaparecer por azar, sobre todo cuando la población es pequeña o la presión de selección es débil.' },
+  { question: '¿Qué significa fitness en este simulador?', answer: 'Fitness es una puntuación simplificada que representa lo bien adaptada que está la población al entorno elegido. Es una métrica didáctica, no una medida de laboratorio.' },
+  { question: '¿Por qué importa tanto el tamaño de la población?', answer: 'El tamaño de la población determina cuánto afectan las fluctuaciones aleatorias a las frecuencias alélicas. En poblaciones grandes, la selección se ve mejor porque el ruido se compensa. En poblaciones pequeñas, el azar puede superar a un rasgo aparentemente ventajoso.' },
+  { question: '¿Cuándo debería usar este simulador en vez de una explicación de libro?', answer: 'Úsalo cuando quieras entender la intuición detrás de la evolución, especialmente la diferencia entre una fuerza direccional como la selección y una fuerza estocástica como la deriva.' },
+];
+
+export const content: NaturalSelectionLocaleContent = {
+  slug, title, description,
+  ui: {
+    population: 'Tamaño de la población',
+    generations: 'Generaciones',
+    mutationRate: 'Tasa de mutación',
+    selectionPressure: 'Presión de selección',
+    driftIntensity: 'Intensidad de deriva',
+    alleleCount: 'Alelos iniciales',
+    innovationRate: 'Tasa de innovación',
+    run: 'Ejecutar simulación',
+    dominantTrait: 'Rasgo dominante',
+    fitness: 'Aptitud final',
+    diversity: 'Diversidad genética',
+    evolutionConsole: 'Consola evolutiva',
+    populationLabel: 'Población',
+    aliveLabel: 'vivos',
+    alleleCountsLabel: 'Conteo de alelos',
+    alleleDefault: 'Alelo 1',
+    populationValueLabel: 'Población',
+  },
+  seo: [
+    { type: 'title', text: 'Selección Natural vs Deriva Genética: entiende la evolución con una población viva', level: 2 },
+    { type: 'paragraph', html: 'Si quieres entender selección natural vs deriva genética, este simulador te da la capa visual que faltaba. En lugar de leer una definición estática, puedes ver cómo cambia una población en tiempo real mientras interactúan la presión de selección, la tasa de mutación, la intensidad de deriva y la reproducción.' },
+    { type: 'title', text: 'Qué significan los controles y por qué importan', level: 3 },
+    { type: 'paragraph', html: 'La selección natural es la parte no aleatoria de la evolución. Aumenta la frecuencia de los rasgos que mejoran la supervivencia o la reproducción. La deriva genética es la parte aleatoria. Cambia las frecuencias alélicas porque no todos los individuos contribuyen por igual a la siguiente generación.' },
+    { type: 'paragraph', html: 'La idea clave es que ambas fuerzas actúan a la vez. La selección intenta empujar a la población en una dirección; la deriva puede llevarla a otra completamente distinta. En poblaciones grandes, la selección suele dominar. En poblaciones pequeñas, el azar puede borrar un rasgo útil o fijar uno neutral.' },
+    { type: 'title', text: 'Cómo leer los resultados de la simulación', level: 3 },
+    { type: 'paragraph', html: 'Las métricas en vivo te ayudan a interpretar el sistema mientras cambia. El rasgo dominante indica qué alelo lidera. La diversidad genética muestra cuánta variación queda. La aptitud final resume qué tan adaptada está la población. Y los contadores de vivos y población muestran si la línea evolutiva crece o colapsa.' },
+    { type: 'title', text: 'Por qué el tamaño de la población cambia la historia', level: 3 },
+    { type: 'list', items: ['<strong>Presión de selección:</strong> cuánto recompensa el entorno un rasgo frente a otro y con qué rapidez se extiende esa ventaja.', '<strong>Intensidad de deriva:</strong> cuánta variación aleatoria afecta a la población en cada generación, incluso cuando ningún rasgo es objetivamente mejor.', '<strong>Tasa de mutación:</strong> con qué frecuencia entra nueva variación en el sistema.', '<strong>Número de alelos:</strong> cuántos alelos explícitos hay al inicio y cuántas variantes nuevas pueden aparecer.', '<strong>Diversidad genética:</strong> por qué la variación es la materia prima de la evolución.'] },
+    { type: 'paragraph', html: 'El resultado es una forma rápida y útil de entender la evolución sin depender sólo de definiciones abstractas. Si buscas un simulador que explique selección natural, deriva genética, mutación, reproducción y por qué un mismo punto de partida puede acabar de forma distinta, esta herramienta está hecha para eso.' },
+    { type: 'title', text: 'Ejemplos rápidos de uso', level: 3 },
+    { type: 'table', headers: ['Objetivo', 'Qué cambiar', 'Qué deberías ver'], rows: [['Mostrar victoria de la selección', 'Sube la presión de selección y baja la deriva', 'Un alelo debe dominar con el tiempo y la diversidad caerá más despacio'], ['Mostrar el azar tomando el control', 'Baja la población y sube la deriva', 'Las frecuencias deben oscilar de forma impredecible'], ['Mostrar nuevas mutaciones', 'Sube mutación e innovación', 'Aparecerán nuevos alelos y el ranking cambiará más a menudo']] },
+    { type: 'paragraph', html: 'Esa combinación de visuales en vivo, ranking explícito de alelos y métricas en tiempo real hace que el simulador sea útil tanto para enseñar como para explicar trade-offs evolutivos sin rodeos.' },
+  ],
+  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 })) },
+  ],
+};