@jjlmoya/utils-games-development 1.64.0 → 1.66.0

package/package.json

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

package/src/category/index.ts

@@ -7,10 +7,11 @@ import { steamBbcodeTranslator } from '../tool/steamBbcodeTranslator/entry';
 import { gameUiAccessibilityTester } from '../tool/gameUIAccessibilityTester/entry';
 import { hitboxHurtboxAnimator } from '../tool/hitboxHurtboxAnimator/entry';
 import { damageFormulaLab } from '../tool/damageFormulaLab/entry';
+import { gameDeltaTimeFixedTimestepLab } from '../tool/gameDeltaTimeFixedTimestepLab/entry';
 
 export const gamesCategory: GamesCategoryEntry = {
   icon: 'mdi:gamepad-variant',
-  tools: [steamCapsuleGenerator, spriteSheetPacker, audioLoopPointFinder, saveFileEditor, steamBbcodeTranslator, gameUiAccessibilityTester, hitboxHurtboxAnimator, damageFormulaLab],
+  tools: [steamCapsuleGenerator, spriteSheetPacker, audioLoopPointFinder, saveFileEditor, steamBbcodeTranslator, gameUiAccessibilityTester, hitboxHurtboxAnimator, damageFormulaLab, gameDeltaTimeFixedTimestepLab],
   i18n: {
     de: () => import('./i18n/de').then((m) => m.content),
     en: () => import('./i18n/en').then((m) => m.content),

package/src/entries.ts

@@ -20,6 +20,8 @@ export { hitboxHurtboxAnimator } from './tool/hitboxHurtboxAnimator/entry';
 export type { HitboxHurtboxAnimatorUI, HitboxHurtboxAnimatorLocaleContent } from './tool/hitboxHurtboxAnimator/entry';
 export { damageFormulaLab } from './tool/damageFormulaLab/entry';
 export type { DamageFormulaLabUI, DamageFormulaLabLocaleContent } from './tool/damageFormulaLab/entry';
+export { gameDeltaTimeFixedTimestepLab } from './tool/gameDeltaTimeFixedTimestepLab/entry';
+export type { GameDeltaTimeFixedTimestepLabUI, GameDeltaTimeFixedTimestepLabLocaleContent } from './tool/gameDeltaTimeFixedTimestepLab/entry';
 export { gamesCategory } from './category';
 import { steamCapsuleGenerator } from './tool/steamCapsuleGenerator/entry';
 import { itchioGameTester } from './tool/itchioGameTester/entry';
@@ -33,5 +35,6 @@ import { pixelArtPaletteSwapper } from './tool/pixelArtPaletteSwapper/entry';
 import { gameUiAccessibilityTester } from './tool/gameUIAccessibilityTester/entry';
 import { hitboxHurtboxAnimator } from './tool/hitboxHurtboxAnimator/entry';
 import { damageFormulaLab } from './tool/damageFormulaLab/entry';
+import { gameDeltaTimeFixedTimestepLab } from './tool/gameDeltaTimeFixedTimestepLab/entry';
 
-export const ALL_ENTRIES = [steamCapsuleGenerator, itchioGameTester, spriteSheetPacker, audioLoopPointFinder, saveFileEditor, localizationSanitizer, steamBbcodeTranslator, retroSfxGenerator, pixelArtPaletteSwapper, gameUiAccessibilityTester, hitboxHurtboxAnimator, damageFormulaLab];
+export const ALL_ENTRIES = [steamCapsuleGenerator, itchioGameTester, spriteSheetPacker, audioLoopPointFinder, saveFileEditor, localizationSanitizer, steamBbcodeTranslator, retroSfxGenerator, pixelArtPaletteSwapper, gameUiAccessibilityTester, hitboxHurtboxAnimator, damageFormulaLab, gameDeltaTimeFixedTimestepLab];

package/src/tests/bibliography_wellformed_export.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync, existsSync } from 'fs';
+import { join, relative } from 'path';
+
+function findBibliographyAstroFiles(dir: string): string[] {
+  const files: string[] = [];
+  if (!existsSync(dir)) return files;
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findBibliographyAstroFiles(fullPath));
+    } else if (entry.isFile() && entry.name === 'bibliography.astro') {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+const toolDir = join(process.cwd(), 'src', 'tool');
+const bibliographyFiles = findBibliographyAstroFiles(toolDir);
+
+describe('Bibliography Component Wellformed Export', () => {
+  it('found tool bibliography.astro components', () => {
+    expect(bibliographyFiles.length).toBeGreaterThan(0);
+  });
+
+  bibliographyFiles.forEach((file) => {
+    const relativePath = relative(process.cwd(), file);
+
+    it(`${relativePath} should use SharedBibliography from @jjlmoya/utils-shared`, () => {
+      const content = readFileSync(file, 'utf-8');
+
+      const usesSharedComponent =
+        content.includes('@jjlmoya/utils-shared') &&
+        (content.includes('Bibliography') || content.includes('SharedBibliography'));
+
+      expect(
+        usesSharedComponent,
+        `File "${relativePath}" does not use the standard Bibliography component from @jjlmoya/utils-shared, resulting in unstyled or raw bibliography output.`,
+      ).toBe(true);
+    });
+  });
+});

package/src/tests/locale_completeness.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { ALL_TOOLS } from '../tools';
 
 describe('Locale Completeness Validation', () => {
-  it('twelve tools are registered', () => {
-    expect(ALL_TOOLS.length).toBe(12);
+  it('thirteen tools are registered', () => {
+    expect(ALL_TOOLS.length).toBe(13);
   });
 });

package/src/tests/seo_parity.test.ts

@@ -26,8 +26,8 @@ async function verifyLocaleParity(
 
   expect(
     locSeoCount,
-    `Locale ${loc} SEO sections count (${locSeoCount}) must match EN (${expected.seo})`,
-  ).toBe(expected.seo);
+    `Locale ${loc} SEO sections count (${locSeoCount}) must include the English base (${expected.seo})`,
+  ).toBeGreaterThanOrEqual(expected.seo);
   expect(
     locFaqCount,
     `Locale ${loc} FAQ items count (${locFaqCount}) must match EN (${expected.faq})`,

package/src/tests/seo_translation_completeness.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const ASIAN_LOCALES = ['ja', 'ko', 'zh'];
+
+function getSimpleSectionLength(section: any): number {
+  if (section.type === 'title') return section.text ? section.text.length : 0;
+  if (section.type === 'paragraph') return section.html ? section.html.replace(/<[^>]*>/g, '').length : 0;
+  if (section.type === 'list') return section.items ? section.items.join('').length : 0;
+  return 0;
+}
+
+function getComplexSectionLength(section: any): number {
+  if (section.type === 'diagnostic' || section.type === 'tip') {
+    return (section.title ? section.title.length : 0) + (section.html ? section.html.replace(/<[^>]*>/g, '').length : 0);
+  }
+  if (section.type === 'table') {
+    return ((section.headers || []).join('').length) + ((section.rows || []).flat().join('').length);
+  }
+  return 0;
+}
+
+function getSectionLength(section: any): number {
+  return getSimpleSectionLength(section) || getComplexSectionLength(section);
+}
+
+function calculateSeoTextLength(seoSections: any[]): number {
+  return seoSections.reduce((acc, section) => acc + getSectionLength(section), 0);
+}
+
+function checkLocaleSeoLength(toolId: string, locale: string, localeLen: number, enLen: number): void {
+  const isAsian = ASIAN_LOCALES.includes(locale);
+  const minLength = Math.floor(enLen * (isAsian ? 0.25 : 0.70));
+  const msgType = isAsian ? 'suspiciously short' : 'truncated/lazy';
+
+  expect(
+    localeLen,
+    `[LAZY SEO TRANSLATION] Tool "${toolId}" locale "${locale}" SEO text is ${msgType} (${localeLen} chars vs EN ${enLen} chars, expected min ${minLength})`,
+  ).toBeGreaterThanOrEqual(minLength);
+}
+
+async function auditSingleLocale(toolId: string, locale: string, loader: any, enSeoLength: number): Promise<void> {
+  if (locale === 'en' || !loader) return;
+  const content = await loader();
+  if (!content.seo || !Array.isArray(content.seo)) return;
+
+  checkLocaleSeoLength(toolId, locale, calculateSeoTextLength(content.seo), enSeoLength);
+}
+
+describe('SEO Translation Completeness & Laziness Audit', () => {
+  ALL_TOOLS.forEach(({ entry }) => {
+    describe(`Tool: ${entry.id}`, () => {
+      it('should not have lazy or truncated SEO content compared to English reference', async () => {
+        const enLoader = entry.i18n['en' as keyof typeof entry.i18n];
+        if (!enLoader) return;
+
+        const enContent = await enLoader();
+        if (!enContent.seo || !Array.isArray(enContent.seo)) return;
+
+        const enSeoLength = calculateSeoTextLength(enContent.seo);
+
+        for (const [locale, loader] of Object.entries(entry.i18n)) {
+          await auditSingleLocale(entry.id, locale, loader, enSeoLength);
+        }
+      });
+    });
+  });
+});
+

package/src/tests/seo_wellformed_export.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync, existsSync } from 'fs';
+import { join, relative } from 'path';
+
+function findSeoAstroFiles(dir: string): string[] {
+  const files: string[] = [];
+  if (!existsSync(dir)) return files;
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findSeoAstroFiles(fullPath));
+    } else if (entry.isFile() && entry.name === 'seo.astro') {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+const toolDir = join(process.cwd(), 'src', 'tool');
+const seoFiles = findSeoAstroFiles(toolDir);
+
+describe('SEO Component Wellformed Export', () => {
+  it('found tool seo.astro components', () => {
+    expect(seoFiles.length).toBeGreaterThan(0);
+  });
+
+  seoFiles.forEach((file) => {
+    const relativePath = relative(process.cwd(), file);
+
+    it(`${relativePath} should dynamically load SEO sections and use SEORenderer`, () => {
+      const content = readFileSync(file, 'utf-8');
+
+      const usesSeoRenderer =
+        content.includes('@jjlmoya/utils-shared') &&
+        (content.includes('SEORenderer') || content.includes('SEOArticle'));
+
+      const acquiresDynamicContent =
+        content.includes('.i18n') ||
+        content.includes('loader') ||
+        content.includes('await loader') ||
+        content.includes('.seo');
+
+      const isBrokenPattern =
+        /sections\s*=\s*\[\s*\]/.test(content) && !acquiresDynamicContent;
+
+      expect(
+        usesSeoRenderer,
+        `File "${relativePath}" does not import or use SEORenderer from @jjlmoya/utils-shared.`,
+      ).toBe(true);
+
+      expect(
+        isBrokenPattern,
+        `File "${relativePath}" relies on a static sections=[] prop default without fetching content from entry.i18n, resulting in empty SEO text on consumers.`,
+      ).toBe(false);
+
+      expect(
+        acquiresDynamicContent,
+        `File "${relativePath}" does not fetch dynamic i18n content for SEO rendering.`,
+      ).toBe(true);
+    });
+  });
+});

package/src/tests/tool_validation.test.ts

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

package/src/tests/translation_copy.test.ts

@@ -91,6 +91,26 @@ function copySimilarity(left: string, right: string): number {
   return (2 * shared) / (leftTotal + rightTotal);
 }
 
+function findCopyViolations(corpora: Map<string, string>): string[] {
+  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];
+      if (!left || !right) continue;
+      const similarity = copySimilarity(corpora.get(left) ?? '', corpora.get(right) ?? '');
+
+      if (similarity >= COPY_THRESHOLD) {
+        violations.push(`${left} ↔ ${right}: ${(similarity * 100).toFixed(1)}%`);
+      }
+    }
+  }
+
+  return violations;
+}
+
 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 () => {
@@ -101,24 +121,7 @@ describe('Locales must not copy another locale wholesale', () => {
         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([]);
+      expect(findCopyViolations(corpora), `Locale copy threshold exceeded in ${entry.id}`).toEqual([]);
     });
   });
 });
