@jjlmoya/utils-hardware 1.23.0 → 1.24.0

package/package.json

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

package/src/category/index.ts

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

package/src/entries.ts

@@ -24,6 +24,8 @@ export { spectrumCanvas } from './tool/colorAccuracyTest/entry';
 export type { SpectrumCanvasLocaleContent } from './tool/colorAccuracyTest/entry';
 export { upsRuntimeCalculator } from './tool/upsRuntimeCalculator/entry';
 export type { UpsRuntimeCalculatorLocaleContent } from './tool/upsRuntimeCalculator/entry';
+export { stereoAudioTest } from './tool/stereoAudioTest/entry';
+export type { StereoAudioTestLocaleContent } from './tool/stereoAudioTest/entry';
 export { hardwareCategory } from './category';
 import { estimadorSaludBateria } from './tool/batteryHealthEstimator/entry';
 import { pixelesPantalla } from './tool/deadPixelTest/entry';
@@ -38,4 +40,5 @@ import { refreshRateDetector } from './tool/refreshRateDetector/entry';
 import { monitorGhostingTest } from './tool/monitorGhostingTest/entry';
 import { spectrumCanvas } from './tool/colorAccuracyTest/entry';
 import { upsRuntimeCalculator } from './tool/upsRuntimeCalculator/entry';
-export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, testRaton, mouseDoubleClickTest, mouseScrollTest, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator];
+import { stereoAudioTest } from './tool/stereoAudioTest/entry';
+export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, testRaton, mouseDoubleClickTest, mouseScrollTest, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, stereoAudioTest];

package/src/index.ts

@@ -30,3 +30,4 @@ 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';
 export { UPS_RUNTIME_CALCULATOR_TOOL } from './tool/upsRuntimeCalculator/index';
+export { STEREO_AUDIO_TEST_TOOL } from './tool/stereoAudioTest/index';

package/src/tests/locale_completeness.test.ts

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

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 13 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(13);
+    it('should have 14 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(14);
     });
 
     it('hardwareCategory should be defined', () => {

package/src/tool/stereoAudioTest/bibliography.astro

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

package/src/tool/stereoAudioTest/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Microsoft Support - Fix sound or audio problems in Windows',
+    url: 'https://support.microsoft.com/windows/fix-sound-or-audio-problems-in-windows-73025246-b61c-40fb-671a-2535c7cd56c8',
+  },
+  {
+    name: 'Apple Support - Adjust audio balance and mono audio on Mac',
+    url: 'https://support.apple.com/guide/mac-help/change-sound-output-settings-mchlp2256/mac',
+  },
+  {
+    name: 'Crutchfield - Speaker placement for stereo listening',
+    url: 'https://www.crutchfield.com/learn/home-stereo-speaker-placement.html',
+  },
+];

package/src/tool/stereoAudioTest/component.astro

