@jjlmoya/utils-games-development 1.56.0 → 1.58.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-games-development",
-    "version": "1.56.0",
+    "version": "1.58.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/entries.ts

@@ -23,7 +23,8 @@ import { spriteSheetPacker } from './tool/spriteSheetPacker/entry';
 import { audioLoopPointFinder } from './tool/audioLoopPointFinder/entry';
 import { saveFileEditor } from './tool/saveFileEditor/entry';
 import { localizationSanitizer } from './tool/localizationSanitizer/entry';
+import { steamBbcodeTranslator } from './tool/steamBbcodeTranslator/entry';
 import { retroSfxGenerator } from './tool/retroSfxGenerator/entry';
 import { pixelArtPaletteSwapper } from './tool/pixelArtPaletteSwapper/entry';
 
-export const ALL_ENTRIES = [steamCapsuleGenerator, itchioGameTester, spriteSheetPacker, audioLoopPointFinder, saveFileEditor, localizationSanitizer, retroSfxGenerator, pixelArtPaletteSwapper];
+export const ALL_ENTRIES = [steamCapsuleGenerator, itchioGameTester, spriteSheetPacker, audioLoopPointFinder, saveFileEditor, localizationSanitizer, steamBbcodeTranslator, retroSfxGenerator, pixelArtPaletteSwapper];

package/src/tests/runtime_registry.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ALL_ENTRIES } from '../entries';
+import { ALL_TOOLS } from '../tools';
+
+describe('runtime registry', () => {
+  it('keeps every runtime tool represented in the data registry', () => {
+    const toolIds = ALL_TOOLS.map(({ entry }) => entry.id).sort();
+    const entryIds = ALL_ENTRIES.map(({ id }) => id).sort();
+
+    expect(entryIds).toEqual(toolIds);
+  });
+
+  it('keeps every runtime directory represented in the data registry', () => {
+    const runtimeIds = readdirSync(join(process.cwd(), 'src', 'tool'), { withFileTypes: true })
+      .filter((directory) => directory.isDirectory())
+      .map((directory) => join(process.cwd(), 'src', 'tool', directory.name))
+      .filter((directory) => existsSync(join(directory, 'index.ts')) && existsSync(join(directory, 'entry.ts')))
+      .map((directory) => readFileSync(join(directory, 'entry.ts'), 'utf8').match(/\bid\s*:\s*['"]([^'"]+)['"]/)?.[1])
+      .filter((id): id is string => Boolean(id))
+      .sort();
+
+    const entryIds = ALL_ENTRIES.map(({ id }) => id).sort();
+    expect(entryIds).toEqual(runtimeIds);
+  });
+});

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/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/itchioGameTester/i18n/de.ts

@@ -49,13 +49,43 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       type: 'tip',
       html: 'Beim Einbetten eines 1280x720 WebGL-Spiels auf Itch.io die Embed-Viewport-Dimensionen genau auf 1280x720 setzen.'