-
-

package/src/tool/audioLoopPointFinder/i18n/de.ts

@@ -132,6 +132,19 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: 'Beim Exportieren von Tonspuren aus diesem Tool werden neue Metadatenstrukturen direkt in den RIFF-Header der ausgegebenen WAV-Binärdatei eingebettet. Die Anwendung erstellt sowohl einen Standard-Sample-Chunk als auch einen LIST-INFO-Chunk mit Text-Tags.',
     },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Loop-Länge und Phasenübergang beurteilen',
+    },
+    {
+      type: 'paragraph',
+      html: 'Ein Nulldurchgang reduziert Sprünge der Amplitude, garantiert aber nicht automatisch einen musikalisch passenden Übergang. Hören Sie den Anfang und das Ende gemeinsam an und prüfen Sie zusätzlich, ob Rhythmus, Harmonie und Hallfahne beim Wiederholen logisch weiterlaufen.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Die Marker werden in Samples gespeichert und bleiben dadurch unabhängig von einer gerundeten Millisekundenanzeige. Exportieren Sie erst nach der akustischen Kontrolle und testen Sie die WAV-Datei anschließend in der Engine, die sie im Spiel abspielen soll.',
+    },
   ],
   faqTitle: 'Häufig gestellte Fragen',
   faq: [

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

@@ -132,6 +132,32 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: 'Lors de l export des pistes depuis cet outil, les structures de métadonnées sont injectées directement dans l en-tête RIFF du fichier WAV. L outil crée un bloc d échantillon standard et un bloc LIST INFO.',
     },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Évaluer la durée de boucle et la transition de phase',
