@jjlmoya/utils-sports 1.59.0 → 1.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-sports",
-    "version": "1.59.0",
+    "version": "1.60.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -27,7 +27,8 @@
         "lint": "eslint src/ --max-warnings 0 && stylelint \"src/**/*.{css,astro}\"",
         "check": "astro check",
         "type-check": "astro check",
-        "test": "vitest run --reporter=verbose --testTimeout=30000",
+        "test": "vitest run --exclude src/tests/qa_*.test.ts --reporter=verbose --testTimeout=30000",
+        "qa:audit": "vitest run src/tests/qa_*.test.ts --reporter=verbose",
         "preversion": "npm run lint && npm run test && npm run build",
         "postversion": "git push && git push --tags",
         "patch": "npm version patch",

package/src/tests/mfe_assets_contract.test.ts

@@ -0,0 +1,48 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import { CATEGORY_OG_IMAGE, getUtilityOgImage } from '../mfe/assets';
+
+const categoryImageMatch = CATEGORY_OG_IMAGE.match(
+  /^(\/_utilities\/[^/]+\/images)\/([^/]+\.webp)\?version=(.+)$/,
+);
+
+if (!categoryImageMatch) {
+  throw new Error(`Unexpected CATEGORY_OG_IMAGE format: ${CATEGORY_OG_IMAGE}`);
+}
+
+const [, imageUrlRoot, categoryImage, assetVersion] = categoryImageMatch;
+const assetRoot = join(process.cwd(), 'public', imageUrlRoot.slice(1));
+const categorySlug = basename(categoryImage, '.webp');
+
+describe('MFE asset contract', () => {
+  it('has one non-empty English-slug OG image per category and registered tool', async () => {
+    const expectedSlugs = new Set([categorySlug]);
+
+    for (const { entry } of ALL_TOOLS) {
+      const englishLoader = entry.i18n.en;
+      if (!englishLoader) throw new Error(`Missing English locale for ${entry.id}`);
+
+      const englishContent = await englishLoader();
+      expectedSlugs.add(englishContent.slug);
+    }
+
+    const actualSlugs = new Set(
+      readdirSync(assetRoot)
+        .filter((filename) => filename.endsWith('.webp'))
+        .map((filename) => filename.slice(0, -'.webp'.length)),
+    );
+
+    expect(actualSlugs).toEqual(expectedSlugs);
+
+    for (const slug of expectedSlugs) {
+      const imagePath = join(assetRoot, `${slug}.webp`);
+      expect(existsSync(imagePath), `${imagePath} should exist`).toBe(true);
+      expect(statSync(imagePath).size, `${imagePath} should not be empty`).toBeGreaterThan(0);
+      expect(getUtilityOgImage(slug)).toBe(
+        `${imageUrlRoot}/${slug}.webp?version=${assetVersion}`,
+      );
+    }
+  }, 30000);
+});

package/src/tests/qa-test-helpers.ts

@@ -0,0 +1,32 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+export const repositoryRoot = process.cwd();
+export const toolRoot = join(repositoryRoot, 'src', 'tool');
+
+export function listToolDirectories(): string[] {
+  return readdirSync(toolRoot)
+    .map((name) => join(toolRoot, name))
+    .filter((path) => statSync(path).isDirectory());
+}
+
+export function findFiles(directory: string, extensions: string[]): string[] {
+  const files: string[] = [];
+
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) files.push(...findFiles(path, extensions));
+    else if (extensions.some((extension) => entry.name.endsWith(extension))) files.push(path);
+  }
+
+  return files;
+}
+
+export function read(path: string): string {
+  return readFileSync(path, 'utf8');
+}
+
+export function displayPath(path: string): string {
+  return relative(repositoryRoot, path).replace(/\\/g, '/');
+}
+

package/src/tests/qa_bibliography_links.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+interface LinkFailure {
+  tool: string;
+  message: string;
+}
+
+function validateUrl(tool: string, rawUrl: string, seen: Set<string>): LinkFailure[] {
+  let url: URL;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return [{ tool, message: `invalid URL: ${rawUrl}` }];
+  }
+
+  const failures: LinkFailure[] = [];
+  if (url.protocol !== 'https:') failures.push({ tool, message: `non-HTTPS URL: ${rawUrl}` });
+  if (url.pathname === '/' && !url.search && !url.hash) {
+    failures.push({ tool, message: `generic homepage, cite the exact document: ${rawUrl}` });
+  }
+  if (seen.has(url.href)) failures.push({ tool, message: `duplicate source URL: ${rawUrl}` });
+  seen.add(url.href);
+  return failures;
+}
+
+describe('QA: bibliography links are specific and usable', () => {
+  it('uses unique HTTPS links to exact source pages instead of generic homepages', async () => {
+    const failures: LinkFailure[] = [];
+
+    for (const tool of ALL_TOOLS) {
+      const loader = tool.entry.i18n.en;
+      if (!loader) {
+        failures.push({ tool: tool.entry.id, message: 'English locale loader is missing' });
+        continue;
+      }
+
+      const content = (await loader()) as ToolLocaleContent;
+      const seen = new Set<string>();
+
+      for (const entry of content.bibliography ?? []) {
+        failures.push(...validateUrl(tool.entry.id, entry.url, seen));
+      }
+    }
+
+    const messages = failures.map(({ tool, message }) => `${tool}: ${message}`);
+    expect(messages, `Bibliography hygiene failures:\n${messages.join('\n')}`).toEqual([]);
+  });
+});