@@ -0,0 +1,251 @@
+---
+import { Icon } from 'astro-icon/components';
+import type { KnownLocale } from '../../types';
+import type { StereoAudioTestUI } from './ui';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as StereoAudioTestUI;
+---
+
+<div
+  class="sat-root"
+  data-config={JSON.stringify({
+    left: t.left,
+    center: t.center,
+    right: t.right,
+    sweep: t.sweep,
+    stop: t.stop,
+    activeIdle: t.activeIdle,
+    activeLeft: t.activeLeft,
+    activeCenter: t.activeCenter,
+    activeRight: t.activeRight,
+    activeSweep: t.activeSweep,
+    secondsUnit: t.secondsUnit,
+  })}
+>
+  <section class="sat-panel">
+    <div class="sat-stage" aria-live="polite">
+      <div class="sat-speaker sat-left">
+        <span></span>
+        <strong>{t.leftSpeaker}</strong>
+      </div>
+      <div class="sat-orbit" aria-hidden="true">
+        <i data-dot></i>
+        <b>{t.centerLine}</b>
+      </div>
+      <div class="sat-speaker sat-right">
+        <span></span>
+        <strong>{t.rightSpeaker}</strong>
+      </div>
+    </div>
+
+    <div class="sat-controls">
+      <div class="sat-buttons">
+        <button type="button" data-play="left"><Icon name="mdi:play" />{t.left}</button>
+        <button type="button" data-play="center"><Icon name="mdi:play" />{t.center}</button>
+        <button type="button" data-play="right"><Icon name="mdi:play" />{t.right}</button>
+        <button type="button" data-play="sweep"><Icon name="mdi:play" />{t.sweep}</button>
+        <button type="button" data-stop>{t.stop}</button>
+      </div>
+
+      <div class="sat-sliders">
+        <label class="sat-control-row">
+          <span>{t.volume}</span>
+          <strong data-volume-label>24%</strong>
+          <input data-volume type="range" min="1" max="80" value="24" />
+        </label>
+        <label class="sat-control-row" data-duration-control>
+          <span>{t.duration}</span>
+          <strong><output data-duration-label>3</output>{t.secondsUnit}</strong>
+          <input data-duration type="range" min="1" max="8" value="3" />
+        </label>
+        <label class="sat-control-row">
+          <span>{t.tone}</span>
+          <strong><output data-frequency-label>520</output>{t.hertzUnit}</strong>
+          <input data-frequency type="range" min="220" max="1200" step="10" value="520" />
+        </label>
+      </div>
+
+      <label class="sat-loop">
+        <input data-loop type="checkbox" />
+        <span>
+          <strong>{t.infiniteMode}</strong>
+          <em>{t.infiniteModeHint}</em>
+        </span>
+      </label>
+
+      <div class="sat-readout">
+        <span>{t.balance}</span>
+        <strong data-status>{t.activeIdle}</strong>
+        <meter min="-1" max="1" low="-0.65" high="0.65" optimum="0" value="0" data-meter></meter>
+      </div>
+      <p>{t.safety}</p>
+    </div>
+  </section>
+</div>
+
+<link rel="stylesheet" href="./stereo-audio-test.css" />
+
+<script>
+  type Channel = 'left' | 'center' | 'right' | 'sweep';
+  interface Config {
+    left: string;
+    center: string;
+    right: string;
+    sweep: string;
+    stop: string;
+    activeIdle: string;
+    activeLeft: string;
+    activeCenter: string;
+    activeRight: string;
+    activeSweep: string;
+    secondsUnit: string;
+  }
+
+  const root = document.querySelector<HTMLElement>('.sat-root');
+  const config = JSON.parse(root?.dataset.config ?? '{}') as Config;
+  const audioState: {
+    context?: AudioContext;
+    oscillator?: OscillatorNode;
+    gain?: GainNode;
+    stopTimer?: number;
+    sweepTimer?: number;
+  } = {};
+  const els = {
+    dot: root?.querySelector<HTMLElement>('[data-dot]'),
+    meter: root?.querySelector<HTMLMeterElement>('[data-meter]'),
+    status: root?.querySelector<HTMLElement>('[data-status]'),
+    volume: root?.querySelector<HTMLInputElement>('[data-volume]'),
+    volumeLabel: root?.querySelector<HTMLElement>('[data-volume-label]'),
+    duration: root?.querySelector<HTMLInputElement>('[data-duration]'),
+    durationControl: root?.querySelector<HTMLElement>('[data-duration-control]'),
+    durationLabel: root?.querySelector<HTMLOutputElement>('[data-duration-label]'),
+    frequency: root?.querySelector<HTMLInputElement>('[data-frequency]'),
+    frequencyLabel: root?.querySelector<HTMLOutputElement>('[data-frequency-label]'),
+    loop: root?.querySelector<HTMLInputElement>('[data-loop]'),
+  };
+
+  function ensureContext() {
+    audioState.context ??= new AudioContext();
+    return audioState.context;
+  }
+
+  function play(channel: Channel) {
+    stop();
+    const context = ensureContext();
+    const oscillator = context.createOscillator();
+    const gain = context.createGain();
+    const panner = context.createStereoPanner();
+    const duration = readNumber(els.duration, 3);
+    const volume = readNumber(els.volume, 24) / 100;
+    const frequency = readNumber(els.frequency, 520);
+
+    oscillator.type = 'sine';
+    oscillator.frequency.value = frequency;
+    gain.gain.setValueAtTime(0.0001, context.currentTime);
+    gain.gain.exponentialRampToValueAtTime(Math.max(0.0001, volume), context.currentTime + 0.03);
+    oscillator.connect(gain).connect(panner).connect(context.destination);
+    oscillator.start();
+    audioState.oscillator = oscillator;
+    audioState.gain = gain;
+
+    const shouldLoop = Boolean(els.loop?.checked);
+    if (channel === 'sweep') {
+      runSweep(panner, duration);
+    } else {
+      setPan(panner, getPan(channel));
+    }
+    if (!shouldLoop) {
+      gain.gain.exponentialRampToValueAtTime(0.0001, context.currentTime + duration);
+      oscillator.stop(context.currentTime + duration + 0.05);
+      audioState.stopTimer = window.setTimeout(stop, (duration + 0.08) * 1000);
+    }
+    setStatus(channel);
+  }
+
+  function runSweep(panner: StereoPannerNode, duration: number) {
+    const start = performance.now();
+    const tick = (now: number) => {
+      const progress = ((now - start) % (duration * 1000)) / (duration * 1000);
+      const pan = Math.sin(progress * Math.PI * 2);
+      setPan(panner, pan);
+      audioState.sweepTimer = requestAnimationFrame(tick);
+    };
+    audioState.sweepTimer = requestAnimationFrame(tick);
+  }
+
+  function setPan(panner: StereoPannerNode, pan: number) {
+    panner.pan.value = pan;
+    root?.style.setProperty('--sat-pan', String(pan));
+    els.meter!.value = pan;
+  }
+
+  function getPan(channel: Channel) {
+    if (channel === 'left') return -1;
+    if (channel === 'right') return 1;
+    return 0;
+  }
+
+  function stop() {
+    if (audioState.stopTimer) window.clearTimeout(audioState.stopTimer);
+    if (audioState.sweepTimer) cancelAnimationFrame(audioState.sweepTimer);
+    if (audioState.oscillator) {
+      try {
+        audioState.oscillator.stop();
+      } catch {
+      }
+      audioState.oscillator = undefined;
+    }
+    audioState.gain = undefined;
+    root?.style.setProperty('--sat-pan', '0');
+    if (els.meter) els.meter.value = 0;
+    if (els.status) els.status.textContent = config.activeIdle;
+  }
+
+  function setStatus(channel: Channel) {
+    const labels = {
+      left: config.activeLeft,
+      center: config.activeCenter,
+      right: config.activeRight,
+      sweep: config.activeSweep,
+    };
+    if (els.status) els.status.textContent = labels[channel];
+  }
+
+  function readNumber(input: HTMLInputElement | null | undefined, fallback: number) {
+    return input ? Number(input.value) : fallback;
+  }
+
+  function syncLabels() {
+    if (els.volumeLabel && els.volume) els.volumeLabel.textContent = `${els.volume.value}%`;
+    if (els.durationLabel && els.duration) els.durationLabel.textContent = els.duration.value;
+    if (els.frequencyLabel && els.frequency) els.frequencyLabel.textContent = els.frequency.value;
+    syncLoopState();
+    updateActiveVolume();
+  }
+
+  function syncLoopState() {
+    const isLooping = Boolean(els.loop?.checked);
+    if (els.duration) els.duration.disabled = isLooping;
+    els.durationControl?.classList.toggle('is-disabled', isLooping);
+  }
+
+  function updateActiveVolume() {
+    if (!audioState.context || !audioState.gain || !els.volume) return;
+    const volume = Math.max(0.0001, Number(els.volume.value) / 100);
+    audioState.gain.gain.setTargetAtTime(volume, audioState.context.currentTime, 0.015);
+  }
+
+  root?.querySelectorAll<HTMLButtonElement>('[data-play]').forEach((button) => {
+    button.addEventListener('click', () => play(button.dataset.play as Channel));
+  });
+  root?.querySelector<HTMLButtonElement>('[data-stop]')?.addEventListener('click', stop);
+  [els.volume, els.duration, els.frequency].forEach((input) => input?.addEventListener('input', syncLabels));
+  els.loop?.addEventListener('change', syncLabels);
+  syncLabels();
+</script>

