@jjlmoya/utils-tabletop 1.18.0 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-tabletop",
-    "version": "1.18.0",
+    "version": "1.20.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,124 @@
+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/decision-wheel/i18n/de.ts

@@ -41,6 +41,14 @@ export const content: DecisionWheelLocaleContent = {
     },
     { type: 'title', text: 'So Verwenden Sie das Entscheidungsrad', level: 2 },
     { type: 'paragraph', html: 'Wählen Sie eine Vorlage oder erstellen Sie eigene Segmente mit Gewichtungen, um die Gewinnwahrscheinlichkeiten anzupassen.' },
+    { type: 'title', text: "Weitere Szenarien", level: 3 },
+    { type: 'paragraph', html: "Nutzen Sie das Rad für Abstimmungen, Zufallsbegegnungen und Spielaktionen." },
+    { type: 'title', text: "Vorlagen nutzen", level: 3 },
+    { type: 'paragraph', html: "Vorlagen laden häufige Entscheidungen für Brettspiele sofort." },
+    { type: 'title', text: "Gewichtungen einstellen", level: 3 },
+    { type: 'paragraph', html: "Gewichtungen machen einzelne Ergebnisse häufiger oder seltener." },
+    { type: 'title', text: "Verlauf prüfen", level: 3 },
+    { type: 'paragraph', html: "Der Verlauf hält die letzten Drehungen für die Gruppe fest." },
   ],
   faq: [
     {
@@ -51,6 +59,22 @@ export const content: DecisionWheelLocaleContent = {
       question: 'Kann ich Farben und Namen anpassen?',
       answer: 'Ja, Sie können beliebig Segmente hinzufügen, Namen ändern, Farben wählen und die Gewichtung von 1 bis 5 anpassen.',
     },
+    {
+      question: "Kann ich Ergebniswahrscheinlichkeiten ändern?",
+      answer: "Ja, ändern Sie das Gewicht eines Segments.",
+    },
+    {
+      question: "Wie viele Segmente sind möglich?",
+      answer: "Bis zu 16 Segmente sind möglich; mindestens zwei werden benötigt.",
+    },
+    {
+      question: "Welche Vorlagen gibt es?",
+      answer: "Ja oder Nein, Zahlen, Aktionen, eigene Optionen, D20, Gesinnung und Beute.",
+    },
+    {
+      question: "Bleiben frühere Drehungen sichtbar?",
+      answer: "Ja, die letzten zehn Ergebnisse werden im Browser angezeigt.",
+    },
   ],
   bibliography,
   howTo: [
@@ -62,6 +86,10 @@ export const content: DecisionWheelLocaleContent = {
       name: 'Das Rad Drehen',
       text: 'Klicken Sie auf Drehen und warten Sie, bis das Rad mit realistischer Verzögerung stoppt.',
     },
+    {
+      name: "Ergebnis prüfen",
+      text: "Nach dem Stopp wird das Gewinnersegment hervorgehoben. Prüfen Sie den Verlauf der letzten Drehungen.",
+    },
   ],
   schemas: [
     {

package/src/tool/decision-wheel/i18n/es.ts

@@ -41,6 +41,14 @@ export const content: DecisionWheelLocaleContent = {
     },
     { type: 'title', text: 'Cómo Usar la Ruleta de Decisiones', level: 2 },
     { type: 'paragraph', html: 'La ruleta facilita elegir al azar entre un conjunto de opciones. Elige un preajuste o crea tus propias secciones con diferentes pesos para ajustar las probabilidades.' },
+    { type: 'title', text: "Más escenarios de decisión", level: 3 },
+    { type: 'paragraph', html: "Usa la ruleta para votaciones, encuentros aleatorios y acciones de la partida." },
+    { type: 'title', text: "Plantillas para juegos de mesa", level: 3 },
+    { type: 'paragraph', html: "Las plantillas cargan rápidamente decisiones habituales de juegos de mesa." },
+    { type: 'title', text: "Ajustar pesos de resultado", level: 3 },
+    { type: 'paragraph', html: "Los pesos hacen que determinados resultados aparezcan más o menos veces." },
+    { type: 'title', text: "Revisar el historial", level: 3 },
+    { type: 'paragraph', html: "El historial conserva los últimos giros para que el grupo los revise." },
   ],
   faq: [
     {
@@ -51,6 +59,22 @@ export const content: DecisionWheelLocaleContent = {
       question: '¿Puedo personalizar los colores y nombres?',
       answer: 'Sí, puedes añadir secciones, cambiar las etiquetas de texto, asignar colores personalizados y ajustar su peso del 1 al 5.',
     },
+    {
+      question: "¿Puedo cambiar las probabilidades?",
+      answer: "Sí, modifica el peso de un segmento.",
+    },
+    {
+      question: "¿Cuántos segmentos admite?",
+      answer: "Admite hasta 16 segmentos y necesita al menos dos.",
+    },
+    {
+      question: "¿Qué plantillas hay disponibles?",
+      answer: "Sí o No, Números, Acciones, opciones propias, D20, Alineamiento y Botín.",
+    },
+    {
+      question: "¿Se conservan los giros anteriores?",
+      answer: "Sí, el navegador muestra los diez últimos resultados.",
+    },
   ],
   bibliography,
   howTo: [
@@ -62,6 +86,10 @@ export const content: DecisionWheelLocaleContent = {
       name: 'Girar la Ruleta',
       text: 'Haz clic en el botón de girar y observa la animación con físicas de deceleración realista.',
     },
+    {
+      name: "Comprueba el resultado",
+      text: "Cuando se detenga, revisa el segmento ganador y el historial de giros.",
+    },
   ],
   schemas: [
     {

package/src/tool/decision-wheel/i18n/fr.ts

@@ -41,6 +41,14 @@ export const content: DecisionWheelLocaleContent = {
     },
     { type: 'title', text: 'Comment Utiliser la Roue de Décision', level: 2 },
     { type: 'paragraph', html: 'Choisissez un modèle prédéfini ou créez vos propres options avec des poids personnalisés pour ajuster les probabilités de chaque secteur.' },
+    { type: 'title', text: "Autres scénarios de décision", level: 3 },
+    { type: 'paragraph', html: "Utilisez la roue pour les votes, les rencontres aléatoires et les actions de partie." },
+    { type: 'title', text: "Modèles pour les jeux de plateau", level: 3 },
+    { type: 'paragraph', html: "Les modèles chargent rapidement les décisions courantes des jeux de plateau." },
+    { type: 'title', text: "Régler les pondérations", level: 3 },
+    { type: 'paragraph', html: "Les pondérations rendent certains résultats plus ou moins fréquents." },
+    { type: 'title', text: "Consulter l'historique", level: 3 },
+    { type: 'paragraph', html: "L'historique conserve les derniers tours pour le groupe." },
   ],
   faq: [
     {
@@ -51,6 +59,22 @@ export const content: DecisionWheelLocaleContent = {
       question: 'Peut-on modifier les couleurs et les étiquettes?',
       answer: 'Oui, vous pouvez éditer librement le nom, la couleur et le poids de chaque option présente sur la roue.',
     },
+    {
+      question: "Puis-je modifier les probabilités ?",
+      answer: "Oui, modifiez le poids d'un segment.",
+    },
+    {
+      question: "Combien de segments sont possibles ?",
+      answer: "La roue accepte jusqu'à 16 segments et en nécessite au moins deux.",
+    },
+    {
+      question: "Quels modèles sont disponibles ?",
+      answer: "Oui ou Non, Nombres, Actions, options personnelles, D20, Alignement et Butin.",
+    },
+    {
+      question: "Les tours précédents restent-ils visibles ?",
+      answer: "Oui, le navigateur affiche les dix derniers résultats.",
+    },
   ],
   bibliography,
   howTo: [
@@ -62,6 +86,10 @@ export const content: DecisionWheelLocaleContent = {
       name: 'Lancer le Tour',
       text: 'Cliquez sur le bouton de rotation pour lancer la roue animée avec ralentissement réaliste.',
     },
+    {
+      name: "Vérifier le résultat",
+      text: "À l'arrêt, vérifiez le segment gagnant puis l'historique des tours.",
+    },
   ],
   schemas: [
     {

package/src/tool/decision-wheel/i18n/id.ts

@@ -41,6 +41,14 @@ export const content: DecisionWheelLocaleContent = {
     },
     { type: 'title', text: 'Cara Menggunakan Roda Keputusan', level: 2 },
     { type: 'paragraph', html: 'Pilih prasetel atau buat segmen Anda sendiri dengan bobot untuk menyesuaikan probabilitas setiap pilihan.' },
+    { type: 'title', text: "Skenario tambahan", level: 3 },
+    { type: 'paragraph', html: "Gunakan roda untuk pemungutan suara, pertemuan acak, dan aksi permainan." },
+    { type: 'title', text: "Preset permainan meja", level: 3 },
+    { type: 'paragraph', html: "Preset memuat keputusan umum permainan meja dengan cepat." },
+    { type: 'title', text: "Mengatur bobot hasil", level: 3 },
+    { type: 'paragraph', html: "Bobot membuat hasil tertentu lebih sering atau lebih jarang muncul." },
+    { type: 'title', text: "Meninjau riwayat", level: 3 },
+    { type: 'paragraph', html: "Riwayat menyimpan putaran terbaru untuk ditinjau bersama." },
   ],
   faq: [
     {
@@ -51,6 +59,22 @@ export const content: DecisionWheelLocaleContent = {
       question: 'Apakah saya bisa mengubah warna dan nama?',
       answer: 'Ya, Anda bebas menambah segmen, mengubah teks label, memilih warna, dan mengubah bobot dari 1 hingga 5.',
     },
+    {
+      question: "Bisakah peluang diubah?",
+      answer: "Bisa, ubah bobot segmen.",
+    },
+    {
+      question: "Berapa banyak segmen yang tersedia?",
+      answer: "Hingga 16 segmen dapat digunakan dan minimal dua diperlukan.",
+    },
+    {
+      question: "Preset apa yang tersedia?",
+      answer: "Ya atau Tidak, Angka, Aksi, pilihan sendiri, D20, Keselarasan, dan Jarahan.",
+    },
+    {
+      question: "Apakah putaran sebelumnya terlihat?",
+      answer: "Ya, browser menampilkan sepuluh hasil terakhir.",
+    },
   ],
   bibliography,
   howTo: [
@@ -62,6 +86,10 @@ export const content: DecisionWheelLocaleContent = {
       name: 'Putar Roda Keputusan',
       text: 'Klik tombol putar untuk melihat animasi putaran dengan deselerasi fisik yang realistis.',
     },
+    {
+      name: "Periksa hasil",
+      text: "Setelah roda berhenti, periksa segmen pemenang dan riwayat putaran.",
+    },
   ],
   schemas: [
     {

package/src/tool/decision-wheel/i18n/it.ts

@@ -41,6 +41,14 @@ export const content: DecisionWheelLocaleContent = {
     },
     { type: 'title', text: 'Come Usare la Ruota delle Decisioni', level: 2 },
     { type: 'paragraph', html: 'Scegli un set preimpostato o crea i tuoi spicchi personali impostando pesi diversi per calibrare le probabilità.' },
+    { type: 'title', text: "Altri scenari decisionali", level: 3 },
+    { type: 'paragraph', html: "Usa la ruota per votazioni, incontri casuali e azioni durante la partita." },
+    { type: 'title', text: "Preset per giochi da tavolo", level: 3 },
+    { type: 'paragraph', html: "I preset caricano rapidamente le decisioni comuni dei giochi da tavolo." },
+    { type: 'title', text: "Regolare i pesi", level: 3 },
+    { type: 'paragraph', html: "I pesi rendono alcuni risultati più o meno frequenti." },
+    { type: 'title', text: "Consultare la cronologia", level: 3 },
+    { type: 'paragraph', html: "La cronologia conserva gli ultimi giri per il gruppo." },
   ],
   faq: [
     {
@@ -51,6 +59,22 @@ export const content: DecisionWheelLocaleContent = {
       question: 'Posso personalizzare colori e testi?',
       answer: 'Sì, puoi aggiungere nuovi spicchi, rinominarli, scegliere un colore e impostare un peso tra 1 e 5.',
     },
+    {
+      question: "Posso cambiare le probabilità?",
+      answer: "Sì, modifica il peso di un segmento.",
+    },
+    {
+      question: "Quanti segmenti sono possibili?",
+      answer: "Sono supportati fino a 16 segmenti e ne servono almeno due.",
+    },
+    {
+      question: "Quali preset sono disponibili?",
+      answer: "Sì o No, Numeri, Azioni, opzioni proprie, D20, Allineamento e Bottino.",
+    },
+    {
+      question: "I giri precedenti restano visibili?",
+      answer: "Sì, il browser mostra gli ultimi dieci risultati.",
+    },
   ],
   bibliography,
   howTo: [
@@ -62,6 +86,10 @@ export const content: DecisionWheelLocaleContent = {
       name: 'Girare la Ruota',
       text: 'Fai clic sul pulsante di avvio e guarda la ruota rallentare con fisica realistica fino a fermarsi.',
     },
+    {
+      name: "Controllare il risultato",
+      text: "Dopo l'arresto, controlla il segmento vincente e la cronologia dei giri.",
+    },
   ],
   schemas: [
     {

package/src/tool/decision-wheel/i18n/ja.ts

@@ -41,6 +41,14 @@ export const content: DecisionWheelLocaleContent = {
     },
     { type: 'title', text: '意思決定ホイールの使い方', level: 2 },
     { type: 'paragraph', html: 'プリセットを選ぶか、独自の項目を作成して重みを設定し、当選確率を自由にコントロールできます。' },
+    { type: 'title', text: "その他のシナリオ", level: 3 },
+    { type: 'paragraph', html: "投票、ランダムイベント、ゲーム中の行動選択にホイールを使えます。" },
+    { type: 'title', text: "卓上ゲームのプリセット", level: 3 },
+    { type: 'paragraph', html: "プリセットで卓上ゲームの一般的な選択肢をすぐに読み込めます。" },
+    { type: 'title', text: "重みを調整する", level: 3 },
+    { type: 'paragraph', html: "重みを変えると結果の出やすさを調整できます。" },
+    { type: 'title', text: "履歴を確認する", level: 3 },
+    { type: 'paragraph', html: "履歴には最近のスピンが残り、グループで確認できます。" },
   ],
   faq: [
     {
@@ -51,6 +59,22 @@ export const content: DecisionWheelLocaleContent = {
       question: '色や名前は変更できますか？',
       answer: 'はい。セグメントを追加し、名前や色、1から5までの重要度の重みを自由に変更可能です。',
     },
+    {
+      question: "確率を変更できますか？",
+      answer: "はい。セグメントの重みを変更します。",
+    },
+    {
+      question: "セグメントはいくつ置けますか？",
+      answer: "最大16個で、動作には2個以上必要です。",
+    },
+    {
+      question: "どんなプリセットがありますか？",
+      answer: "はい・いいえ、数字、アクション、カスタム、D20、属性、戦利品です。",
+    },
+    {
+      question: "以前のスピンは表示されますか？",
+      answer: "はい。ブラウザーに直近10件が表示されます。",
+    },
   ],
   bibliography,
   howTo: [
@@ -62,6 +86,10 @@ export const content: DecisionWheelLocaleContent = {
       name: 'ホイールをスピン',
       text: 'スタートボタンをクリックすると、リアルな摩擦減速アニメーションを伴ってホイールが回転します。',
     },
+    {
+      name: "結果を確認する",
+      text: "停止後に当選セグメントと最近のスピン履歴を確認します。",
+    },
   ],
   schemas: [
     {