+    },
+    {
+      type: 'paragraph',
+      html: 'Un passage par zéro réduit les sauts d amplitude, mais ne garantit pas une transition musicale cohérente. Écoutez le début et la fin ensemble et vérifiez que le rythme, l harmonie et la réverbération se poursuivent naturellement pendant la répétition.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Les marqueurs sont conservés en échantillons et ne dépendent donc pas d un arrondi en millisecondes. Exportez après le contrôle auditif, puis testez le fichier WAV dans le moteur qui le lira réellement pendant le jeu.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Évaluer la durée de boucle et la transition de phase',
+    },
+    {
+      type: 'paragraph',
+      html: 'Un passage par zéro réduit les sauts d amplitude, mais ne garantit pas une transition musicale cohérente. Écoutez le début et la fin ensemble et vérifiez que le rythme, l harmonie et la réverbération se poursuivent naturellement pendant la répétition.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Les marqueurs sont conservés en échantillons et ne dépendent donc pas d un arrondi en millisecondes. Exportez après le contrôle auditif, puis testez le fichier WAV dans le moteur qui le lira réellement pendant le jeu.',
+    },
   ],
   faqTitle: 'Foire Aux Questions',
   faq: [

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

@@ -132,6 +132,10 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: 'Saat mengekspor trek audio dari alat ini, struktur metadata baru disuntikkan langsung ke dalam header RIFF dari file WAV.',
     },
