@jjlmoya/utils-drones 1.35.0 → 1.37.0

package/src/tool/drone-mission-battery-reserve-planner/logic.ts

@@ -0,0 +1,203 @@
+export type UnitSystem = 'metric' | 'imperial';
+export type WindDirection = 'headwind' | 'tailwind' | 'crosswind';
+export type MissionStatusKey = 'optimal' | 'tight' | 'critical' | 'exceeded';
+
+export interface MissionInputs {
+  unitSystem: UnitSystem;
+  batteryCapacityMah: number;
+  voltageNominal: number;
+  averageCurrentAmps: number;
+  cruiseSpeedKmh: number;
+  oneWayDistanceKm: number;
+  targetHoverTimeMin: number;
+  windSpeedKmh: number;
+  windDirection: WindDirection;
+  reservePolicyPercent: number;
+}
+
+export interface MissionResults {
+  totalEnergyWh: number;
+  usableEnergyWh: number;
+  reserveEnergyWh: number;
+  basePowerDrawWatts: number;
+  outboundPowerWatts: number;
+  returnPowerWatts: number;
+  totalAutonomyMinutes: number;
+  outboundSpeedKmh: number;
+  returnSpeedKmh: number;
+  outboundTimeMinutes: number;
+  targetHoverTimeMinutes: number;
+  returnTimeMinutes: number;
+  totalMissionTimeMinutes: number;
+  outboundEnergyWh: number;
+  targetHoverEnergyWh: number;
+  returnEnergyWh: number;
+  missionEnergyUsedWh: number;
+  remainingEnergyLandingWh: number;
+  remainingEnergyLandingPercent: number;
+  maxSafeRadiusKm: number;
+  voltageSagWhLoss: number;
+  statusKey: MissionStatusKey;
+}
+
+const KMH_TO_MPH = 0.621371;
+const KM_TO_MILES = 0.621371;
+
+export function clampValue(val: number, min: number, max: number): number {
+  return Math.min(Math.max(val, min), max);
+}
+
+export function computeEffectiveSpeeds(
+  cruiseKmh: number,
+  windKmh: number,
+  dir: WindDirection
+): { outbound: number; returnLeg: number } {
+  if (dir === 'headwind') {
+    return { outbound: Math.max(1, cruiseKmh - windKmh), returnLeg: cruiseKmh + windKmh * 0.85 };
+  }
+  if (dir === 'tailwind') {
+    return { outbound: cruiseKmh + windKmh * 0.85, returnLeg: Math.max(1, cruiseKmh - windKmh) };
+  }
+  const effective = Math.max(1, Math.sqrt(Math.max(0, cruiseKmh * cruiseKmh - windKmh * windKmh * 0.5)));
+  return { outbound: effective, returnLeg: effective };
+}
+
+export function calculateWindPowerPenalty(
+  basePowerWatts: number,
+  cruiseKmh: number,
+  windKmh: number,
+  dir: WindDirection
+): { outboundPower: number; returnPower: number } {
+  const windRatio = windKmh / Math.max(10, cruiseKmh);
+
+  if (dir === 'headwind') {
+    return {
+      outboundPower: basePowerWatts * Math.pow(1 + 0.65 * windRatio, 1.3),
+      returnPower: basePowerWatts * Math.max(0.75, 1 - 0.35 * windRatio),
+    };
+  }
+  if (dir === 'tailwind') {
+    return {
+      outboundPower: basePowerWatts * Math.max(0.75, 1 - 0.35 * windRatio),
+      returnPower: basePowerWatts * Math.pow(1 + 0.65 * windRatio, 1.3),
+    };
+  }
+  const crossPower = basePowerWatts * (1 + 0.25 * windRatio);
+  return { outboundPower: crossPower, returnPower: crossPower };
+}
+
+export function calculateEnergyMetrics(inputs: MissionInputs): {
+  totalEnergyWh: number;
+  usableEnergyWh: number;
+  reserveEnergyWh: number;
+  basePowerDrawWatts: number;
+  totalAutonomyMinutes: number;
+  voltageSagWhLoss: number;
+} {
+  const cap = Math.max(1, inputs.batteryCapacityMah);
+  const volt = Math.max(0.1, inputs.voltageNominal);
+  const current = Math.max(0.1, inputs.averageCurrentAmps);
+  const reservePct = clampValue(inputs.reservePolicyPercent, 5, 50) / 100;
+
+  const grossWh = (cap * volt) / 1000;
+  const sagLoss = grossWh * Math.min(0.12, 0.02 + 0.015 * (current / (cap / 1000)));
+  const totalWh = Math.max(0.1, grossWh - sagLoss);
+  const reserveWh = totalWh * reservePct;
+  const usableWh = totalWh - reserveWh;
+  const baseWatts = volt * current;
+
+  return {
+    totalEnergyWh: totalWh,
+    usableEnergyWh: usableWh,
+    reserveEnergyWh: reserveWh,
+    basePowerDrawWatts: baseWatts,
+    totalAutonomyMinutes: (usableWh / baseWatts) * 60,
+    voltageSagWhLoss: sagLoss,
+  };
+}
+
+export function determineMissionStatus(
+  remainingWh: number,
+  reserveWh: number,
+  _totalEnergyWh: number
+): MissionStatusKey {
+  if (remainingWh < 0) return 'exceeded';
+  if (remainingWh < reserveWh * 0.5) return 'critical';
+  if (remainingWh < reserveWh) return 'tight';
+  return 'optimal';
+}
+
+interface LegParams {
+  distKm: number;
+  hoverMin: number;
+  baseWatts: number;
+  outboundSpeed: number;
+  returnSpeed: number;
+  outboundPower: number;
+  returnPower: number;
+}
+
+function calculateTransitLegs(p: LegParams) {
+  const outboundTimeMin = (p.distKm / p.outboundSpeed) * 60;
+  const returnTimeMin = (p.distKm / p.returnSpeed) * 60;
+  const outboundEnergyWh = (outboundTimeMin / 60) * p.outboundPower;
+  const hoverEnergyWh = (p.hoverMin / 60) * p.baseWatts;
+  const returnEnergyWh = (returnTimeMin / 60) * p.returnPower;
+
+  return {
+    outboundTimeMin, returnTimeMin, hoverTimeMin: p.hoverMin,
+    totalMissionTimeMin: outboundTimeMin + p.hoverMin + returnTimeMin,
+    outboundEnergyWh, hoverEnergyWh, returnEnergyWh,
+    totalUsedWh: outboundEnergyWh + hoverEnergyWh + returnEnergyWh,
+  };
+}
+
+interface SafeRadiusParams {
+  usableWh: number;
+  hoverWh: number;
+  outboundPower: number;
+  returnPower: number;
+  outboundSpeed: number;
+  returnSpeed: number;
+}
+
+function calculateSafeRadius(p: SafeRadiusParams): number {
+  const transitWh = Math.max(0, p.usableWh - p.hoverWh);
+  const perKm = (p.outboundPower / p.outboundSpeed) + (p.returnPower / p.returnSpeed);
+  return perKm > 0 ? Math.max(0, transitWh / perKm) : 0;
+}
+
+export function calculateMissionReserve(inputs: MissionInputs): MissionResults {
+  const e = calculateEnergyMetrics(inputs);
+  const s = computeEffectiveSpeeds(Math.max(1, inputs.cruiseSpeedKmh), Math.max(0, inputs.windSpeedKmh), inputs.windDirection);
+  const p = calculateWindPowerPenalty(e.basePowerDrawWatts, Math.max(1, inputs.cruiseSpeedKmh), Math.max(0, inputs.windSpeedKmh), inputs.windDirection);
+  const legs = calculateTransitLegs({
+    distKm: Math.max(0, inputs.oneWayDistanceKm), hoverMin: Math.max(0, inputs.targetHoverTimeMin),
+    baseWatts: e.basePowerDrawWatts, outboundSpeed: s.outbound, returnSpeed: s.returnLeg,
+    outboundPower: p.outboundPower, returnPower: p.returnPower,
+  });
+  const maxSafeRadiusKm = calculateSafeRadius({
+    usableWh: e.usableEnergyWh, hoverWh: legs.hoverEnergyWh, outboundPower: p.outboundPower,
+    returnPower: p.returnPower, outboundSpeed: s.outbound, returnSpeed: s.returnLeg,
+  });
+
+  const remWh = e.totalEnergyWh - legs.totalUsedWh;
+  return {
+    totalEnergyWh: e.totalEnergyWh, usableEnergyWh: e.usableEnergyWh, reserveEnergyWh: e.reserveEnergyWh,
+    basePowerDrawWatts: e.basePowerDrawWatts, outboundPowerWatts: p.outboundPower, returnPowerWatts: p.returnPower,
+    totalAutonomyMinutes: e.totalAutonomyMinutes, outboundSpeedKmh: s.outbound, returnSpeedKmh: s.returnLeg,
+    outboundTimeMinutes: legs.outboundTimeMin, targetHoverTimeMinutes: legs.hoverTimeMin, returnTimeMinutes: legs.returnTimeMin,
+    totalMissionTimeMinutes: legs.totalMissionTimeMin, outboundEnergyWh: legs.outboundEnergyWh, targetHoverEnergyWh: legs.hoverEnergyWh,
+    returnEnergyWh: legs.returnEnergyWh, missionEnergyUsedWh: legs.totalUsedWh, remainingEnergyLandingWh: remWh,
+    remainingEnergyLandingPercent: (remWh / e.totalEnergyWh) * 100, maxSafeRadiusKm, voltageSagWhLoss: e.voltageSagWhLoss,
+    statusKey: determineMissionStatus(remWh, e.reserveEnergyWh, e.totalEnergyWh),
+  };
+}
+
+export function convertDistance(km: number, unit: UnitSystem): number {
+  return unit === 'imperial' ? km * KM_TO_MILES : km;
+}
+
+export function convertSpeed(kmh: number, unit: UnitSystem): number {
+  return unit === 'imperial' ? kmh * KMH_TO_MPH : kmh;
+}

