script.js

// =====================
//  Constants
// =====================
const G = 6.674e-11;   // Gravitational constant (N·m²/kg²)
const g = 9.8;          // Gravity (m/s²)
const R = 8.314;        // Ideal gas constant (J/mol·K)
const DEG = Math.PI / 180; // Degrees to radians

// =====================
//  Topics & Formulas
// =====================
const TOPICS = [
  {
    id: 'kinematics',
    label: 'Kinematics',
    subs: [
      {
        id: 'avg_vel',
        label: 'Average velocity',
        formula: 'v_avg = Δx / Δt',
        inputs: [
          { id: 'dx', label: 'Displacement Δx', unit: 'm' },
          { id: 'dt', label: 'Time Δt', unit: 's' }
        ],
        calc: v => ({
          val: v.dx / v.dt,
          unit: 'm/s',
          formula: `v_avg = ${v.dx} / ${v.dt}`
        })
      },
      {
        id: 'accel',
        label: 'Acceleration',
        formula: 'a = (v_f − v_i) / Δt',
        inputs: [
          { id: 'vf', label: 'Final velocity v_f', unit: 'm/s' },
          { id: 'vi', label: 'Initial velocity v_i', unit: 'm/s' },
          { id: 'dt', label: 'Time Δt', unit: 's' }
        ],
        calc: v => ({
          val: (v.vf - v.vi) / v.dt,
          unit: 'm/s²',
          formula: `a = (${v.vf} − ${v.vi}) / ${v.dt}`
        })
      },
      {
        id: 'eq1',
        label: '1st equation of motion',
        formula: 'v_f = v_i + at',
        inputs: [
          { id: 'vi', label: 'Initial velocity v_i', unit: 'm/s' },
          { id: 'a',  label: 'Acceleration a', unit: 'm/s²' },
          { id: 't',  label: 'Time t', unit: 's' }
        ],
        calc: v => ({
          val: v.vi + v.a * v.t,
          unit: 'm/s',
          formula: `v_f = ${v.vi} + ${v.a} × ${v.t}`
        })
      },
      {
        id: 'eq2',
        label: '2nd equation of motion',
        formula: 'x = v_i·t + ½at²',
        inputs: [
          { id: 'vi', label: 'Initial velocity v_i', unit: 'm/s' },
          { id: 'a',  label: 'Acceleration a', unit: 'm/s²' },
          { id: 't',  label: 'Time t', unit: 's' }
        ],
        calc: v => ({
          val: v.vi * v.t + 0.5 * v.a * v.t * v.t,
          unit: 'm',
          formula: `x = ${v.vi}×${v.t} + ½×${v.a}×${v.t}²`
        })
      },
      {
        id: 'eq3',
        label: '3rd equation of motion',
        formula: 'v_f² = v_i² + 2ax',
        inputs: [
          { id: 'vi', label: 'Initial velocity v_i', unit: 'm/s' },
          { id: 'a',  label: 'Acceleration a', unit: 'm/s²' },
          { id: 'x',  label: 'Displacement x', unit: 'm' }
        ],
        calc: v => {
          const r = v.vi * v.vi + 2 * v.a * v.x;
          if (r < 0) return { err: 'v_f² is negative — check inputs' };
          return {
            val: Math.sqrt(r),
            unit: 'm/s',
            formula: `v_f = √(${v.vi}² + 2×${v.a}×${v.x})`
          };
        }
      }
    ]
  },

  // Additional kinematics helpers (added if missing)
  {
    id: 'kin_helpers',
    label: 'Kinematics Helpers',
    subs: [
      {
        id: 'velocity_mag',
        label: 'Velocity',
        formula: 'v = √(v_x² + v_y²)',
        inputs: [
          { id: 'vx', label: 'Velocity x-component v_x', unit: 'm/s' },
          { id: 'vy', label: 'Velocity y-component v_y', unit: 'm/s' }
        ],
        calc: v => ({
          val: Math.sqrt(v.vx * v.vx + v.vy * v.vy),
          unit: 'm/s',
          formula: `v = √(${v.vx}² + ${v.vy}²)`
        })
      },
      {
        id: 'speed',
        label: 'Speed',
        formula: 'speed = d / Δt',
        inputs: [
          { id: 'd',  label: 'Distance d', unit: 'm' },
          { id: 'dt', label: 'Time Δt', unit: 's' }
        ],
        calc: v => ({ val: v.d / v.dt, unit: 'm/s', formula: `speed = ${v.d} / ${v.dt}` })
      },
      {
        id: 'distance',
        label: 'Distance',
        formula: 'd = v·t',
        inputs: [
          { id: 'v', label: 'Speed v', unit: 'm/s' },
          { id: 't', label: 'Time t', unit: 's' }
        ],
        calc: v => ({ val: v.v * v.t, unit: 'm', formula: `d = ${v.v} × ${v.t}` })
      },
      {
        id: 'displacement',
        label: 'Displacement',
        formula: 'Δx = v·t',
        inputs: [
          { id: 'v', label: 'Velocity v', unit: 'm/s' },
          { id: 't', label: 'Time t', unit: 's' }
        ],
        calc: v => ({ val: v.v * v.t, unit: 'm', formula: `Δx = ${v.v} × ${v.t}` })
      },
      {
        id: 'time',
        label: 'Time',
        formula: 't = d / v',
        inputs: [
          { id: 'd', label: 'Distance d', unit: 'm' },
          { id: 'v', label: 'Speed v', unit: 'm/s' }
        ],
        calc: v => ({ val: v.d / v.v, unit: 's', formula: `t = ${v.d} / ${v.v}` })
      },
      {
        id: 'initial_velocity',
        label: 'Initial velocity',
        formula: 'v_i = v_f − a·t',
        inputs: [
          { id: 'vf', label: 'Final velocity v_f', unit: 'm/s' },
          { id: 'a',  label: 'Acceleration a', unit: 'm/s²' },
          { id: 't',  label: 'Time t', unit: 's' }
        ],
        calc: v => ({ val: v.vf - v.a * v.t, unit: 'm/s', formula: `v_i = ${v.vf} − ${v.a} × ${v.t}` })
      },
      {
        id: 'final_velocity',
        label: 'Final velocity (solve)',
        formula: 'v_f = v_i + a·t',
        inputs: [
          { id: 'vi', label: 'Initial velocity v_i', unit: 'm/s' },
          { id: 'a',  label: 'Acceleration a', unit: 'm/s²' },
          { id: 't',  label: 'Time t', unit: 's' }
        ],
        calc: v => ({ val: v.vi + v.a * v.t, unit: 'm/s', formula: `v_f = ${v.vi} + ${v.a} × ${v.t}` })
      },
      {
        id: 'relative_velocity',
        label: 'Relative velocity',
        formula: 'v_rel = v1 − v2',
        inputs: [
          { id: 'v1', label: 'Velocity v₁', unit: 'm/s' },
          { id: 'v2', label: 'Velocity v₂', unit: 'm/s' }
        ],
        calc: v => ({ val: v.v1 - v.v2, unit: 'm/s', formula: `v_rel = ${v.v1} − ${v.v2}` })
      },
      {
        id: 'free_fall',
        label: 'Free fall',
        formula: 't = √(2h/g), v_f = g·t',
        inputs: [
          { id: 'h', label: 'Height h', unit: 'm' }
        ],
        calc: v => {
          const t = Math.sqrt(2 * v.h / g);
          const vf = g * t;
          return { val: vf, unit: `m/s (t=${t.toFixed(4)} s)`, formula: `v_f = ${vf.toFixed(4)} m/s; t = ${t.toFixed(4)} s` };
        }
      },
      {
        id: 'eq4',
        label: '4th equation',
        formula: 'x = ((v_i + v_f)/2)·t',
        inputs: [
          { id: 'vi', label: 'Initial velocity v_i', unit: 'm/s' },
          { id: 'vf', label: 'Final velocity v_f', unit: 'm/s' },
          { id: 't',  label: 'Time t', unit: 's' }
        ],
        calc: v => ({ val: ((v.vi + v.vf) / 2) * v.t, unit: 'm', formula: `x = ((${v.vi} + ${v.vf})/2) × ${v.t}` })
      },
      {
        id: 'eq5',
        label: '5th equation',
        formula: 'x = v_f·t − ½at²',
        inputs: [
          { id: 'vf', label: 'Final velocity v_f', unit: 'm/s' },
          { id: 'a',  label: 'Acceleration a', unit: 'm/s²' },
          { id: 't',  label: 'Time t', unit: 's' }
        ],
        calc: v => ({ val: v.vf * v.t - 0.5 * v.a * v.t * v.t, unit: 'm', formula: `x = ${v.vf} × ${v.t} − ½ × ${v.a} × ${v.t}²` })
      }
    ]
  },

  {
    id: 'dynamics',
    label: 'Dynamics & Forces',
    subs: [
      {
        id: 'newton2',
        label: "Newton's 2nd law",
        formula: 'F = ma',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' },
          { id: 'a', label: 'Acceleration a', unit: 'm/s²' }
        ],
        calc: v => ({ val: v.m * v.a, unit: 'N', formula: `F = ${v.m} × ${v.a}` })
      },
      {
        id: 'weight',
        label: 'Weight',
        formula: 'W = mg  (g = 9.8 m/s²)',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' }
        ],
        calc: v => ({ val: v.m * g, unit: 'N', formula: `W = ${v.m} × 9.8` })
      },
      {
        id: 'gravity',
        label: 'Universal gravitation',
        formula: 'F = G·m₁m₂ / r²',
        inputs: [
          { id: 'm1', label: 'Mass m₁', unit: 'kg' },
          { id: 'm2', label: 'Mass m₂', unit: 'kg' },
          { id: 'r',  label: 'Distance r', unit: 'm' }
        ],
        calc: v => ({
          val: G * v.m1 * v.m2 / (v.r * v.r),
          unit: 'N',
          formula: `F = G × ${v.m1} × ${v.m2} / ${v.r}²`
        })
      },
      {
        id: 'hooke',
        label: "Hooke's law",
        formula: 'F = −kx',
        inputs: [
          { id: 'k', label: 'Spring constant k', unit: 'N/m' },
          { id: 'x', label: 'Displacement x', unit: 'm' }
        ],
        calc: v => ({ val: -v.k * v.x, unit: 'N', formula: `F = −${v.k} × ${v.x}` })
      },
      {
        id: 'friction',
        label: 'Friction force',
        formula: 'F_f = μN',
        inputs: [
          { id: 'mu', label: 'Coefficient of friction μ', unit: '' },
          { id: 'N',  label: 'Normal force N', unit: 'N' }
        ],
        calc: v => ({ val: v.mu * v.N, unit: 'N', formula: `F_f = ${v.mu} × ${v.N}` })
      },
      {
        id: 'momentum',
        label: 'Momentum',
        formula: 'p = mv',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' },
          { id: 'v', label: 'Velocity v', unit: 'm/s' }
        ],
        calc: v => ({ val: v.m * v.v, unit: 'kg·m/s', formula: `p = ${v.m} × ${v.v}` })
      },
      {
        id: 'impulse',
        label: 'Impulse',
        formula: 'J = F·Δt',
        inputs: [
          { id: 'F',  label: 'Force F', unit: 'N' },
          { id: 'dt', label: 'Time Δt', unit: 's' }
        ],
        calc: v => ({ val: v.F * v.dt, unit: 'N·s', formula: `J = ${v.F} × ${v.dt}` })
      },
      {
        id: 'mass',
        label: 'Mass (from F=ma)',
        formula: 'm = F / a',
        inputs: [
          { id: 'F', label: 'Force F', unit: 'N' },
          { id: 'a', label: 'Acceleration a', unit: 'm/s²' }
        ],
        calc: v => {
          if (v.a === 0) return { err: 'Acceleration cannot be zero' };
          return ({ val: v.F / v.a, unit: 'kg', formula: `m = ${v.F} / ${v.a}` });
        }
      },
      {
        id: 'normal_force',
        label: 'Normal force (horizontal)',
        formula: 'N = mg',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' }
        ],
        calc: v => ({ val: v.m * g, unit: 'N', formula: `N = ${v.m} × 9.8` })
      },
      {
        id: 'tension',
        label: 'Tension (hanging object)',
        formula: 'T = mg',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' }
        ],
        calc: v => ({ val: v.m * g, unit: 'N', formula: `T = ${v.m} × 9.8` })
      },
      {
        id: 'tension_accel',
        label: 'Tension (accelerating)',
        formula: 'T = m(g + a)  or  T = m(g − a)',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' },
          { id: 'a', label: 'Acceleration a', unit: 'm/s²' },
          { id: 'dir', label: 'Direction (1=up, 0=down)', unit: '' }
        ],
        calc: v => {
          const direction = v.dir === 0 ? -1 : 1;
          return ({ val: v.m * (g + direction * v.a), unit: 'N', formula: `T = ${v.m} × (9.8 ${direction > 0 ? '+' : '−'} ${Math.abs(v.a)})` });
        }
      },
      {
        id: 'pressure',
        label: 'Pressure',
        formula: 'P = F / A',
        inputs: [
          { id: 'F', label: 'Force F', unit: 'N' },
          { id: 'A', label: 'Area A', unit: 'm²' }
        ],
        calc: v => {
          if (v.A === 0) return { err: 'Area cannot be zero' };
          return ({ val: v.F / v.A, unit: 'Pa', formula: `P = ${v.F} / ${v.A}` });
        }
      }
    ]
  },

  {
    id: 'energy',
    label: 'Work & Energy',
    subs: [
      {
        id: 'work',
        label: 'Work done',
        formula: 'W = Fd·cos θ',
        inputs: [
          { id: 'F',     label: 'Force F', unit: 'N' },
          { id: 'd',     label: 'Distance d', unit: 'm' },
          { id: 'theta', label: 'Angle θ', unit: '°' }
        ],
        calc: v => ({
          val: v.F * v.d * Math.cos(v.theta * DEG),
          unit: 'J',
          formula: `W = ${v.F} × ${v.d} × cos(${v.theta}°)`
        })
      },
      {
        id: 'ke',
        label: 'Kinetic energy',
        formula: 'KE = ½mv²',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' },
          { id: 'v', label: 'Velocity v', unit: 'm/s' }
        ],
        calc: v => ({
          val: 0.5 * v.m * v.v * v.v,
          unit: 'J',
          formula: `KE = ½ × ${v.m} × ${v.v}²`
        })
      },
      {
        id: 'pe',
        label: 'Potential energy',
        formula: 'PE = mgh',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' },
          { id: 'h', label: 'Height h', unit: 'm' }
        ],
        calc: v => ({
          val: v.m * g * v.h,
          unit: 'J',
          formula: `PE = ${v.m} × 9.8 × ${v.h}`
        })
      },
      {
        id: 'mech',
        label: 'Mechanical energy (find v_f)',
        formula: 'KE_i + PE_i = KE_f + PE_f',
        inputs: [
          { id: 'm',  label: 'Mass m', unit: 'kg' },
          { id: 'vi', label: 'Initial velocity v_i', unit: 'm/s' },
          { id: 'hi', label: 'Initial height h_i', unit: 'm' },
          { id: 'hf', label: 'Final height h_f', unit: 'm' }
        ],
        calc: v => {
          const ei = 0.5 * v.m * v.vi * v.vi + v.m * g * v.hi;
          const vf2 = 2 * (ei - v.m * g * v.hf) / v.m;
          if (vf2 < 0) return { err: 'Not enough energy to reach final height' };
          return {
            val: Math.sqrt(vf2),
            unit: 'm/s (final velocity)',
            formula: `v_f = √(v_i² + 2g(h_i − h_f))`
          };
        }
      },
      {
        id: 'power',
        label: 'Power (W/t)',
        formula: 'P = W / Δt',
        inputs: [
          { id: 'W',  label: 'Work done W', unit: 'J' },
          { id: 'dt', label: 'Time Δt', unit: 's' }
        ],
        calc: v => ({ val: v.W / v.dt, unit: 'W', formula: `P = ${v.W} / ${v.dt}` })
      },
      {
        id: 'powerFv',
        label: 'Power (F·v)',
        formula: 'P = Fv',
        inputs: [
          { id: 'F', label: 'Force F', unit: 'N' },
          { id: 'v', label: 'Velocity v', unit: 'm/s' }
        ],
        calc: v => ({ val: v.F * v.v, unit: 'W', formula: `P = ${v.F} × ${v.v}` })
      },
      {
        id: 'pe_elastic',
        label: 'Elastic potential energy',
        formula: 'PE_elastic = ½kx²',
        inputs: [
          { id: 'k', label: 'Spring constant k', unit: 'N/m' },
          { id: 'x', label: 'Displacement x', unit: 'm' }
        ],
        calc: v => ({
          val: 0.5 * v.k * v.x * v.x,
          unit: 'J',
          formula: `PE_elastic = ½ × ${v.k} × ${v.x}²`
        })
      },
      {
        id: 'efficiency',
        label: 'Efficiency',
        formula: 'η = (E_out / E_in) × 100%',
        inputs: [
          { id: 'E_out', label: 'Useful energy output', unit: 'J' },
          { id: 'E_in', label: 'Total energy input', unit: 'J' }
        ],
        calc: v => {
          if (v.E_in === 0) return { err: 'Energy input cannot be zero' };
          return ({
            val: (v.E_out / v.E_in) * 100,
            unit: '%',
            formula: `η = (${v.E_out} / ${v.E_in}) × 100`
          });
        }
      },
      {
        id: 'energy_conservation',
        label: 'Energy conservation (find final height)',
        formula: 'KE_i + PE_i = KE_f + PE_f (no friction)',
        inputs: [
          { id: 'm',  label: 'Mass m', unit: 'kg' },
          { id: 'vi', label: 'Initial velocity v_i', unit: 'm/s' },
          { id: 'hi', label: 'Initial height h_i', unit: 'm' },
          { id: 'vf', label: 'Final velocity v_f', unit: 'm/s' }
        ],
        calc: v => {
          const ei = 0.5 * v.m * v.vi * v.vi + v.m * g * v.hi;
          const hf = (ei - 0.5 * v.m * v.vf * v.vf) / (v.m * g);
          return ({
            val: hf,
            unit: 'm (final height)',
            formula: `h_f = (½m·v_i² + m·g·h_i − ½m·v_f²) / (m·g)`
          });
        }
      },
      {
        id: 'total_energy',
        label: 'Total mechanical energy',
        formula: 'E_total = KE + PE_gravity + PE_elastic',
        inputs: [
          { id: 'ke', label: 'Kinetic energy KE', unit: 'J' },
          { id: 'pe_g', label: 'Gravitational PE', unit: 'J' },
          { id: 'pe_e', label: 'Elastic PE (enter 0 if none)', unit: 'J' }
        ],
        calc: v => ({
          val: v.ke + v.pe_g + (v.pe_e || 0),
          unit: 'J',
          formula: `E_total = ${v.ke} + ${v.pe_g} + ${v.pe_e || 0}`
        })
      }
    ]
  },

  {
    id: 'fluid',
    label: 'Fluids',
    subs: [
      {
        id: 'density',
        label: 'Density',
        formula: 'ρ = m / V',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' },
          { id: 'V', label: 'Volume V', unit: 'm³' }
        ],
        calc: v => {
          if (v.V === 0) return { err: 'Volume cannot be zero' };
          return ({ val: v.m / v.V, unit: 'kg/m³', formula: `ρ = ${v.m} / ${v.V}` });
        }
      },
      {
        id: 'pressure',
        label: 'Pressure',
        formula: 'P = F / A',
        inputs: [
          { id: 'F', label: 'Force F', unit: 'N' },
          { id: 'A', label: 'Area A', unit: 'm²' }
        ],
        calc: v => {
          if (v.A === 0) return { err: 'Area cannot be zero' };
          return ({ val: v.F / v.A, unit: 'Pa', formula: `P = ${v.F} / ${v.A}` });
        }
      },
      {
        id: 'hydro',
        label: 'Hydrostatic pressure',
        formula: 'P = ρgh',
        inputs: [
          { id: 'rho', label: 'Fluid density ρ', unit: 'kg/m³' },
          { id: 'h',   label: 'Depth h', unit: 'm' }
        ],
        calc: v => ({
          val: v.rho * g * v.h,
          unit: 'Pa',
          formula: `P = ${v.rho} × 9.8 × ${v.h}`
        })
      },
      {
        id: 'buoyant_force',
        label: 'Buoyant force',
        formula: 'F_b = ρ_fluid · g · V_displaced',
        inputs: [
          { id: 'rho', label: 'Fluid density ρ', unit: 'kg/m³' },
          { id: 'V',   label: 'Volume displaced V', unit: 'm³' }
        ],
        calc: v => ({
          val: v.rho * g * v.V,
          unit: 'N',
          formula: `F_b = ${v.rho} × 9.8 × ${v.V}`
        })
      },
      {
        id: 'pascal_pressure',
        label: "Pascal's principle (pressure ratio)",
        formula: 'P = F₁/A₁ = F₂/A₂  →  F₂ = F₁·(A₂/A₁)',
        inputs: [
          { id: 'F1', label: 'Force F₁', unit: 'N' },
          { id: 'A1', label: 'Area A₁', unit: 'm²' },
          { id: 'A2', label: 'Area A₂', unit: 'm²' }
        ],
        calc: v => {
          if (v.A1 === 0) return { err: 'Area A₁ cannot be zero' };
          return ({
            val: v.F1 * (v.A2 / v.A1),
            unit: 'N (force on piston 2)',
            formula: `F₂ = ${v.F1} × (${v.A2} / ${v.A1})`
          });
        }
      },
      {
        id: 'continuity',
        label: 'Continuity equation',
        formula: 'A₁v₁ = A₂v₂  (constant flow)',
        inputs: [
          { id: 'A1', label: 'Cross-section A₁', unit: 'm²' },
          { id: 'v1', label: 'Velocity v₁', unit: 'm/s' },
          { id: 'A2', label: 'Cross-section A₂', unit: 'm²' }
        ],
        calc: v => {
          if (v.A2 === 0) return { err: 'Area A₂ cannot be zero' };
          return ({
            val: (v.A1 * v.v1) / v.A2,
            unit: 'm/s (velocity v₂)',
            formula: `v₂ = (${v.A1} × ${v.v1}) / ${v.A2}`
          });
        }
      },
      {
        id: 'bernoulli',
        label: "Bernoulli's equation (find P₂)",
        formula: 'P₁ + ½ρv₁² + ρgh₁ = P₂ + ½ρv₂² + ρgh₂',
        inputs: [
          { id: 'P1',  label: 'Pressure P₁', unit: 'Pa' },
          { id: 'rho', label: 'Fluid density ρ', unit: 'kg/m³' },
          { id: 'v1',  label: 'Velocity v₁', unit: 'm/s' },
          { id: 'h1',  label: 'Height h₁', unit: 'm' },
          { id: 'v2',  label: 'Velocity v₂', unit: 'm/s' },
          { id: 'h2',  label: 'Height h₂', unit: 'm' }
        ],
        calc: v => {
          const P2 = v.P1 + 0.5 * v.rho * (v.v1 * v.v1 - v.v2 * v.v2) + v.rho * g * (v.h1 - v.h2);
          return ({
            val: P2,
            unit: 'Pa (pressure at point 2)',
            formula: `P₂ = P₁ + ½ρ(v₁² − v₂²) + ρg(h₁ − h₂)`
          });
        }
      }
    ]
  },

  {
    id: 'thermodynamics',
    label: 'Thermodynamics',
    subs: [
      {
        id: 'heat_energy',
        label: 'Heat energy (sensible)',
        formula: 'Q = mcΔT',
        inputs: [
          { id: 'm',  label: 'Mass m', unit: 'kg' },
          { id: 'c',  label: 'Specific heat c', unit: 'J/(kg·K)' },
          { id: 'dT', label: 'Temp change ΔT', unit: 'K' }
        ],
        calc: v => ({
          val: v.m * v.c * v.dT,
          unit: 'J',
          formula: `Q = ${v.m} × ${v.c} × ${v.dT}`
        })
      },
      {
        id: 'specific_heat',
        label: 'Specific heat capacity',
        formula: 'c = Q / (m·ΔT)',
        inputs: [
          { id: 'Q',  label: 'Heat energy Q', unit: 'J' },
          { id: 'm',  label: 'Mass m', unit: 'kg' },
          { id: 'dT', label: 'Temp change ΔT', unit: 'K' }
        ],
        calc: v => {
          if (v.m === 0 || v.dT === 0) return { err: 'Mass and temperature change cannot be zero' };
          return ({
            val: v.Q / (v.m * v.dT),
            unit: 'J/(kg·K)',
            formula: `c = ${v.Q} / (${v.m} × ${v.dT})`
          });
        }
      },
      {
        id: 'latent',
        label: 'Latent heat',
        formula: 'Q = mL',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' },
          { id: 'L', label: 'Latent heat L', unit: 'J/kg' }
        ],
        calc: v => ({ val: v.m * v.L, unit: 'J', formula: `Q = ${v.m} × ${v.L}` })
      },
      {
        id: 'thermal_expansion_linear',
        label: 'Linear thermal expansion',
        formula: 'ΔL = α·L₀·ΔT',
        inputs: [
          { id: 'alpha', label: 'Linear expansion coefficient α', unit: '1/K' },
          { id: 'L0',    label: 'Original length L₀', unit: 'm' },
          { id: 'dT',    label: 'Temp change ΔT', unit: 'K' }
        ],
        calc: v => ({
          val: v.alpha * v.L0 * v.dT,
          unit: 'm (length change)',
          formula: `ΔL = ${v.alpha} × ${v.L0} × ${v.dT}`
        })
      },
      {
        id: 'thermal_expansion_volume',
        label: 'Volumetric thermal expansion',
        formula: 'ΔV = β·V₀·ΔT',
        inputs: [
          { id: 'beta', label: 'Volume expansion coefficient β', unit: '1/K' },
          { id: 'V0',   label: 'Original volume V₀', unit: 'm³' },
          { id: 'dT',   label: 'Temp change ΔT', unit: 'K' }
        ],
        calc: v => ({
          val: v.beta * v.V0 * v.dT,
          unit: 'm³ (volume change)',
          formula: `ΔV = ${v.beta} × ${v.V0} × ${v.dT}`
        })
      },
      {
        id: 'heat_transfer',
        label: 'Heat transfer (conduction)',
        formula: 'Q = k·A·ΔT / d',
        inputs: [
          { id: 'k',  label: 'Thermal conductivity k', unit: 'W/(m·K)' },
          { id: 'A',  label: 'Area A', unit: 'm²' },
          { id: 'dT', label: 'Temp difference ΔT', unit: 'K' },
          { id: 'd',  label: 'Thickness d', unit: 'm' }
        ],
        calc: v => {
          if (v.d === 0) return { err: 'Thickness cannot be zero' };
          return ({
            val: (v.k * v.A * v.dT) / v.d,
            unit: 'W (heat transfer rate)',
            formula: `Q = ${v.k} × ${v.A} × ${v.dT} / ${v.d}`
          });
        }
      },
      {
        id: 'ideal_gas_pressure',
        label: 'Ideal gas law (find P)',
        formula: 'PV = nRT  →  P = nRT / V',
        inputs: [
          { id: 'n', label: 'Moles n', unit: 'mol' },
          { id: 'T', label: 'Temperature T', unit: 'K' },
          { id: 'V', label: 'Volume V', unit: 'm³' }
        ],
        calc: v => {
          if (v.V === 0) return { err: 'Volume cannot be zero' };
          return ({
            val: v.n * R * v.T / v.V,
            unit: 'Pa',
            formula: `P = ${v.n} × 8.314 × ${v.T} / ${v.V}`
          });
        }
      },
      {
        id: 'ideal_gas_volume',
        label: 'Ideal gas law (find V)',
        formula: 'PV = nRT  →  V = nRT / P',
        inputs: [
          { id: 'n', label: 'Moles n', unit: 'mol' },
          { id: 'R', label: 'Gas constant R', unit: 'J/(mol·K)' },
          { id: 'T', label: 'Temperature T', unit: 'K' },
          { id: 'P', label: 'Pressure P', unit: 'Pa' }
        ],
        calc: v => {
          if (v.P === 0) return { err: 'Pressure cannot be zero' };
          return ({
            val: (v.n * v.R * v.T) / v.P,
            unit: 'm³',
            formula: `V = ${v.n} × ${v.R} × ${v.T} / ${v.P}`
          });
        }
      },
      {
        id: 'ideal_gas_temp',
        label: 'Ideal gas law (find T)',
        formula: 'PV = nRT  →  T = PV / nR',
        inputs: [
          { id: 'P', label: 'Pressure P', unit: 'Pa' },
          { id: 'V', label: 'Volume V', unit: 'm³' },
          { id: 'n', label: 'Moles n', unit: 'mol' }
        ],
        calc: v => {
          if (v.n === 0) return { err: 'Moles cannot be zero' };
          return ({
            val: (v.P * v.V) / (v.n * R),
            unit: 'K',
            formula: `T = ${v.P} × ${v.V} / (${v.n} × 8.314)`
          });
        }
      }
    ]
  },

  {
    id: 'waves',
    label: 'Waves & Light',
    subs: [
      {
        id: 'wavespeed',
        label: 'Wave speed',
        formula: 'v = fλ',
        inputs: [
          { id: 'f',   label: 'Frequency f', unit: 'Hz' },
          { id: 'lam', label: 'Wavelength λ', unit: 'm' }
        ],
        calc: v => ({ val: v.f * v.lam, unit: 'm/s', formula: `v = ${v.f} × ${v.lam}` })
      },
      {
        id: 'freqperiod',
        label: 'Frequency from period',
        formula: 'f = 1 / T',
        inputs: [
          { id: 'T', label: 'Period T', unit: 's' }
        ],
        calc: v => {
          if (v.T === 0) return { err: 'Period cannot be zero' };
          return ({ val: 1 / v.T, unit: 'Hz', formula: `f = 1 / ${v.T}` });
        }
      },
      {
        id: 'period',
        label: 'Period from frequency',
        formula: 'T = 1 / f',
        inputs: [
          { id: 'f', label: 'Frequency f', unit: 'Hz' }
        ],
        calc: v => {
          if (v.f === 0) return { err: 'Frequency cannot be zero' };
          return ({ val: 1 / v.f, unit: 's', formula: `T = 1 / ${v.f}` });
        }
      },
      {
        id: 'wavelength',
        label: 'Wavelength',
        formula: 'λ = v / f',
        inputs: [
          { id: 'v', label: 'Wave speed v', unit: 'm/s' },
          { id: 'f', label: 'Frequency f', unit: 'Hz' }
        ],
        calc: v => {
          if (v.f === 0) return { err: 'Frequency cannot be zero' };
          return ({ val: v.v / v.f, unit: 'm', formula: `λ = ${v.v} / ${v.f}` });
        }
      },
      {
        id: 'wave_equation',
        label: 'Wave number and angular frequency',
        formula: 'k = 2π/λ,  ω = 2πf',
        inputs: [
          { id: 'lam', label: 'Wavelength λ', unit: 'm' },
          { id: 'f',   label: 'Frequency f', unit: 'Hz' }
        ],
        calc: v => {
          if (v.lam === 0) return { err: 'Wavelength cannot be zero' };
          const k = (2 * Math.PI) / v.lam;
          const omega = 2 * Math.PI * v.f;
          return ({
            val: `k = ${k.toFixed(4)} rad/m, ω = ${omega.toFixed(4)} rad/s`,
            unit: '',
            formula: `k = 2π/${v.lam}, ω = 2π×${v.f}`
          });
        }
      },
      {
        id: 'wave_displacement',
        label: 'Wave displacement equation',
        formula: 'y = A·sin(kx − ωt)',
        inputs: [
          { id: 'A', label: 'Amplitude A', unit: 'm' },
          { id: 'k', label: 'Wave number k', unit: 'rad/m' },
          { id: 'x', label: 'Position x', unit: 'm' },
          { id: 'w', label: 'Angular frequency ω', unit: 'rad/s' },
          { id: 't', label: 'Time t', unit: 's' }
        ],
        calc: v => ({
          val: v.A * Math.sin(v.k * v.x - v.w * v.t),
          unit: 'm (displacement)',
          formula: `y = ${v.A} × sin(${v.k}×${v.x} − ${v.w}×${v.t})`
        })
      },
      {
        id: 'amplitude',
        label: 'Amplitude (from wave energy)',
        formula: 'A = √(2·E / (ρ·V·ω²))',
        inputs: [
          { id: 'E',   label: 'Wave energy E', unit: 'J' },
          { id: 'rho', label: 'Medium density ρ', unit: 'kg/m³' },
          { id: 'V',   label: 'Volume of medium V', unit: 'm³' },
          { id: 'w',   label: 'Angular frequency ω', unit: 'rad/s' }
        ],
        calc: v => {
          if (v.rho === 0 || v.V === 0 || v.w === 0) return { err: 'Invalid parameters (cannot be zero)' };
          const A = Math.sqrt((2 * v.E) / (v.rho * v.V * v.w * v.w));
          return ({
            val: A,
            unit: 'm',
            formula: `A = √(2×${v.E} / (${v.rho}×${v.V}×${v.w}²))`
          });
        }
      },
      {
        id: 'wave_energy',
        label: 'Wave energy',
        formula: 'E = ½·ρ·V·ω²·A²',
        inputs: [
          { id: 'rho', label: 'Medium density ρ', unit: 'kg/m³' },
          { id: 'V',   label: 'Volume of medium V', unit: 'm³' },
          { id: 'w',   label: 'Angular frequency ω', unit: 'rad/s' },
          { id: 'A',   label: 'Amplitude A', unit: 'm' }
        ],
        calc: v => ({
          val: 0.5 * v.rho * v.V * v.w * v.w * v.A * v.A,
          unit: 'J',
          formula: `E = ½ × ${v.rho} × ${v.V} × ${v.w}² × ${v.A}²`
        })
      },
      {
        id: 'wave_intensity',
        label: 'Wave intensity',
        formula: 'I = P / A  (or  I = ½·ρ·v·ω²·A²)',
        inputs: [
          { id: 'P', label: 'Power P', unit: 'W' },
          { id: 'A', label: 'Area A', unit: 'm²' }
        ],
        calc: v => {
          if (v.A === 0) return { err: 'Area cannot be zero' };
          return ({
            val: v.P / v.A,
            unit: 'W/m²',
            formula: `I = ${v.P} / ${v.A}`
          });
        }
      },
      {
        id: 'snell',
        label: "Snell's law (find θ₂)",
        formula: 'n₁·sin θ₁ = n₂·sin θ₂',
        inputs: [
          { id: 'n1',  label: 'Refractive index n₁', unit: '' },
          { id: 'th1', label: 'Angle of incidence θ₁', unit: '°' },
          { id: 'n2',  label: 'Refractive index n₂', unit: '' }
        ],
        calc: v => {
          const sinTh2 = v.n1 * Math.sin(v.th1 * DEG) / v.n2;
          if (Math.abs(sinTh2) > 1) return { err: 'Total internal reflection — no refracted ray' };
          return {
            val: Math.asin(sinTh2) / DEG,
            unit: '° (angle of refraction θ₂)',
            formula: `θ₂ = arcsin(${v.n1} × sin(${v.th1}°) / ${v.n2})`
          };
        }
      }
    ]
  },

  {
    id: 'electricity',
    label: 'Electricity',
    subs: [
      {
        id: 'ohm',
        label: "Ohm's law",
        formula: 'V = IR',
        inputs: [
          { id: 'I', label: 'Current I', unit: 'A' },
          { id: 'R', label: 'Resistance R', unit: 'Ω' }
        ],
        calc: v => ({ val: v.I * v.R, unit: 'V', formula: `V = ${v.I} × ${v.R}` })
      },
      {
        id: 'power_iv',
        label: 'Electric power (IV)',
        formula: 'P = IV',
        inputs: [
          { id: 'I', label: 'Current I', unit: 'A' },
          { id: 'V', label: 'Voltage V', unit: 'V' }
        ],
        calc: v => ({ val: v.I * v.V, unit: 'W', formula: `P = ${v.I} × ${v.V}` })
      },
      {
        id: 'power_i2r',
        label: 'Electric power (I²R)',
        formula: 'P = I²R',
        inputs: [
          { id: 'I', label: 'Current I', unit: 'A' },
          { id: 'R', label: 'Resistance R', unit: 'Ω' }
        ],
        calc: v => ({
          val: v.I * v.I * v.R,
          unit: 'W',
          formula: `P = ${v.I}² × ${v.R}`
        })
      },
      {
        id: 'power_v2r',
        label: 'Electric power (V²/R)',
        formula: 'P = V²/R',
        inputs: [
          { id: 'V', label: 'Voltage V', unit: 'V' },
          { id: 'R', label: 'Resistance R', unit: 'Ω' }
        ],
        calc: v => ({
          val: v.V * v.V / v.R,
          unit: 'W',
          formula: `P = ${v.V}² / ${v.R}`
        })
      },
      {
        id: 'r_series',
        label: 'Resistors in series',
        formula: 'R_total = R₁ + R₂ + R₃',
        inputs: [
          { id: 'R1', label: 'R₁', unit: 'Ω' },
          { id: 'R2', label: 'R₂', unit: 'Ω' },
          { id: 'R3', label: 'R₃  (enter 0 to skip)', unit: 'Ω' }
        ],
        calc: v => ({
          val: v.R1 + v.R2 + (v.R3 || 0),
          unit: 'Ω',
          formula: `R_total = ${v.R1} + ${v.R2} + ${v.R3 || 0}`
        })
      },
      {
        id: 'r_parallel',
        label: 'Resistors in parallel',
        formula: '1/R_total = 1/R₁ + 1/R₂ + 1/R₃',
        inputs: [
          { id: 'R1', label: 'R₁', unit: 'Ω' },
          { id: 'R2', label: 'R₂', unit: 'Ω' },
          { id: 'R3', label: 'R₃  (enter 0 to skip)', unit: 'Ω' }
        ],
        calc: v => {
          let inv = 1 / v.R1 + 1 / v.R2;
          if (v.R3) inv += 1 / v.R3;
          return {
            val: 1 / inv,
            unit: 'Ω',
            formula: `R_total = 1/(1/${v.R1} + 1/${v.R2}${v.R3 ? ' + 1/' + v.R3 : ''})`
          };
        }
      },
      {
        id: 'current',
        label: 'Electric current',
        formula: 'I = V / R',
        inputs: [
          { id: 'V', label: 'Voltage V', unit: 'V' },
          { id: 'R', label: 'Resistance R', unit: 'Ω' }
        ],
        calc: v => {
          if (v.R === 0) return { err: 'Resistance cannot be zero' };
          return ({ val: v.V / v.R, unit: 'A', formula: `I = ${v.V} / ${v.R}` });
        }
      },
      {
        id: 'voltage',
        label: 'Voltage (from I and R)',
        formula: 'V = IR',
        inputs: [
          { id: 'I', label: 'Current I', unit: 'A' },
          { id: 'R', label: 'Resistance R', unit: 'Ω' }
        ],
        calc: v => ({ val: v.I * v.R, unit: 'V', formula: `V = ${v.I} × ${v.R}` })
      },
      {
        id: 'resistance',
        label: 'Resistance',
        formula: 'R = V / I',
        inputs: [
          { id: 'V', label: 'Voltage V', unit: 'V' },
          { id: 'I', label: 'Current I', unit: 'A' }
        ],
        calc: v => {
          if (v.I === 0) return { err: 'Current cannot be zero' };
          return ({ val: v.V / v.I, unit: 'Ω', formula: `R = ${v.V} / ${v.I}` });
        }
      },
      {
        id: 'electrical_energy',
        label: 'Electrical energy',
        formula: 'E = Pt  or  E = VIt',
        inputs: [
          { id: 'P', label: 'Power P', unit: 'W' },
          { id: 't', label: 'Time t', unit: 's' }
        ],
        calc: v => ({
          val: v.P * v.t,
          unit: 'J',
          formula: `E = ${v.P} × ${v.t}`
        })
      },
      {
        id: 'charge',
        label: 'Electric charge',
        formula: 'Q = It',
        inputs: [
          { id: 'I', label: 'Current I', unit: 'A' },
          { id: 't', label: 'Time t', unit: 's' }
        ],
        calc: v => ({
          val: v.I * v.t,
          unit: 'C',
          formula: `Q = ${v.I} × ${v.t}`
        })
      },
      {
        id: 'current_from_charge',
        label: 'Current from charge',
        formula: 'I = Q / t',
        inputs: [
          { id: 'Q', label: 'Charge Q', unit: 'C' },
          { id: 't', label: 'Time t', unit: 's' }
        ],
        calc: v => {
          if (v.t === 0) return { err: 'Time cannot be zero' };
          return ({ val: v.Q / v.t, unit: 'A', formula: `I = ${v.Q} / ${v.t}` });
        }
      },
      {
        id: 'capacitance',
        label: 'Capacitance',
        formula: 'C = Q / V',
        inputs: [
          { id: 'Q', label: 'Charge Q', unit: 'C' },
          { id: 'V', label: 'Voltage V', unit: 'V' }
        ],
        calc: v => {
          if (v.V === 0) return { err: 'Voltage cannot be zero' };
          return ({ val: v.Q / v.V, unit: 'F', formula: `C = ${v.Q} / ${v.V}` });
        }
      },
      {
        id: 'capacitor_energy',
        label: 'Energy in capacitor',
        formula: 'E = ½CV²',
        inputs: [
          { id: 'C', label: 'Capacitance C', unit: 'F' },
          { id: 'V', label: 'Voltage V', unit: 'V' }
        ],
        calc: v => ({
          val: 0.5 * v.C * v.V * v.V,
          unit: 'J',
          formula: `E = ½ × ${v.C} × ${v.V}²`
        })
      }
    ]
  },

  {
    id: 'magnetism',
    label: 'Magnetism',
    subs: [
      {
        id: 'magnetic_force',
        label: 'Magnetic force on charge',
        formula: 'F = qvB·sin θ',
        inputs: [
          { id: 'q',     label: 'Charge q', unit: 'C' },
          { id: 'v',     label: 'Velocity v', unit: 'm/s' },
          { id: 'B',     label: 'Magnetic field B', unit: 'T' },
          { id: 'theta', label: 'Angle θ', unit: '°' }
        ],
        calc: v => ({
          val: v.q * v.v * v.B * Math.sin(v.theta * DEG),
          unit: 'N',
          formula: `F = ${v.q} × ${v.v} × ${v.B} × sin(${v.theta}°)`
        })
      },
      {
        id: 'magnetic_field',
        label: 'Magnetic field strength',
        formula: 'B = μ₀I / (2πr)',
        inputs: [
          { id: 'I', label: 'Current I', unit: 'A' },
          { id: 'r', label: 'Distance r', unit: 'm' }
        ],
        calc: v => {
          if (v.r === 0) return { err: 'Distance cannot be zero' };
          const mu0 = 4 * Math.PI * 1e-7;
          return ({
            val: (mu0 * v.I) / (2 * Math.PI * v.r),
            unit: 'T',
            formula: `B = (4π×10⁻⁷ × ${v.I}) / (2π × ${v.r})`
          });
        }
      },
      {
        id: 'magnetic_flux',
        label: 'Magnetic flux',
        formula: 'Φ = B·A·cos θ',
        inputs: [
          { id: 'B',     label: 'Magnetic field B', unit: 'T' },
          { id: 'A',     label: 'Area A', unit: 'm²' },
          { id: 'theta', label: 'Angle θ', unit: '°' }
        ],
        calc: v => ({
          val: v.B * v.A * Math.cos(v.theta * DEG),
          unit: 'Wb',
          formula: `Φ = ${v.B} × ${v.A} × cos(${v.theta}°)`
        })
      },
      {
        id: 'force_on_wire',
        label: 'Force on current-carrying wire',
        formula: 'F = BIL·sin θ',
        inputs: [
          { id: 'B',     label: 'Magnetic field B', unit: 'T' },
          { id: 'I',     label: 'Current I', unit: 'A' },
          { id: 'L',     label: 'Length of wire L', unit: 'm' },
          { id: 'theta', label: 'Angle θ', unit: '°' }
        ],
        calc: v => ({
          val: v.B * v.I * v.L * Math.sin(v.theta * DEG),
          unit: 'N',
          formula: `F = ${v.B} × ${v.I} × ${v.L} × sin(${v.theta}°)`
        })
      },
      {
        id: 'moving_charge_force',
        label: 'Force on moving charge (Lorentz)',
        formula: 'F = q(E + v × B)',
        inputs: [
          { id: 'q', label: 'Charge q', unit: 'C' },
          { id: 'E', label: 'Electric field E', unit: 'N/C' },
          { id: 'v', label: 'Velocity v', unit: 'm/s' },
          { id: 'B', label: 'Magnetic field B', unit: 'T' }
        ],
        calc: v => ({
          val: v.q * (v.E + v.v * v.B),
          unit: 'N',
          formula: `F = ${v.q} × (${v.E} + ${v.v} × ${v.B})`
        })
      },
      {
        id: 'induced_emf',
        label: 'Induced EMF (Faraday)',
        formula: 'ε = −dΦ/dt  (ε = nBAlf for generators)',
        inputs: [
          { id: 'dPhi', label: 'Change in flux dΦ', unit: 'Wb' },
          { id: 'dt',   label: 'Time interval dt', unit: 's' }
        ],
        calc: v => {
          if (v.dt === 0) return { err: 'Time cannot be zero' };
          return ({
            val: Math.abs(v.dPhi / v.dt),
            unit: 'V',
            formula: `ε = |${v.dPhi} / ${v.dt}|`
          });
        }
      },
      {
        id: 'emf_generator',
        label: 'EMF from rotating coil',
        formula: 'ε = nBAlf',
        inputs: [
          { id: 'n', label: 'Number of turns n', unit: '' },
          { id: 'B', label: 'Magnetic field B', unit: 'T' },
          { id: 'A', label: 'Area A', unit: 'm²' },
          { id: 'l', label: 'Frequency f', unit: 'Hz' }
        ],
        calc: v => ({
          val: v.n * v.B * v.A * v.l,
          unit: 'V',
          formula: `ε = ${v.n} × ${v.B} × ${v.A} × ${v.l}`
        })
      },
      {
        id: 'magnetic_flux_density',
        label: 'Magnetic flux density (field inside solenoid)',
        formula: 'B = μ₀·n·I',
        inputs: [
          { id: 'n', label: 'Turns per unit length n', unit: 'm⁻¹' },
          { id: 'I', label: 'Current I', unit: 'A' }
        ],
        calc: v => {
          const mu0 = 4 * Math.PI * 1e-7;
          return ({
            val: mu0 * v.n * v.I,
            unit: 'T',
            formula: `B = 4π×10⁻⁷ × ${v.n} × ${v.I}`
          });
        }
      }
    ]
  },

  {
    id: 'optics',
    label: 'Optics',
    subs: [
      {
        id: 'lens_formula',
        label: 'Lens formula',
        formula: '1/f = 1/u + 1/v',
        inputs: [
          { id: 'u', label: 'Object distance u', unit: 'm' },
          { id: 'v', label: 'Image distance v', unit: 'm' }
        ],
        calc: v => {
          if (v.u === 0 || v.v === 0) return { err: 'Distances cannot be zero' };
          const f_inv = (1 / v.u) + (1 / v.v);
          if (f_inv === 0) return { err: 'Invalid input — focal length is infinite' };
          return ({
            val: 1 / f_inv,
            unit: 'm (focal length)',
            formula: `f = 1/(1/${v.u} + 1/${v.v})`
          });
        }
      },
      {
        id: 'mirror_formula',
        label: 'Mirror formula',
        formula: '1/f = 1/u + 1/v',
        inputs: [
          { id: 'u', label: 'Object distance u', unit: 'm' },
          { id: 'v', label: 'Image distance v', unit: 'm' }
        ],
        calc: v => {
          if (v.u === 0 || v.v === 0) return { err: 'Distances cannot be zero' };
          const f_inv = (1 / v.u) + (1 / v.v);
          if (f_inv === 0) return { err: 'Invalid input — focal length is infinite' };
          return ({
            val: 1 / f_inv,
            unit: 'm (focal length)',
            formula: `f = 1/(1/${v.u} + 1/${v.v})`
          });
        }
      },
      {
        id: 'magnification',
        label: 'Magnification',
        formula: 'm = −v/u  (or m = h_i/h_o)',
        inputs: [
          { id: 'v', label: 'Image distance v', unit: 'm' },
          { id: 'u', label: 'Object distance u', unit: 'm' }
        ],
        calc: v => {
          if (v.u === 0) return { err: 'Object distance cannot be zero' };
          return ({
            val: -(v.v / v.u),
            unit: '',
            formula: `m = −${v.v} / ${v.u}`
          });
        }
      },
      {
        id: 'refractive_index',
        label: 'Refractive index',
        formula: 'n = c / v',
        inputs: [
          { id: 'v', label: 'Speed of light in medium v', unit: 'm/s' }
        ],
        calc: v => {
          const c = 3e8;
          if (v.v === 0) return { err: 'Speed cannot be zero' };
          return ({
            val: c / v.v,
            unit: '',
            formula: `n = 3×10⁸ / ${v.v}`
          });
        }
      },
      {
        id: 'snell_law',
        label: "Snell's law",
        formula: 'n₁·sin θ₁ = n₂·sin θ₂',
        inputs: [
          { id: 'n1',  label: 'Refractive index n₁', unit: '' },
          { id: 'th1', label: 'Angle of incidence θ₁', unit: '°' },
          { id: 'n2',  label: 'Refractive index n₂', unit: '' }
        ],
        calc: v => {
          const sinTh2 = v.n1 * Math.sin(v.th1 * DEG) / v.n2;
          if (Math.abs(sinTh2) > 1) return { err: 'Total internal reflection — no refracted ray' };
          return {
            val: Math.asin(sinTh2) / DEG,
            unit: '° (angle of refraction θ₂)',
            formula: `θ₂ = arcsin(${v.n1} × sin(${v.th1}°) / ${v.n2})`
          };
        }
      },
      {
        id: 'critical_angle',
        label: 'Critical angle',
        formula: 'sin θ_c = n₂ / n₁',
        inputs: [
          { id: 'n1', label: 'Refractive index n₁ (denser medium)', unit: '' },
          { id: 'n2', label: 'Refractive index n₂ (rarer medium)', unit: '' }
        ],
        calc: v => {
          if (v.n1 === 0 || v.n2 > v.n1) return { err: 'Invalid: n₂ must be less than n₁' };
          const sinThc = v.n2 / v.n1;
          if (sinThc > 1) return { err: 'No critical angle exists' };
          return ({
            val: Math.asin(sinThc) / DEG,
            unit: '°',
            formula: `θ_c = arcsin(${v.n2} / ${v.n1})`
          });
        }
      },
      {
        id: 'optical_power',
        label: 'Optical power',
        formula: 'P = 1 / f',
        inputs: [
          { id: 'f', label: 'Focal length f', unit: 'm' }
        ],
        calc: v => {
          if (v.f === 0) return { err: 'Focal length cannot be zero' };
          return ({
            val: 1 / v.f,
            unit: 'D (diopters)',
            formula: `P = 1 / ${v.f}`
          });
        }
      }
    ]
  },

  {
    id: 'modern_physics',
    label: 'Modern Physics',
    subs: [
      {
        id: 'photon_energy',
        label: 'Photon energy',
        formula: 'E = hf',
        inputs: [
          { id: 'f', label: 'Frequency f', unit: 'Hz' }
        ],
        calc: v => {
          const h = 6.626e-34;
          return ({
            val: h * v.f,
            unit: 'J',
            formula: `E = 6.626×10⁻³⁴ × ${v.f}`
          });
        }
      },
      {
        id: 'plancks_equation',
        label: "Planck's equation",
        formula: 'E = hf = hc/λ',
        inputs: [
          { id: 'lam', label: 'Wavelength λ', unit: 'm' }
        ],
        calc: v => {
          const h = 6.626e-34;
          const c = 3e8;
          if (v.lam === 0) return { err: 'Wavelength cannot be zero' };
          return ({
            val: (h * c) / v.lam,
            unit: 'J',
            formula: `E = (6.626×10⁻³⁴ × 3×10⁸) / ${v.lam}`
          });
        }
      },
      {
        id: 'de_broglie',
        label: 'de Broglie wavelength',
        formula: 'λ = h / p',
        inputs: [
          { id: 'p', label: 'Momentum p', unit: 'kg·m/s' }
        ],
        calc: v => {
          const h = 6.626e-34;
          if (v.p === 0) return { err: 'Momentum cannot be zero' };
          return ({
            val: h / v.p,
            unit: 'm',
            formula: `λ = 6.626×10⁻³⁴ / ${v.p}`
          });
        }
      },
      {
        id: 'mass_energy_equiv',
        label: 'Mass-energy equivalence',
        formula: 'E = mc²',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' }
        ],
        calc: v => {
          const c = 3e8;
          return ({
            val: v.m * c * c,
            unit: 'J',
            formula: `E = ${v.m} × (3×10⁸)²`
          });
        }
      },
      {
        id: 'time_dilation',
        label: 'Time dilation (special relativity)',
        formula: 't = t₀ / √(1 − v²/c²)',
        inputs: [
          { id: 't0', label: 'Proper time t₀', unit: 's' },
          { id: 'v',  label: 'Velocity v', unit: 'm/s' }
        ],
        calc: v => {
          const c = 3e8;
          const factor = v.v / c;
          if (factor >= 1) return { err: 'Velocity must be less than speed of light' };
          const gamma = 1 / Math.sqrt(1 - factor * factor);
          return ({
            val: v.t0 * gamma,
            unit: 's',
            formula: `t = ${v.t0} / √(1 − (${v.v}/(3×10⁸))²)`
          });
        }
      },
      {
        id: 'length_contraction',
        label: 'Length contraction (special relativity)',
        formula: 'L = L₀·√(1 − v²/c²)',
        inputs: [
          { id: 'L0', label: 'Proper length L₀', unit: 'm' },
          { id: 'v',  label: 'Velocity v', unit: 'm/s' }
        ],
        calc: v => {
          const c = 3e8;
          const factor = v.v / c;
          if (factor >= 1) return { err: 'Velocity must be less than speed of light' };
          return ({
            val: v.L0 * Math.sqrt(1 - factor * factor),
            unit: 'm',
            formula: `L = ${v.L0} × √(1 − (${v.v}/(3×10⁸))²)`
          });
        }
      }
    ]
  },

  {
    id: 'nuclear_physics',
    label: 'Nuclear Physics',
    subs: [
      {
        id: 'radioactive_decay',
        label: 'Radioactive decay (N remaining)',
        formula: 'N = N₀·(1/2)^(t/T₁/₂)',
        inputs: [
          { id: 'N0', label: 'Initial nuclei N₀', unit: '' },
          { id: 't',  label: 'Time t', unit: 's' },
          { id: 'T',  label: 'Half-life T₁/₂', unit: 's' }
        ],
        calc: v => {
          if (v.T === 0) return { err: 'Half-life cannot be zero' };
          return ({
            val: v.N0 * Math.pow(0.5, v.t / v.T),
            unit: '',
            formula: `N = ${v.N0} × (0.5)^(${v.t}/${v.T})`
          });
        }
      },
      {
        id: 'half_life',
        label: 'Half-life',
        formula: 'T₁/₂ = ln(2) / λ',
        inputs: [
          { id: 'lambda', label: 'Decay constant λ', unit: 's⁻¹' }
        ],
        calc: v => {
          if (v.lambda === 0) return { err: 'Decay constant cannot be zero' };
          return ({
            val: Math.ln(2) / v.lambda,
            unit: 's',
            formula: `T₁/₂ = 0.693 / ${v.lambda}`
          });
        }
      },
      {
        id: 'activity',
        label: 'Activity',
        formula: 'A = λN',
        inputs: [
          { id: 'lambda', label: 'Decay constant λ', unit: 's⁻¹' },
          { id: 'N',      label: 'Number of nuclei N', unit: '' }
        ],
        calc: v => ({
          val: v.lambda * v.N,
          unit: 'Bq',
          formula: `A = ${v.lambda} × ${v.N}`
        })
      },
      {
        id: 'mass_defect',
        label: 'Mass defect',
        formula: 'Δm = (Z·m_p + (A−Z)·m_n) − m_nucleus',
        inputs: [
          { id: 'Z',  label: 'Proton number Z', unit: '' },
          { id: 'N',  label: 'Neutron number N', unit: '' },
          { id: 'mn', label: 'Nuclear mass', unit: 'kg' }
        ],
        calc: v => {
          const mp = 1.6726e-27;
          const mn_p = 1.6749e-27;
          const expected_mass = v.Z * mp + v.N * mn_p;
          const mass_defect = expected_mass - v.mn;
          return ({
            val: Math.abs(mass_defect),
            unit: 'kg',
            formula: `Δm = (${v.Z}×${mp} + ${v.N}×${mn_p}) − ${v.mn}`
          });
        }
      },
      {
        id: 'binding_energy',
        label: 'Nuclear binding energy',
        formula: 'BE = Δm·c²',
        inputs: [
          { id: 'Delta_m', label: 'Mass defect Δm', unit: 'kg' }
        ],
        calc: v => {
          const c = 3e8;
          return ({
            val: v.Delta_m * c * c,
            unit: 'J',
            formula: `BE = ${v.Delta_m} × (3×10⁸)²`
          });
        }
      },
      {
        id: 'fission_energy',
        label: 'Nuclear fission energy released',
        formula: 'E = (m_initial − m_final)·c²',
        inputs: [
          { id: 'mi', label: 'Initial mass', unit: 'kg' },
          { id: 'mf', label: 'Final mass', unit: 'kg' }
        ],
        calc: v => {
          const c = 3e8;
          const mass_lost = v.mi - v.mf;
          return ({
            val: mass_lost * c * c,
            unit: 'J',
            formula: `E = (${v.mi} − ${v.mf}) × (3×10⁸)²`
          });
        }
      },
      {
        id: 'fusion_energy',
        label: 'Nuclear fusion energy released',
        formula: 'E = (m_reactants − m_products)·c²',
        inputs: [
          { id: 'mr', label: 'Reactant mass', unit: 'kg' },
          { id: 'mp', label: 'Product mass', unit: 'kg' }
        ],
        calc: v => {
          const c = 3e8;
          const mass_lost = v.mr - v.mp;
          return ({
            val: mass_lost * c * c,
            unit: 'J',
            formula: `E = (${v.mr} − ${v.mp}) × (3×10⁸)²`
          });
        }
      }
    ]
  },

  {
    id: 'rotational_motion',
    label: 'Rotational Motion',
    subs: [
      {
        id: 'angular_velocity',
        label: 'Angular velocity',
        formula: 'ω = θ / t',
        inputs: [
          { id: 'theta', label: 'Angular displacement θ', unit: 'rad' },
          { id: 't',     label: 'Time t', unit: 's' }
        ],
        calc: v => {
          if (v.t === 0) return { err: 'Time cannot be zero' };
          return ({
            val: v.theta / v.t,
            unit: 'rad/s',
            formula: `ω = ${v.theta} / ${v.t}`
          });
        }
      },
      {
        id: 'angular_acceleration',
        label: 'Angular acceleration',
        formula: 'α = (ω_f − ω_i) / t',
        inputs: [
          { id: 'wf', label: 'Final angular velocity ω_f', unit: 'rad/s' },
          { id: 'wi', label: 'Initial angular velocity ω_i', unit: 'rad/s' },
          { id: 't',  label: 'Time t', unit: 's' }
        ],
        calc: v => {
          if (v.t === 0) return { err: 'Time cannot be zero' };
          return ({
            val: (v.wf - v.wi) / v.t,
            unit: 'rad/s²',
            formula: `α = (${v.wf} − ${v.wi}) / ${v.t}`
          });
        }
      },
      {
        id: 'torque',
        label: 'Torque',
        formula: 'τ = F·r·sin θ',
        inputs: [
          { id: 'F',     label: 'Force F', unit: 'N' },
          { id: 'r',     label: 'Lever arm r', unit: 'm' },
          { id: 'theta', label: 'Angle θ', unit: '°' }
        ],
        calc: v => ({
          val: v.F * v.r * Math.sin(v.theta * DEG),
          unit: 'N·m',
          formula: `τ = ${v.F} × ${v.r} × sin(${v.theta}°)`
        })
      },
      {
        id: 'moment_of_inertia',
        label: 'Moment of inertia',
        formula: 'I = mr²  (point mass)',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' },
          { id: 'r', label: 'Distance from axis r', unit: 'm' }
        ],
        calc: v => ({
          val: v.m * v.r * v.r,
          unit: 'kg·m²',
          formula: `I = ${v.m} × ${v.r}²`
        })
      },
      {
        id: 'moment_inertia_rod',
        label: 'Moment of inertia (rod through center)',
        formula: 'I = (1/12)·M·L²',
        inputs: [
          { id: 'M', label: 'Mass M', unit: 'kg' },
          { id: 'L', label: 'Length L', unit: 'm' }
        ],
        calc: v => ({
          val: (1/12) * v.M * v.L * v.L,
          unit: 'kg·m²',
          formula: `I = (1/12) × ${v.M} × ${v.L}²`
        })
      },
      {
        id: 'rotational_kinetic_energy',
        label: 'Rotational kinetic energy',
        formula: 'KE_rot = ½Iω²',
        inputs: [
          { id: 'I', label: 'Moment of inertia I', unit: 'kg·m²' },
          { id: 'w', label: 'Angular velocity ω', unit: 'rad/s' }
        ],
        calc: v => ({
          val: 0.5 * v.I * v.w * v.w,
          unit: 'J',
          formula: `KE_rot = ½ × ${v.I} × ${v.w}²`
        })
      },
      {
        id: 'angular_momentum',
        label: 'Angular momentum',
        formula: 'L = Iω',
        inputs: [
          { id: 'I', label: 'Moment of inertia I', unit: 'kg·m²' },
          { id: 'w', label: 'Angular velocity ω', unit: 'rad/s' }
        ],
        calc: v => ({
          val: v.I * v.w,
          unit: 'kg·m²/s',
          formula: `L = ${v.I} × ${v.w}`
        })
      },
      {
        id: 'centripetal_force',
        label: 'Centripetal force',
        formula: 'F_c = mω²r  or  F_c = mv²/r',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' },
          { id: 'v', label: 'Linear velocity v', unit: 'm/s' },
          { id: 'r', label: 'Radius r', unit: 'm' }
        ],
        calc: v => {
          if (v.r === 0) return { err: 'Radius cannot be zero' };
          return ({
            val: (v.m * v.v * v.v) / v.r,
            unit: 'N',
            formula: `F_c = ${v.m} × ${v.v}² / ${v.r}`
          });
        }
      },
      {
        id: 'centripetal_acceleration',
        label: 'Centripetal acceleration',
        formula: 'a_c = ω²r  or  a_c = v²/r',
        inputs: [
          { id: 'v', label: 'Linear velocity v', unit: 'm/s' },
          { id: 'r', label: 'Radius r', unit: 'm' }
        ],
        calc: v => {
          if (v.r === 0) return { err: 'Radius cannot be zero' };
          return ({
            val: (v.v * v.v) / v.r,
            unit: 'm/s²',
            formula: `a_c = ${v.v}² / ${v.r}`
          });
        }
      },
      {
        id: 'rotational_equation',
        label: 'Rotational equation of motion',
        formula: 'τ = Iα',
        inputs: [
          { id: 'I', label: 'Moment of inertia I', unit: 'kg·m²' },
          { id: 'a', label: 'Angular acceleration α', unit: 'rad/s²' }
        ],
        calc: v => ({
          val: v.I * v.a,
          unit: 'N·m (torque)',
          formula: `τ = ${v.I} × ${v.a}`
        })
      }
    ]
  },

  {
    id: 'oscillations',
    label: 'Oscillations',
    subs: [
      {
        id: 'period_oscillation',
        label: 'Period of oscillation',
        formula: 'T = 1 / f',
        inputs: [
          { id: 'f', label: 'Frequency f', unit: 'Hz' }
        ],
        calc: v => {
          if (v.f === 0) return { err: 'Frequency cannot be zero' };
          return ({
            val: 1 / v.f,
            unit: 's',
            formula: `T = 1 / ${v.f}`
          });
        }
      },
      {
        id: 'frequency_oscillation',
        label: 'Frequency of oscillation',
        formula: 'f = 1 / T',
        inputs: [
          { id: 'T', label: 'Period T', unit: 's' }
        ],
        calc: v => {
          if (v.T === 0) return { err: 'Period cannot be zero' };
          return ({
            val: 1 / v.T,
            unit: 'Hz',
            formula: `f = 1 / ${v.T}`
          });
        }
      },
      {
        id: 'angular_frequency_osc',
        label: 'Angular frequency (oscillation)',
        formula: 'ω = 2πf',
        inputs: [
          { id: 'f', label: 'Frequency f', unit: 'Hz' }
        ],
        calc: v => ({
          val: 2 * Math.PI * v.f,
          unit: 'rad/s',
          formula: `ω = 2π × ${v.f}`
        })
      },
      {
        id: 'spring_oscillation',
        label: 'Spring oscillation (period)',
        formula: 'T = 2π√(m/k)',
        inputs: [
          { id: 'm', label: 'Mass m', unit: 'kg' },
          { id: 'k', label: 'Spring constant k', unit: 'N/m' }
        ],
        calc: v => {
          if (v.k === 0) return { err: 'Spring constant cannot be zero' };
          return ({
            val: 2 * Math.PI * Math.sqrt(v.m / v.k),
            unit: 's',
            formula: `T = 2π√(${v.m}/${v.k})`
          });
        }
      },
      {
        id: 'spring_frequency',
        label: 'Spring oscillation (frequency)',
        formula: 'f = (1/2π)√(k/m)',
        inputs: [
          { id: 'k', label: 'Spring constant k', unit: 'N/m' },
          { id: 'm', label: 'Mass m', unit: 'kg' }
        ],
        calc: v => {
          if (v.m === 0) return { err: 'Mass cannot be zero' };
          return ({
            val: (1 / (2 * Math.PI)) * Math.sqrt(v.k / v.m),
            unit: 'Hz',
            formula: `f = (1/2π)√(${v.k}/${v.m})`
          });
        }
      },
      {
        id: 'pendulum_period',
        label: 'Pendulum period',
        formula: 'T = 2π√(L/g)',
        inputs: [
          { id: 'L', label: 'Length L', unit: 'm' }
        ],
        calc: v => {
          if (v.L < 0) return { err: 'Length cannot be negative' };
          return ({
            val: 2 * Math.PI * Math.sqrt(v.L / g),
            unit: 's',
            formula: `T = 2π√(${v.L}/9.8)`
          });
        }
      },
      {
        id: 'simple_harmonic_motion',
        label: 'Simple harmonic motion (displacement)',
        formula: 'x = A·sin(ωt + φ)',
        inputs: [
          { id: 'A',   label: 'Amplitude A', unit: 'm' },
          { id: 'w',   label: 'Angular frequency ω', unit: 'rad/s' },
          { id: 't',   label: 'Time t', unit: 's' },
          { id: 'phi', label: 'Phase φ', unit: 'rad' }
        ],
        calc: v => ({
          val: v.A * Math.sin(v.w * v.t + v.phi),
          unit: 'm',
          formula: `x = ${v.A} × sin(${v.w}×${v.t} + ${v.phi})`
        })
      }
    ]
  },

  {
    id: 'sound',
    label: 'Sound',
    subs: [
      {
        id: 'speed_of_sound',
        label: 'Speed of sound',
        formula: 'v = f·λ',
        inputs: [
          { id: 'f',   label: 'Frequency f', unit: 'Hz' },
          { id: 'lam', label: 'Wavelength λ', unit: 'm' }
        ],
        calc: v => ({
          val: v.f * v.lam,
          unit: 'm/s',
          formula: `v = ${v.f} × ${v.lam}`
        })
      },
      {
        id: 'echo_distance',
        label: 'Echo distance',
        formula: 'd = v·t/2',
        inputs: [
          { id: 'v', label: 'Speed of sound v', unit: 'm/s' },
          { id: 't', label: 'Total time t', unit: 's' }
        ],
        calc: v => ({
          val: (v.v * v.t) / 2,
          unit: 'm',
          formula: `d = (${v.v} × ${v.t}) / 2`
        })
      },
      {
        id: 'sound_intensity',
        label: 'Sound intensity',
        formula: 'I = P / A',
        inputs: [
          { id: 'P', label: 'Power P', unit: 'W' },
          { id: 'A', label: 'Area A', unit: 'm²' }
        ],
        calc: v => {
          if (v.A === 0) return { err: 'Area cannot be zero' };
          return ({
            val: v.P / v.A,
            unit: 'W/m²',
            formula: `I = ${v.P} / ${v.A}`
          });
        }
      },
      {
        id: 'doppler_effect',
        label: 'Doppler effect (observer at rest)',
        formula: "f' = f × (v ± v_observer) / (v ∓ v_source)",
        inputs: [
          { id: 'f',  label: 'Original frequency f', unit: 'Hz' },
          { id: 'v',  label: 'Speed of sound v', unit: 'm/s' },
          { id: 'vs', label: 'Source velocity v_s', unit: 'm/s' },
          { id: 'sign', label: 'Moving toward (+1) or away (-1)', unit: '' }
        ],
        calc: v => {
          if (v.v === 0) return { err: 'Speed of sound cannot be zero' };
          const sign = v.sign === 1 ? -1 : 1;
          const f_prime = v.f * v.v / (v.v + sign * v.vs);
          return ({
            val: f_prime,
            unit: 'Hz',
            formula: `f' = ${v.f} × ${v.v} / (${v.v} ${sign > 0 ? '+' : '−'} ${v.vs})`
          });
        }
      },
      {
        id: 'sound_level_decibel',
        label: 'Sound level (decibel)',
        formula: 'L = 10·log₁₀(I/I₀)',
        inputs: [
          { id: 'I', label: 'Sound intensity I', unit: 'W/m²' }
        ],
        calc: v => {
          const I0 = 1e-12;
          if (v.I <= 0) return { err: 'Intensity must be positive' };
          return ({
            val: 10 * Math.log10(v.I / I0),
            unit: 'dB',
            formula: `L = 10×log₁₀(${v.I} / 10⁻¹²)`
          });
        }
      },
      {
        id: 'intensity_from_decibel',
        label: 'Intensity from decibel',
        formula: 'I = I₀·10^(L/10)',
        inputs: [
          { id: 'L', label: 'Sound level L', unit: 'dB' }
        ],
        calc: v => {
          const I0 = 1e-12;
          return ({
            val: I0 * Math.pow(10, v.L / 10),
            unit: 'W/m²',
            formula: `I = 10⁻¹² × 10^(${v.L}/10)`
          });
        }
      },
      {
        id: 'sound_wavelength',
        label: 'Sound wavelength',
        formula: 'λ = v / f',
        inputs: [
          { id: 'v', label: 'Speed of sound v', unit: 'm/s' },
          { id: 'f', label: 'Frequency f', unit: 'Hz' }
        ],
        calc: v => {
          if (v.f === 0) return { err: 'Frequency cannot be zero' };
          return ({
            val: v.v / v.f,
            unit: 'm',
            formula: `λ = ${v.v} / ${v.f}`
          });
        }
      }
    ]
  }
];