+    { type: 'title', level: 2, text: 'Menilai durasi loop dan transisi fase' },
+    { type: 'paragraph', html: 'Zero crossing mengurangi lonjakan amplitudo, tetapi tidak otomatis membuat transisi musik terdengar alami. Dengarkan bagian awal dan akhir secara berurutan, lalu periksa ritme, harmoni, serta ekor reverb saat loop diulang.' },
+    { type: 'paragraph', html: 'Marker disimpan dalam satuan sample sehingga tidak bergantung pada pembulatan milidetik. Setelah pemeriksaan audio, ekspor WAV dan uji berkas tersebut di engine yang akan memutarnya dalam game.' },
+    { type: 'paragraph', html: 'Periksa juga bahwa panjang loop sesuai dengan frasa musik dan tidak memotong nada atau ekor efek. Nilai marker dalam sample memberikan ketelitian yang tetap saat file berpindah antara perangkat, tetapi hasil akhirnya tetap harus didengarkan pada tempo dan volume permainan yang sebenarnya.' },
   ],
   faqTitle: 'Pertanyaan yang Sering Diajukan',
   faq: [

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

@@ -132,6 +132,9 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: 'Durante l esportazione delle tracce, le nuove strutture di metadati vengono iniettate direttamente nell intestazione RIFF del file binario WAV.',
     },
+    { type: 'title', level: 2, text: 'Valutare la durata del loop e la transizione di fase' },
+    { type: 'paragraph', html: 'Un passaggio per lo zero riduce i salti di ampiezza, ma non garantisce da solo una transizione musicale naturale. Ascolta in sequenza inizio e fine e controlla ritmo, armonia e coda del riverbero durante la ripetizione.' },
+    { type: 'paragraph', html: 'I marker sono conservati in campioni e non dipendono dall arrotondamento dei millisecondi. Dopo il controllo d ascolto, esporta il WAV e provalo nel motore che lo riprodurrà nel gioco.' },
   ],
   faqTitle: 'Domande Frequenti',
   faq: [

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

@@ -132,6 +132,10 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: 'Bij het exporteren van audiotracks vanuit deze tool worden nieuwe metadatastructuren direct in de RIFF-header van het WAV-bestand geplaatst.',
     },