package/src/tool/drone-mission-battery-reserve-planner/seo.astro

@@ -0,0 +1,15 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { droneMissionBatteryReservePlanner } from './entry';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await droneMissionBatteryReservePlanner.i18n[locale]?.();
+if (!content) return null;
+---
+
+{content.seo?.length > 0 && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/drone-mission-battery-reserve-planner/storage.ts

@@ -0,0 +1,59 @@
+import type { MissionInputs, UnitSystem, WindDirection } from './logic';
+
+const STORAGE_KEY = 'jjlmoya_drone_mission_battery_reserve_planner_state';
+
+export const DEFAULT_MISSION_INPUTS: MissionInputs = {
+  unitSystem: 'metric',
+  batteryCapacityMah: 10000,
+  voltageNominal: 22.2,
+  averageCurrentAmps: 18,
+  cruiseSpeedKmh: 45,
+  oneWayDistanceKm: 6,
+  targetHoverTimeMin: 5,
+  windSpeedKmh: 12,
+  windDirection: 'headwind',
+  reservePolicyPercent: 20,
+};
+
+function parseNumberField(val: unknown, fallback: number): number {
+  return typeof val === 'number' && !Number.isNaN(val) ? val : fallback;
+}
+
+function parseUnitSystem(val: unknown): UnitSystem {
+  return val === 'imperial' ? 'imperial' : 'metric';
+}
+
+function parseWindDirection(val: unknown): WindDirection {
+  if (val === 'tailwind' || val === 'crosswind') return val;
+  return 'headwind';
+}
+
+export function loadSavedInputs(): MissionInputs {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return DEFAULT_MISSION_INPUTS;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') return DEFAULT_MISSION_INPUTS;
+
+    return {
+      unitSystem: parseUnitSystem(parsed.unitSystem),
+      batteryCapacityMah: parseNumberField(parsed.batteryCapacityMah, DEFAULT_MISSION_INPUTS.batteryCapacityMah),
+      voltageNominal: parseNumberField(parsed.voltageNominal, DEFAULT_MISSION_INPUTS.voltageNominal),
+      averageCurrentAmps: parseNumberField(parsed.averageCurrentAmps, DEFAULT_MISSION_INPUTS.averageCurrentAmps),
+      cruiseSpeedKmh: parseNumberField(parsed.cruiseSpeedKmh, DEFAULT_MISSION_INPUTS.cruiseSpeedKmh),
+      oneWayDistanceKm: parseNumberField(parsed.oneWayDistanceKm, DEFAULT_MISSION_INPUTS.oneWayDistanceKm),
+      targetHoverTimeMin: parseNumberField(parsed.targetHoverTimeMin, DEFAULT_MISSION_INPUTS.targetHoverTimeMin),
+      windSpeedKmh: parseNumberField(parsed.windSpeedKmh, DEFAULT_MISSION_INPUTS.windSpeedKmh),
+      windDirection: parseWindDirection(parsed.windDirection),
+      reservePolicyPercent: parseNumberField(parsed.reservePolicyPercent, DEFAULT_MISSION_INPUTS.reservePolicyPercent),
+    };
+  } catch {
+    return DEFAULT_MISSION_INPUTS;
+  }
+}
+
+export function saveInputs(inputs: MissionInputs): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(inputs));
+  } catch {}
+}