package/src/tests/qa_claim_evidence.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { displayPath, listToolDirectories, read } from './qa-test-helpers';
+
+const evidenceClaims = [
+  /\bofficial algorithm\b/i,
+  /\balgoritmo oficial\b/i,
+  /\b(?:records|data|rates|tables) updated(?:\s+(?:to|through)\s+20\d{2})?\b/i,
+  /\b(?:registros|datos|tasas|tablas) actualizad[oa]s?(?:\s+(?:a|hasta)\s+20\d{2})?\b/i,
+  /\b(?:validated|verified) (?:method|algorithm|calculation)\b/i,
+  /\b(?:método|algoritmo|cálculo) (?:validado|verificado)\b/i,
+  /\b(?:guarantees|ensures)\b/i,
+  /\bgarantiza\b/i,
+  /\bofficial (?:data|rate|calculation)\b/i,
+  /\b(?:datos|tasa|cálculo) oficial(?:es)?\b/i,
+];
+
+const requiredEvidenceFields = [
+  'reviewedAt',
+  'methodology',
+  'sources',
+  'referenceCases',
+  'limitations',
+];
+
+describe('QA: strong factual claims are traceable', () => {
+  it('requires machine-readable validation evidence beside tools making strong claims', () => {
+    const failures: string[] = [];
+
+    for (const directory of listToolDirectories()) {
+      const localePaths = ['en', 'es']
+        .map((locale) => join(directory, 'i18n', `${locale}.ts`))
+        .filter(existsSync);
+      const claims = localePaths.flatMap((path) => {
+        const source = read(path);
+        return evidenceClaims
+          .filter((pattern) => pattern.test(source))
+          .map((pattern) => `${displayPath(path)} matches ${pattern.source}`);
+      });
+      if (claims.length === 0) continue;
+
+      const evidencePath = join(directory, 'validation.ts');
+      if (!existsSync(evidencePath)) {
+        failures.push(`${displayPath(evidencePath)} missing; claims: ${claims.join(' | ')}`);
+        continue;
+      }
+
+      const evidence = read(evidencePath);
+      const missingFields = requiredEvidenceFields.filter(
+        (field) => !new RegExp(`\\b${field}\\s*:`).test(evidence),
+      );
+      if (missingFields.length > 0) {
+        failures.push(`${displayPath(evidencePath)} missing fields: ${missingFields.join(', ')}`);
+      }
+    }
+
+    expect(
+      failures,
+      [
+        'Claims such as official, validated, guaranteed or updated need inspectable evidence.',
+        'Add validation.ts with reviewedAt, methodology, sources, referenceCases and limitations,',
+        'or weaken/remove the unsupported claim.',
+        ...failures,
+      ].join('\n'),
+    ).toEqual([]);
+  });
+});
+