+    { type: 'title', level: 2, text: 'Loopduur en faseovergang beoordelen' },
+    { type: 'paragraph', html: 'Een nuldoorgang beperkt sprongen in amplitude, maar garandeert niet automatisch een muzikale overgang. Luister naar begin en einde achter elkaar en controleer ritme, harmonie en de galmstaart tijdens het herhalen.' },
+    { type: 'paragraph', html: 'Markers worden in samples bewaard en zijn daardoor niet afhankelijk van afronding naar milliseconden. Exporteer pas na de luistercontrole en test het WAV-bestand in de engine die het in de game afspeelt.' },
+    { type: 'paragraph', html: 'Controleer ook of de looplengte bij de muzikale frase past en geen noot of effectstaart afsnijdt. Markers in samples behouden hun nauwkeurigheid wanneer het bestand tussen apparaten verhuist, maar luister altijd op het echte tempo en volume van de game.' },
   ],
   faqTitle: 'Veelgestelde Vragen',
   faq: [

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

@@ -132,6 +132,10 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: 'Podczas eksportowania ścieżek z tego narzędzia nowe struktury metadanych są wstrzykiwane bezpośrednio do nagłówka RIFF pliku WAV.',
     },
+    { type: 'title', level: 2, text: 'Ocena długości pętli i przejścia fazowego' },
+    { type: 'paragraph', html: 'Przejście przez zero ogranicza skoki amplitudy, ale samo nie gwarantuje naturalnego przejścia muzycznego. Posłuchaj początku i końca jeden po drugim oraz sprawdź rytm, harmonię i wybrzmienie pogłosu podczas powtarzania.' },
+    { type: 'paragraph', html: 'Znaczniki są zapisywane w próbkach, więc nie zależą od zaokrąglenia do milisekund. Po kontroli odsłuchowej wyeksportuj WAV i przetestuj go w silniku, który odtworzy go w grze.' },
+    { type: 'paragraph', html: 'Sprawdź także, czy długość pętli pasuje do frazy muzycznej i nie ucina nuty ani wybrzmienia efektu. Znaczniki w próbkach zachowują precyzję między urządzeniami, ale wynik trzeba odsłuchać w rzeczywistym tempie i przy docelowej głośności gry.' },
   ],
   faqTitle: 'Często Zadawane Pytania',
   faq: [

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

@@ -132,6 +132,9 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: 'Ao exportar faixas de áudio desta ferramenta, novas estruturas de metadatos são injetadas diretamente no cabeçalho RIFF do arquivo WAV.',
     },
+    { type: 'title', level: 2, text: 'Avaliar a duração do loop e a transição de fase' },
+    { type: 'paragraph', html: 'Um cruzamento por zero reduz saltos de amplitude, mas não garante sozinho uma transição musical natural. Ouça o início e o fim em sequência e confira ritmo, harmonia e cauda de reverberação durante a repetição.' },
+    { type: 'paragraph', html: 'Os marcadores são armazenados em samples e não dependem do arredondamento em milissegundos. Depois da conferência auditiva, exporte o WAV e teste-o na engine que fará a reprodução no jogo.' },
   ],
   faqTitle: 'Perguntas Frequentes',
   faq: [

package/src/tool/audioLoopPointFinder/i18n/ru.ts

@@ -132,6 +132,10 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: 'При экспорте аудиодорожек из этой утилиты новые структуры метаданных внедряются непосредственно в заголовок RIFF выходного файла WAV.',
     },
+    { type: 'title', level: 2, text: 'Оценка длины петли и перехода фазы' },
+    { type: 'paragraph', html: 'Переход через ноль уменьшает скачки амплитуды, но сам по себе не гарантирует естественное музыкальное соединение. Прослушайте начало и конец подряд и проверьте ритм, гармонию и хвост реверберации при повторении.' },
+    { type: 'paragraph', html: 'Маркеры сохраняются в сэмплах и не зависят от округления миллисекунд. После проверки на слух экспортируйте WAV и протестируйте его в движке, который будет воспроизводить файл в игре.' },
+    { type: 'paragraph', html: 'Также проверьте, соответствует ли длина петли музыкальной фразе и не обрезает ли ноту или хвост эффекта. Маркеры в сэмплах сохраняют точность при переносе файла между устройствами, однако результат нужно прослушать в реальном темпе и с целевой громкостью игры.' },
   ],
   faqTitle: 'Часто Задаваемые Вопросы',
   faq: [

package/src/tool/audioLoopPointFinder/i18n/sv.ts

@@ -132,6 +132,10 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: 'När du exporterar ljudspår från detta verktyg bäddas nya metadatastrukturer in direkt i RIFF-headern på den exporterade WAV-filen.',
     },
