@jjlmoya/utils-hardware 1.19.0 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-hardware",
-    "version": "1.19.0",
+    "version": "1.20.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -8,11 +8,12 @@ import { mouseDoubleClickTest } from '../tool/mouseDoubleClickTest/index';
 import { estimadorSaludBateria } from '../tool/batteryHealthEstimator/index';
 import { toneGenerator } from '../tool/toneGenerator/index';
 import { refreshRateDetector } from '../tool/refreshRateDetector/index';
+import { monitorGhostingTest } from '../tool/monitorGhostingTest/index';
 import { spectrumCanvas } from '../tool/colorAccuracyTest/index';
 
 export const hardwareCategory: HardwareCategoryEntry = {
   icon: 'mdi:memory',
-  tools: [pixelesPantalla, testTeclado, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, estimadorSaludBateria, toneGenerator, refreshRateDetector, spectrumCanvas],
+  tools: [pixelesPantalla, testTeclado, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, estimadorSaludBateria, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     es: () => import('./i18n/es').then((m) => m.content),

package/src/entries.ts

@@ -16,6 +16,8 @@ export { toneGenerator } from './tool/toneGenerator/entry';
 export type { ToneGeneratorLocaleContent } from './tool/toneGenerator/entry';
 export { refreshRateDetector } from './tool/refreshRateDetector/entry';
 export type { RefreshRateDetectorLocaleContent } from './tool/refreshRateDetector/entry';
+export { monitorGhostingTest } from './tool/monitorGhostingTest/entry';
+export type { MonitorGhostingTestLocaleContent } from './tool/monitorGhostingTest/entry';
 export { spectrumCanvas } from './tool/colorAccuracyTest/entry';
 export type { SpectrumCanvasLocaleContent } from './tool/colorAccuracyTest/entry';
 export { hardwareCategory } from './category';
@@ -28,5 +30,6 @@ import { testRaton } from './tool/mousePollingTest/entry';
 import { mouseDoubleClickTest } from './tool/mouseDoubleClickTest/entry';
 import { toneGenerator } from './tool/toneGenerator/entry';
 import { refreshRateDetector } from './tool/refreshRateDetector/entry';
+import { monitorGhostingTest } from './tool/monitorGhostingTest/entry';
 import { spectrumCanvas } from './tool/colorAccuracyTest/entry';
-export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, testRaton, mouseDoubleClickTest, toneGenerator, refreshRateDetector, spectrumCanvas];
+export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, testRaton, mouseDoubleClickTest, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas];

package/src/index.ts

@@ -26,4 +26,5 @@ export { MOUSE_DOUBLE_CLICK_TEST_TOOL } from './tool/mouseDoubleClickTest/index'
 export { ESTIMADOR_SALUD_BATERIA_TOOL } from './tool/batteryHealthEstimator/index';
 export { TONE_GENERATOR_TOOL } from './tool/toneGenerator/index';
 export { REFRESH_RATE_DETECTOR_TOOL } from './tool/refreshRateDetector/index';
+export { MONITOR_GHOSTING_TEST_TOOL } from './tool/monitorGhostingTest/index';
 export { SPECTRUM_CANVAS_TOOL } from './tool/colorAccuracyTest/index';

package/src/tests/locale_completeness.test.ts

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

package/src/tests/tool_validation.test.ts

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

package/src/tool/monitorGhostingTest/bibliography.astro

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

package/src/tool/monitorGhostingTest/bibliography.ts

@@ -0,0 +1,20 @@
+import type { BibliographyEntry } from '../../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Blur Busters UFO Motion Tests: visual tests for ghosting, pursuit tracking, and motion clarity',
+    url: 'https://www.testufo.com/',
+  },
+  {
+    name: 'RTINGS: monitor response time, overshoot, and motion handling methodology',
+    url: 'https://www.rtings.com/monitor/tests/motion/motion-blur-and-response-time',
+  },
+  {
+    name: 'TFTCentral: response time, overdrive, overshoot, and pursuit camera monitor testing',
+    url: 'https://tftcentral.co.uk/articles/response_time',
+  },
+  {
+    name: 'Blur Busters: G-SYNC 101 guide to frame pacing, VRR behavior, and display motion',
+    url: 'https://blurbusters.com/gsync/gsync101-input-lag-tests-and-settings/',
+  }
+];

