@jjlmoya/utils-hardware 1.28.0 → 1.29.0

package/package.json

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

package/src/category/index.ts

@@ -8,6 +8,7 @@ import { mouseDoubleClickTest } from '../tool/mouseDoubleClickTest/index';
 import { mouseScrollTest } from '../tool/mouseScrollTest/index';
 import { estimadorSaludBateria } from '../tool/batteryHealthEstimator/index';
 import { toneGenerator } from '../tool/toneGenerator/index';
+import { subwooferCrossoverTest } from '../tool/subwooferCrossoverTest/index';
 import { refreshRateDetector } from '../tool/refreshRateDetector/index';
 import { monitorGhostingTest } from '../tool/monitorGhostingTest/index';
 import { spectrumCanvas } from '../tool/colorAccuracyTest/index';
@@ -21,7 +22,7 @@ import { mobileSensorTest } from '../tool/mobileSensorTest/index';
 
 export const hardwareCategory: HardwareCategoryEntry = {
   icon: 'mdi:memory',
-  tools: [pixelesPantalla, testTeclado, keyboardChatterTest, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, mouseScrollTest, estimadorSaludBateria, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, mobileSensorTest, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor],
+  tools: [pixelesPantalla, testTeclado, keyboardChatterTest, testMando, probadorVibracionMando, testRaton, mouseDoubleClickTest, mouseScrollTest, estimadorSaludBateria, toneGenerator, subwooferCrossoverTest, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, mobileSensorTest, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor],
   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 { mouseScrollTest } from './tool/mouseScrollTest/entry';
 export type { MouseScrollTestLocaleContent } from './tool/mouseScrollTest/entry';
 export { toneGenerator } from './tool/toneGenerator/entry';
 export type { ToneGeneratorLocaleContent } from './tool/toneGenerator/entry';
+export { subwooferCrossoverTest } from './tool/subwooferCrossoverTest/entry';
+export type { SubwooferCrossoverTestLocaleContent } from './tool/subwooferCrossoverTest/entry';
 export { refreshRateDetector } from './tool/refreshRateDetector/entry';
 export type { RefreshRateDetectorLocaleContent } from './tool/refreshRateDetector/entry';
 export { monitorGhostingTest } from './tool/monitorGhostingTest/entry';
@@ -46,6 +48,7 @@ import { testRaton } from './tool/mousePollingTest/entry';
 import { mouseDoubleClickTest } from './tool/mouseDoubleClickTest/entry';
 import { mouseScrollTest } from './tool/mouseScrollTest/entry';
 import { toneGenerator } from './tool/toneGenerator/entry';
+import { subwooferCrossoverTest } from './tool/subwooferCrossoverTest/entry';
 import { refreshRateDetector } from './tool/refreshRateDetector/entry';
 import { monitorGhostingTest } from './tool/monitorGhostingTest/entry';
 import { spectrumCanvas } from './tool/colorAccuracyTest/entry';
@@ -56,4 +59,4 @@ import { keyboardChatterTest } from './tool/keyboardChatterTest/entry';
 import { webUsbSerialMonitor } from './tool/webUsbSerialMonitor/entry';
 import { usbPowerBudgetCalculator } from './tool/usbPowerBudgetCalculator/entry';
 import { mobileSensorTest } from './tool/mobileSensorTest/entry';
-export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, keyboardChatterTest, testRaton, mouseDoubleClickTest, mouseScrollTest, toneGenerator, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, mobileSensorTest, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor];
+export const ALL_ENTRIES = [estimadorSaludBateria, pixelesPantalla, testMando, probadorVibracionMando, testTeclado, keyboardChatterTest, testRaton, mouseDoubleClickTest, mouseScrollTest, toneGenerator, subwooferCrossoverTest, refreshRateDetector, monitorGhostingTest, spectrumCanvas, upsRuntimeCalculator, usbPowerBudgetCalculator, mobileSensorTest, stereoAudioTest, webBluetoothBleScanner, webUsbSerialMonitor];

