@jjlmoya/utils-nautical 1.22.0 → 1.23.0

package/src/tool/hullSpeed/hull-draw.ts

@@ -0,0 +1,185 @@
+import type { HullKind } from './logic';
+
+interface Frame {
+  s: number;
+  b: number;
+  w: number;
+  L: number;
+  kind: HullKind;
+}
+
+export interface BoatDraw {
+  stern: number;
+  bow: number;
+  wl: number;
+  lift: number;
+  kind: HullKind;
+}
+
+function frameOf(draw: BoatDraw): Frame {
+  return {
+    s: draw.stern,
+    b: draw.bow,
+    w: draw.wl + draw.lift,
+    L: draw.bow - draw.stern,
+    kind: draw.kind,
+  };
+}
+
+function fb(kind: HullKind, length: number): number {
+  if (kind === 'planing') return 54 + length * 0.03;
+  if (kind === 'semi') return 62 + length * 0.035;
+  return 74 + length * 0.045;
+}
+
+function sheer(frame: Frame): { ds: number; db: number; ox: number; oy: number } {
+  if (frame.kind === 'planing') {
+    return {
+      ds: frame.w - 50,
+      db: frame.w - 58,
+      ox: Math.min(18, frame.L * 0.04),
+      oy: 12,
+    };
+  }
+  const rise = fb(frame.kind, frame.L);
+  return {
+    ds: frame.w - rise * 0.78,
+    db: frame.w - rise * 1.22,
+    ox: Math.min(24, frame.L * 0.05),
+    oy: 16,
+  };
+}
+
+function deckPlane(frame: Frame): string {
+  const { ds, db, ox, oy } = sheer(frame);
+  return `M ${frame.s} ${ds} L ${frame.b} ${db} L ${frame.b + ox} ${db - oy} L ${frame.s + ox} ${ds - oy} Z`;
+}
+
+function topsides(frame: Frame): string {
+  const { ds, db } = sheer(frame);
+  if (frame.kind === 'planing') {
+    const aft = frame.s - 18;
+    return `M ${frame.s} ${frame.w} L ${aft} ${ds} L ${frame.b - 8} ${db} L ${frame.b + 6} ${frame.w - 6} L ${frame.b} ${frame.w} Z`;
+  }
+  const stem = frame.kind === 'displacement' ? 18 : 9;
+  return `M ${frame.s} ${frame.w} L ${frame.s - 10} ${ds} L ${frame.b} ${db} L ${frame.b + stem} ${frame.w - 10} L ${frame.b} ${frame.w} Z`;
+}
+
+function gunwale(frame: Frame): string {
+  const { ds, db } = sheer(frame);
+  return `M ${frame.s} ${ds} L ${frame.b} ${db} L ${frame.b} ${db + 7} L ${frame.s} ${ds + 7} Z`;
+}
+
+function transom(frame: Frame): string {
+  const { ds, ox, oy } = sheer(frame);
+  if (frame.kind === 'planing') {
+    const aft = frame.s - 18;
+    return `M ${frame.s} ${frame.w} L ${aft} ${ds} L ${aft + ox} ${ds - oy} L ${frame.s + ox} ${frame.w - 4} Z`;
+  }
+  return `M ${frame.s} ${frame.w} L ${frame.s} ${ds} L ${frame.s + ox} ${ds - oy} L ${frame.s + ox} ${frame.w - 8} Z`;
+}
+
+function underbody(frame: Frame): string {
+  const s = frame.s;
+  const L = frame.L;
+  const w = frame.w;
+  if (frame.kind === 'planing') {
+    return `M ${s} ${w} L ${s + L * 0.18} ${w + 10} L ${s + L * 0.72} ${w + 11} L ${s + L * 0.92} ${w + 6} L ${frame.b} ${w} Z`;
+  }
+  return `M ${s} ${w} C ${s + L * 0.14} ${w + 32} ${s + L * 0.38} ${w + 48} ${s + L * 0.52} ${w + 46} C ${s + L * 0.72} ${w + 40} ${s + L * 0.9} ${w + 24} ${frame.b} ${w} Z`;
+}
+
+function keelPath(frame: Frame): string {
+  const s = frame.s;
+  const L = frame.L;
+  const w = frame.w;
+  if (frame.kind === 'planing') {
+    return `M ${s + L * 0.16} ${w} L ${s + L * 0.6} ${w} L ${s + L * 0.4} ${w + 22} Z`;
+  }
+  if (frame.kind === 'semi') {
+    return `M ${s + L * 0.22} ${w} L ${s + L * 0.7} ${w} L ${s + L * 0.5} ${w + 52} L ${s + L * 0.32} ${w + 46} Z`;
+  }
+  return `M ${s + L * 0.18} ${w} L ${s + L * 0.66} ${w} L ${s + L * 0.54} ${w + 78} L ${s + L * 0.28} ${w + 70} Z`;
+}
+
+function cabinPath(frame: Frame): string {
+  const { ds } = sheer(frame);
+  if (frame.kind === 'planing') return planingCockpit(frame, ds);
+  const x0 = frame.s + frame.L * 0.27;
+  const x1 = frame.s + frame.L * 0.6;
+  return `<path class="n-hull-cabin" d="M ${x0} ${ds} L ${x0 + 10} ${ds - 46} L ${x1 - 4} ${ds - 44} L ${x1 + 12} ${ds} Z" />`;
+}
+
+function planingCockpit(frame: Frame, ds: number): string {
+  const x0 = frame.s + frame.L * 0.22;
+  const x1 = frame.s + frame.L * 0.48;
+  const x2 = frame.s + frame.L * 0.7;
+  const screen = `M ${x1} ${ds} L ${x1 + 10} ${ds - 32} L ${x2} ${ds - 30} L ${x2 + 8} ${ds} Z`;
+  const console = `M ${x0} ${ds} L ${x0} ${ds - 16} L ${x1 - 4} ${ds - 16} L ${x1 - 4} ${ds} Z`;
+  return `<path class="n-hull-cabin" d="${console}" /><path class="n-hull-glass" d="${screen}" />`;
+}
+
+function ports(frame: Frame): string {
+  if (frame.kind === 'planing') return '';
+  const { ds } = sheer(frame);
+  const y = ds - 22;
+  const x1 = frame.s + frame.L * 0.36;
+  const x2 = frame.s + frame.L * 0.48;
+  return `<circle class="n-hull-glass" cx="${x1.toFixed(1)}" cy="${y.toFixed(1)}" r="5" /><circle class="n-hull-glass" cx="${x2.toFixed(1)}" cy="${y.toFixed(1)}" r="5" />`;
+}
+
+function rig(frame: Frame): string {
+  if (frame.kind === 'planing') return '';
+  const { ds } = sheer(frame);
+  const x = frame.s + frame.L * 0.42;
+  const boom = frame.L * 0.28;
+  return `<path class="n-hull-spar" d="M ${x} ${ds - 44} L ${x} ${ds - 168}" /><path class="n-hull-spar" d="M ${x} ${ds - 70} L ${x + boom} ${ds - 58}" />`;
+}
+
+function rudder(frame: Frame): string {
+  const s = frame.s;
+  const w = frame.w;
+  return `M ${s + 7} ${w} L ${s - 6} ${w + 40} L ${s + 12} ${w + 40} L ${s + 16} ${w} Z`;
+}
+
+function drive(frame: Frame): string {
+  if (frame.kind === 'planing') return outboard(frame);
+  return `<path class="n-hull-keel" d="${rudder(frame)}" />`;
+}
+
+function outboard(frame: Frame): string {
+  const { ds } = sheer(frame);
+  const x = frame.s - 14;
+  const cowling = `M ${x - 7} ${ds - 4} L ${x + 9} ${ds - 4} L ${x + 8} ${ds + 18} L ${x - 6} ${ds + 18} Z`;
+  const shaft = `M ${x} ${ds + 18} L ${x} ${frame.w + 28}`;
+  const foot = `M ${x - 5} ${frame.w + 24} L ${x + 14} ${frame.w + 26} L ${x + 12} ${frame.w + 34} L ${x - 4} ${frame.w + 32} Z`;
+  return `<path class="n-hull-keel" d="${cowling}" /><path class="n-hull-spar" d="${shaft}" /><path class="n-hull-keel" d="${foot}" />`;
+}
+
+function chine(frame: Frame): string {
+  if (frame.kind !== 'planing') return '';
+  const y = frame.w - 16;
+  return `<path class="n-hull-chine" d="M ${frame.s + 6} ${y} L ${frame.b - 10} ${y - 8}" />`;
+}
+
+function boot(frame: Frame): string {
+  return `M ${frame.s} ${frame.w - 4} L ${frame.b} ${frame.w - 4} L ${frame.b} ${frame.w + 5} L ${frame.s} ${frame.w + 5} Z`;
+}
+
+export function boatMarkup(draw: BoatDraw): string {
+  const frame = frameOf(draw);
+  return [
+    `<path class="n-hull-keel" d="${keelPath(frame)}" />`,
+    drive(frame),
+    `<path class="n-hull-body" d="${underbody(frame)}" />`,
+    `<path class="n-hull-topside" d="${topsides(frame)}" />`,
+    `<path class="n-hull-transom" d="${transom(frame)}" />`,
+    `<path class="n-hull-deck" d="${deckPlane(frame)}" />`,
+    `<path class="n-hull-gunwale" d="${gunwale(frame)}" />`,
+    `<path class="n-hull-bootfill" d="${boot(frame)}" />`,
+    chine(frame),
+    cabinPath(frame),
+    ports(frame),
+    rig(frame),
+  ].join('');
+}

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