package/src/tool/drone-mission-battery-reserve-planner/ui.ts

@@ -0,0 +1,78 @@
+export interface DroneMissionBatteryReservePlannerUI {
+  [key: string]: unknown;
+  title: string;
+  subtitle: string;
+  description: string;
+  sections: {
+    batteryPropulsion: string;
+    flightAtmosphere: string;
+  };
+  inputs: {
+    unitSystemLabel: string;
+    metricLabel: string;
+    imperialLabel: string;
+    presetLabel: string;
+    batteryCapacityLabel: string;
+    batteryVoltageLabel: string;
+    averageCurrentLabel: string;
+    cruiseSpeedLabel: string;
+    oneWayDistanceLabel: string;
+    targetHoverTimeLabel: string;
+    windSpeedLabel: string;
+    windDirectionLabel: string;
+    windHeadwindLabel: string;
+    windTailwindLabel: string;
+    windCrosswindLabel: string;
+    reservePolicyLabel: string;
+  };
+  presets: {
+    mappingSurvey: string;
+    fpvRecon: string;
+    cinematicInspection: string;
+    microRecon: string;
+    surveyMeta: string;
+    scoutMeta: string;
+    hoverMeta: string;
+  };
+  results: {
+    totalCapacityEnergy: string;
+    usableEnergy: string;
+    reserveEnergyBuffer: string;
+    totalAutonomyTime: string;
+    maxSafeMissionRadius: string;
+    outboundLegTime: string;
+    targetHoverTime: string;
+    returnLegTime: string;
+    totalMissionTime: string;
+    remainingEnergyLanding: string;
+    feasibilityStatus: string;
+    voltageSagSubLabel: string;
+    maxRadiusSubLabel: string;
+    powerSubLabel: string;
+  };
+  statusBadges: {
+    optimalTitle: string;
+    optimalSubtitle: string;
+    tightTitle: string;
+    tightSubtitle: string;
+    criticalTitle: string;
+    criticalSubtitle: string;
+    exceededTitle: string;
+    exceededSubtitle: string;
+  };
+  chart: {
+    batteryProfileTitle: string;
+    modelTitle: string;
+    windLabel: string;
+    homeNode: string;
+    targetNode: string;
+    landNode: string;
+    launchPadLabel: string;
+    surveyHoverLabel: string;
+    safeRadiusLabel: string;
+    outboundSegment: string;
+    targetSegment: string;
+    returnSegment: string;
+    reserveSegment: string;
+  };
+}