+    { type: 'title', level: 2, text: 'Bedöm loopens längd och fasövergång' },
+    { type: 'paragraph', html: 'En nollgenomgång minskar amplitudhopp, men garanterar inte automatiskt en naturlig musikalisk övergång. Lyssna på början och slutet efter varandra och kontrollera rytm, harmoni och efterklang när loopen upprepas.' },
+    { type: 'paragraph', html: 'Markörerna sparas i samplingar och påverkas därför inte av avrundning till millisekunder. Exportera efter lyssningskontrollen och testa WAV-filen i motorn som ska spela den i spelet.' },
+    { type: 'paragraph', html: 'Kontrollera också att loopens längd passar den musikaliska frasen och inte klipper en ton eller en effektklang. Markörer i samplingar behåller precision mellan enheter, men resultatet ska alltid lyssnas på i spelets verkliga tempo och volym.' },
   ],
   faqTitle: 'Vanliga Frågor',
   faq: [

package/src/tool/audioLoopPointFinder/i18n/tr.ts

@@ -132,6 +132,10 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: 'Bu araçtan ses parçalarını dışa aktarırken yeni üstveri yapıları doğrudan WAV dosyasının RIFF başlığına enjekte edilir.',
     },
+    { type: 'title', level: 2, text: 'Döngü süresini ve faz geçişini değerlendirme' },
+    { type: 'paragraph', html: 'Sıfır geçişi genlik sıçramalarını azaltır, ancak tek başına doğal bir müzik geçişini garanti etmez. Başlangıç ve bitişi art arda dinleyin; tekrar sırasında ritmi, armoniyi ve yankı kuyruğunu kontrol edin.' },
+    { type: 'paragraph', html: 'İşaretçiler sample cinsinden saklandığı için milisaniye yuvarlamasına bağlı değildir. Dinleme kontrolünden sonra WAV dosyasını dışa aktarın ve oyunda çalacak motorda test edin.' },
+    { type: 'paragraph', html: 'Döngü uzunluğunun müzik cümlesine uyduğunu ve bir notayı ya da efekt kuyruğunu kesmediğini de kontrol edin. Sample cinsindeki işaretçiler dosya cihazlar arasında taşınsa bile hassasiyeti korur; yine de sonucu oyunun gerçek temposunda ve ses düzeyinde dinleyin.' },
   ],
   faqTitle: 'Sıkça Sorulan Sorular',
   faq: [

package/src/tool/audioLoopPointFinder/i18n/zh.ts

@@ -132,6 +132,10 @@ export const content: ToolLocaleContent<AudioLoopPointFinderUI> = {
       type: 'paragraph',
       html: '从此工具导出音频轨道时，新的元数据结构将直接注入到输出WAV二进制文件的RIFF头中。',
     },
+    { type: 'title', level: 2, text: '评估循环长度与相位衔接' },
+    { type: 'paragraph', html: '过零点可以减少振幅跳变，但不能单独保证自然的音乐衔接。请连续聆听开头和结尾，并检查循环重复时的节奏、和声以及混响尾音。' },
+    { type: 'paragraph', html: '标记点以采样数保存，不依赖毫秒四舍五入。完成听感检查后再导出 WAV，并在游戏实际使用的引擎中测试播放结果。' },
+    { type: 'paragraph', html: '还要确认循环长度符合音乐乐句，不会截断音符或效果尾音。采样数标记在设备之间传递时仍能保持精度，但最终结果应在游戏的实际速度和音量下试听。' },
   ],
   faqTitle: '常见问题解答',
   faq: [

package/src/tool/damageFormulaLab/bibliography.astro

@@ -1,24 +1,6 @@
 ---
-import type { BibliographyEntry } from '../../types';
-
-interface Props {
-  title?: string;
-  entries?: BibliographyEntry[];
-}
-
-const { title = 'References', entries = [] } = Astro.props;
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { bibliographyEntries } from './bibliography';
 ---
 
-{entries.length > 0 && (
-  <section class="damage-lab-references" aria-labelledby="damage-lab-reference-title">
-    <h2 id="damage-lab-reference-title">{title}</h2>
-    <ul>
-      {entries.map((entry) => <li><a href={entry.url} rel="noopener noreferrer" target="_blank">{entry.name}</a></li>)}
-    </ul>
-  </section>
-)}
-
-<style>
-  .damage-lab-references { margin-block: 2rem; }
-  .damage-lab-references a { color: var(--n-primary); }
-</style>
+<SharedBibliography links={bibliographyEntries} />

package/src/tool/damageFormulaLab/i18n/de.ts

@@ -172,6 +172,19 @@ export const content: ToolLocaleContent<DamageFormulaLabUI> = {
       title: 'Schaden und Trefferanzahl stets gemeinsam betrachten',
       html: 'Eine kleine Schadensänderung kann eine gesundheitsbezogene Schwelle überschreiten und einen Treffer einsparen. Vergleichen Sie Schadenswerte immer mit Treffern und TTK.',
     },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Rundung und Widerstandsreihenfolge sichtbar machen',
+    },
+    {
+      type: 'paragraph',
+      html: 'Die gleiche Formel kann je nach Rundung und Reihenfolge der Modifikatoren ein anderes Kampfergebnis liefern. Prüfen Sie deshalb nicht nur den mittleren Kurvenbereich, sondern auch kleine Trefferwerte, hohe Verteidigung und die Schwelle, an der ein weiterer Treffer nötig wird.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Die TTK-Anzeige ist eine mathematische Projektion auf Basis der eingegebenen Angriffskadenz. Sie berücksichtigt keine Ausweichbewegung, Cooldowns, Zufallsfolgen oder Unterbrechungen; verwenden Sie die Kurven als Designhilfe und validieren Sie die Regel anschließend im Spieltest.',
+    },
   ],
   faq,
   bibliographyTitle: 'Referenzen zur Schadensberechnung in Spielen',

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