@@ -0,0 +1,199 @@
+import { bibliography } from '../bibliography';
+import type { HullSpeedLocaleContent, HullSpeedUI } from '../index';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+
+const slug = 'rumpfgeschwindigkeit-rechner';
+const title = 'Rechner für Rumpfgeschwindigkeit';
+const description =
+  'Ermittle die theoretische Rumpfgeschwindigkeit aus der Wasserlinienlänge, vergleiche ein Log und sieh, wann ein Verdränger in seine eigene Bugwelle klettert.';
+
+const ui: HullSpeedUI = {
+  metric: 'Metrisch',
+  imperial: 'Imperial',
+  unitGroup: 'Einheiten',
+  sceneLabel: 'Wasserlinie und Bugwelle',
+  hullSpeedLabel: 'Rumpfgeschwindigkeit',
+  knotsUnit: 'kn',
+  kmhUnit: 'km/h',
+  mphUnit: 'mph',
+  ratioLabel: 'S/L',
+  froudeLabel: 'Fr',
+  lwlLabelMetric: 'Wasserlinienlänge',
+  lwlLabelImperial: 'Wasserlinienlänge',
+  lwlUnitM: 'm',
+  lwlUnitFt: 'ft',
+  observedLabel: 'Loggeschwindigkeit',
+  observedHint: 'Lass 0 stehen, um die theoretische Welle zu zeichnen. Tippe ein Log, um zu sehen, ob du noch in der Mulde sitzt.',
+  stretchHint: 'Zieh den Rumpf, um die Wasserlinie zu strecken',
+  hullKindLabel: 'Rumpfform',
+  displacement: 'Verdränger',
+  semi: 'Halbverdränger',
+  planing: 'Gleiter',
+  boatsLabel: 'Beispielwasserlinien',
+  dinghy: 'Jolle',
+  daysailer: 'Daysailer',
+  cruiser: 'Kreuzer',
+  bluewater: 'Hochsee',
+  workboat: 'Arbeitsschiff',
+  bandBelow: 'Noch eine kurze Welle',
+  bandNear: 'Näher an der Wellenbarriere',
+  bandAt: 'Auf der Bugwelle',
+  bandAbove: 'Versucht, die Welle zu erklimmen',
+  bandPlane: 'Im Gleitmodus, über der Rumpfgeschwindigkeit',
+  planingNote:
+    'Ein Gleiter kann diese Welle hinter sich lassen. Die Rumpfgeschwindigkeit ist eine Referenz, keine Wand.',
+  displacementNote:
+    'Ein Verdränger zahlt steil, sobald er seinen eigenen Sog einholt. Nimm sie als praktische Decke, nicht als GPS Ziel.',
+  semiNote:
+    'Halbverdränger können den klassischen Faktor mit genug Leistung etwas überschreiten, bei scharfem Widerstandsanstieg.',
+  waveLegend: 'Bugwelle',
+  waterLegend: 'Wasserlinie',
+  markLegend: 'Rumpfgeschwindigkeit',
+  faqTitle: 'Fragen zur Rumpfgeschwindigkeit',
+  bibliographyTitle: 'Quellen',
+};
+
+const faq: HullSpeedLocaleContent['faq'] = [
+  {
+    question: 'Was ist die Rumpfgeschwindigkeit eines Segelboots?',
+    answer:
+      'Es ist die Geschwindigkeit, bei der ein Verdränger mit einer Bugwelle fährt, die ungefähr so lang ist wie seine Wasserlinie. In nautischen Einheiten schätzt man sie als 1.34 mal die Wurzel der Wasserlinienlänge in Fuß. Das ist eine kritische Geschwindigkeit, kein harter physikalischer Stopp.',
+  },
+  {
+    question: 'Wie berechnet man die Rumpfgeschwindigkeit?',
+    answer:
+      'Wandle die Wasserlinie in Fuß um, ziehe die Wurzel und multipliziere mit 1.34, um Knoten zu erhalten. Eine 10 m Wasserlinie sind etwa 32.8 ft, also rund 7.7 kn. Derselbe Punkt entspricht einer Froude Zahl nahe 0.40.',
+  },
+  {
+    question: 'Gilt die Rumpfgeschwindigkeit auch für Gleiter?',
+    answer:
+      'Die Formel beschreibt weiter die Welle, die der Rumpf im Verdrängermodus machen würde. Gleiter und viele Halbverdränger sind gebaut, um über diese Welle zu klettern. Nimm die Zahl als Referenz und lies den Hinweis zur Rumpfform.',
+  },
+  {
+    question: 'Soll ich Wasserlinienlänge oder Gesamtlänge nehmen?',
+    answer:
+      'Nimm die Länge in der Wasserlinie (LWL), die getauchte Länge, die die Welle wirklich macht. Gesamtlänge, Bugspriete und Überhänge setzen die Wellenlänge nicht. Miss LWL im Wasser, nicht die LOA aus dem Prospekt.',
+  },
+];
+
+const howTo: HullSpeedLocaleContent['howTo'] = [
+  {
+    name: 'Wasserlinie strecken',
+    text: 'Zieh den Rumpf, bewege die Schiene oder wähle von der Jolle bis zum Arbeitsschiff. Die Rumpfgeschwindigkeit ist 1.34 mal die Wurzel dieser Länge in Fuß.',
+  },
+  {
+    name: 'Rumpfform wählen',
+    text: 'Verdränger, Halbverdränger oder Gleiter ändert den Kiel und ob das Boot aus seiner eigenen Welle herausklettern kann.',
+  },
+  {
+    name: 'Die Mulde lesen',
+    text: 'Bei Rumpfgeschwindigkeit sitzen Bug und Heckwelle eine Wasserlinie auseinander und das Boot liegt im Trog. Das ist die Barriere.',
+  },
+  {
+    name: 'Ein Log vergleichen',
+    text: 'Gib die Fahrt durchs Wasser ein. Eine kürzere Welle heißt, du fährst noch günstig. Eine längere Welle heißt, du kletterst in die Mulde.',
+  },
+];
+
+const seo: HullSpeedLocaleContent['seo'] = [
+  {
+    type: 'title',
+    text: 'Was die Rumpfgeschwindigkeit wirklich sagt',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'Ein Verdränger schiebt eine Welle vom Bug und eine vom Heck. Liegen diese Kämme etwa eine Wasserlinie auseinander, fährt das Boot mit seinem eigenen Sog. Extra Leistung türmt dann vor allem Wasser auf, statt Fahrt zu kaufen. Diesen Zustand nennen Segler Rumpfgeschwindigkeit.',
+  },
+  {
+    type: 'paragraph',
+    html: 'Der Rechner nutzt das übliche Amateurverhältnis 1.34 Knoten je Wurzel der Wasserlinie in Fuß. Schlanke, lange Rümpfe liegen etwas höher, Lastkähne tiefer. Nimm das Ergebnis als Lehrstrich und vergleiche es mit einem echten Log.',
+  },
+  {
+    type: 'title',
+    text: 'Durchgerechnete Wasserlinien',
+    level: 2,
+  },
+  {
+    type: 'table',
+    headers: ['Wasserlinie', 'Rumpfgeschwindigkeit', 'Typisches Boot'],
+    rows: [
+      ['4.2 m / 13.8 ft', '5.0 kn', 'Jolle'],
+      ['6.5 m / 21.3 ft', '6.2 kn', 'Daysailer'],
+      ['10 m / 32.8 ft', '7.7 kn', 'Familienkreuzer'],
+      ['13.5 m / 44.3 ft', '8.9 kn', 'Hochseeyacht'],
+      ['18 m / 59.1 ft', '10.3 kn', 'Kleines Arbeitsschiff'],
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Die Bugwelle lesen',
+    level: 2,
+  },
+  {
+    type: 'list',
+    items: [
+      'Unter der Marke ist die Welle kurz und das Boot noch günstig zu treiben.',
+      'Nahe der Marke wird die Bugwelle steiler und Kraftstoff oder Segel kaufen weniger Fahrt.',
+      'Auf der Marke passt die Wellenlänge zur LWL. Ein Verdränger steht an der klassischen Barriere.',
+      'Darüber klettert ein Verdränger in seinen Sog. Ein Gleiter kann schon oben sein.',
+    ],
+  },
+  {
+    type: 'tip',
+    title: 'LWL messen, nicht LOA',
+    html: 'Die Prospektlänge enthält Überhänge. Die Welle interessiert die getauchte Wasserlinie. Hast du nur LOA, wird die berechnete Rumpfgeschwindigkeit zu optimistisch.',
+  },
+  {
+    type: 'title',
+    text: 'Die Froude Zahl in einem Satz',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'Rumpfgeschwindigkeit ist eine bequeme Verpackung einer Froude Zahl nahe 0.40: Fahrt geteilt durch die Wurzel aus Schwerkraft mal Länge. Deshalb sind längere Wasserlinien schneller, auch wenn die Rumpfform gleich bleibt. LWL strecken hebt die Verdrängergrenze sauber; Pferdestärken tun das nicht.',
+  },
+];
+
+const schemas: HullSpeedLocaleContent['schemas'] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'UtilityApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  } as WithContext<SoftwareApplication>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faq.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+  } as WithContext<FAQPage>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: `${title} verwenden`,
+    step: howTo.map((step) => ({
+      '@type': 'HowToStep',
+      name: step.name,
+      text: step.text,
+    })),
+  } as WithContext<HowTo>,
+];
+
+export const content: HullSpeedLocaleContent = {
+  slug,
+  title,
+  description,
+  ui,
+  seo,
+  faq,
+  bibliography,
+  howTo,
+  schemas,
+};

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