package/src/index.ts

@@ -26,6 +26,7 @@ export { MOUSE_DOUBLE_CLICK_TEST_TOOL } from './tool/mouseDoubleClickTest/index'
 export { MOUSE_SCROLL_TEST_TOOL } from './tool/mouseScrollTest/index';
 export { ESTIMADOR_SALUD_BATERIA_TOOL } from './tool/batteryHealthEstimator/index';
 export { TONE_GENERATOR_TOOL } from './tool/toneGenerator/index';
+export { SUBWOOFER_CROSSOVER_TEST_TOOL } from './tool/subwooferCrossoverTest/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

@@ -22,7 +22,7 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(19);
+    expect(ALL_TOOLS.length).toBe(20);
   });
 });
 

package/src/tests/tool_validation.test.ts

@@ -5,7 +5,7 @@ import { hardwareCategory } from '../data';
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
     it('should have all tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(19);
+      expect(ALL_TOOLS.length).toBe(20);
     });
 
     it('hardwareCategory should be defined', () => {

package/src/tool/subwooferCrossoverTest/bibliography.astro

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

package/src/tool/subwooferCrossoverTest/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Dolby - Speaker setup guides for home theater',
+    url: 'https://www.dolby.com/about/support/guide/speaker-setup-guides/',
+  },
+  {
+    name: 'THX - Speaker and subwoofer placement',
+    url: 'https://www.thx.com/questions/where-should-i-position-my-speakers-and-subwoofer/',
+  },
+  {
+    name: 'SVS - Subwoofer room placement and tuning',
+    url: 'https://www.svsound.com/blogs/subwoofer-setup-and-tuning',
+  },
+];

package/src/tool/subwooferCrossoverTest/component.astro