@@ -172,6 +172,19 @@ export const content: ToolLocaleContent<DamageFormulaLabUI> = {
       title: 'Observer conjointement les dégâts et le nombre de coups',
       html: 'Une légère variation de dégâts peut franchir un seuil de santé et supprimer un coup complet. Comparez toujours les dégâts avec le nombre de coups et le TTK.',
     },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Rendre visibles l arrondi et l ordre des résistances',
+    },
+    {
+      type: 'paragraph',
+      html: 'Une même formule peut produire un combat différent selon l arrondi et l ordre des modificateurs. Examinez donc la zone centrale de la courbe, mais aussi les petits dégâts, la défense élevée et le seuil qui ajoute une attaque nécessaire.',
+    },
+    {
+      type: 'paragraph',
+      html: 'L affichage du TTK est une projection mathématique fondée sur la cadence saisie. Il ne modélise ni esquive, ni temps de recharge, ni suite aléatoire, ni interruption: utilisez les courbes pour guider le design puis vérifiez la règle en jeu.',
+    },
   ],
   faq,
   bibliographyTitle: 'Références sur la modélisation des dégâts',

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

@@ -172,6 +172,19 @@ export const content: ToolLocaleContent<DamageFormulaLabUI> = {
       title: 'Periksa damage dan jumlah pukulan secara bersamaan',
       html: 'Perubahan kecil pada damage bisa saja melewati ambang batas darah target dan mengurangi 1 pukulan penuh. Selalu bandingkan nilai damage dengan jumlah pukulan dan TTK.',
     },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Membuat pembulatan dan urutan resistance terlihat',
+    },
+    {
+      type: 'paragraph',
+      html: 'Formula yang sama dapat menghasilkan pertarungan berbeda bergantung pada pembulatan dan urutan modifier. Jangan hanya memeriksa bagian tengah kurva; lihat juga damage kecil, defense tinggi, dan batas yang menambah satu serangan lagi.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Nilai TTK adalah proyeksi matematika berdasarkan cadence yang dimasukkan. Nilai ini tidak memodelkan dodge, cooldown, urutan acak, atau interupsi, sehingga hasil kurva perlu diuji kembali dalam game.',
+    },
   ],
   faq,
   bibliographyTitle: 'Referensi kalkulasi damage game',

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