// =====================
//  State
// =====================
let currentTopic = null;
let currentSub   = null;

// =====================
//  Utility: format number
// =====================
function fmt(n) {
  if (Math.abs(n) >= 1e6 || (Math.abs(n) < 0.001 && n !== 0)) {
    return n.toExponential(4);
  }
  return parseFloat(n.toFixed(6)).toString();
}

// =====================
//  Breadcrumb update
// =====================
function updateBreadcrumb() {
  const bc = document.getElementById('breadcrumb');
  let html = '<span>Physics</span>';
  if (currentTopic) html += `<span class="sep"> › </span><span>${currentTopic.label}</span>`;
  if (currentSub)   html += `<span class="sep"> › </span><span>${currentSub.label}</span>`;
  bc.innerHTML = html;
}

// =====================
//  View: Main topic grid
// =====================
function showMain() {
  currentTopic = null;
  currentSub   = null;

  document.getElementById('main-view').style.display = '';
  document.getElementById('sub-view').style.display  = 'none';
  document.getElementById('calc-view').style.display = 'none';

  // Reset display
  document.getElementById('disp-formula').textContent = '— select a formula below —';
  document.getElementById('disp-result').textContent  = '';
  document.getElementById('disp-unit').textContent    = '';

  updateBreadcrumb();
}