package/src/tool/fpv-drone-speed-calculator/bibliography.astro

@@ -0,0 +1,6 @@
+---
+import { Bibliography as BibliographyComponent } from '@jjlmoya/utils-shared';
+import { bibliography } from './bibliography';
+---
+
+<BibliographyComponent links={bibliography} />

package/src/tool/fpv-drone-speed-calculator/bibliography.ts

@@ -0,0 +1,14 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Universidad Politécnica de Madrid - Comparación de una hélice de paso fijo con una de paso variable para una aplicación de un avión VTOL',
+    url: 'https://oa.upm.es/64973/',
+  },
+  {
+    name: 'NASA Technical Reports Server - Efficient Variable-Pitch Propeller Aerodynamic Model Development for Vectored-Thrust eVTOL Aircraft',
+    url: 'https://ntrs.nasa.gov/citations/20220005627',
+  },
+];
+
+export const BIBLIOGRAPHY_ITEMS = bibliography;

package/src/tool/fpv-drone-speed-calculator/component.astro

@@ -0,0 +1,115 @@
+---
+import type { FpvDroneSpeedUI } from './ui';
+
+interface Props {
+  ui: FpvDroneSpeedUI;
+}
+
+const { ui } = Astro.props;
+---
+
+<div class="fpv-speed-tool" data-fpv-speed-calculator data-unit="metric">
+  <script is:inline type="application/json" data-fpv-speed-ui set:html={JSON.stringify(ui)}></script>
+
+  <div class="speed-brief">
+    <div>
+      <span class="brief-kicker">{ui.calculateFromLabel}</span>
+      <p>{ui.assumptionsText}</p>
+    </div>
+    <div class="unit-switch" role="group" aria-label={ui.unitsLabel}>
+      <button type="button" class="unit-button is-selected" data-unit="metric" aria-pressed="true">{ui.metricUnit}</button>
+      <button type="button" class="unit-button" data-unit="imperial" aria-pressed="false">{ui.imperialUnit}</button>
+    </div>
+  </div>
+
+  <section class="flight-deck" aria-labelledby="speed-inputs-title">
+    <div class="control-rail">
+      <div class="rail-heading">
+        <span class="brief-kicker">{ui.inputsLabel}</span>
+        <h2 id="speed-inputs-title">{ui.presetsLabel}</h2>
+      </div>
+      <div class="preset-track">
+        <button type="button" class="preset-button" data-preset="racing">{ui.presetRacing}</button>
+        <button type="button" class="preset-button is-selected" data-preset="freestyle">{ui.presetFreestyle}</button>
+        <button type="button" class="preset-button" data-preset="cruiser">{ui.presetCruiser}</button>
+      </div>
+      <div class="input-list">
+        <label class="input-row"><span>{ui.motorKvLabel}</span><input data-field="motorKv" type="number" min="100" max="10000" step="50" inputmode="decimal" /><small>KV</small></label>
+        <label class="input-row"><span>{ui.batteryVoltageLabel}</span><input data-field="batteryVoltage" type="number" min="1" max="80" step="0.1" inputmode="decimal" /><small>V</small></label>
+        <label class="input-row"><span>{ui.propellerPitchLabel}</span><input data-field="propellerPitchInches" type="number" min="0.5" max="25" step="0.1" inputmode="decimal" /><small>in</small></label>
+        <label class="input-row"><span>{ui.efficiencyLabel}</span><input data-field="efficiencyPercent" type="number" min="50" max="98" step="1" inputmode="decimal" /><small>%</small></label>
+        <label class="input-row"><span>{ui.aircraftMassLabel}</span><input data-field="aircraftMassGrams" type="number" min="1" max="50000" step="10" inputmode="decimal" /><small data-unit-label="mass">g</small></label>
+      </div>
+    </div>
+
+    <div class="speed-orchestra">
+      <div class="speed-orchestra-header">
+        <div>
+          <span class="brief-kicker">{ui.resultsLabel}</span>
+          <h2>{ui.speedLaneLabel}</h2>
+        </div>
+        <div class="diagnosis" data-output="diagnosis" aria-live="polite">{ui.diagnosisPlanning}</div>
+      </div>
+
+      <div class="speed-lane" aria-label={ui.speedLaneLabel}>
+        <div class="lane-grid" aria-hidden="true"></div>
+        <div class="lane-horizon" aria-hidden="true"></div>
+        <div class="lane-header">
+          <span>{ui.speedLaneLabel}</span>
+          <span><b data-output="speed-axis-start">{ui.speedAxisStart}</b><i></i><b data-output="speed-axis-end">{ui.speedAxisEnd}</b></span>
+        </div>
+        <div class="speed-comparison">
+          <div class="comparison-scale" aria-hidden="true">
+            <span data-output="speed-axis-start">{ui.speedAxisStart}</span>
+            <span data-output="speed-axis-mid">150 km/h</span>
+            <span data-output="speed-axis-end">{ui.speedAxisEnd}</span>
+          </div>
+          <div class="comparison-row">
+            <div class="comparison-label"><span>{ui.estimatedSpeedLabel}</span><strong data-output="estimated-speed">178 km/h</strong></div>
+            <div class="comparison-track"><i class="comparison-fill comparison-fill-estimated"></i></div>
+          </div>
+          <div class="comparison-row">
+            <div class="comparison-label"><span>{ui.pitchSpeedLabel}</span><strong data-output="pitch-speed">217 km/h</strong></div>
+            <div class="comparison-track"><i class="comparison-fill comparison-fill-pitch"></i></div>
+          </div>
+          <div class="comparison-gap"><span>{ui.slipLabel}</span><strong data-output="speed-gap">39 km/h</strong><small data-output="slip">18%</small></div>
+        </div>
+      </div>
+
+      <div class="speed-readouts">
+        <div class="hero-readout"><strong data-output="estimated-speed">178 km/h</strong><span>{ui.estimatedSpeedLabel}</span></div>
+        <div class="readout"><strong data-output="pitch-speed">217 km/h</strong><span>{ui.pitchSpeedLabel}</span></div>
+        <div class="readout"><strong data-output="loaded-rpm">36,000 rpm</strong><span>{ui.loadedRpmLabel}</span></div>
+      </div>
+
+      <p class="diagnosis-advice" data-output="diagnosis-advice" aria-live="polite">{ui.diagnosisPlanningAdvice}</p>
+
+      <section class="sensitivity" aria-labelledby="sensitivity-title">
+        <div class="subheading"><span class="brief-kicker">{ui.sensitivityLabel}</span><h3 id="sensitivity-title">{ui.propellerPitchLabel}</h3></div>
+        <div class="sensitivity-row">
+          <div class="sensitivity-point"><span>{ui.lowerPitchLabel}</span><strong data-output="lower-speed">158 km/h</strong><small data-output="lower-pitch">3.8 in</small><div class="sensitivity-bar"><i data-bar="lower"></i></div></div>
+          <div class="sensitivity-point is-current"><span>{ui.selectedPitchLabel}</span><strong data-output="current-speed">178 km/h</strong><small data-output="current-pitch">4.3 in</small><div class="sensitivity-bar"><i data-bar="current"></i></div></div>
+          <div class="sensitivity-point"><span>{ui.higherPitchLabel}</span><strong data-output="higher-speed">199 km/h</strong><small data-output="higher-pitch">4.8 in</small><div class="sensitivity-bar"><i data-bar="higher"></i></div></div>
+        </div>
+      </section>
+
+      <div class="metric-strip">
+        <div><span>{ui.noLoadRpmLabel}</span><strong data-output="no-load-rpm">43,290 rpm</strong></div>
+        <div><span>{ui.slipLabel}</span><strong data-output="slip">18%</strong></div>
+        <div><span>{ui.loadEffectLabel}</span><strong data-output="load-effect">7%</strong></div>
+      </div>
+    </div>
+  </section>
+
+  <div class="assumptions-row">
+    <p><strong>{ui.assumptionsLabel}</strong> {ui.assumptionsText}</p>
+    <p>{ui.safetyText}</p>
+  </div>
+</div>
+
+<script>
+  import { initFpvDroneSpeedCalculator } from './controller';
+
+  const root = document.querySelector<HTMLElement>('[data-fpv-speed-calculator]');
+  if (root) initFpvDroneSpeedCalculator(root);
+</script>