@@ -172,6 +172,7 @@ export const content: ToolLocaleContent<DamageFormulaLabUI> = {
       title: 'Esamina sempre sia il danno che i colpi necessari',
       html: 'Una piccola variazione di danno può superare una soglia di salute ed eliminare un intero colpo. Confronta sempre il danno con il TTK.',
     },
+    { type: 'paragraph', html: 'La stessa formula può produrre un combattimento diverso in base all arrotondamento e all ordine dei modificatori. Controlla anche danni piccoli, difesa alta e la soglia che richiede un colpo aggiuntivo; il TTK non include schivate, cooldown o interruzioni.' },
   ],
   faq,
   bibliographyTitle: 'Riferimenti per il calcolo del danno nei videogiochi',

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

@@ -70,6 +70,7 @@ export const content: ToolLocaleContent<DamageFormulaLabUI> = {
   ui: {
     onboarding: '現在のダメージ計算式と代替案を入力し、戦闘ステータスを調整して極端なステータス帯での挙動を検証します。',
     privacyNote: 'ローカル専用設計。計算式や設定はブラウザ内のみで処理されます。',
+    localNote: '戦闘モデルは非公開です。計算式とファイルはこのブラウザ内に留まります。',
     loadSprite: '計算式入力エリア',
     formulaDeck: '計算式デッキ',
     formulaALabel: '計算式A (現行モデル)',

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

@@ -70,6 +70,7 @@ export const content: ToolLocaleContent<DamageFormulaLabUI> = {
   ui: {
     onboarding: '현재 사용 중인 데미지 공식과 대안 공식을 입력하고 전투 능력치를 조정하여 수치적 경계를 검증하세요.',
     privacyNote: '로컬 전용 모델. 공식과 설정은 브라우저 내부에서만 처리됩니다.',
+    localNote: '비공개 전투 모델입니다. 공식과 파일은 이 브라우저 안에만 보관됩니다.',
     formulaDeck: '공식 챔버',
     formulaALabel: '공식 A (현재 모델)',
     formulaBLabel: '공식 B (대안 모델)',

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

@@ -172,6 +172,7 @@ export const content: ToolLocaleContent<DamageFormulaLabUI> = {
       title: 'Bekijk schade en treffers altijd samen',
       html: 'Een kleine verandering in schade kan een gezondheidsdrempel overschrijden en een complete treffer schelen. Vergelijk schade altijd met TTK.',
     },
+    { type: 'paragraph', html: 'Dezelfde formule kan door afronding en de volgorde van modifiers een ander gevecht opleveren. Controleer ook kleine schade, hoge verdediging en de drempel voor een extra treffer; TTK modelleert geen ontwijken, cooldowns of onderbrekingen.' },
   ],
   faq,
   bibliographyTitle: 'Referenties voor schadeberekening in games',

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

@@ -172,6 +172,7 @@ export const content: ToolLocaleContent<DamageFormulaLabUI> = {
       title: 'Analizuj obrażenia i liczbę ciosów jednocześnie',
       html: 'Niewielka zmiana obrażeń może przekroczyć próg zdrowia i zmniejszyć liczbę ciosów o jeden. Zawsze porównuj obrażenia z czasem zabicia (TTK).',
     },
+    { type: 'paragraph', html: 'Ta sama formuła może dać inny przebieg walki zależnie od zaokrągleń i kolejności modyfikatorów. Sprawdź także małe obrażenia, wysoką obronę i próg dodatkowego trafienia; TTK nie obejmuje uników, cooldownów ani przerw.' },
   ],
   faq,
   bibliographyTitle: 'Referencje do projektowania matematyki w grach',

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

@@ -172,6 +172,7 @@ export const content: ToolLocaleContent<DamageFormulaLabUI> = {
       title: 'Examine o dano e o número de golpes juntos',
       html: 'Uma pequena alteração no dano pode cruzar um limiar de vida e eliminar um golpe completo. Compare sempre o dano com o TTK.',
     },
+    { type: 'paragraph', html: 'A mesma fórmula pode produzir um combate diferente conforme o arredondamento e a ordem dos modificadores. Confira também danos pequenos, defesa alta e o limite que exige um golpe extra; o TTK não modela esquivas, recargas ou interrupções.' },
   ],
   faq,
   bibliographyTitle: 'Referências de cálculo de dano em jogos',