// =====================
//  View: Sub-formula list
// =====================
function showSub(topicId) {
  currentTopic = TOPICS.find(t => t.id === topicId);
  currentSub   = null;

  document.getElementById('main-view').style.display = 'none';
  document.getElementById('sub-view').style.display  = 'flex';
  document.getElementById('calc-view').style.display = 'none';

  document.getElementById('sub-label').textContent = currentTopic.label;

  const sg = document.getElementById('sub-grid');
  const sb = document.getElementById('sub-back');
  sb.innerHTML = '';
  sg.innerHTML = '';

  // Back button
  const back = document.createElement('button');
  back.className   = 'btn-back';
  back.textContent = '← All topics';
  back.onclick     = showMain;
  sb.appendChild(back);

  // Formula buttons
  let subs = currentTopic.subs || [];
  // If showing kinematics, merge any helper kinematics entries present elsewhere
  if (currentTopic && currentTopic.id === 'kinematics') {
    const kh = TOPICS.find(t => t.id === 'kin_helpers');
    if (kh && Array.isArray(kh.subs)) subs = subs.concat(kh.subs);
  }

  subs.forEach(s => {
    const b = document.createElement('button');
    b.className   = 'btn-sub';
    b.textContent = s.label;
    b.onclick     = () => showCalc(s.id);
    sg.appendChild(b);
  });

  updateBreadcrumb();
}