@@ -0,0 +1,253 @@
+---
+import type { KnownLocale } from '../../types';
+import type { SubwooferCrossoverTestUI } from './ui';
+import { Icon } from 'astro-icon/components';
+import './subwoofer-crossover-test.css';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as SubwooferCrossoverTestUI;
+
+const S = JSON.stringify({
+  ready: t.statusReady,
+  running: t.statusRunning,
+  stopped: t.statusStopped,
+  start: t.start,
+  stop: t.stop,
+  safeStart: t.safeStart,
+  dropoutEmpty: t.dropoutEmpty,
+  crossoverEstimate: t.crossoverEstimate,
+});
+---
+
+<div id="sct-root" class="sct-shell" data-s={S}>
+  <section class="sct-console" aria-label={t.sweepLabel}>
+    <div class="sct-stage">
+      <div class="sct-orbit" aria-hidden="true">
+        <div class="sct-ring sct-ring-a"></div>
+        <div class="sct-ring sct-ring-b"></div>
+        <div class="sct-driver">
+          <Icon name="mdi:speaker" class="sct-speaker-icon" />
+        </div>
+      </div>
+
+      <div class="sct-frequency-panel">
+        <span id="sct-status" class="sct-status">{t.statusReady}</span>
+        <output id="sct-frequency" class="sct-frequency" aria-live="polite">200 Hz</output>
+        <div class="sct-meter" aria-hidden="true">
+          <span id="sct-meter-fill" class="sct-meter-fill"></span>
+        </div>
+        <div class="sct-readouts">
+          <span>{t.targetFrequency}: <strong>10 Hz</strong></span>
+          <span>{t.elapsed}: <strong id="sct-elapsed">0.0s</strong></span>
+        </div>
+      </div>
+    </div>
+
+    <div class="sct-controls">
+      <button id="sct-toggle" class="sct-primary" type="button">
+        <Icon name="mdi:play" class="sct-button-icon" />
+        <span>{t.start}</span>
+      </button>
+      <button id="sct-mark" class="sct-secondary" type="button" disabled>
+        <Icon name="mdi:map-marker-radius" class="sct-button-icon" />
+        <span>{t.markDropout}</span>
+      </button>
+      <button id="sct-reset" class="sct-ghost" type="button">
+        <Icon name="mdi:restart" class="sct-button-icon" />
+        <span>{t.reset}</span>
+      </button>
+    </div>
+
+    <div class="sct-tuning">
+      <label class="sct-slider-wrap" for="sct-volume">
+        <span>{t.volume}</span>
+        <input id="sct-volume" class="sct-slider" type="range" min="0" max="0.6" value="0.22" step="0.01" />
+      </label>
+      <label class="sct-slider-wrap" for="sct-duration">
+        <span>{t.duration}</span>
+        <input id="sct-duration" class="sct-slider" type="range" min="20" max="90" value="45" step="5" />
+      </label>
+    </div>
+
+    <div class="sct-result">
+      <div>
+        <span class="sct-result-label">{t.dropoutLabel}</span>
+        <strong id="sct-dropout">{t.dropoutEmpty}</strong>
+      </div>
+      <p id="sct-note">{t.safeStart}</p>
+    </div>
+
+  </section>
+
+  <script>
+    const root = document.getElementById('sct-root');
+    const strings = JSON.parse(root?.dataset?.s ?? '{}') as Record<string, string>;
+    const frequencyDisplay = document.getElementById('sct-frequency');
+    const elapsedDisplay = document.getElementById('sct-elapsed');
+    const meterFill = document.getElementById('sct-meter-fill') as HTMLSpanElement | null;
+    const statusDisplay = document.getElementById('sct-status');
+    const toggleButton = document.getElementById('sct-toggle') as HTMLButtonElement | null;
+    const markButton = document.getElementById('sct-mark') as HTMLButtonElement | null;
+    const resetButton = document.getElementById('sct-reset') as HTMLButtonElement | null;
+    const volumeInput = document.getElementById('sct-volume') as HTMLInputElement | null;
+    const durationInput = document.getElementById('sct-duration') as HTMLInputElement | null;
+    const dropoutDisplay = document.getElementById('sct-dropout');
+    const noteDisplay = document.getElementById('sct-note');
+
+    const startHz = 200;
+    const endHz = 10;
+    let audioContext: AudioContext | null = null;
+    let oscillator: OscillatorNode | null = null;
+    let gainNode: GainNode | null = null;
+    let startTime = 0;
+    let animationId = 0;
+    let running = false;
+    let currentHz = startHz;
+
+    function formatHz(value: number): string {
+      return value >= 100 ? `${Math.round(value)} Hz` : `${value.toFixed(1)} Hz`;
+    }
+
+    function sweepFrequency(elapsed: number, duration: number): number {
+      const progress = Math.min(1, Math.max(0, elapsed / duration));
+      return startHz * Math.pow(endHz / startHz, progress);
+    }
+
+    function setButtonPlaying(isPlaying: boolean): void {
+      if (!toggleButton) return;
+      const label = toggleButton.querySelector('span');
+      toggleButton.dataset.playing = isPlaying ? 'true' : 'false';
+      if (label) label.textContent = isPlaying ? strings.stop! : strings.start!;
+    }
+
+    function getAudioContext(): AudioContext | null {
+      if (audioContext) return audioContext;
+      const win = window as typeof window & { webkitAudioContext?: typeof AudioContext };
+      const Context = win.AudioContext ?? win.webkitAudioContext;
+      if (!Context) return null;
+      audioContext = new Context();
+      return audioContext;
+    }
+
+    function getElapsed(): { elapsed: number; progress: number } {
+      const duration = Number(durationInput?.value ?? 45);
+      const elapsed = running && audioContext ? audioContext.currentTime - startTime : 0;
+      currentHz = running ? sweepFrequency(elapsed, duration) : currentHz;
+      const progress = Math.min(1, Math.max(0, elapsed / duration));
+      return { elapsed, progress };
+    }
+
+    function refreshFrequencyDisplay(elapsed: number, progress: number): void {
+      if (frequencyDisplay) frequencyDisplay.textContent = formatHz(currentHz);
+      if (elapsedDisplay) elapsedDisplay.textContent = `${elapsed.toFixed(1)}s`;
+      if (meterFill) meterFill.style.transform = `scaleX(${1 - progress})`;
+    }
+
+    function updateVisuals(): void {
+      const { elapsed, progress } = getElapsed();
+      refreshFrequencyDisplay(elapsed, progress);
+      if (running && progress < 1) {
+        animationId = requestAnimationFrame(updateVisuals);
+      } else if (running) {
+        stopSweep();
+      }
+    }
+
+    function setupOscillator(context: AudioContext, duration: number, volume: number): void {
+      oscillator = context.createOscillator();
+      gainNode = context.createGain();
+      oscillator.type = 'sine';
+      oscillator.frequency.setValueAtTime(startHz, context.currentTime);
+      oscillator.frequency.exponentialRampToValueAtTime(endHz, context.currentTime + duration);
+      gainNode.gain.setValueAtTime(0.0001, context.currentTime);
+      gainNode.gain.exponentialRampToValueAtTime(Math.max(0.0001, volume), context.currentTime + 0.08);
+      gainNode.gain.setValueAtTime(Math.max(0.0001, volume), context.currentTime + duration - 0.08);
+      gainNode.gain.exponentialRampToValueAtTime(0.0001, context.currentTime + duration);
+      oscillator.connect(gainNode);
+      gainNode.connect(context.destination);
+      oscillator.start();
+      oscillator.stop(context.currentTime + duration);
+    }
+
+    function applyRunningState(): void {
+      root?.classList.add('is-running');
+      if (markButton) markButton.disabled = false;
+      if (statusDisplay) statusDisplay.textContent = strings.running!;
+    }
+
+    function startSweep(): void {
+      const context = getAudioContext();
+      if (!context) return;
+      if (context.state === 'suspended') void context.resume();
+      stopSweep(false);
+      setupOscillator(context, Number(durationInput?.value ?? 45), Number(volumeInput?.value ?? 0.22));
+      startTime = context.currentTime;
+      currentHz = startHz;
+      running = true;
+      applyRunningState();
+      setButtonPlaying(true);
+      updateVisuals();
+    }
+
+    function cleanupAudio(): void {
+      if (gainNode && audioContext) {
+        gainNode.gain.cancelScheduledValues(audioContext.currentTime);
+        gainNode.gain.setTargetAtTime(0.0001, audioContext.currentTime, 0.025);
+      }
+      if (oscillator) {
+        try { oscillator.stop(); } catch { }
+        oscillator.disconnect();
+      }
+      oscillator = null;
+      gainNode = null;
+    }
+
+    function applyStoppedState(): void {
+      root?.classList.remove('is-running');
+      if (markButton) markButton.disabled = true;
+    }
+
+    function stopSweep(resetStatus = true): void {
+      cancelAnimationFrame(animationId);
+      cleanupAudio();
+      running = false;
+      applyStoppedState();
+      if (resetStatus && statusDisplay) statusDisplay.textContent = strings.stopped!;
+      setButtonPlaying(false);
+    }
+
+    toggleButton?.addEventListener('click', () => {
+      if (running) stopSweep();
+      else startSweep();
+    });
+
+    markButton?.addEventListener('click', () => {
+      if (!dropoutDisplay) return;
+      dropoutDisplay.textContent = formatHz(currentHz);
+      if (noteDisplay) {
+        noteDisplay.textContent = `${strings.crossoverEstimate!}: ${formatHz(currentHz)}.`;
+      }
+      stopSweep();
+    });
+
+    resetButton?.addEventListener('click', () => {
+      stopSweep(false);
+      currentHz = startHz;
+      if (dropoutDisplay) dropoutDisplay.textContent = strings.dropoutEmpty!;
+      if (noteDisplay) noteDisplay.textContent = strings.safeStart!;
+      if (statusDisplay) statusDisplay.textContent = strings.ready!;
+      updateVisuals();
+    });
+
+    volumeInput?.addEventListener('input', () => {
+      if (gainNode && audioContext) {
+        gainNode.gain.setTargetAtTime(Number(volumeInput.value), audioContext.currentTime, 0.03);
+      }
+    });
+  </script>
+</div>