package/src/tool/monitorGhostingTest/component.astro

@@ -0,0 +1,156 @@
+---
+import type { KnownLocale } from '../../types';
+import type { MonitorGhostingTestUI } from './ui';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as MonitorGhostingTestUI;
+---
+
+<div id="mgt-root" class="mgt-root" data-config={JSON.stringify({
+  pixelsPerSecondUnit: t.pixelsPerSecondUnit,
+  pixelUnit: t.pixelUnit,
+  millisecondUnit: t.millisecondUnit,
+  fullscreen: t.fullscreen,
+  exitFullscreen: t.exitFullscreen,
+  pause: t.pause,
+  resume: t.resume,
+})}>
+  <section class="mgt-card">
+    <div class="mgt-stage">
+      <div class="mgt-monitor" id="mgt-monitor">
+        <div class="mgt-screen">
+          <div class="mgt-ruler" aria-hidden="true"></div>
+          <div id="mgt-track" class="mgt-track">
+            <span class="mgt-ghost ghost-5"></span>
+            <span class="mgt-ghost ghost-4"></span>
+            <span class="mgt-ghost ghost-3"></span>
+            <span class="mgt-ghost ghost-2"></span>
+            <span class="mgt-ghost ghost-1"></span>
+            <span id="mgt-target-object" class="mgt-target-object">
+              <span class="mgt-bars" aria-hidden="true"></span>
+              <span class="mgt-word">{t.targetText}</span>
+              <span class="mgt-ufo" aria-hidden="true">
+                <span class="mgt-ufo-dome"></span>
+                <span class="mgt-ufo-body"></span>
+                <span class="mgt-ufo-light"></span>
+              </span>
+            </span>
+          </div>
+          <div class="mgt-pursuit" aria-hidden="true"></div>
+          <div class="mgt-screen-actions">
+            <button id="mgt-fullscreen" type="button">{t.fullscreen}</button>
+            <button id="mgt-pause" type="button">{t.pause}</button>
+          </div>
+        </div>
+      </div>
+
+      <div class="mgt-panel">
+        <div class="mgt-readout">
+          <span>{t.badge}</span>
+          <strong id="mgt-blur">--</strong>
+          <small>{t.estimatedBlur}</small>
+        </div>
+
+        <label class="mgt-control">
+          <span>{t.speedLabel}</span>
+          <b id="mgt-speed-value">--</b>
+          <input id="mgt-speed" type="range" min="240" max="1920" step="120" value="960" />
+        </label>
+
+        <label class="mgt-control">
+          <span>{t.trailLabel}</span>
+          <b id="mgt-trail-value">--</b>
+          <input id="mgt-trail" type="range" min="1" max="10" step="1" value="5" />
+        </label>
+
+        <label class="mgt-select">
+          <span>{t.backgroundLabel}</span>
+          <select id="mgt-background">
+            <option value="dark">{t.backgroundDark}</option>
+            <option value="light">{t.backgroundLight}</option>
+            <option value="grid">{t.backgroundGrid}</option>
+          </select>
+        </label>
+
+        <label class="mgt-select">
+          <span>{t.patternLabel}</span>
+          <select id="mgt-pattern">
+            <option value="bars">{t.patternBars}</option>
+            <option value="text">{t.patternText}</option>
+            <option value="ufo">{t.patternUfo}</option>
+          </select>
+        </label>
+
+        <label class="mgt-toggle">
+          <span>
+            <b>{t.pursuitLabel}</b>
+            <small>{t.pursuitOn} / {t.pursuitOff}</small>
+          </span>
+          <input id="mgt-pursuit" type="checkbox" checked />
+        </label>
+
+        <div class="mgt-metrics">
+          <div>
+            <span>{t.frameStep}</span>
+            <strong id="mgt-frame-step">--</strong>
+          </div>
+          <div>
+            <span>{t.persistence}</span>
+            <strong id="mgt-persistence">--</strong>
+          </div>
+          <div>
+            <span>{t.sampleCount}</span>
+            <strong id="mgt-sample-count">--</strong>
+          </div>
+        </div>
+
+        <p class="mgt-instructions">{t.instructions}</p>
+        <button id="mgt-reset" class="mgt-reset" type="button">{t.reset}</button>
+      </div>
+    </div>
+  </section>
+</div>
+
+<script>
+  import { MonitorGhostingLab } from './logic';
+
+  const root = document.getElementById('mgt-root');
+  const labels = JSON.parse(root?.dataset.config ?? '{}');
+
+  new MonitorGhostingLab(
+    {
+      root,
+      monitor: document.getElementById('mgt-monitor'),
+      track: document.getElementById('mgt-track'),
+      target: document.getElementById('mgt-target-object'),
+      speed: document.getElementById('mgt-speed') as HTMLInputElement | null,
+      trail: document.getElementById('mgt-trail') as HTMLInputElement | null,
+      background: document.getElementById('mgt-background') as HTMLSelectElement | null,
+      pattern: document.getElementById('mgt-pattern') as HTMLSelectElement | null,
+      pursuit: document.getElementById('mgt-pursuit') as HTMLInputElement | null,
+      fullscreen: document.getElementById('mgt-fullscreen'),
+      pause: document.getElementById('mgt-pause'),
+      reset: document.getElementById('mgt-reset'),
+      speedValue: document.getElementById('mgt-speed-value'),
+      trailValue: document.getElementById('mgt-trail-value'),
+      blur: document.getElementById('mgt-blur'),
+      frameStep: document.getElementById('mgt-frame-step'),
+      persistence: document.getElementById('mgt-persistence'),
+      sampleCount: document.getElementById('mgt-sample-count'),
+    },
+    {
+      pixelsPerSecondUnit: labels.pixelsPerSecondUnit,
+      pixelUnit: labels.pixelUnit,
+      millisecondUnit: labels.millisecondUnit,
+      fullscreen: labels.fullscreen,
+      exitFullscreen: labels.exitFullscreen,
+      pause: labels.pause,
+      resume: labels.resume,
+    },
+  );
+</script>