// =====================
//  View: Calculator inputs
// =====================
function showCalc(subId) {
  // find sub across topic's subs and any merged kinematics helpers
  let subs = currentTopic.subs || [];
  if (currentTopic && currentTopic.id === 'kinematics') {
    const kh = TOPICS.find(t => t.id === 'kin_helpers');
    if (kh && Array.isArray(kh.subs)) subs = subs.concat(kh.subs);
  }
  currentSub = subs.find(s => s.id === subId);

  document.getElementById('sub-view').style.display  = 'none';
  document.getElementById('calc-view').style.display = 'flex';

  document.getElementById('calc-formula-box').textContent = currentSub.formula;
  document.getElementById('disp-formula').textContent     = currentSub.formula;
  document.getElementById('disp-result').textContent      = '';
  document.getElementById('disp-unit').textContent        = '';
  document.getElementById('calc-err').textContent         = '';

  const cb = document.getElementById('calc-back');
  cb.innerHTML = '';
  const ci = document.getElementById('calc-inputs');
  ci.innerHTML = '';

  // Back button
  const back = document.createElement('button');
  back.className   = 'btn-back';
  back.textContent = `← ${currentTopic.label}`;
  back.onclick     = () => showSub(currentTopic.id);
  cb.appendChild(back);

  // Input fields
  currentSub.inputs.forEach(inp => {
    const row   = document.createElement('div');
    row.className = 'input-row';

    const labelText = inp.unit ? `${inp.label} (${inp.unit})` : inp.label;
    row.innerHTML = `
      <label for="inp_${inp.id}">${labelText}</label>
      <input type="number" id="inp_${inp.id}" placeholder="0" step="any" />
    `;
    ci.appendChild(row);
  });

  // Focus first input
  const firstInput = ci.querySelector('input');
  if (firstInput) firstInput.focus();

  updateBreadcrumb();
}