package/src/tests/qa_logic_reference_coverage.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+import { basename, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import {
+  displayPath,
+  findFiles,
+  listToolDirectories,
+  read,
+  repositoryRoot,
+} from './qa-test-helpers';
+
+function hasDedicatedLogicTest(toolDirectory: string): boolean {
+  const localCandidates = [
+    join(toolDirectory, 'logic.test.ts'),
+    join(toolDirectory, 'logic.spec.ts'),
+    join(toolDirectory, '__tests__', 'logic.test.ts'),
+    join(toolDirectory, '__tests__', 'logic.spec.ts'),
+  ];
+  if (localCandidates.some(existsSync)) return true;
+
+  const toolName = basename(toolDirectory);
+  const centralTests = findFiles(join(repositoryRoot, 'src', 'tests'), ['.test.ts', '.spec.ts']);
+  return centralTests.some((testPath) => {
+    const source = read(testPath).replace(/\\/g, '/');
+    return source.includes(`/tool/${toolName}/logic`) || source.includes(`../tool/${toolName}/logic`);
+  });
+}
+
+describe('QA: calculation logic has reference tests', () => {
+  it('gives every public calculator logic module its own behavioral test suite', () => {
+    const failures = listToolDirectories()
+      .filter((directory) => existsSync(join(directory, 'logic.ts')))
+      .filter((directory) => !hasDedicatedLogicTest(directory))
+      .map((directory) => `${displayPath(join(directory, 'logic.ts'))} -> no test imports this module`);
+
+    expect(
+      failures,
+      [
+        'Add behavioral tests through each logic module public API.',
+        'At minimum cover a documented reference case, boundaries, invalid input and invariants.',
+        ...failures,
+      ].join('\n'),
+    ).toEqual([]);
+  });
+});
+

package/src/tests/qa_runtime_i18n.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+import { basename, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import {
+  displayPath,
+  findFiles,
+  listToolDirectories,
+  read,
+  repositoryRoot,
+} from './qa-test-helpers';
+
+interface VisibleLiteral {
+  line: number;
+  value: string;
+}
+
+const domTextAssignment = /\.(?:innerText|textContent|innerHTML)\s*=/;
+const quotedLiteral = /(['"`])((?:\\.|(?!\1).)*)\1/g;
+
+function visibleWords(value: string): string {
+  return value
+    .replace(/\$\{[^}]*\}/g, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&[a-z]+;/gi, ' ')
+    .replace(/[\d\p{P}\p{S}_]+/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function isTechnicalLiteral(value: string): boolean {
+  return ['.', '#', '['].some((prefix) => value.startsWith(prefix))
+    || /^data-[a-z0-9-]+$/i.test(value);
+}
+
+function hardcodedVisibleLiterals(source: string): VisibleLiteral[] {
+  const failures: VisibleLiteral[] = [];
+
+  source.split(/\r?\n/).forEach((line, index) => {
+    if (!domTextAssignment.test(line)) return;
+
+    const assignment = line.slice(line.search(domTextAssignment));
+    for (const match of assignment.matchAll(quotedLiteral)) {
+      const literal = match[2];
+      if (!literal || isTechnicalLiteral(literal)) continue;
+      const words = visibleWords(literal);
+      if (words && /\p{L}/u.test(words)) {
+        failures.push({ line: index + 1, value: literal });
+      }
+    }
+  });
+
+  return failures;
+}
+
+function runtimeSources(toolDirectory: string): string {
+  return findFiles(toolDirectory, ['.astro', '.ts', '.js'])
+    .filter((path) => !path.includes(`${join(toolDirectory, 'i18n')}`))
+    .filter((path) => basename(path) !== 'ui.ts')
+    .map(read)
+    .join('\n');
+}
+
+describe('QA: runtime copy is localized', () => {
+  const componentFiles = findFiles(join(repositoryRoot, 'src', 'tool'), ['.astro']);
+
+  it('does not write user-facing string literals directly into the DOM', () => {
+    const failures = componentFiles.flatMap((path) =>
+      hardcodedVisibleLiterals(read(path)).map(
+        ({ line, value }) => `${displayPath(path)}:${line} -> ${JSON.stringify(value)}`,
+      ),
+    );
+
+    expect(
+      failures,
+      `Move visible browser copy to the tool UI locale contract:\n${failures.join('\n')}`,
+    ).toEqual([]);
+  });
+
+  it('uses every string declared by each UI locale contract', () => {
+    const failures: string[] = [];
+
+    for (const directory of listToolDirectories()) {
+      const uiPath = join(directory, 'ui.ts');
+      if (!existsSync(uiPath)) continue;
+
+      const keys = Array.from(read(uiPath).matchAll(/^\s*(\w+)\??:\s*string\s*;/gm), (match) => match[1]);
+      const runtime = runtimeSources(directory);
+      const unused = keys.filter((key) => !new RegExp(`\\b${key}\\b`).test(runtime));
+
+      if (unused.length > 0) {
+        failures.push(`${displayPath(uiPath)} -> unused: ${unused.join(', ')}`);
+      }
+    }
+
+    expect(
+      failures,
+      `Unused locale keys are dead copy or may mean the browser bypasses translations:\n${failures.join('\n')}`,
+    ).toEqual([]);
+  });
+});

package/src/tool/rugbyScoreKeeper/component.astro

@@ -18,7 +18,7 @@ const t = (ui ?? {}) as RugbyScoreKeeperUI;
   <div class="rg-strip">
     <div class="rg-team">
       <input type="text" class="rg-name" id="rg-name-home" value={t.home} aria-label={t.home} />
-      <div class="rg-score" id="rg-score-home">0</div>
+      <div class="rg-score" id="rg-score-home" aria-live="polite">0</div>
       <div class="rg-bonus" id="rg-bonus-home"></div>
     </div>
     <div class="rg-divider">
@@ -27,7 +27,7 @@ const t = (ui ?? {}) as RugbyScoreKeeperUI;
     </div>
     <div class="rg-team">
       <input type="text" class="rg-name" id="rg-name-away" value={t.away} aria-label={t.away} />
-      <div class="rg-score" id="rg-score-away">0</div>
+      <div class="rg-score" id="rg-score-away" aria-live="polite">0</div>
       <div class="rg-bonus" id="rg-bonus-away"></div>
     </div>
   </div>
@@ -54,10 +54,10 @@ const t = (ui ?? {}) as RugbyScoreKeeperUI;
       <div class="rg-clock-ring">
         <svg class="rg-clock-svg" viewBox="0 0 120 120">
           <circle class="rg-clock-bg" cx="60" cy="60" r="54" />
-          <circle class="rg-clock-fill" id="rg-clock-fill" cx="60" cy="60" r="54" />
+          <circle class="rg-clock-fill" id="rg-clock-fill" cx="60" cy="60" r="54" aria-hidden="true" />
         </svg>
         <div class="rg-clock-inner">
-          <div class="rg-clock-time" id="rg-clock-time">00:00</div>
+          <div class="rg-clock-time" id="rg-clock-time" aria-live="polite">00:00</div>
           <div class="rg-clock-label">{t.half} <span id="rg-half-label">1</span></div>
         </div>
       </div>
@@ -68,8 +68,8 @@ const t = (ui ?? {}) as RugbyScoreKeeperUI;
       <div class="rg-sinbin-form">
         <input type="text" class="rg-input" id="rg-sinbin-input" placeholder={t.sinBinPlayer} aria-label={t.sinBinPlayer} />
         <select class="rg-select" id="rg-sinbin-duration" aria-label={t.sinBin + " duration"}>
-          <option value="600">10 min</option>
-          <option value="300">5 min</option>
+          <option value="600">10 {t.minutesShort}</option>
+          <option value="300">5 {t.minutesShort}</option>
         </select>
         <button class="rg-btn rg-btn-yellow" id="rg-btn-sinbin">{t.sinBinAdd}</button>
       </div>
@@ -110,12 +110,13 @@ const t = (ui ?? {}) as RugbyScoreKeeperUI;
     </div>
   </div>
 
-  <div id="rg-banner" class="rg-banner" style="display:none">
+  <div id="rg-banner" class="rg-banner" role="status" aria-live="polite" style="display:none">
     <div class="rg-banner-text" id="rg-banner-text"></div>
   </div>
 
-  <div class="rg-reset-modal" id="rg-modal">
+  <div class="rg-reset-modal" id="rg-modal" role="dialog" aria-modal="true" aria-labelledby="rg-modal-title">
     <div class="rg-modal-content">
+      <h2 class="rg-modal-title" id="rg-modal-title">{t.resetMatch}</h2>
       <div class="rg-modal-text">{t.resetConfirm}</div>
       <div class="rg-modal-btns">
         <button class="rg-btn rg-btn-modal-cancel" id="rg-modal-cancel">{t.cancel}</button>

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Letztes Rückgängig',
     timeOff: 'Zeit Gestoppt',
     timeOn: 'Zeit Läuft',
+    fullTime: 'Spielende',
+    minutesShort: 'Min.',
   },
 };

package/src/tool/rugbyScoreKeeper/i18n/en.ts

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Undo Last',
     timeOff: 'Time Off',
     timeOn: 'Time On',
+    fullTime: 'Full time',
+    minutesShort: 'min',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Deshacer Último',
     timeOff: 'Tiempo Detenido',
     timeOn: 'Tiempo en Marcha',
+    fullTime: 'Fin del partido',
+    minutesShort: 'min',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Annuler le Dernier',
     timeOff: 'Temps Arrêté',
     timeOn: 'Temps en Marche',
+    fullTime: 'Fin du match',
+    minutesShort: 'min',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Batalkan terakhir',
     timeOff: 'Waktu Berhenti',
     timeOn: 'Waktu Berjalan',
+    fullTime: 'Pertandingan Selesai',
+    minutesShort: 'mnt',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Annulla Ultimo',
     timeOff: 'Tempo Fermo',
     timeOn: 'Tempo in Gioco',
+    fullTime: 'Fine partita',
+    minutesShort: 'min',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: '最後を元に戻す',
     timeOff: 'タイムオフ',
     timeOn: 'タイムオン',
+    fullTime: '試合終了',
+    minutesShort: '分',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: '마지막 실행 취소',
     timeOff: '타임 오프',
     timeOn: '타임 온',
+    fullTime: '경기 종료',
+    minutesShort: '분',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Ongedaan Maken Laatste',
     timeOff: 'Tijd Stil',
     timeOn: 'Tijd Loopt',
+    fullTime: 'Einde wedstrijd',
+    minutesShort: 'min',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Cofnij ostatnie',
     timeOff: 'Czas zatrzymany',
     timeOn: 'Czas włączony',
+    fullTime: 'Koniec meczu',
+    minutesShort: 'min',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Desfazer Último',
     timeOff: 'Tempo Parado',
     timeOn: 'Tempo em Jogo',
+    fullTime: 'Fim de jogo',
+    minutesShort: 'min',
   },
 };

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

@@ -13,7 +13,7 @@ const faqData = [
   },
   {
     question: 'Что происходит, когда игрок получает жёлтую карточку в регби?',
-    answer: '�-ёлтая карточка означает временное удаление на скамейку штрафников. Игрок должен покинуть поле на 10 минут игрового времени. Его команда играет в меньшинстве в этот период. Таймер скамейки штрафников отсчитывает время только когда часы матча запущены.',
+    answer: 'Жёлтая карточка означает временное удаление на скамейку штрафников. Игрок должен покинуть поле на 10 минут игрового времени. Его команда играет в меньшинстве в этот период. Таймер скамейки штрафников отсчитывает время только когда часы матча запущены.',
   },
   {
     question: 'Сколько длится матч по регби-юнион?',
@@ -23,12 +23,12 @@ const faqData = [
 
 const howToData = [
   {
-    name: '�-аписывайте игровые события',
+          name: 'Записывайте игровые события',
     text: 'Нажимайте кнопки Попытка, Реализация, Штрафной или Дроп-гол для записи очков. После нажатия Попытки кнопка Реализации подсвечивается автоматически.',
   },
   {
     name: 'Управляйте штрафными удалениями',
-    text: 'Нажмите �-ёлтая карточка, чтобы отправить игрока на скамейку штрафников. Введите его имя или номер, и начнётся автоматический 10-минутный отсчёт.',
+          text: 'Нажмите "Жёлтая карточка", чтобы отправить игрока на скамейку штрафников. Введите его имя или номер, и начнётся автоматический 10-минутный отсчёт.',
   },
   {
     name: 'Контролируйте время матча',
@@ -92,7 +92,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     },
     {
       type: 'paragraph',
-      html: 'Управляйте подсчётом очков в матче по регби с помощью нашего интерактивного цифрового табло. �-аписывайте попытки, реализации, штрафные и дроп-голы в реальном времени. Система управления скамейкой штрафников автоматически отсчитывает время удалений, а часы матча идеально синхронизируют обе половины. Судите ли вы местный клубный матч или тренируете молодёжную команду, этот инструмент автоматически обработает все детали подсчёта и хронометража.',
+            html: 'Управляйте подсчётом очков в матче по регби с помощью нашего интерактивного цифрового табло. Записывайте попытки, реализации, штрафные и дроп-голы в реальном времени. Система управления скамейкой штрафников автоматически отсчитывает время удалений, а часы матча идеально синхронизируют обе половины. Судите ли вы местный клубный матч или тренируете молодёжную команду, этот инструмент автоматически обработает все детали подсчёта и хронометража.',
     },
     {
       type: 'title',
@@ -109,7 +109,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
       items: [
         {
           title: 'Попытка',
-          description: '�-анести мяч в зачётную зону на 5 очков.',
+             description: 'Занести мяч в зачётную зону на 5 очков.',
           icon: 'mdi:rugby',
           points: ['Начисляется 5 очков', 'Даёт право на реализацию', 'Требуется занос мяча'],
         },
@@ -162,7 +162,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     },
     {
       type: 'title',
-      text: '�-ачем использовать цифровой счётчик регби',
+           text: 'Зачем использовать цифровой счётчик регби',
       level: 2,
     },
     {
@@ -182,7 +182,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     dropGoal: 'Дроп-гол +3',
     conversionYes: 'Да',
     conversionNo: 'Нет',
-    sinBin: '�-ёлтая карточка',
+  sinBin: 'Жёлтая карточка',
     sinBinTitle: 'Скамейка штрафников',
     sinBinPlayer: 'Имя или номер игрока:',
     sinBinAdd: 'Начать отстранение',
@@ -209,10 +209,12 @@ export const content: RugbyScoreKeeperLocaleContent = {
     totalPoints: 'Всего',
     fullscreen: 'Полный экран',
     toggleSound: 'Вкл/Выкл звук',
-    eventLog: '�-урнал событий',
+  eventLog: 'Журнал событий',
     eventEmpty: 'Событий пока нет',
     undoBtn: 'Отменить последнее',
     timeOff: 'Время выкл',
     timeOn: 'Время вкл',
+    fullTime: 'Матч окончен',
+    minutesShort: 'мин',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Ångra senaste',
     timeOff: 'Tid stoppad',
     timeOn: 'Tid igång',
+    fullTime: 'Matchen är slut',
+    minutesShort: 'min',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Son işlemi geri al',
     timeOff: 'Süre durdu',
     timeOn: 'Süre başladı',
+    fullTime: 'Maç bitti',
+    minutesShort: 'dk',
   },
 };

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

@@ -214,5 +214,7 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: '撤销上一步',
     timeOff: '时间停',
     timeOn: '时间开',
+    fullTime: '比赛结束',
+    minutesShort: '分钟',
   },
 };

package/src/tool/rugbyScoreKeeper/logic.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'vitest';
+import {
+  addSinBin,
+  createInitialState,
+  scorePenalty,
+  scoreTry,
+  startMatch,
+  startSecondHalf,
+  teamTotal,
+  tickClock,
+  tickSinBin,
+  toggleClock,
+  undoLast,
+  losingBonus,
+} from './logic';
+
+describe('rugbyScoreKeeper game clock', () => {
+  it('starts the second half without losing the score, statistics, history, or sin-bin timers', () => {
+    let state = createInitialState();
+    state = scoreTry(state, 'home');
+    state = scorePenalty(state, 'away');
+    state = addSinBin(state, 'Number 8', 600);
+    state = startMatch({ ...state, elapsed: 2399 });
+
+    state = tickClock(state, 1);
+
+    expect(state.half).toBe(1);
+    expect(state.elapsed).toBe(2400);
+    expect(state.clockRunning).toBe(false);
+    expect(teamTotal(state.home)).toBe(5);
+    expect(teamTotal(state.away)).toBe(3);
+    expect(state.history).toHaveLength(3);
+    expect(state.sinBin[0]?.remaining).toBe(599);
+
+    const halftimeState = structuredClone(state);
+    state = startSecondHalf(state);
+
+    expect(state).toEqual({
+      ...halftimeState,
+      half: 2,
+      clockRunning: true,
+    });
+
+    state = tickClock(state, 1);
+    expect(state.elapsed).toBe(2401);
+    expect(state.clockRunning).toBe(true);
+    expect(teamTotal(state.home)).toBe(5);
+    expect(teamTotal(state.away)).toBe(3);
+  });
+
+  it('does not start the second half before halftime', () => {
+    const state = startMatch({ ...createInitialState(), elapsed: 2399 });
+
+    expect(startSecondHalf(state)).toBe(state);
+  });
+
+  it('ends the match at 80 minutes after the second half', () => {
+    let state = startSecondHalf({
+      ...createInitialState(),
+      matchStarted: true,
+      elapsed: 2400,
+    });
+    state = { ...state, elapsed: 4799 };
+
+    state = tickClock(state, 1);
+
+    expect(state.elapsed).toBe(4800);
+    expect(state.clockRunning).toBe(false);
+    expect(state.matchEnded).toBe(true);
+  });
+
+  it('undoes a sin-bin event and its timer together', () => {
+    const withSinBin = addSinBin(createInitialState(), '  Player <x>  ', 600);
+    expect(withSinBin.sinBin).toHaveLength(1);
+    expect(withSinBin.sinBin[0]?.player).toBe('Player <x>');
+    const undone = undoLast(withSinBin);
+    expect(undone.sinBin).toEqual([]);
+    expect(undone.history).toEqual([]);
+  });
+
+  it('rejects invalid timer input and keeps match state immutable', () => {
+    const state = createInitialState();
+    expect(addSinBin(state, ' ', 600)).toBe(state);
+    expect(addSinBin(state, 'Player', 0)).toBe(state);
+    expect(addSinBin(state, 'Player', Number.NaN)).toBe(state);
+    expect(tickSinBin(state, 0)).not.toBe(state);
+    expect(tickSinBin(state, -1).sinBin).toEqual([]);
+  });
+
+  it('does not score or toggle after full time', () => {
+    const ended = { ...createInitialState(), matchEnded: true };
+    expect(scoreTry(ended, 'home')).toBe(ended);
+    expect(toggleClock(ended)).toBe(ended);
+  });
+
+  it('does not award a losing bonus for a tie', () => {
+    const state = createInitialState();
+    expect(losingBonus(state.home, state.away, 'home')).toBe(false);
+    const homeTry = scoreTry(state, 'home');
+    expect(losingBonus(homeTry.home, homeTry.away, 'away')).toBe(true);
+  });
+});

package/src/tool/rugbyScoreKeeper/logic.ts

@@ -7,6 +7,8 @@ export interface HistoryEvent {
   team: TeamKey;
   label: string;
   minute: string;
+  player?: string;
+  sinBinId?: number;
 }
 
 export interface TeamScore {
@@ -62,52 +64,60 @@ function fmtMin(elapsed: number): string {
   return `Min ${Math.floor(elapsed / 60)}`;
 }
 
-function pushEvent(s: MatchState, type: EventType, team: TeamKey, label: string) {
-  s.history.push({ type, team, label, minute: fmtMin(s.elapsed) });
+function pushEvent(s: MatchState, type: EventType, team: TeamKey, details: { label?: string; player?: string; sinBinId?: number } = {}) {
+  s.history.push({ type, team, label: details.label ?? type, minute: fmtMin(s.elapsed), ...details });
 }
 
 export function scoreTry(state: MatchState, team: TeamKey): MatchState {
+  if (state.matchEnded) return state;
   const s = structuredClone(state);
   if (team === 'home') s.home.tries++; else s.away.tries++;
-  pushEvent(s, 'try', team, 'TRY');
+  pushEvent(s, 'try', team, { label: 'TRY' });
   return s;
 }
 
 export function scoreConversion(state: MatchState, team: TeamKey, success: boolean): MatchState {
+  if (state.matchEnded) return state;
   const s = structuredClone(state);
   if (success) {
     if (team === 'home') s.home.conversions++; else s.away.conversions++;
-    pushEvent(s, 'conv', team, 'CONV +2');
+    pushEvent(s, 'conv', team, { label: 'CONV +2' });
   } else {
     if (team === 'home') s.home.missedConversions++; else s.away.missedConversions++;
-    pushEvent(s, 'missed-conv', team, 'CONV miss');
+    pushEvent(s, 'missed-conv', team, { label: 'CONV miss' });
   }
   return s;
 }
 
 export function scorePenalty(state: MatchState, team: TeamKey): MatchState {
+  if (state.matchEnded) return state;
   const s = structuredClone(state);
   if (team === 'home') s.home.penalties++; else s.away.penalties++;
-  pushEvent(s, 'pen', team, 'PEN +3');
+  pushEvent(s, 'pen', team, { label: 'PEN +3' });
   return s;
 }
 
 export function scoreDropGoal(state: MatchState, team: TeamKey): MatchState {
+  if (state.matchEnded) return state;
   const s = structuredClone(state);
   if (team === 'home') s.home.dropGoals++; else s.away.dropGoals++;
-  pushEvent(s, 'drop', team, 'DG +3');
+  pushEvent(s, 'drop', team, { label: 'DG +3' });
   return s;
 }
 
 export function addSinBin(state: MatchState, player: string, duration: number): MatchState {
+  const cleanPlayer = player.trim();
+  if (state.matchEnded || !cleanPlayer || !Number.isFinite(duration) || duration <= 0) return state;
   const s = structuredClone(state);
-  s.sinBin.push({ id: Date.now(), player, remaining: duration, total: duration });
-  pushEvent(s, 'sinbin', 'home', `${player} SIN BIN`);
+  const id = Math.max(Date.now(), ...s.sinBin.map((entry) => entry.id + 1));
+  s.sinBin.push({ id, player: cleanPlayer, remaining: duration, total: duration });
+  pushEvent(s, 'sinbin', 'home', { label: `${cleanPlayer} SIN BIN`, player: cleanPlayer, sinBinId: id });
   return s;
 }
 
 export function tickSinBin(state: MatchState, delta: number): MatchState {
   const s = structuredClone(state);
+  if (!Number.isFinite(delta) || delta <= 0) return s;
   s.sinBin = s.sinBin
     .map((e) => ({ ...e, remaining: Math.max(0, e.remaining - delta) }))
     .filter((e) => e.remaining > 0);
@@ -116,7 +126,7 @@ export function tickSinBin(state: MatchState, delta: number): MatchState {
 
 export function tickClock(state: MatchState, delta: number): MatchState {
   const s = structuredClone(state);
-  if (!s.clockRunning || s.matchEnded) return s;
+  if (!s.clockRunning || s.matchEnded || !Number.isFinite(delta) || delta <= 0) return s;
   s.elapsed += delta;
   if (s.elapsed >= 2400 && s.half === 1) {
     s.elapsed = 2400;
@@ -131,23 +141,36 @@ export function tickClock(state: MatchState, delta: number): MatchState {
 }
 
 export function startMatch(state: MatchState): MatchState {
+  if (state.matchEnded) return state;
   return { ...state, clockRunning: true, matchStarted: true };
 }
 
+export function startSecondHalf(state: MatchState): MatchState {
+  if (state.half !== 1 || state.elapsed < 2400 || state.matchEnded) return state;
+  return { ...state, half: 2, clockRunning: true };
+}
+
 export function toggleClock(state: MatchState): MatchState {
+  if (state.matchEnded) return state;
   return { ...state, clockRunning: !state.clockRunning };
 }
 
+function undoScore(ts: TeamScore, type: EventType) {
+  if (type === 'try') ts.tries = Math.max(0, ts.tries - 1);
+  else if (type === 'conv') ts.conversions = Math.max(0, ts.conversions - 1);
+  else if (type === 'missed-conv') ts.missedConversions = Math.max(0, ts.missedConversions - 1);
+  else if (type === 'pen') ts.penalties = Math.max(0, ts.penalties - 1);
+  else if (type === 'drop') ts.dropGoals = Math.max(0, ts.dropGoals - 1);
+}
+
 export function undoLast(state: MatchState): MatchState {
   const s = structuredClone(state);
   const ev = s.history.pop();
   if (!ev) return s;
   const ts = ev.team === 'home' ? s.home : s.away;
-  if (ev.type === 'try') ts.tries = Math.max(0, ts.tries - 1);
-  else if (ev.type === 'conv') ts.conversions = Math.max(0, ts.conversions - 1);
-  else if (ev.type === 'missed-conv') ts.missedConversions = Math.max(0, ts.missedConversions - 1);
-  else if (ev.type === 'pen') ts.penalties = Math.max(0, ts.penalties - 1);
-  else if (ev.type === 'drop') ts.dropGoals = Math.max(0, ts.dropGoals - 1);
+  if (ev.type === 'sinbin' && ev.sinBinId !== undefined) {
+    s.sinBin = s.sinBin.filter((entry) => entry.id !== ev.sinBinId);
+  } else undoScore(ts, ev.type);
   return s;
 }
 
@@ -170,7 +193,10 @@ export function bonusPoints(ts: TeamScore): string[] {
 }
 
 export function losingBonus(home: TeamScore, away: TeamScore, team: TeamKey): boolean {
-  const diff = Math.abs(teamTotal(home) - teamTotal(away));
-  const losing = teamTotal(home) < teamTotal(away) ? 'home' : 'away';
+  const homeTotal = teamTotal(home);
+  const awayTotal = teamTotal(away);
+  if (homeTotal === awayTotal) return false;
+  const diff = Math.abs(homeTotal - awayTotal);
+  const losing = homeTotal < awayTotal ? 'home' : 'away';
   return losing === team && diff <= 7;
 }

package/src/tool/rugbyScoreKeeper/rugby-scorekeeper.css

@@ -623,3 +623,15 @@
   0%, 100% { opacity: 1; }
   50% { opacity: 0.5; }
 }
+
+@media (max-width: 560px) {
+  .rg-app { padding: 8px; }
+  .rg-main-card { padding: 8px; }
+  .rg-strip { padding: 10px 8px; }
+  .rg-divider { padding: 0 4px; }
+  .rg-mid-row, .rg-bottom-row { grid-template-columns: 1fr; }
+  .rg-sinbin-form { flex-wrap: wrap; }
+  .rg-sinbin-form .rg-input { flex-basis: 100%; }
+  .rg-sinbin-form .rg-btn-yellow { flex: 1; }
+  .rg-btn { min-height: 44px; }
+}

package/src/tool/rugbyScoreKeeper/ui-helpers.ts

@@ -0,0 +1,20 @@
+import type { HistoryEvent } from './logic';
+import type { RugbyScoreKeeperUI } from './ui';
+
+export function escapeHtml(value: string): string {
+  return value.replace(/[&<>"']/g, (char) => ({
+    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
+  }[char] ?? char));
+}
+
+export function eventLabel(event: HistoryEvent, ui: RugbyScoreKeeperUI): string {
+  switch (event.type) {
+    case 'try': return `${ui.tryScored} +5`;
+    case 'conv': return `${ui.conversionSuccess} +2`;
+    case 'missed-conv': return ui.conversionMiss;
+    case 'pen': return `${ui.penaltyScored} +3`;
+    case 'drop': return `${ui.dropGoalScored} +3`;
+    case 'sinbin': return event.player ? `${ui.sinBin}: ${event.player}` : ui.sinBin;
+    default: return event.label;
+  }
+}

package/src/tool/rugbyScoreKeeper/ui-init.ts

@@ -1,39 +1,38 @@
 import type { TeamKey, MatchState, TeamScore } from './logic';
+import type { RugbyScoreKeeperUI } from './ui';
+import { escapeHtml, eventLabel } from './ui-helpers';
 import {
   createInitialState, scoreTry, scoreConversion, scorePenalty, scoreDropGoal,
-  addSinBin, tickClock, startMatch, toggleClock, teamTotal,
+  addSinBin, tickClock, startMatch, startSecondHalf, toggleClock, teamTotal,
   formatTime, formatSinBinTime, undoLast, bonusPoints, losingBonus,
 } from './logic';
 
-interface RGUI {
-  home: string; away: string; tryLabel: string; conversion: string; penalty: string;
-  dropGoal: string; sinBin: string; sinBinPlayer: string; sinBinAdd: string;
-  sinBinEmpty: string; matchClock: string; half: string; half1: string;
-  half2: string; startMatch: string; resetMatch: string; resetConfirm: string;
-  cancel: string; confirm: string; scoringSummary: string; tryScored: string;
-  conversionSuccess: string; penaltyScored: string; dropGoalScored: string;
-  totalPoints: string; fullscreen: string; toggleSound: string;
-  eventLog: string; eventEmpty: string; undoBtn: string; timeOff: string; timeOn: string;
-}
+type ClockId = { v: ReturnType<typeof setInterval> | undefined };
 
-function getUI(): RGUI {
+function getUI(): RugbyScoreKeeperUI {
   const app = document.getElementById('rg-app') as HTMLElement;
-  return JSON.parse(app?.dataset.rgUi ?? '{}') as RGUI;
+  return JSON.parse(app?.dataset.rgUi ?? '{}') as RugbyScoreKeeperUI;
 }
 
-function q<T extends HTMLElement = HTMLElement>(id: string): T | null {
+function q<T extends Element = HTMLElement>(id: string): T | null {
   return document.getElementById(id) as T | null;
 }
 
+function renderHalf(s: MatchState) {
+  const label = q('rg-half-label');
+  const badge = q('rg-half-badge');
+  if (label) label.textContent = String(s.half);
+  if (badge) badge.textContent = s.half === 1 ? getUI().half1 : getUI().half2;
+}
+
 function renderScoreboard(s: MatchState) {
   const sh = q('rg-score-home');
   const sa = q('rg-score-away');
   const ct = q('rg-clock-time');
-  const hl = q('rg-half-label');
   if (sh) sh.textContent = String(teamTotal(s.home));
   if (sa) sa.textContent = String(teamTotal(s.away));
   if (ct) ct.textContent = formatTime(s.elapsed);
-  if (hl) hl.textContent = String(s.half);
+  renderHalf(s);
   const cf = q<SVGPathElement>('rg-clock-fill');
   if (cf) {
     const max = s.half === 1 ? 2400 : 4800;
@@ -58,9 +57,10 @@ function renderHistory(s: MatchState) {
     return;
   }
   if (undo) undo.removeAttribute('disabled');
+  const ui = getUI();
   list.innerHTML = s.history.map((e) => {
     const cls = e.team === 'home' ? 'rg-ev-home' : 'rg-ev-away';
-    return `<div class="rg-history-event ${cls}"><span class="rg-ev-min">${e.minute}</span><span class="rg-ev-label">${e.label}</span></div>`;
+    return `<div class="rg-history-event ${cls}"><span class="rg-ev-min">${escapeHtml(e.minute)}</span><span class="rg-ev-label">${escapeHtml(eventLabel(e, ui))}</span></div>`;
   }).join('');
   requestAnimationFrame(() => { list.scrollTo(0, 1e9); });
 }
@@ -87,12 +87,13 @@ function renderSinBin(s: MatchState) {
     sl.innerHTML = `<div class="rg-sinbin-empty">${getUI().sinBinEmpty}</div>`;
     return;
   }
+  const ui = getUI();
   sl.innerHTML = s.sinBin.map((e) => {
-    const pct = (e.remaining / e.total) * 100;
+    const pct = Math.max(0, Math.min(100, (e.remaining / e.total) * 100));
     let cls = 'rg-sinbin-safe';
     if (pct < 25) cls = 'rg-sinbin-critical';
     else if (pct < 60) cls = 'rg-sinbin-warn';
-    return `<div class="rg-sinbin-card ${cls}"><div class="rg-sinbin-player">${e.player}</div><div class="rg-sinbin-time">${formatSinBinTime(e.remaining)}</div><div class="rg-sinbin-bar"><div class="rg-sinbin-fill" style="width:${pct}%"></div></div><div class="rg-sinbin-return">${pct <= 0 ? getUI().sinBinEmpty : ''}</div></div>`;
+    return `<div class="rg-sinbin-card ${cls}"><div class="rg-sinbin-player">${escapeHtml(e.player)}</div><div class="rg-sinbin-time">${formatSinBinTime(e.remaining)}</div><div class="rg-sinbin-bar"><div class="rg-sinbin-fill" style="width:${pct}%"></div></div><div class="rg-sinbin-return">${pct <= 0 ? ui.sinBinEmpty : ''}</div></div>`;
   }).join('');
 }
 
@@ -102,10 +103,11 @@ function renderSummary(s: MatchState) {
   if (!sb) return;
   const bodyRows = sb.querySelectorAll('tr');
   bodyRows.forEach((row, i) => {
-    if (i >= rows.length) return;
+    const key = rows[i];
+    if (!key) return;
     const tds = row.querySelectorAll('td');
-    if (tds[1]) tds[1].textContent = String(s.home[rows[i]]);
-    if (tds[2]) tds[2].textContent = String(s.away[rows[i]]);
+    if (tds[1]) tds[1].textContent = String(s.home[key]);
+    if (tds[2]) tds[2].textContent = String(s.away[key]);
   });
   const hTotal = teamTotal(s.home);
   const aTotal = teamTotal(s.away);
@@ -115,11 +117,11 @@ function renderSummary(s: MatchState) {
   if (ta) { ta.textContent = String(aTotal); }
 }
 
-function showBanner(html: string, isPeak: boolean) {
+function showBanner(message: string, isPeak: boolean) {
   const bn = q('rg-banner');
   const bt = q('rg-banner-text');
   if (!bn || !bt) return;
-  bt.innerHTML = html;
+  bt.textContent = message;
   bn.className = `rg-banner ${isPeak ? 'rg-banner-peak' : 'rg-banner-warn'}`;
   bn.style.display = 'flex';
   bn.classList.remove('rg-banner-hide');
@@ -131,8 +133,8 @@ function showBanner(html: string, isPeak: boolean) {
 }
 
 function toggleConv(team: TeamKey | null) {
-  const ch = q(`rg-conv-home`);
-  const ca = q(`rg-conv-away`);
+  const ch = q<HTMLButtonElement>(`rg-conv-home`);
+  const ca = q<HTMLButtonElement>(`rg-conv-away`);
   if (ch) ch.disabled = team !== 'home';
   if (ca) ca.disabled = team !== 'away';
 }
@@ -149,33 +151,25 @@ function teamName(team: TeamKey): string {
 }
 
 function handleScoreClick(ctx: { state: MatchState; convTeam: TeamKey | null }, team: TeamKey, action: string) {
+  if (ctx.state.matchEnded) return;
   const name = teamName(team);
+  const ui = getUI();
   if (action === 'try') {
-    ctx.state = scoreTry(ctx.state, team);
-    ctx.convTeam = team;
-    toggleConv(team);
-    showBanner(`TRY! ${name} +5`, true);
-    renderScoreboard(ctx.state);
+    ctx.state = scoreTry(ctx.state, team); ctx.convTeam = team;
+    toggleConv(team); showBanner(`${ui.tryScored} ${name} +5`, true); renderScoreboard(ctx.state);
     return;
   }
   if (action === 'conv' && ctx.convTeam) {
-    ctx.state = scoreConversion(ctx.state, ctx.convTeam, true);
-    toggleConv(null);
-    ctx.convTeam = null;
-    showBanner(`CONVERSION! +2`, true);
-    renderScoreboard(ctx.state);
+    ctx.state = scoreConversion(ctx.state, ctx.convTeam, true); toggleConv(null); ctx.convTeam = null;
+    showBanner(`${ui.conversionSuccess} +2`, true); renderScoreboard(ctx.state);
     return;
   }
   if (action === 'pen') {
-    ctx.state = scorePenalty(ctx.state, team);
-    showBanner(`PENALTY! ${name} +3`, true);
-    renderScoreboard(ctx.state);
+    ctx.state = scorePenalty(ctx.state, team); showBanner(`${ui.penaltyScored} ${name} +3`, true); renderScoreboard(ctx.state);
     return;
   }
   if (action === 'drop') {
-    ctx.state = scoreDropGoal(ctx.state, team);
-    showBanner(`DROP GOAL! ${name} +3`, true);
-    renderScoreboard(ctx.state);
+    ctx.state = scoreDropGoal(ctx.state, team); showBanner(`${ui.dropGoalScored} ${name} +3`, true); renderScoreboard(ctx.state);
   }
 }
 
@@ -188,22 +182,33 @@ function wireScoreButtons(ctx: { state: MatchState; convTeam: TeamKey | null })
   });
 }
 
-function handleClock(ctx: { state: MatchState }, clockId: { v: number }, ui: RGUI) {
+function runClock(ctx: { state: MatchState }, clockId: ClockId, btn: HTMLElement, ui: RugbyScoreKeeperUI) {
+  clockId.v = setInterval(() => {
+    ctx.state = tickClock(ctx.state, 1);
+    renderScoreboard(ctx.state);
+    if (ctx.state.half === 1 && ctx.state.elapsed === 2400 && !ctx.state.clockRunning) {
+      btn.textContent = ui.half2;
+    }
+    if (ctx.state.matchEnded) {
+      if (clockId.v) clearInterval(clockId.v);
+      btn.textContent = ui.startMatch;
+      showBanner(ui.fullTime, false);
+    }
+  }, 1000);
+}
+
+function handleClock(ctx: { state: MatchState }, clockId: ClockId, ui: RugbyScoreKeeperUI) {
   const btn = q('rg-btn-clock');
   if (!btn) return;
   if (!ctx.state.matchStarted) {
     ctx.state = startMatch(ctx.state);
     btn.textContent = ui.timeOff;
     renderScoreboard(ctx.state);
-    clockId.v = setInterval(() => {
-      ctx.state = tickClock(ctx.state, 1);
-      renderScoreboard(ctx.state);
-      if (ctx.state.matchEnded) {
-        clearInterval(clockId.v);
-        btn.textContent = ui.startMatch;
-        showBanner('FULL TIME! Match is over', false);
-      }
-    }, 1000);
+    runClock(ctx, clockId, btn, ui);
+  } else if (ctx.state.half === 1 && ctx.state.elapsed >= 2400) {
+    ctx.state = startSecondHalf(ctx.state);
+    btn.textContent = ui.timeOff;
+    renderScoreboard(ctx.state);
   } else if (ctx.state.clockRunning) {
     ctx.state = toggleClock(ctx.state);
     btn.textContent = ui.timeOn;
@@ -218,7 +223,7 @@ function handleSinBin(ctx: { state: MatchState }) {
   const dur = q<HTMLSelectElement>('rg-sinbin-duration');
   if (!inp || !dur || !inp.value.trim()) return;
   ctx.state = addSinBin(ctx.state, inp.value.trim(), Number(dur.value));
-  showBanner(`SIN BIN ${dur.value === '600' ? '10min' : '5min'}`, false);
+  showBanner(`${getUI().sinBin} ${formatSinBinTime(Number(dur.value))}`, false);
   inp.value = '';
   renderScoreboard(ctx.state);
 }
@@ -230,8 +235,8 @@ function handleUndo(ctx: { state: MatchState; convTeam: TeamKey | null }) {
   renderScoreboard(ctx.state);
 }
 
-function confirmReset(ctx: { state: MatchState; convTeam: TeamKey | null }, clockId: { v: number }, ui: RGUI) {
-  clearInterval(clockId.v);
+function confirmReset(ctx: { state: MatchState; convTeam: TeamKey | null }, clockId: ClockId, ui: RugbyScoreKeeperUI) {
+  if (clockId.v) clearInterval(clockId.v);
   ctx.state = createInitialState();
   ctx.convTeam = null;
   toggleConv(null);
@@ -244,7 +249,7 @@ function confirmReset(ctx: { state: MatchState; convTeam: TeamKey | null }, cloc
 export function initRugbyScorekeeper() {
   const ui = getUI();
   const ctx = { state: createInitialState(), convTeam: null as TeamKey | null };
-  const clockId = { v: 0 };
+  const clockId: ClockId = { v: undefined };
 
   wireScoreButtons(ctx);
   onBtn('rg-btn-clock', () => handleClock(ctx, clockId, ui));

package/src/tool/rugbyScoreKeeper/ui.ts

@@ -42,4 +42,6 @@ export interface RugbyScoreKeeperUI {
   undoBtn: string;
   timeOff: string;
   timeOn: string;
+  fullTime: string;
+  minutesShort: string;
 }