package/src/tool/fpv-drone-speed-calculator/controller.ts

@@ -0,0 +1,105 @@
+import { calculateFpvDroneSpeed, type FpvDroneSpeedInputs } from './logic';
+import { formatMassInput, parseMassInput, renderResults, updateUnitLabels, type DisplayUnit } from './dom-views';
+import type { FpvDroneSpeedUI } from './ui';
+
+interface Preset {
+  id: string;
+  inputs: FpvDroneSpeedInputs;
+}
+
+const PRESETS: Preset[] = [
+  { id: 'racing', inputs: { motorKv: 2450, batteryVoltage: 16.8, propellerPitchInches: 4.3, efficiencyPercent: 84, aircraftMassGrams: 620 } },
+  { id: 'freestyle', inputs: { motorKv: 1950, batteryVoltage: 22.2, propellerPitchInches: 4.3, efficiencyPercent: 82, aircraftMassGrams: 700 } },
+  { id: 'cruiser', inputs: { motorKv: 1500, batteryVoltage: 22.2, propellerPitchInches: 3.5, efficiencyPercent: 78, aircraftMassGrams: 1200 } },
+];
+
+const DEFAULT_INPUTS = PRESETS[1]!.inputs;
+
+function input(root: HTMLElement, field: string): HTMLInputElement | null {
+  return root.querySelector<HTMLInputElement>(`[data-field="${field}"]`);
+}
+
+function setInput(root: HTMLElement, field: string, value: string): void {
+  const element = input(root, field);
+  if (element) element.value = value;
+}
+
+function readInputs(root: HTMLElement, unit: DisplayUnit): FpvDroneSpeedInputs {
+  const read = (field: string): number => Number(input(root, field)?.value ?? 0);
+  return {
+    motorKv: read('motorKv'),
+    batteryVoltage: read('batteryVoltage'),
+    propellerPitchInches: read('propellerPitchInches'),
+    efficiencyPercent: read('efficiencyPercent'),
+    aircraftMassGrams: parseMassInput(input(root, 'aircraftMassGrams')?.value ?? '', unit),
+  };
+}
+
+function setInputs(root: HTMLElement, values: FpvDroneSpeedInputs, unit: DisplayUnit): void {
+  setInput(root, 'motorKv', String(values.motorKv));
+  setInput(root, 'batteryVoltage', String(values.batteryVoltage));
+  setInput(root, 'propellerPitchInches', String(values.propellerPitchInches));
+  setInput(root, 'efficiencyPercent', String(values.efficiencyPercent));
+  setInput(root, 'aircraftMassGrams', formatMassInput(values.aircraftMassGrams, unit));
+}
+
+function selectPreset(root: HTMLElement, id: string): void {
+  root.querySelectorAll<HTMLElement>('[data-preset]').forEach((element) => {
+    element.classList.toggle('is-selected', element.dataset.preset === id);
+  });
+}
+
+function selectUnit(root: HTMLElement, unit: DisplayUnit): void {
+  root.querySelectorAll<HTMLElement>('[data-unit]').forEach((element) => {
+    const active = element.dataset.unit === unit;
+    element.classList.toggle('is-selected', active);
+    element.setAttribute('aria-pressed', String(active));
+  });
+}
+
+function recalculate(root: HTMLElement, ui: FpvDroneSpeedUI, unit: DisplayUnit): void {
+  const results = calculateFpvDroneSpeed(readInputs(root, unit));
+  renderResults({ root, results, ui, unit });
+}
+
+function changeUnit(root: HTMLElement, ui: FpvDroneSpeedUI, from: DisplayUnit, to: DisplayUnit): void {
+  if (from === to) return;
+  const values = readInputs(root, from);
+  setInputs(root, values, to);
+  root.dataset.unit = to;
+  selectUnit(root, to);
+  updateUnitLabels(root, to, ui);
+  recalculate(root, ui, to);
+}
+
+function readUi(root: HTMLElement): FpvDroneSpeedUI {
+  const element = root.querySelector<HTMLScriptElement>('[data-fpv-speed-ui]');
+  return JSON.parse(element?.textContent ?? '{}') as FpvDroneSpeedUI;
+}
+
+export function initFpvDroneSpeedCalculator(root: HTMLElement): void {
+  const ui = readUi(root);
+  let unit: DisplayUnit = 'metric';
+  setInputs(root, DEFAULT_INPUTS, unit);
+  updateUnitLabels(root, unit, ui);
+  selectUnit(root, unit);
+  root.dataset.unit = unit;
+
+  root.querySelectorAll<HTMLElement>('[data-preset]').forEach((element) => element.addEventListener('click', () => {
+    const preset = PRESETS.find((item) => item.id === element.dataset.preset);
+    if (!preset) return;
+    setInputs(root, preset.inputs, unit);
+    selectPreset(root, preset.id);
+    recalculate(root, ui, unit);
+  }));
+  root.querySelectorAll<HTMLElement>('[data-unit]').forEach((element) => element.addEventListener('click', () => {
+    const next = element.dataset.unit === 'imperial' ? 'imperial' : 'metric';
+    changeUnit(root, ui, unit, next);
+    unit = next;
+  }));
+  root.querySelectorAll<HTMLInputElement>('input[data-field]').forEach((element) => element.addEventListener('input', () => {
+    selectPreset(root, '');
+    recalculate(root, ui, unit);
+  }));
+  recalculate(root, ui, unit);
+}