package/src/tool/subwooferCrossoverTest/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+import type { SubwooferCrossoverTestUI } from './ui';
+
+export type SubwooferCrossoverTestLocaleContent = ToolLocaleContent<SubwooferCrossoverTestUI>;
+
+export const subwooferCrossoverTest: HardwareToolEntry<SubwooferCrossoverTestUI> = {
+  id: 'subwoofer-crossover-test',
+  icons: {
+    bg: 'mdi:speaker-wireless',
+    fg: 'mdi:waves-arrow-left',
+  },
+  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/subwooferCrossoverTest/i18n/de.ts

@@ -0,0 +1,188 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { SubwooferCrossoverTestUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'subwoofer-frequenzweichen-test-online';
+const title = 'Subwoofer Frequenzweichentest';
+const description =
+  'Führe einen Sinus-Sweep von 200 Hz bis 10 Hz in deinem Browser durch, um zu finden, wo dein Subwoofer abfällt, aussetzt oder an die Hauptlautsprecher übergibt.';
+
+const faqData = [
+  {
+    question: 'Was misst ein Subwoofer-Frequenzweichen-Test?',
+    answer:
+      'Er hilft dir, den Punkt zu hören, an dem der Bass zwischen deinen Hauptlautsprechern und dem Subwoofer nicht mehr durchgängig klingt. Eine Lücke, ein plötzlicher Pegelwechsel oder ein fehlender Bereich kann auf eine falsche Übergangsfrequenz, ein Phasenproblem, Raumauslöschung oder die Grenze des Subwoofers hinweisen.',
+  },
+  {
+    question: 'Warum sweeped dieser Test von 200 Hz auf 10 Hz herunter?',
+    answer:
+      'Die meisten Heimkino-Übergangsfrequenzen liegen zwischen 60 Hz und 120 Hz, während viele Kompaktlautsprecher oberhalb oder unterhalb dieses Bereichs an Ausgabe verlieren. Das Heruntersweepen von 200 Hz macht die Lautsprecher-Subwoofer-Übergabe leicht hörbar, bevor der Ton den tiefen Subbass erreicht.',
+  },
+  {
+    question: 'Kann dieser Online-Subwoofer-Basstest Lautsprecher beschädigen?',
+    answer:
+      'Ja, sehr tiefe Frequenzen bei hoher Lautstärke können kleine Lautsprecher überlasten oder einen Subwoofer überfordern. Starte leise, vermeide verstärkte Bassmoden und stoppe sofort, wenn du Klappern, Klopfen oder mechanische Überlastung hörst.',
+  },
+  {
+    question: 'Ist die markierte Ausfallfrequenz die exakte Übergangsfrequenz, die ich einstellen sollte?',
+    answer:
+      'Nein. Betrachte sie als Hörtipp, nicht als Labormessung. Die beste Übergangsfrequenz hängt auch von den Lautsprecherspezifikationen, der Raumaufstellung, der Phase, der Entfernungskorrektur und dem Kalibrierungsziel ab.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Stelle eine sichere Hörlautstärke ein',
+    text: 'Reduziere zuerst die Systemlautstärke. Der Sweep verwendet eine erzeugte Sinuswelle, sodass der Bass auch dann intensiv werden kann, wenn die Browser-Lautstärke moderat erscheint.',
+  },
+  {
+    name: 'Starte den 200 Hz bis 10 Hz Sweep',
+    text: 'Drücke Sweep starten und höre von deinem normalen Sitzplatz aus. Der Ton bewegt sich gleichmäßig durch den Bassbereich, in dem sich Subwoofer, Hauptlautsprecher und Raumakustik überlappen.',
+  },
+  {
+    name: 'Höre auf den Ausfall oder die Übergabe',
+    text: 'Achte auf den Moment, in dem der Bass schwächer wird, verschwindet, den Ort wechselt oder zwischen Subwoofer und Hauptlautsprechern ungleichmäßig klingt.',
+  },
+  {
+    name: 'Markiere die Frequenz',
+    text: 'Drücke Ausfall markieren am ersten deutlichen Problempegel. Verwende diese Frequenz als Hinweis zur Anpassung von Übergangsfrequenz, Phase, Aufstellung oder Raumkorrektur.',
+  },
+];
+
+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, index) => ({
+    '@type': 'HowToStep',
+    position: index + 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: 'EUR' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<SubwooferCrossoverTestUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  bibliography,
+  seo: [
+    { type: 'title', text: 'Finde Die Basslücke Zwischen Deinen Lautsprechern Und Dem Subwoofer', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'Ein Subwoofer sollte nicht wie eine separate Box in der Ecke klingen. Der Bass sollte gleichmäßig bleiben, wenn die Töne von deinen Hauptlautsprechern in den Sub übergehen. Dieser Test sweeped von <strong>200 Hz bis 10 Hz</strong>, damit du genau die Zone hören kannst, in der die Übergabe schwach, dröhnend, ortbar oder stumm wird.',
+    },
+    {
+      type: 'table',
+      headers: ['Was du hörst', 'Was es normalerweise bedeutet', 'Was du zuerst versuchen solltest'],
+      rows: [
+        ['Bass verschwindet um 70-100 Hz', 'Subwoofer und Lautsprecher löschen sich gegenseitig nahe der Übergangsfrequenz aus.', 'Phase umkehren, Entfernung/Verzögerung anpassen, dann den Sweep wiederholen.'],
+        ['Bass dröhnt in einem schmalen Band', 'Raummode oder zu viel Überlappung zwischen Lautsprechern und Subwoofer.', 'Übergangsfrequenz leicht senken oder Subwoofer/Hörposition verschieben.'],
+        ['Bass scheint vom Subwoofer-Standort zu kommen', 'Übergangsfrequenz zu hoch oder Subwoofer-Pegel zu heiß.', '80 Hz oder niedriger versuchen und Subwoofer-Verstärkung reduzieren.'],
+        ['Tiefbass verblasst unter 30-40 Hz', 'Normale Ausdehnungsgrenze vieler Subs, besonders kompakter Modelle.', 'Subwoofer-Spezifikation prüfen, bevor du ein Problem verfolgst, das physikalisch sein könnte.'],
+      ],
+    },
+    { type: 'title', text: 'Was Dir Die Ausfallfrequenz Sagt', level: 3 },
+    {
+      type: 'diagnostic',
+      variant: 'info',
+      title: 'Verwende die markierte Frequenz als Abstimmungshinweis',
+      badge: 'Hörtipps',
+      html: '<p>Wenn der markierte Punkt nahe deiner AVR-Übergangsfrequenz liegt, ist das Problem wahrscheinlich Integration: Phase, Entfernung, Polarität, Pegel oder die Steilheit der Filter. Liegt der markierte Punkt viel tiefer, hörst du vielleicht, wie der Subwoofer an seine Leistungsgrenze stößt. Ändert sich das Problem stark, wenn du deinen Kopf bewegst, dominiert der Raum das Ergebnis.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Übliche Übergangsfrequenzbereiche',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Lautsprechertyp', 'Typischer Übergangsfrequenz-Startpunkt', 'Warum'],
+      rows: [
+        ['Kleine Satelliten', '100-150 Hz', 'Winzige Gehäuse können normalerweise keinen sauberen oberen Bass bei Kino-Lautstärken wiedergeben.'],
+        ['Regallautsprecher', '70-100 Hz', 'Oft genug Bass für eine saubere Übergabe, ohne den Sub ortbar zu machen.'],
+        ['Standlautsprecher', '50-80 Hz', 'Größere Tieftöner können mehr Mittelbass bewältigen, aber der Raum kann trotzdem Subwoofer-Bassmanagement bevorzugen.'],
+        ['THX-Setup', '80 Hz', 'Ein praktischer Standardwert, der für viele Systeme gut funktioniert und Tiefbass zum Sub leitet.'],
+      ],
+    },
+    { type: 'title', text: 'Übergangsfrequenzproblem Oder Raumproblem?', level: 3 },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          title: 'Übergangsfrequenz oder Phasenproblem',
+          description: 'Die Schwachstelle erscheint nahe der Übergangsfrequenz und verbessert sich nach Änderung von Phase, Polarität, Entfernung oder Übergangsfrequenz-Einstellung.',
+          points: ['Normalerweise vom gleichen Sitzplatz aus wiederholbar.', 'Oft um 60-120 Hz zentriert.'],
+        },
+        {
+          title: 'Raumauslöschung',
+          description: 'Die Schwachstelle ändert sich drastisch, wenn du deinen Kopf bewegst, den Sitzplatz wechselst oder den Subwoofer ein kurzes Stück verschiebst.',
+          points: ['Sehr positionsabhängig.', 'Oft mehr durch Aufstellung als durch Einstellungen zu lösen.'],
+        },
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Beste Art, den Test durchzuführen',
+      html: 'Setze dich dorthin, wo du tatsächlich Filme schaust oder Musik hörst. Stehe nicht neben dem Subwoofer. Eine Übergangsfrequenz, die neben dem Gehäuse gut klingt, kann auf dem Sofa immer noch eine Lücke hinterlassen.',
+    },
+    {
+      type: 'summary',
+      title: 'Was nach dem Sweep zu ändern ist',
+      items: [
+        'Liegt die Lücke nahe der aktuellen Übergangsfrequenz, probiere 10-Hz-Änderungen und wiederhole den Sweep.',
+        'Teste den Phasenschalter oder die Verzögerungseinstellung des Subwoofers, wenn das schwache Band nahe der Übergangsfrequenz liegt.',
+        'Wird der Bass an einem Sitzplatz stärker und verschwindet an einem anderen, verschiebe den Subwoofer, bevor du alle AVR-Einstellungen änderst.',
+        'Nach Aufstellungs- oder Übergangsfrequenzänderungen führe die Raumkorrektur erneut aus, damit der Receiver das neue Setup misst.',
+        'Verwende die markierte Frequenz als Leitfaden für die Abstimmung und bestätige dann mit Musik, Filmen und vertrauten Basslinien.',
+      ],
+    },
+  ],
+  ui: {
+    sweepLabel: 'Subwoofer-Tieffrequenz-Sweep',
+    currentFrequency: 'Aktuelle Frequenz',
+    targetFrequency: 'Ziel',
+    elapsed: 'Verstrichen',
+    statusReady: 'Bereit für Tief-Sweep',
+    statusRunning: 'Sweepe nach unten',
+    statusStopped: 'Sweep gestoppt',
+    start: 'Sweep starten',
+    stop: 'Sweep stoppen',
+    markDropout: 'Ausfall markieren',
+    reset: 'Zurücksetzen',
+    volume: 'Ausgabepegel',
+    duration: 'Sweep-Dauer',
+    safeStart: 'Starte mit niedriger Lautstärke und markiere dann die erste Frequenz, bei der der Bass schwer hörbar wird.',
+    roomNote: 'Raumposition und Phase können das Ergebnis drastisch verändern.',
+    dropoutLabel: 'Markierter Punkt',
+    dropoutEmpty: 'Noch nicht markiert',
+    crossoverEstimate: 'Geschätzter Ausfallpunkt',
+  },
+};