package/src/tool/monitorGhostingTest/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+
+import type { MonitorGhostingTestUI } from './ui';
+export type MonitorGhostingTestLocaleContent = ToolLocaleContent<MonitorGhostingTestUI>;
+
+export const monitorGhostingTest: HardwareToolEntry<MonitorGhostingTestUI> = {
+  id: 'monitor-ghosting-test',
+  icons: {
+    bg: 'mdi:monitor',
+    fg: 'mdi:motion-play',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

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

@@ -0,0 +1,293 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { MonitorGhostingTestUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'monitor-ghosting-test-deutsch';
+const title = 'Monitor Ghosting Test';
+const description =
+  'Testen Sie Monitor-Ghosting, Bewegungsunschärfe, Overdrive-Nachzieheffekte und Pixel-Reaktionsverhalten mit bewegten Balken, Text und Vollbild-Bewegungsmustern.';
+
+const faqData = [
+  {
+    question: 'Was ist Monitor-Ghosting?',
+    answer:
+      'Monitor-Ghosting ist eine sichtbare Spur, die bewegten Objekten folgt, wenn Pixel nicht schnell genug übergehen können. Es tritt häufig bei langsamen LCD-Panels, schlecht eingestellten Overdrive-Modi und Displays auf, die unter ihrer optimalen Bildwiederholrate laufen.',
+  },
+  {
+    question: 'Kann dieser Test die genaue Reaktionszeit messen?',
+    answer:
+      'Ein Browser-Test kann keine Laborgeräte wie eine Pursuit-Kamera oder Fotodiode ersetzen, aber er kann sichtbare Bewegungsartefakte aufdecken, Monitoreinstellungen vergleichen und Ihnen helfen, den klarsten Overdrive-Modus zu wählen.',
+  },
+  {
+    question: 'Warum erzeugt Overdrive manchmal helle Nachzieheffekte?',
+    answer:
+      'Overdrive treibt Pixel stärker an, um Übergänge zu beschleunigen. Wenn er über den Zielfarbton hinausschiebt, sehen Sie möglicherweise inverses Ghosting: einen hellen oder farbigen Halo hinter bewegten Objekten.',
+  },
+  {
+    question: 'Sollte ich auf dunklem oder hellem Hintergrund testen?',
+    answer:
+      'Beides. Einige Panels verschmieren Dunkel-zu-Grau-Übergänge mehr als Hell-zu-Dunkel-Übergänge, daher zeigt ein Wechsel des Hintergrunds Artefakte, die ein einzelnes Muster verbergen kann.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Bewegungsgeschwindigkeit einstellen',
+    text: 'Beginnen Sie nahe der Standardgeschwindigkeit und erhöhen Sie sie, bis die Nachzieheffekte leicht zu prüfen sind, ohne das Objekt aus den Augen zu verlieren.',
+  },
+  {
+    name: 'Spurstärke ändern',
+    text: 'Verwenden Sie die Spursteuerung, um die Nachleuchtdauer beim Vergleich der Monitoreinstellungen besser sichtbar zu machen.',
+  },
+  {
+    name: 'Mehrere Hintergründe testen',
+    text: 'Wechseln Sie zwischen dunklen, hellen und Gitter-Hintergründen, um schwarze Verschmierungen, inverses Ghosting und Overdrive-Halos aufzudecken.',
+  },
+  {
+    name: 'Overdrive-Einstellungen vergleichen',
+    text: 'Öffnen Sie das Monitor-OSD und testen Sie die Modi Aus, Normal, Schnell und Extrem. Wählen Sie den Modus mit der klarsten Bewegung und dem geringsten Halo.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<MonitorGhostingTestUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography,
+  seo: [
+    {
+      type: 'title',
+      text: 'Monitor Ghosting Test: Bewegungsunschärfe und Pixel-Reaktion prüfen',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Monitor-Ghosting tritt auf, wenn bewegte Objekte eine sichtbare Spur hinterlassen. Es kann Spiele verschmiert wirken lassen, scrollenden Text schwerer lesbar machen und einen Monitor mit hoher Bildwiederholrate schlechter aussehen lassen als erwartet. Dieser Monitor-Ghosting-Test bietet bewegte Balken, Text und kontrastreiche Muster, damit Sie Overdrive-Modi, Bildwiederholraten, Hintergründe und Bewegungsgeschwindigkeiten ohne Softwareinstallation vergleichen können.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Der Test ist für die praktische Inspektion konzipiert. Er erhebt keinen Anspruch auf laborgenaue Grau-zu-Grau-Reaktionszeiten, hilft aber bei der Beantwortung der Frage, die die meisten Benutzer tatsächlich haben: <strong>welche Monitoreinstellung sieht auf diesem Display am klarsten aus?</strong>',
+    },
+    {
+      type: 'title',
+      text: 'Wie Ghosting aussieht',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Ein dunkler Schatten, der dem bewegten Objekt folgt, oft als schwarze Verschmierung bezeichnet',
+        'Ein blasser oder farbiger Halo hinter dem Objekt, oft durch übermäßigen Overdrive verursacht',
+        'Eine lange durchscheinende Spur, die Kanten weich erscheinen lässt',
+        'Mehrere schwache Kopien des Objekts, besonders bei Displays mit langsamer Pixel-Reaktion',
+        'Ungleichmäßige Klarheit zwischen dunklen, hellen und Gitter-Hintergründen',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Ghosting, Bewegungsunschärfe und inverses Ghosting',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Artefakt', 'Was Sie sehen', 'Häufige Ursache'],
+      rows: [
+        ['Ghosting', 'Eine dunklere oder verblasste Kopie folgt dem Objekt', 'Pixel-Reaktion ist zu langsam für die Bewegungsgeschwindigkeit'],
+        ['Bewegungsunschärfe', 'Das ganze bewegte Objekt sieht weich aus', 'Sample-and-Hold-Unschärfe, niedrige Bildwiederholrate oder Augenverfolgungsunschärfe'],
+        ['Inverses Ghosting', 'Heller Halo oder farbige Überschwinger', 'Overdrive-Einstellung ist zu aggressiv'],
+        ['Schwarze Verschmierung', 'Dunkle Szenen hinterlassen starke Schatten', 'VA-Panel-Dunkelübergänge sind langsam'],
+        ['Stottern', 'Bewegung springt statt zu fließen', 'Frame-Pacing, niedrige FPS oder Browser-/Systemlast'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Ein praktischer Diagnose-Workflow',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Beginnen Sie mit Ihrem Monitor in seiner nativen Auflösung und der höchsten stabilen Bildwiederholrate. Wenn Sie einen 144Hz-, 165Hz-, 240Hz- oder 360Hz-Monitor besitzen, bestätigen Sie, dass das Betriebssystem diesen Modus tatsächlich verwendet, bevor Sie die Bewegungsklarheit beurteilen. Öffnen Sie den Test im Vollbild, wählen Sie das Klarheitsbalken-Ziel und beobachten Sie die hintere Kante des bewegten Objekts. Die hintere Kante ist der Ort, an dem Geisterspuren, dunkle Verschmierungen und helle Overdrive-Halos am einfachsten zu vergleichen sind.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Verwenden Sie dunklen Hintergrund, um schwarze Verschmierungen und langsame Dunkelübergänge aufzudecken',
+        'Verwenden Sie hellen Hintergrund, um farbige Overdrive-Halos aufzudecken',
+        'Verwenden Sie Gitter-Hintergrund, um die Kantenklarheit anhand kontrastreicher Referenzlinien zu prüfen',
+        'Verwenden Sie das Textziel, wenn Ihr echtes Problem verschwommenes Scrollen oder schwer lesbare Bewegung ist',
+        'Verwenden Sie Vollbild, bevor Sie einen Monitor beurteilen, da Browser-Chrome und Skalierung von Bewegungsartefakten ablenken können',
+        'Erhöhen Sie die Geschwindigkeit erst, nachdem Sie dem Objekt bequem folgen können',
+        'Vergleichen Sie jeweils eine Monitoreinstellung, damit Sie wissen, was sich geändert hat',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Die beste Overdrive-Einstellung für Ihren Monitor wählen',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Die meisten Gaming-Monitore enthalten eine Overdrive-Einstellung namens Aus, Normal, Schnell, Schneller, Extrem, Reaktionszeit oder Trace Free. Die schnellste Option ist nicht immer die beste. Eine moderate Einstellung bietet oft das beste Gleichgewicht: weniger Unschärfe als Aus, aber weniger Halos als Extrem.',
+    },
+    {
+      type: 'table',
+      headers: ['Overdrive-Modus', 'Erwartetes Ergebnis', 'Empfehlung'],
+      rows: [
+        ['Aus', 'Geringste Überschwinger, aber mehr Unschärfe', 'Nützliche Baseline für Vergleiche'],
+        ['Normal', 'Moderate Unschärfereduzierung', 'Oft am besten für den täglichen Gebrauch'],
+        ['Schnell', 'Schärfere Bewegung mit gewissem Halo-Risiko', 'Gut, wenn die Spuren sauber bleiben'],
+        ['Extrem', 'Niedrigste Reaktionszeitangabe, höchstes Überschwinger-Risiko', 'Vermeiden, wenn helle inverse Spuren erscheinen'],
+        ['Adaptiv/Variabel', 'Verhalten ändert sich mit der Bildwiederholrate', 'Erneut im tatsächlich genutzten FPS-Bereich testen'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Was zu ändern ist, wenn der Test schlecht aussieht',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Was Sie sehen', 'Wahrscheinliche Ursache', 'Was zu versuchen ist'],
+      rows: [
+        ['Lange dunkle Spur hinter dem Ziel', 'Langsame dunkle Pixel-Übergänge oder schwacher Overdrive', 'Versuchen Sie einen stärkeren Overdrive-Modus und testen Sie erneut auf dunklem und Gitter-Hintergrund'],
+        ['Heller Halo oder farbiger Umriss hinter dem Ziel', 'Overdrive-Überschwinger oder inverses Ghosting', 'Overdrive um eine Stufe reduzieren und bei Ihrer tatsächlichen Bildwiederholrate vergleichen'],
+        ['Bewegung sieht ruckartig statt verschwommen aus', 'Frame-Pacing, Browser-Last oder Abweichung der Bildwiederholrate', 'Schwere Apps schließen, Vollbild aktivieren, Bildwiederholrate des Betriebssystems bestätigen'],
+        ['Text wird beim Bewegen unlesbar', 'Sample-and-Hold-Unschärfe, niedrige Bildwiederholrate oder langsame Reaktion', 'Bildwiederholrate erhöhen, Textmuster testen, Overdrive-Modi vergleichen'],
+        ['Artefakte ändern sich bei FPS-Änderung', 'VRR oder adaptives Overdrive-Verhalten', 'Erneut im tatsächlich genutzten FPS-Bereich testen'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Warum die Bildwiederholrate wichtig ist',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Höhere Bildwiederholraten verkürzen die Zeit, die jedes Bild sichtbar bleibt, was Bewegung klarer erscheinen lassen kann. Die Bildwiederholrate allein beseitigt jedoch kein Ghosting. Ein 240Hz-Monitor mit langsamen Pixel-Übergängen kann immer noch verschmieren, während ein gut eingestelltes 144Hz-Panel sauberer aussehen kann als ein schlecht eingestelltes schnelleres Panel.',
+    },
+    {
+      type: 'table',
+      headers: ['Bildwiederholrate', 'Bilddauer', 'Was zu erwarten ist'],
+      rows: [
+        ['60Hz', '16,7 ms', 'Sample-and-Hold-Unschärfe und langsamere Bewegung sind leicht zu erkennen'],
+        ['120Hz', '8,3 ms', 'Viel flüssiger, aber Pixel-Reaktion ist weiterhin wichtig'],
+        ['144Hz', '6,9 ms', 'Gängige Gaming-Basislinie für Bewegungsklarheit'],
+        ['240Hz', '4,2 ms', 'Sehr flüssig, wenn die Reaktionsabstimmung gut ist'],
+        ['360Hz', '2,8 ms', 'Anspruchsvoll: schlechte Overdrive-Abstimmung wird offensichtlich'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'VRR, Gaming und realitätsnahes Testen',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Variable Bildwiederholrate kann das Verhalten eines Monitors verändern, da einige Displays bei verschiedenen Bildwiederholraten unterschiedliche Overdrive-Abstimmungen verwenden. Wenn Ihr Problem nur in Spielen auftritt, testen Sie nicht nur bei der maximalen Desktop-Bildwiederholrate. Testen Sie erneut im FPS-Bereich, in dem Sie tatsächlich spielen, besonders um 60 FPS, 90 FPS, 120 FPS und jede von Ihnen verwendete FPS-Begrenzung.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Wenn Ghosting bei niedrigen FPS schlimmer ist, hat der Monitor möglicherweise eine schwache variable Overdrive-Abstimmung',
+        'Wenn Halos nur bei hohen Bildwiederholraten erscheinen, ist der Overdrive-Modus möglicherweise zu aggressiv',
+        'Wenn die Bewegung stottert, während die Spur kurz bleibt, ist das Problem wahrscheinlich Frame-Pacing statt Pixel-Reaktion',
+        'Wenn Vollbild anders aussieht als der Fenstermodus, prüfen Sie Browser-Skalierung, Betriebssystem-Skalierung und Compositor-Verhalten',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Fehlerbehebung bei schlechten Ergebnissen',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Bestätigen Sie, dass Ihr Display-Kabel die angestrebte Bildwiederholrate unterstützt',
+        'Deaktivieren Sie Bewegungsglättung, Black Frame Insertion oder MPRT-Modi beim Vergleich des normalen Overdrive',
+        'Testen Sie erneut nach dem Umschalten des Monitors auf seine native Auflösung',
+        'Verwenden Sie Vollbild oder reduzieren Sie den Browser-Zoom, wenn die Bewegung inkonsistent erscheint',
+        'Schließen Sie rechenintensive Hintergrund-Apps, wenn die Animation stottert',
+        'Testen Sie dasselbe Muster nach dem Ändern der GPU-Systemsteuerungseinstellungen für die Bildwiederholrate',
+        'Versuchen Sie ein anderes Kabel oder einen anderen Anschluss, wenn der Monitor seine angegebene Bildwiederholrate nicht erreicht',
+        'Testen Sie erneut mit VRR ein und aus, wenn sich das Ghosting zwischen Desktop und Spielen ändert',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Grenzen eines Online-Ghosting-Tests',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Ein browserbasierter Ghosting-Test hängt von der Browser-Animationszeit, der GPU-Last, der Betriebssystem-Zusammensetzung und Ihrer Display-Konfiguration ab. Er eignet sich hervorragend für den visuellen Vergleich, aber exakte Reaktionszeitmessungen erfordern spezielle Ausrüstung wie Pursuit-Kameras, Fotodioden oder oszilloskopbasierte Methoden. Verwenden Sie diesen Test, um Einstellungen zu wählen und offensichtliche Artefakte zu erkennen, nicht um Herstellerangaben zu Reaktionszeiten zu zertifizieren.',
+    },
+  ],
+  ui: {
+    badge: 'Bewegungsklarheit',
+    speedLabel: 'Bewegungsgeschwindigkeit',
+    pixelsPerSecondUnit: 'px/s',
+    pixelUnit: 'px',
+    millisecondUnit: 'ms',
+    trailLabel: 'Spurstärke',
+    backgroundLabel: 'Hintergrund',
+    backgroundDark: 'Dunkel',
+    backgroundLight: 'Hell',
+    backgroundGrid: 'Gitter',
+    patternLabel: 'Testziel',
+    patternBars: 'Klarheitsbalken',
+    patternText: 'Textblock',
+    patternUfo: 'UFO',
+    pursuitLabel: 'Verfolgungsführung',
+    pursuitOn: 'An',
+    pursuitOff: 'Aus',
+    fullscreen: 'Vollbild',
+    exitFullscreen: 'Vollbild verlassen',
+    pause: 'Pause',
+    resume: 'Fortsetzen',
+    targetText: 'BEWEGUNG',
+    estimatedBlur: 'geschätzte Unschärfe',
+    frameStep: 'Bildschritt',
+    persistence: 'Nachleuchtdauer',
+    sampleCount: 'Spurproben',
+    instructions: 'Beobachten Sie die hintere Kante des bewegten Ziels, während Sie Geschwindigkeit, Spurstärke, Hintergrund, Vollbildmodus und Monitor-Overdrive-Einstellungen ändern.',
+    reset: 'Zurücksetzen',
+  },
+};