package/src/tool/stereoAudioTest/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+import type { StereoAudioTestUI } from './ui';
+
+export type StereoAudioTestLocaleContent = ToolLocaleContent<StereoAudioTestUI>;
+
+export const stereoAudioTest: HardwareToolEntry<StereoAudioTestUI> = {
+  id: 'stereo-audio-test',
+  icons: {
+    bg: 'mdi:speaker-multiple',
+    fg: 'mdi:surround-sound',
+  },
+  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/stereoAudioTest/i18n/de.ts

@@ -0,0 +1,229 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { StereoAudioTestUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'stereo-audio-pruefung';
+const title = 'Stereo Audiotest';
+const description = 'Ueberpruefen Sie linke und rechte Lautsprecherkanaele, Stereo Balance, Verkabelungsrichtung und Kopfhoererabbildung mit browsergenerierten Testtoenen.';
+
+const faqData = [
+  {
+    question: 'Wie teste ich linke und rechte Lautsprecher online?',
+    answer: 'Starten Sie mit niedriger Lautstärke, drücken Sie Links und dann Rechts. Der linke Ton sollte nur aus dem linken Lautsprecher oder der linken Ohrmuschel kommen, und der rechte Ton sollte nur von der rechten Seite kommen. Verwenden Sie Mitte, um zu bestätigen, dass beide Seiten gleichmäßig spielen.',
+  },
+  {
+    question: 'Warum spielen beide Lautsprecher während des Links- oder Rechtstests?',
+    answer: 'Einige Geräte, Betriebssysteme, Bluetooth-Lautsprecher, Mono-Modi, Eingabehilfen oder Audioverbesserungen mischen Stereo zu Mono herunter. Überprüfen Sie System-Balance, Mono-Audio-Einstellungen, Kabelverdrahtung und app-spezifische Audioeffekte.',
+  },
+  {
+    question: 'Kann dies vertauschte Lautsprecherkabel diagnostizieren?',
+    answer: 'Ja. Wenn die Links-Taste aus dem rechten Lautsprecher und die Rechts-Taste aus dem linken Lautsprecher spielt, ist der Ausgabepfad irgendwo zwischen Computer, Kabel, Verstärker, Lautsprechern oder Kopfhörern vertauscht.',
+  },
+  {
+    question: 'Ist ein Sinuston für Lautsprecher und Kopfhörer sicher?',
+    answer: 'Ein kurzer Sinuston bei moderater Lautstärke ist normalerweise sicher. Vermeiden Sie hohe Lautstärke, lange Sitzungen oder sehr hohe Frequenzen, insbesondere bei Kopfhörern, kleinen Laptop-Lautsprechern oder unbekannten Verstärkern.',
+  },
+  {
+    question: 'Beeinflusst der Browser den Stereotest?',
+    answer: 'Das Tool verwendet den Web Audio API StereoPannerNode. Es ist in modernen Browsern zuverlässig, aber die endgültige Ausgabe hängt dennoch von Betriebssystem-Routing, Treibern, Bluetooth-Codecs, externen DACs und Lautsprecherverkabelung ab.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Eine leise Startlautstärke einstellen',
+    text: 'Senken Sie die Systemlautstärke und verwenden Sie den Lautstärkeregler des Tools, bevor Sie einen Testton abspielen.',
+  },
+  {
+    name: 'Jede Seite testen',
+    text: 'Drücken Sie Links und Rechts. Jeder Ton sollte eindeutig auf den passenden Lautsprecher oder die Kopfhörerseite beschränkt sein.',
+  },
+  {
+    name: 'Center-Balance prüfen',
+    text: 'Drücken Sie Mitte. Der Ton sollte zwischen beiden Lautsprechern zentriert erscheinen, nicht stark zu einer Seite gezogen.',
+  },
+  {
+    name: 'Sweep verwenden',
+    text: 'Führen Sie Sweep aus, um Bewegung über das Stereofeld zu hören und Aussetzer, vertauschte Verkabelung oder ungleichmäßige Abbildung zu erkennen.',
+  },
+];
+
+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<StereoAudioTestUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  bibliography,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Linker und rechter Lautsprechertest online',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Verwenden Sie diesen Online-Stereo-Audiotest, um zu überprüfen, ob Ihre linken und rechten Lautsprecher, Kopfhörer, Ohrhörer, Soundbar, DAC, Verstärker oder Monitorlautsprecher korrekt geroutet sind. Das Tool spielt browsergenerierte Töne über den linken Kanal, rechten Kanal, beide Kanäle oder einen beweglichen Stereosweep ab, damit Sie schnell vertauschte Kanäle, Mono-Ausgabe, schwache Lautsprecher, Balance-Probleme und Verkabelungsfehler erkennen können, ohne Audiosoftware installieren zu müssen.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Ein korrektes Stereo-Setup bewahrt die Richtung: Der linke Testton sollte nur aus dem linken Lautsprecher oder der linken Ohrmuschel kommen, der rechte Testton sollte nur von der rechten Seite kommen und der Center-Ton sollte zwischen beiden Seiten gleichmäßig ausbalanciert klingen. Wenn der Ton auf der falschen Seite, gleichzeitig auf beiden Seiten oder auf einer Seite deutlich lauter erscheint, liegt das Problem meist in den Ausgabeeinstellungen, dem Mono-Eingabehilfemodus, der Kabelverdrahtung, dem Bluetooth-Routing, der Lautsprecheraufstellung oder Audioverbesserungssoftware.',
+    },
+    {
+      type: 'table',
+      headers: ['Taste', 'Was Sie hören sollten', 'Zur Diagnose verwenden'],
+      rows: [
+        ['Links', 'Ton nur vom linken Lautsprecher, linken Kopfhörertreiber oder linken Ohrhörer.', 'Vertauschte Kabel, falsche Lautsprecheraufstellung, Mono-Ausgabe oder Kanal-Neuzuordnung.'],
+        ['Rechts', 'Ton nur vom rechten Lautsprecher, rechten Kopfhörertreiber oder rechten Ohrhörer.', 'Vertauschte Ausgänge, falsche Adapterverkabelung oder Treibereffekte, die die Kanalreihenfolge ändern.'],
+        ['Mitte', 'Ton erscheint in der Mitte, da beide Kanäle gleichmäßig spielen.', 'System-Balance-Versatz, ein schwacher Lautsprecher, verstopftes Ohrhörer-Gitter oder ungleiche Verstärkerverstärkung.'],
+        ['Sweep', 'Ton bewegt sich sanft über das Stereobild von Seite zu Seite.', 'Aussetzer, instabile Bluetooth-Verbindungen, Phasenprobleme, virtuelle Surround-Artefakte oder ungleichmäßige Abbildung.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Die häufigsten Stereoprobleme, die dieser Test findet',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Linker und rechter Kanal sind vertauscht: Die linke Taste spielt auf der rechten Seite oder die rechte Taste spielt auf der linken Seite.',
+        'Stereo ist zu Mono zusammengefallen: Links, rechts und Mitte klingen alle fast identisch aus beiden Lautsprechern.',
+        'Eine Seite ist leiser: Center-Audio zieht zu einem Lautsprecher, auch wenn der System-Balance-Regler zentriert aussieht.',
+        'Kopfhörer sind falsch verkabelt oder getragen: Spiel-Schritte, Musik-Panning und Videoanrufe fühlen sich räumlich verwirrend an.',
+        'Bluetooth- oder USB-Audio wird verarbeitet: Soundbars, Docks, Headsets und TV-Modi können das Signal heruntermischen oder virtualisieren.',
+        'Lautsprecheraufstellung ist irreführend: Ein Lautsprecher zu nah an einer Wand, durch Möbel blockiert oder weiter entfernt, kann das Center-Bild verschieben.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'So beheben Sie vertauschte linke und rechte Audio-Kanäle',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Tauschen Sie bei kabelgebundenen Lautsprechern die linken und rechten Stecker am Verstärker, Audio-Interface, DAC oder Computerausgang.',
+        'Stellen Sie bei passiven Lautsprechern sicher, dass der linke Lautsprecher an den linken Verstärkeranschlüssen und der rechte Lautsprecher an den rechten Anschlüssen angeschlossen ist.',
+        'Überprüfen Sie bei Kopfhörern, ob sie in der richtigen Ausrichtung getragen werden, und testen Sie ohne Adapter, Verlängerungskabel oder Splitterkabel.',
+        'Überprüfen Sie unter Windows oder macOS die Ausgabebalance und deaktivieren Sie Mono-Audio in den Eingabehilfen- oder Soundeinstellungen.',
+        'Deaktivieren Sie bei Bluetooth-Lautsprechern und Soundbars virtuellen Surround, Party-Modus, Dual-Audio, Raumkorrektur oder TV-Soundmodi während des Tests.',
+        'Überprüfen Sie bei Audio-Interfaces, DAWs und Mischern das Kanal-Routing, Pan-Regler, Monitor-Mix-Einstellungen und alle vom Hersteller bereitgestellten Software-Mixer.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'So interpretieren Sie den Center-Lautsprechertest',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Der Center-Ton ist kein separater physischer Center-Lautsprecher in einem normalen Zweikanal-Setup. Es ist dasselbe Signal, das gleichmäßig an links und rechts gesendet wird. Bei Kopfhörern sollte es sich zentriert im Kopf anfühlen; bei Lautsprechern sollte es ein Phantom-Center zwischen ihnen bilden. Wenn es nach links oder rechts lehnt, überprüfen Sie System-Balance, Lautsprecherabstand, Lautsprecherwinkel, Lautstärkeregler, Verstärker-Trimmung, Ohrhörer-Passform, Staub im Treibergitter und ob ein Lautsprecher teilweise blockiert oder defekt ist.',
+    },
+    {
+      type: 'table',
+      headers: ['Was passiert', 'Wahrscheinliche Ursache', 'Nächster Schritt'],
+      rows: [
+        ['Links spielt von beiden Seiten', 'Mono-Audio, Downmixing oder räumliche Audioverarbeitung.', 'Deaktivieren Sie Mono-Ausgabe und virtuellen Surround und testen Sie erneut.'],
+        ['Links spielt von der rechten Seite', 'Kanäle sind irgendwo in der Wiedergabekette vertauscht.', 'Tauschen Sie Kabel oder ändern Sie das Kanal-Routing im Treiber, Mixer oder Verstärker.'],
+        ['Mitte ist auf einer Seite lauter', 'Balance, Aufstellung, Treiberschaden, Ohrpassform oder blockiertes Lautsprechergitter.', 'Vergleichen Sie mit einem anderen Kopfhörer oder Lautsprecherpaar und überprüfen Sie die physische Aufstellung.'],
+        ['Sweep springt oder verschwindet', 'Bluetooth-Instabilität, Audioverbesserungsartefakte oder ein defektes Kabel/Stecker.', 'Testen Sie mit kabelgebundener Ausgabe oder einem anderen Kabel, um das schwache Glied zu isolieren.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Kopfhörer- und Ohrhörer-Links-Rechts-Test',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Für Kopfhörer und Ohrhörer ist der Links/Rechts-Test besonders nützlich vor dem Spielen, Audiobearbeitung, Filme schauen oder an Anrufen teilnehmen. Setzen Sie das Headset normal auf, starten Sie mit niedriger Lautstärke, drücken Sie Links und Rechts und bestätigen Sie, dass jeder Ton auf dem richtigen Ohr ankommt. Wenn beide Seiten gleich klingen, verwendet Ihr Gerät möglicherweise Mono-Audio. Wenn eine Seite dumpf oder leiser ist, reinigen Sie das Ohrhörer-Gitter, setzen Sie den Ohrstöpsel neu ein, überprüfen Sie das Kabel und vergleichen Sie mit einem anderen Ausgabegerät.',
+    },
+    {
+      type: 'title',
+      text: 'Sichere Audiotest-Tipps',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Starten Sie mit niedriger Systemlautstärke, insbesondere bei Kopfhörern.',
+        'Verwenden Sie Endlosschleife bis Stopp nur, wenn Sie aktiv kontinuierlichen Ton für Kabelverfolgung, Aufstellung oder Balance-Einstellung benötigen.',
+        'Halten Sie Testtöne kurz bei kleinen Lautsprechern; kontinuierliche Sinuswellen können schnell unangenehm werden.',
+        'Vermeiden Sie maximale Verstärkung bei kleinen Laptop-Lautsprechern und unbekannten Verstärkern.',
+        'Setzen Sie Kopfhörer nicht auf Ihre Ohren, bevor Sie bestätigt haben, dass die Lautstärke sicher ist.',
+        'Wiederholen Sie nach dem Wechseln von Kabeln oder Einstellungen die Links-, Rechts-, Center- und Sweep-Tests in dieser Reihenfolge.',
+        'Kombinieren Sie für Studio- oder Heimkino-Kalibrierung diesen Schnelltest mit einem SPL-Messgerät oder der Receiver-Kalibrierungsroutine.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Schnelldiagnose',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Wenn links und rechts vertauscht sind, überprüfen Sie zuerst die physische Verkabelung, da dies die schnellste Lösung für Desktop-Lautsprecher, Verstärker und Audio-Interfaces ist. Wenn beide Tasten von beiden Seiten spielen, suchen Sie nach Mono-Ausgabe, räumlichem Audio, virtuellem Surround oder einem Gerät, das Stereo absichtlich heruntermischt. Wenn die Mitte außermittig ist, aber links und rechts korrekt geroutet sind, liegt das Problem normalerweise an Balance, Aufstellung, Ohrpassform, blockierten Gittern oder ungleicher Lautsprecherausgabe.',
+    },
+  ],
+  ui: {
+    left: 'Links',
+    center: 'Mitte',
+    right: 'Rechts',
+    sweep: 'Sweep',
+    stop: 'Stopp',
+    volume: 'Lautstärke',
+    duration: 'Dauer',
+    infiniteMode: 'Endlosschleife',
+    infiniteModeHint: 'Hält einen Kanal für kontinuierliche Tests am Laufen.',
+    secondsUnit: 's',
+    hertzUnit: 'Hz',
+    tone: 'Ton',
+    balance: 'Balance',
+    activeIdle: 'Bereit',
+    activeLeft: 'Spiele linken Kanal',
+    activeCenter: 'Spiele zentrierten Ton',
+    activeRight: 'Spiele rechten Kanal',
+    activeSweep: 'Sweep über das Stereofeld',
+    safety: 'Leise starten. Testtöne können über Kopfhörer, Verstärker und kleine Laptop-Lautsprecher laut sein.',
+    leftSpeaker: 'Linker Lautsprecher',
+    rightSpeaker: 'Rechter Lautsprecher',
+    centerLine: 'Stereofeld',
+  },
+};