// =====================
//  Compute result
// =====================
function compute() {
  const errEl = document.getElementById('calc-err');
  errEl.textContent = '';

  const ZERO_DENOM = ['dt', 'T', 'V', 'A', 'r', 'R', 'R1', 'R2', 'n2'];
  const vals = {};
  let valid  = true;

  for (const inp of currentSub.inputs) {
    const el = document.getElementById('inp_' + inp.id);
    const v  = parseFloat(el.value);

    if (isNaN(v)) {
      errEl.textContent = `Please enter a value for "${inp.label}"`;
      el.focus();
      valid = false;
      break;
    }

    if (ZERO_DENOM.includes(inp.id) && v === 0) {
      errEl.textContent = `"${inp.label}" cannot be zero (division by zero)`;
      el.focus();
      valid = false;
      break;
    }

    vals[inp.id] = v;
  }

  if (!valid) return;

  try {
    const res = currentSub.calc(vals);

    if (res.err) {
      errEl.textContent = res.err;
      return;
    }

    document.getElementById('disp-formula').textContent = res.formula || currentSub.formula;
    document.getElementById('disp-result').textContent  = fmt(res.val);
    document.getElementById('disp-unit').textContent    = res.unit || '';
  } catch (e) {
    errEl.textContent = 'Calculation error — please check your inputs.';
  }
}

// =====================
//  Initialise
// =====================
(function init() {
  const tg = document.getElementById('topic-grid');

  TOPICS.forEach(t => {
    // skip internal helper-only topics (e.g., kin_helpers)
    if (t.id === 'kin_helpers') return;

    const b = document.createElement('button');
    b.className = 'btn-topic';
    b.innerHTML = `
      <span class="topic-name">${t.label}</span>
    `;
    b.onclick = () => showSub(t.id);
    tg.appendChild(b);
  });

  // Allow Enter key to trigger calculate
  document.addEventListener('keydown', e => {
    if (e.key === 'Enter' && currentSub) compute();
  });
})();