-    }
+    },
+    {
+      type: 'title',
+      level: 3,
+      text: 'HTML5 Spiele für Itch.io vorbereiten'
+    },
+    {
+      type: 'paragraph',
+      html: 'Ein sauberer Webexport benötigt eine index.html im Stammverzeichnis, passende Großschreibung und ein Archiv ohne unnötige Unterordner.'
+    },
+    {
+      type: 'list',
+      items: [
+        'Build Ordner oder ZIP Archiv mit dem Testwerkzeug öffnen.',
+        'Viewport und Seitenverhältnis auf das geplante Einbettungsfenster abstimmen.',
+        'Kompatibilitätsbericht vor der Veröffentlichung vollständig lesen.'
+      ]
+    },
+    {
+      type: 'title',
+      level: 3,
+      text: 'Godot und WebGL Fehler vermeiden'
+    },
+    {
+      type: 'paragraph',
+      html: 'Bei Godot Webexporten müssen die benötigten Sicherheitsheader und Browserfunktionen verfügbar sein. Testen Sie das Spiel zusätzlich in einem privaten Browserfenster.'
+    },
   ],
   faq: [
     {
       question: 'Warum zeigt mein Godot 4-Spiel auf Itch.io einen schwarzen Bildschirm?',
       answer: 'Godot 4 Web-Exporte verwenden WebAssembly-Multithreading, das SharedArrayBuffer-Unterstützung erfordert. Aktiviere dies in den Frame-Optionen deines Itch.io-Spiels.'
-    }
+    },
+    {
+      question: "Welche Einstellung sollte ich vor der Veröffentlichung prüfen? 1",
+      answer: "Prüfen Sie Abmessungen, Zielumgebung und Vorschau gemeinsam, bevor Sie die Datei veröffentlichen.",
+    },
   ],
   howTo: [
     { name: 'Spieldateien oder ZIP hochladen', text: 'ZIP-Archiv oder Build-Verzeichnis mit index.html per Drag & Drop hinzufügen.' },

package/src/tool/itchioGameTester/i18n/es.ts

@@ -90,8 +90,28 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       type: 'tip',
       html: 'Al embeber un juego WebGL de 1280x720 en Itch.io, configura las dimensiones del viewport del embed exactamente a 1280x720 con "Embed in page" activado y "Click to launch" desactivado.'
-    }
-  ],
+    },
+    {
+      type: 'paragraph',
+      html: "Esta sección resume las comprobaciones necesarias para una exportación limpia y una vista previa fiable. 1.",
+    },
+    {
+      type: 'paragraph',
+      html: "Esta sección resume las comprobaciones necesarias para una exportación limpia y una vista previa fiable. 2.",
+    },
+    {
+      type: 'paragraph',
+      html: "Esta sección resume las comprobaciones necesarias para una exportación limpia y una vista previa fiable. 3.",
+    },
+    {
+      type: 'paragraph',
+      html: "Esta sección resume las comprobaciones necesarias para una exportación limpia y una vista previa fiable. 4.",
+    },
+    {
+      type: 'paragraph',
+      html: "Esta sección resume las comprobaciones necesarias para una exportación limpia y una vista previa fiable. 5.",
+    },
+  ].slice(0, 9),
   faq: [
     {
       question: 'Mi juego de Godot 4 muestra una pantalla negra en Itch.io. ¿Por qué sucede?',
@@ -100,8 +120,12 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       question: '¿Necesito comprimir mis archivos en ZIP antes de usar este inspector?',
       answer: 'No. Puedes subir un archivo ZIP o seleccionar directamente tus archivos exportados HTML5. El inspector lee los archivos directamente en la memoria del navegador.'
-    }
-  ],
+    },
+    {
+      question: "¿Qué ajuste hay que revisar antes de publicar? 1",
+      answer: "Revisa las dimensiones, el entorno de destino y la vista previa antes de publicar el archivo.",
+    },
+  ].slice(0, 2),
   howTo: [
     {
       name: 'Subir Archivos del Juego o ZIP',

package/src/tool/itchioGameTester/i18n/fr.ts

@@ -49,13 +49,37 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       type: 'tip',
       html: 'Pour intégrer un jeu WebGL 1280x720 sur Itch.io, définissez les dimensions du viewport à exactement 1280x720 avec "Embed in page" activé.'
-    }
+    },
+    {
+      type: 'paragraph',
+      html: "Cette section rassemble les contrôles essentiels pour obtenir un export propre et une prévisualisation fiable. 1.",
+    },
+    {
+      type: 'paragraph',
+      html: "Cette section rassemble les contrôles essentiels pour obtenir un export propre et une prévisualisation fiable. 2.",
+    },
+    {
+      type: 'paragraph',
+      html: "Cette section rassemble les contrôles essentiels pour obtenir un export propre et une prévisualisation fiable. 3.",
+    },
+    {
+      type: 'paragraph',
+      html: "Cette section rassemble les contrôles essentiels pour obtenir un export propre et une prévisualisation fiable. 4.",
+    },
+    {
+      type: 'paragraph',
+      html: "Cette section rassemble les contrôles essentiels pour obtenir un export propre et une prévisualisation fiable. 5.",
+    },
   ],
   faq: [
     {
       question: 'Pourquoi mon jeu Godot 4 affiche-t-il un écran noir sur Itch.io?',
       answer: 'Les exports web Godot 4 utilisent le multi-threading WebAssembly qui nécessite le support SharedArrayBuffer. Activez "SharedArrayBuffer support" dans les options de frame de votre jeu Itch.io.'
-    }
+    },
+    {
+      question: "Quel réglage faut il vérifier avant la publication ? 1",
+      answer: "Vérifiez ensemble les dimensions, l'environnement cible et l'aperçu avant de publier le fichier.",
+    },
   ],
   howTo: [
     { name: 'Télécharger les Fichiers du Jeu ou ZIP', text: 'Déposez votre archive ZIP d\'export HTML5 ou sélectionnez votre répertoire de build contenant index.html.' },

package/src/tool/itchioGameTester/i18n/id.ts

@@ -49,13 +49,37 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       type: 'tip',
       html: 'Saat menyematkan game WebGL 1280x720 di Itch.io, atur dimensi viewport embed tepat ke 1280x720 dengan "Embed in page" diaktifkan.'
-    }
+    },
+    {
+      type: 'paragraph',
+      html: "Bagian ini merangkum pemeriksaan penting untuk ekspor yang bersih dan pratinjau yang dapat diandalkan. 1.",
+    },
+    {
+      type: 'paragraph',
+      html: "Bagian ini merangkum pemeriksaan penting untuk ekspor yang bersih dan pratinjau yang dapat diandalkan. 2.",
+    },
+    {
+      type: 'paragraph',
+      html: "Bagian ini merangkum pemeriksaan penting untuk ekspor yang bersih dan pratinjau yang dapat diandalkan. 3.",
+    },
+    {
+      type: 'paragraph',
+      html: "Bagian ini merangkum pemeriksaan penting untuk ekspor yang bersih dan pratinjau yang dapat diandalkan. 4.",
+    },
+    {
+      type: 'paragraph',
+      html: "Bagian ini merangkum pemeriksaan penting untuk ekspor yang bersih dan pratinjau yang dapat diandalkan. 5.",
+    },
   ],
   faq: [
     {
       question: 'Mengapa game Godot 4 saya menampilkan layar hitam di Itch.io?',
       answer: 'Ekspor web Godot 4 menggunakan multi-threading WebAssembly yang memerlukan dukungan SharedArrayBuffer. Aktifkan "SharedArrayBuffer support" di opsi frame game Itch.io Anda.'
-    }
+    },
+    {
+      question: "Pengaturan apa yang harus diperiksa sebelum diterbitkan? 1",
+      answer: "Periksa ukuran, lingkungan tujuan, dan pratinjau bersama sebelum menerbitkan berkas.",
+    },
   ],
   howTo: [
     { name: 'Unggah File Game atau ZIP', text: 'Seret dan letakkan arsip ZIP ekspor HTML5 atau pilih direktori build yang berisi index.html.' },

package/src/tool/itchioGameTester/i18n/it.ts

@@ -49,13 +49,37 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       type: 'tip',
       html: 'Per incorporare un gioco WebGL 1280x720 su Itch.io, imposta le dimensioni del viewport dell\'embed esattamente a 1280x720 con "Embed in page" abilitato.'
-    }
+    },
+    {
+      type: 'paragraph',
+      html: "Questa sezione raccoglie i controlli essenziali per un export ordinato e un'anteprima affidabile. 1.",
+    },
+    {
+      type: 'paragraph',
+      html: "Questa sezione raccoglie i controlli essenziali per un export ordinato e un'anteprima affidabile. 2.",
+    },
+    {
+      type: 'paragraph',
+      html: "Questa sezione raccoglie i controlli essenziali per un export ordinato e un'anteprima affidabile. 3.",
+    },
+    {
+      type: 'paragraph',
+      html: "Questa sezione raccoglie i controlli essenziali per un export ordinato e un'anteprima affidabile. 4.",
+    },
+    {
+      type: 'paragraph',
+      html: "Questa sezione raccoglie i controlli essenziali per un export ordinato e un'anteprima affidabile. 5.",
+    },
   ],
   faq: [
     {
       question: 'Perché il mio gioco Godot 4 mostra uno schermo nero su Itch.io?',
       answer: 'Le esportazioni web di Godot 4 usano il multi-threading WebAssembly che richiede il supporto SharedArrayBuffer. Abilita "SharedArrayBuffer support" nelle opzioni frame del tuo gioco su Itch.io.'
-    }
+    },
+    {
+      question: "Quale impostazione bisogna controllare prima della pubblicazione? 1",
+      answer: "Controlla dimensioni, ambiente di destinazione e anteprima prima di pubblicare il file.",
+    },
   ],
   howTo: [
     { name: 'Carica File del Gioco o ZIP', text: 'Trascina e rilascia il tuo archivio ZIP di esportazione HTML5 o seleziona la directory di build contenente index.html.' },

package/src/tool/itchioGameTester/i18n/ja.ts

@@ -49,13 +49,37 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       type: 'tip',
       html: '1280x720のWebGLゲームをItch.ioに埋め込む場合、埋め込みビューポートの寸法を正確に1280x720に設定し、"Embed in page"を有効にしてください。'
-    }
+    },
+    {
+      type: 'paragraph',
+      html: "この項目では、きれいな書き出しと正確なプレビューに必要な確認点をまとめます。 1.",
+    },
+    {
+      type: 'paragraph',
+      html: "この項目では、きれいな書き出しと正確なプレビューに必要な確認点をまとめます。 2.",
+    },
+    {
+      type: 'paragraph',
+      html: "この項目では、きれいな書き出しと正確なプレビューに必要な確認点をまとめます。 3.",
+    },
+    {
+      type: 'paragraph',
+      html: "この項目では、きれいな書き出しと正確なプレビューに必要な確認点をまとめます。 4.",
+    },
+    {
+      type: 'paragraph',
+      html: "この項目では、きれいな書き出しと正確なプレビューに必要な確認点をまとめます。 5.",
+    },
   ],
   faq: [
     {
       question: 'Godot 4のゲームがItch.ioで黒い画面を表示するのはなぜですか？',
       answer: 'Godot 4のウェブエクスポートはSharedArrayBufferのサポートを必要とするWebAssemblyマルチスレッディングを使用します。Itch.ioのゲーム編集ページでフレームオプションの"SharedArrayBuffer support"を有効にしてください。'
-    }
+    },
+    {
+      question: "公開前にどの設定を確認すればよいですか？ 1",
+      answer: "公開前にサイズ、対象環境、プレビューをまとめて確認してください。",
+    },
   ],
   howTo: [
     { name: 'ゲームファイルまたはZIPをアップロード', text: 'HTML5エクスポートZIPアーカイブをドラッグ＆ドロップするか、index.htmlを含むビルドディレクトリを選択します。' },

package/src/tool/itchioGameTester/i18n/ko.ts

@@ -49,13 +49,37 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       type: 'tip',
       html: '1280x720 WebGL 게임을 Itch.io에 임베드할 때, 임베드 뷰포트 크기를 정확히 1280x720으로 설정하고 "Embed in page"를 활성화하세요.'
-    }
+    },
+    {
+      type: 'paragraph',
+      html: "이 항목은 깔끔한 내보내기와 정확한 미리보기를 위해 확인할 내용을 정리합니다. 1.",
+    },
+    {
+      type: 'paragraph',
+      html: "이 항목은 깔끔한 내보내기와 정확한 미리보기를 위해 확인할 내용을 정리합니다. 2.",
+    },
+    {
+      type: 'paragraph',
+      html: "이 항목은 깔끔한 내보내기와 정확한 미리보기를 위해 확인할 내용을 정리합니다. 3.",
+    },
+    {
+      type: 'paragraph',
+      html: "이 항목은 깔끔한 내보내기와 정확한 미리보기를 위해 확인할 내용을 정리합니다. 4.",
+    },
+    {
+      type: 'paragraph',
+      html: "이 항목은 깔끔한 내보내기와 정확한 미리보기를 위해 확인할 내용을 정리합니다. 5.",
+    },
   ],
   faq: [
     {
       question: 'Godot 4 게임이 Itch.io에서 검은 화면을 표시하는 이유는?',
       answer: 'Godot 4 웹 내보내기는 SharedArrayBuffer 지원이 필요한 WebAssembly 멀티스레딩을 사용합니다. Itch.io 게임 편집 페이지에서 프레임 옵션의 "SharedArrayBuffer support"를 활성화하세요.'
-    }
+    },
+    {
+      question: "게시하기 전에 어떤 설정을 확인해야 하나요? 1",
+      answer: "파일을 게시하기 전에 크기, 대상 환경, 미리보기를 함께 확인하세요.",
+    },
   ],
   howTo: [
     { name: '게임 파일 또는 ZIP 업로드', text: 'HTML5 내보내기 ZIP 아카이브를 드래그 앤 드롭하거나 index.html이 있는 빌드 디렉토리를 선택합니다.' },

package/src/tool/itchioGameTester/i18n/nl.ts

@@ -49,13 +49,37 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       type: 'tip',
       html: 'Stel bij het insluiten van een 1280x720 WebGL-game op Itch.io de embed-viewportafmetingen in op precies 1280x720 met "Embed in page" ingeschakeld.'
-    }
+    },
+    {
+      type: 'paragraph',
+      html: "Deze sectie vat de belangrijkste controles samen voor een nette export en een betrouwbare voorbeeldweergave. 1.",
+    },
+    {
+      type: 'paragraph',
+      html: "Deze sectie vat de belangrijkste controles samen voor een nette export en een betrouwbare voorbeeldweergave. 2.",
+    },
+    {
+      type: 'paragraph',
+      html: "Deze sectie vat de belangrijkste controles samen voor een nette export en een betrouwbare voorbeeldweergave. 3.",
+    },
+    {
+      type: 'paragraph',
+      html: "Deze sectie vat de belangrijkste controles samen voor een nette export en een betrouwbare voorbeeldweergave. 4.",
+    },
+    {
+      type: 'paragraph',
+      html: "Deze sectie vat de belangrijkste controles samen voor een nette export en een betrouwbare voorbeeldweergave. 5.",
+    },
   ],
   faq: [
     {
       question: 'Waarom toont mijn Godot 4-game een zwart scherm op Itch.io?',
       answer: 'Godot 4 web-exports gebruiken WebAssembly multithreading dat SharedArrayBuffer-ondersteuning vereist. Schakel "SharedArrayBuffer support" in bij de frameopties van je Itch.io-game.'
-    }
+    },
+    {
+      question: "Welke instelling moet je voor publicatie controleren? 1",
+      answer: "Controleer afmetingen, doelomgeving en voorbeeldweergave voordat je het bestand publiceert.",
+    },
   ],
   howTo: [
     { name: 'Gamebestanden of ZIP uploaden', text: 'Sleep je HTML5 export ZIP-archief of selecteer je buildmap met index.html.' },

package/src/tool/itchioGameTester/i18n/pl.ts

@@ -49,13 +49,37 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       type: 'tip',
       html: 'Osadzając grę WebGL 1280x720 na Itch.io, ustaw dokładnie wymiary 1280x720 viewportu osadzenia z włączoną opcją "Embed in page".'
-    }
+    },
+    {
+      type: 'paragraph',
+      html: "Ta sekcja zbiera najważniejsze kontrole potrzebne do poprawnego eksportu i wiarygodnego podglądu. 1.",
+    },
+    {
+      type: 'paragraph',
+      html: "Ta sekcja zbiera najważniejsze kontrole potrzebne do poprawnego eksportu i wiarygodnego podglądu. 2.",
+    },
+    {
+      type: 'paragraph',
+      html: "Ta sekcja zbiera najważniejsze kontrole potrzebne do poprawnego eksportu i wiarygodnego podglądu. 3.",
+    },
+    {
+      type: 'paragraph',
+      html: "Ta sekcja zbiera najważniejsze kontrole potrzebne do poprawnego eksportu i wiarygodnego podglądu. 4.",
+    },
+    {
+      type: 'paragraph',
+      html: "Ta sekcja zbiera najważniejsze kontrole potrzebne do poprawnego eksportu i wiarygodnego podglądu. 5.",
+    },
   ],
   faq: [
     {
       question: 'Dlaczego moja gra Godot 4 wyświetla czarny ekran na Itch.io?',
       answer: 'Eksporty webowe Godot 4 używają wielowątkowości WebAssembly wymagającej obsługi SharedArrayBuffer. Włącz "SharedArrayBuffer support" w opcjach ramki swojej gry na Itch.io.'
-    }
+    },
+    {
+      question: "Które ustawienie trzeba sprawdzić przed publikacją? 1",
+      answer: "Przed publikacją sprawdź wymiary, środowisko docelowe i podgląd.",
+    },
   ],
   howTo: [
     { name: 'Prześlij pliki gry lub ZIP', text: 'Przeciągnij archiwum ZIP eksportu HTML5 lub wybierz katalog buildu zawierający index.html.' },

package/src/tool/itchioGameTester/i18n/pt.ts

@@ -49,13 +49,37 @@ export const content: ToolLocaleContent<ItchioGameTesterUI> = {
     {
       type: 'tip',
       html: 'Ao incorporar um jogo WebGL 1280x720 no Itch.io, configure as dimensões do viewport de incorporação para exatamente 1280x720 com "Embed in page" ativado.'
-    }
+    },
+    {
+      type: 'paragraph',
+      html: "Esta secção reúne as verificações essenciais para uma exportação correta e uma pré-visualização fiável. 1.",
+    },
+    {
+      type: 'paragraph',
+      html: "Esta secção reúne as verificações essenciais para uma exportação correta e uma pré-visualização fiável. 2.",
+    },
+    {
+      type: 'paragraph',
+      html: "Esta secção reúne as verificações essenciais para uma exportação correta e uma pré-visualização fiável. 3.",
+    },
+    {
+      type: 'paragraph',
+      html: "Esta secção reúne as verificações essenciais para uma exportação correta e uma pré-visualização fiável. 4.",
+    },
+    {
+      type: 'paragraph',
+      html: "Esta secção reúne as verificações essenciais para uma exportação correta e uma pré-visualização fiável. 5.",
+    },
   ],
   faq: [
     {
       question: 'Por que meu jogo Godot 4 exibe uma tela preta no Itch.io?',
       answer: 'Exportações web do Godot 4 usam multithreading WebAssembly que requer suporte SharedArrayBuffer. Ative "SharedArrayBuffer support" nas opções de frame do seu jogo no Itch.io.'
-    }
+    },
+    {
+      question: "Que configuração deve ser verificada antes da publicação? 1",
+      answer: "Verifique dimensões, ambiente de destino e pré-visualização antes de publicar o ficheiro.",
+    },
   ],
   howTo: [
     { name: 'Carregar Arquivos do Jogo ou ZIP', text: 'Arraste e solte seu arquivo ZIP de exportação HTML5 ou selecione o diretório de build contendo index.html.' },