@@ -0,0 +1,199 @@
+import { bibliography } from '../bibliography';
+import type { HullSpeedLocaleContent, HullSpeedUI } from '../index';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+
+const slug = 'sailboat-hull-speed-calculator';
+const title = 'Sailboat Hull Speed Calculator';
+const description =
+  'Find theoretical hull speed from waterline length, compare an observed speed, and see when a displacement hull is climbing its own bow wave.';
+
+const ui: HullSpeedUI = {
+  metric: 'Metric',
+  imperial: 'Imperial',
+  unitGroup: 'Units',
+  sceneLabel: 'Waterline and bow wave',
+  hullSpeedLabel: 'Hull speed',
+  knotsUnit: 'kn',
+  kmhUnit: 'km/h',
+  mphUnit: 'mph',
+  ratioLabel: 'S/L',
+  froudeLabel: 'Fr',
+  lwlLabelMetric: 'Waterline length',
+  lwlLabelImperial: 'Waterline length',
+  lwlUnitM: 'm',
+  lwlUnitFt: 'ft',
+  observedLabel: 'Log speed',
+  observedHint: 'Leave at 0 to draw the theoretical wave. Type a log reading to see if you are still sitting in the hole.',
+  stretchHint: 'Drag the hull to stretch the waterline',
+  hullKindLabel: 'Hull form',
+  displacement: 'Displacement',
+  semi: 'Semi displacement',
+  planing: 'Planing',
+  boatsLabel: 'Example waterlines',
+  dinghy: 'Dinghy',
+  daysailer: 'Daysailer',
+  cruiser: 'Cruiser',
+  bluewater: 'Bluewater',
+  workboat: 'Workboat',
+  bandBelow: 'Still making a short wave',
+  bandNear: 'Approaching the wave barrier',
+  bandAt: 'Riding the bow wave',
+  bandAbove: 'Trying to climb the wave',
+  bandPlane: 'On the plane, past hull speed',
+  planingNote:
+    'A planing hull can leave this wave behind. Hull speed is a reference, not a wall.',
+  displacementNote:
+    'A displacement hull pays steeply as it catches its own wake. Treat hull speed as a practical ceiling, not a GPS target.',
+  semiNote:
+    'Semi displacement hulls can press a little past the classic ratio with enough power, at a sharp rise in resistance.',
+  waveLegend: 'Bow wave',
+  waterLegend: 'Waterline',
+  markLegend: 'Hull speed',
+  faqTitle: 'Hull speed questions',
+  bibliographyTitle: 'References',
+};
+
+const faq: HullSpeedLocaleContent['faq'] = [
+  {
+    question: 'What is hull speed on a sailboat?',
+    answer:
+      'Hull speed is the speed at which a displacement hull is travelling with a bow wave about as long as its own waterline. In nautical units it is commonly estimated as 1.34 times the square root of waterline length in feet. It is a critical speed, not a hard physical stop.',
+  },
+  {
+    question: 'How do you calculate hull speed?',
+    answer:
+      'Convert waterline length to feet, take the square root, and multiply by 1.34 to get knots. A 10 m waterline is about 32.8 ft, so hull speed is about 7.7 kn. The same point corresponds to a Froude number near 0.40.',
+  },
+  {
+    question: 'Does hull speed apply to planing boats?',
+    answer:
+      'The formula still describes the wave the hull would make if it stayed in displacement mode. Planing and many semi displacement craft are designed to climb over that wave. Use the number as a reference, then look at the hull form note.',
+  },
+  {
+    question: 'Should I use waterline length or overall length?',
+    answer:
+      'Use length on the waterline (LWL), the immersed length that actually makes the wave. Overall length, bowsprits and overhangs do not set the wavelength. Measure LWL in the water, not from a brochure LOA.',
+  },
+];
+
+const howTo: HullSpeedLocaleContent['howTo'] = [
+  {
+    name: 'Stretch the waterline',
+    text: 'Drag the hull, move the waterline rail, or pick a dinghy through workboat. Hull speed is 1.34 times the square root of that length in feet.',
+  },
+  {
+    name: 'Choose hull form',
+    text: 'Displacement, semi displacement or planing changes the keel and whether the boat can climb out of its own wave.',
+  },
+  {
+    name: 'Read the hole',
+    text: 'At hull speed the bow wave and stern wave sit one waterline apart and the boat sits in the trough. That is the barrier.',
+  },
+  {
+    name: 'Compare a log speed',
+    text: 'Enter speed through the water. A shorter wave means you are still cheap to drive. A longer wave means you are climbing the hole.',
+  },
+];
+
+const seo: HullSpeedLocaleContent['seo'] = [
+  {
+    type: 'title',
+    text: 'What hull speed is actually telling you',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'A displacement hull pushes a wave from the bow and another from the stern. When those crests sit about one waterline apart, the boat is travelling with its own wake. Extra power then mostly heaps water up instead of buying speed. That condition is what sailors call hull speed.',
+  },
+  {
+    type: 'paragraph',
+    html: 'The calculator uses the common amateur ratio 1.34 knots per square root of waterline feet. Fine, long hulls can sit a little higher; barges sit lower. Treat the result as a teaching mark, then compare a real log speed against it.',
+  },
+  {
+    type: 'title',
+    text: 'Worked waterline examples',
+    level: 2,
+  },
+  {
+    type: 'table',
+    headers: ['Waterline', 'Hull speed', 'Typical boat'],
+    rows: [
+      ['4.2 m / 13.8 ft', '5.0 kn', 'Dinghy'],
+      ['6.5 m / 21.3 ft', '6.2 kn', 'Daysailer'],
+      ['10 m / 32.8 ft', '7.7 kn', 'Family cruiser'],
+      ['13.5 m / 44.3 ft', '8.9 kn', 'Bluewater yacht'],
+      ['18 m / 59.1 ft', '10.3 kn', 'Small workboat'],
+    ],
+  },
+  {
+    type: 'title',
+    text: 'How to read the bow wave',
+    level: 2,
+  },
+  {
+    type: 'list',
+    items: [
+      'Below the mark the wave is short and the boat is still cheap to drive.',
+      'Near the mark the bow wave steepens and fuel or sail power buys less speed.',
+      'On the mark the wavelength matches LWL. A displacement hull is at the classic barrier.',
+      'Above the mark a displacement hull is climbing its wake. A planing hull may already be up.',
+    ],
+  },
+  {
+    type: 'tip',
+    title: 'Measure LWL, not LOA',
+    html: 'Brochure length includes overhangs. The wave cares about the immersed waterline. If you only have LOA, the hull speed you compute will be optimistic.',
+  },
+  {
+    type: 'title',
+    text: 'Froude number in one sentence',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'Hull speed is a convenient packaging of a Froude number near 0.40: speed divided by the square root of gravity times length. That is why longer waterlines are faster even when the hull shape stays the same. Stretching LWL is the clean way to raise a displacement limit; adding horsepower is not.',
+  },
+];
+
+const schemas: HullSpeedLocaleContent['schemas'] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'UtilityApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  } as WithContext<SoftwareApplication>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faq.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+  } as WithContext<FAQPage>,
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: `How to use ${title}`,
+    step: howTo.map((step) => ({
+      '@type': 'HowToStep',
+      name: step.name,
+      text: step.text,
+    })),
+  } as WithContext<HowTo>,
+];
+
+export const content: HullSpeedLocaleContent = {
+  slug,
+  title,
+  description,
+  ui,
+  seo,
+  faq,
+  bibliography,
+  howTo,
+  schemas,
+};