warplab 1.0.0

package/dist-server/mcp.js

@@ -0,0 +1,1600 @@
+#!/usr/bin/env node
+
+// server/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/core/vec3.ts
+var Vec3 = class _Vec3 {
+  constructor(x = 0, y = 0, z2 = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z2;
+  }
+  clone() {
+    return new _Vec3(this.x, this.y, this.z);
+  }
+  copy(v) {
+    this.x = v.x;
+    this.y = v.y;
+    this.z = v.z;
+    return this;
+  }
+  get length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+  get lengthSq() {
+    return this.x * this.x + this.y * this.y + this.z * this.z;
+  }
+  normalize() {
+    const l = this.length;
+    if (l > 0) {
+      this.x /= l;
+      this.y /= l;
+      this.z /= l;
+    }
+    return this;
+  }
+  multiplyScalar(s) {
+    this.x *= s;
+    this.y *= s;
+    this.z *= s;
+    return this;
+  }
+  addScaledVector(v, s) {
+    this.x += v.x * s;
+    this.y += v.y * s;
+    this.z += v.z * s;
+    return this;
+  }
+  dot(v) {
+    return this.x * v.x + this.y * v.y + this.z * v.z;
+  }
+  crossVectors(a, b) {
+    this.x = a.y * b.z - a.z * b.y;
+    this.y = a.z * b.x - a.x * b.z;
+    this.z = a.x * b.y - a.y * b.x;
+    return this;
+  }
+};
+
+// src/core/catalog.ts
+var GWOSC_API = "https://gwosc.org/eventapi/json/allevents/";
+function seededRandom(seed) {
+  let s = seed;
+  return () => {
+    s = (s * 16807 + 0) % 2147483647;
+    return s / 2147483647;
+  };
+}
+async function fetchEventCatalog() {
+  const res = await fetch(GWOSC_API);
+  if (!res.ok) throw new Error(`GWOSC API returned ${res.status}`);
+  const data = await res.json();
+  const catalogPriority = {
+    "O1_O2-Preliminary": 1,
+    "Initial_LIGO_Virgo": 1,
+    "GWTC-1-marginal": 2,
+    "GWTC-1-confident": 3,
+    "GWTC-2": 4,
+    "GWTC-2.1-marginal": 5,
+    "GWTC-2.1-auxiliary": 5,
+    "GWTC-2.1-confident": 6,
+    "GWTC-3-marginal": 7,
+    "GWTC-3-confident": 8,
+    "O3_Discovery_Papers": 8,
+    "O3_IMBH_marginal": 7,
+    "IAS-O3a": 5,
+    "GWTC-4.0": 9,
+    "O4_Discovery_Papers": 9
+  };
+  const deduped = /* @__PURE__ */ new Map();
+  for (const [, entry] of Object.entries(data.events)) {
+    const e = entry;
+    const name = e.commonName ?? "";
+    if (!name) continue;
+    const existing = deduped.get(name);
+    if (existing) {
+      const existingPri = catalogPriority[existing["catalog.shortName"] ?? ""] ?? 0;
+      const newPri = catalogPriority[e["catalog.shortName"] ?? ""] ?? 0;
+      if (newPri > existingPri || newPri === existingPri && !existing.mass_1_source && e.mass_1_source) {
+        deduped.set(name, e);
+      }
+    } else {
+      deduped.set(name, e);
+    }
+  }
+  const events = [];
+  for (const [, e] of deduped) {
+    if (!e.mass_1_source || !e.mass_2_source) continue;
+    const gps = e.GPS ?? 0;
+    const distance = e.luminosity_distance ?? 0;
+    const rng = seededRandom(Math.floor(gps));
+    const ra = rng() * 2 * Math.PI;
+    const dec = Math.asin(2 * rng() - 1);
+    const r = distance;
+    const x = r * Math.cos(dec) * Math.cos(ra);
+    const y = r * Math.cos(dec) * Math.sin(ra);
+    const z2 = r * Math.sin(dec);
+    const event = {
+      commonName: e.commonName ?? "",
+      GPS: gps,
+      mass_1_source: e.mass_1_source,
+      mass_1_source_lower: e.mass_1_source_lower ?? 0,
+      mass_1_source_upper: e.mass_1_source_upper ?? 0,
+      mass_2_source: e.mass_2_source,
+      mass_2_source_lower: e.mass_2_source_lower ?? 0,
+      mass_2_source_upper: e.mass_2_source_upper ?? 0,
+      luminosity_distance: distance,
+      luminosity_distance_lower: e.luminosity_distance_lower ?? 0,
+      luminosity_distance_upper: e.luminosity_distance_upper ?? 0,
+      redshift: e.redshift ?? 0,
+      chi_eff: e.chi_eff ?? 0,
+      network_matched_filter_snr: e.network_matched_filter_snr ?? 0,
+      far: e.far ?? 0,
+      catalog_shortName: e["catalog.shortName"] ?? "",
+      total_mass_source: e.total_mass_source ?? 0,
+      chirp_mass_source: e.chirp_mass_source ?? 0,
+      chirp_mass_source_lower: e.chirp_mass_source_lower ?? 0,
+      chirp_mass_source_upper: e.chirp_mass_source_upper ?? 0,
+      final_mass_source: e.final_mass_source ?? 0,
+      final_mass_source_lower: e.final_mass_source_lower ?? 0,
+      final_mass_source_upper: e.final_mass_source_upper ?? 0,
+      p_astro: e.p_astro ?? 0,
+      mapPosition: { x, y, z: z2 }
+    };
+    events.push(event);
+  }
+  events.sort(
+    (a, b) => b.network_matched_filter_snr - a.network_matched_filter_snr
+  );
+  return events;
+}
+function classifyEvent(event) {
+  const total = event.mass_1_source + event.mass_2_source;
+  if (total < 5) return "BNS";
+  if (event.mass_2_source < 3) return "NSBH";
+  return "BBH";
+}
+
+// src/core/waveform.ts
+function generateWaveform(event) {
+  const m1 = event.mass_1_source;
+  const m2 = event.mass_2_source;
+  const totalMass = m1 + m2;
+  const chirpMass = Math.pow(m1 * m2, 3 / 5) / Math.pow(totalMass, 1 / 5);
+  const sampleRate = 512;
+  const duration = Math.min(4, Math.max(1.5, 120 / chirpMass));
+  const numSamples = Math.floor(duration * sampleRate);
+  const mergerIndex = Math.floor(numSamples * 0.75);
+  const hPlus = new Array(numSamples);
+  const hCross = new Array(numSamples);
+  const fRingdown = 32e3 / totalMass;
+  const tauRingdown = totalMass / 5e3;
+  for (let i = 0; i < numSamples; i++) {
+    const t = i / sampleRate;
+    const tMerger = mergerIndex / sampleRate;
+    let amplitude;
+    let phase;
+    if (i < mergerIndex) {
+      const tau = Math.max(tMerger - t, 1e-3);
+      const freqFactor = chirpMass / 30;
+      amplitude = 0.3 * Math.pow(0.5 / tau, 1 / 4);
+      phase = -2 * Math.PI * 20 * Math.pow(0.5, 3 / 8) * (8 / 5) * Math.pow(tau, 5 / 8) * freqFactor;
+      amplitude = Math.min(amplitude, 1);
+    } else {
+      const tPost = t - tMerger;
+      amplitude = Math.exp(-tPost / tauRingdown);
+      phase = 2 * Math.PI * fRingdown * tPost;
+    }
+    hPlus[i] = amplitude * Math.cos(phase);
+    hCross[i] = amplitude * Math.sin(phase);
+  }
+  let maxAmp = 0;
+  for (let i = 0; i < numSamples; i++) {
+    const a = Math.sqrt(hPlus[i] ** 2 + hCross[i] ** 2);
+    if (a > maxAmp) maxAmp = a;
+  }
+  if (maxAmp > 0) {
+    for (let i = 0; i < numSamples; i++) {
+      hPlus[i] /= maxAmp;
+      hCross[i] /= maxAmp;
+    }
+  }
+  return {
+    eventName: event.commonName,
+    sampleRate,
+    hPlus,
+    hCross,
+    duration,
+    peakIndex: mergerIndex
+  };
+}
+function generateCustomWaveform(params) {
+  const { m1, m2, chi1, chi2, inclination } = params;
+  const totalMass = m1 + m2;
+  const chirpMass = Math.pow(m1 * m2, 3 / 5) / Math.pow(totalMass, 1 / 5);
+  const chiEff = (m1 * chi1 + m2 * chi2) / totalMass;
+  const sampleRate = 512;
+  const duration = Math.min(4, Math.max(1.5, 120 / chirpMass));
+  const numSamples = Math.floor(duration * sampleRate);
+  const mergerIndex = Math.floor(numSamples * 0.75);
+  const hPlus = new Array(numSamples);
+  const hCross = new Array(numSamples);
+  const fRingdown = 32e3 / totalMass * (1 + 0.15 * Math.abs(chiEff));
+  const tauRingdown = totalMass / 5e3;
+  const cosInc = Math.cos(inclination);
+  const ampPlus = (1 + cosInc * cosInc) / 2;
+  const ampCross = cosInc;
+  for (let i = 0; i < numSamples; i++) {
+    const t = i / sampleRate;
+    const tMerger = mergerIndex / sampleRate;
+    let amplitude;
+    let phase;
+    if (i < mergerIndex) {
+      const tau = Math.max(tMerger - t, 1e-3);
+      const freqFactor = chirpMass / 30;
+      amplitude = 0.3 * Math.pow(0.5 / tau, 1 / 4);
+      phase = -2 * Math.PI * 20 * Math.pow(0.5, 3 / 8) * (8 / 5) * Math.pow(tau, 5 / 8) * freqFactor;
+      amplitude = Math.min(amplitude, 1);
+    } else {
+      const tPost = t - tMerger;
+      amplitude = Math.exp(-tPost / tauRingdown);
+      phase = 2 * Math.PI * fRingdown * tPost;
+    }
+    hPlus[i] = amplitude * ampPlus * Math.cos(phase);
+    hCross[i] = amplitude * ampCross * Math.sin(phase);
+  }
+  let maxAmp = 0;
+  for (let i = 0; i < numSamples; i++) {
+    const a = Math.sqrt(hPlus[i] ** 2 + hCross[i] ** 2);
+    if (a > maxAmp) maxAmp = a;
+  }
+  if (maxAmp > 0) {
+    for (let i = 0; i < numSamples; i++) {
+      hPlus[i] /= maxAmp;
+      hCross[i] /= maxAmp;
+    }
+  }
+  const name = `Custom (${m1.toFixed(0)}+${m2.toFixed(0)} M\u2609)`;
+  return {
+    eventName: name,
+    sampleRate,
+    hPlus,
+    hCross,
+    duration,
+    peakIndex: mergerIndex
+  };
+}
+
+// src/core/qnm.ts
+var BERTI_COEFFS = {
+  "2,2,0": [1.5251, -1.1568, 0.1292, 0.7, 1.4187, -0.499],
+  "2,2,1": [1.3673, -1.026, 0.1628, 0.3562, 2.342, -0.2467]
+};
+var MSUN_KG = 1989e27;
+var G = 6674e-14;
+var C = 2998e5;
+var MSUN_SEC = G * MSUN_KG / (C * C * C);
+function estimateFinalSpin(m1, m2, chi1 = 0, chi2 = 0) {
+  const totalMass = m1 + m2;
+  const eta = m1 * m2 / (totalMass * totalMass);
+  const chiEff = (m1 * chi1 + m2 * chi2) / totalMass;
+  const aFinal = Math.sqrt(12) * eta - 3.871 * eta * eta + 4.028 * eta * eta * eta + chiEff * eta * (2 - 1.25 * eta);
+  return Math.min(Math.max(aFinal, 0), 0.998);
+}
+function estimateFinalMass(m1, m2) {
+  const totalMass = m1 + m2;
+  const eta = m1 * m2 / (totalMass * totalMass);
+  const erad = 0.0559745 * eta + 0.1469 * eta * eta;
+  return totalMass * (1 - erad);
+}
+function computeQNMModes(m1, m2, chi1 = 0, chi2 = 0, modes = ["2,2,0", "2,2,1"]) {
+  const finalMass = estimateFinalMass(m1, m2);
+  const finalSpin = estimateFinalSpin(m1, m2, chi1, chi2);
+  const mfSec = finalMass * MSUN_SEC;
+  const results = [];
+  for (const modeKey of modes) {
+    const coeffs = BERTI_COEFFS[modeKey];
+    if (!coeffs) continue;
+    const [f1, f2, f3, q1, q2, q3] = coeffs;
+    const omegaHat = f1 + f2 * Math.pow(1 - finalSpin, f3);
+    const Q = q1 + q2 * Math.pow(1 - finalSpin, q3);
+    const frequency = omegaHat / (2 * Math.PI * mfSec);
+    const dampingTime = Q / (Math.PI * frequency);
+    const [l, m, n] = modeKey.split(",").map(Number);
+    results.push({
+      l,
+      m,
+      n,
+      frequency,
+      dampingTime,
+      qualityFactor: Q,
+      label: `(${l},${m},${n})`
+    });
+  }
+  return results;
+}
+
+// src/core/noise-curve.ts
+function fftInPlace(re, im) {
+  const N = re.length;
+  for (let i = 1, j = 0; i < N; i++) {
+    let bit = N >> 1;
+    while (j & bit) {
+      j ^= bit;
+      bit >>= 1;
+    }
+    j ^= bit;
+    if (i < j) {
+      [re[i], re[j]] = [re[j], re[i]];
+      [im[i], im[j]] = [im[j], im[i]];
+    }
+  }
+  for (let len = 2; len <= N; len *= 2) {
+    const halfLen = len / 2;
+    const angle = -2 * Math.PI / len;
+    const wRe = Math.cos(angle);
+    const wIm = Math.sin(angle);
+    for (let i = 0; i < N; i += len) {
+      let curRe = 1;
+      let curIm = 0;
+      for (let j = 0; j < halfLen; j++) {
+        const a = i + j;
+        const b = a + halfLen;
+        const tRe = curRe * re[b] - curIm * im[b];
+        const tIm = curRe * im[b] + curIm * re[b];
+        re[b] = re[a] - tRe;
+        im[b] = im[a] - tIm;
+        re[a] += tRe;
+        im[a] += tIm;
+        const nextRe = curRe * wRe - curIm * wIm;
+        curIm = curRe * wIm + curIm * wRe;
+        curRe = nextRe;
+      }
+    }
+  }
+}
+function nextPow2(n) {
+  let p = 1;
+  while (p < n) p *= 2;
+  return p;
+}
+function computeCharacteristicStrain(waveform) {
+  const minN = 2048;
+  const N = nextPow2(Math.max(waveform.hPlus.length, minN));
+  const dt = 1 / waveform.sampleRate;
+  const re = new Float64Array(N);
+  const im = new Float64Array(N);
+  for (let i = 0; i < waveform.hPlus.length; i++) {
+    re[i] = waveform.hPlus[i];
+  }
+  fftInPlace(re, im);
+  const halfN = N / 2;
+  const df = 1 / (N * dt);
+  const frequencies = new Float64Array(halfN);
+  const hc = new Float64Array(halfN);
+  for (let k = 0; k < halfN; k++) {
+    const f = k * df;
+    frequencies[k] = f;
+    const mag = Math.sqrt(re[k] * re[k] + im[k] * im[k]) * dt;
+    hc[k] = 2 * f * mag;
+  }
+  return { frequencies, hc };
+}
+var ALIGO_DATA = [
+  [10, 1e-20],
+  [11, 65e-22],
+  [12, 42e-22],
+  [13, 29e-22],
+  [14, 21e-22],
+  [15, 16e-22],
+  [16, 13e-22],
+  [17, 11e-22],
+  [18, 9e-22],
+  [19, 78e-23],
+  [20, 68e-23],
+  [22, 53e-23],
+  [24, 43e-23],
+  [26, 36e-23],
+  [28, 31e-23],
+  [30, 27e-23],
+  [33, 23e-23],
+  [36, 2e-22],
+  [40, 17e-23],
+  [45, 14e-23],
+  [50, 12e-23],
+  [55, 105e-24],
+  [60, 95e-24],
+  [65, 87e-24],
+  [70, 8e-23],
+  [75, 75e-24],
+  [80, 7e-23],
+  [85, 66e-24],
+  [90, 63e-24],
+  [95, 6e-23],
+  [100, 57e-24],
+  [110, 52e-24],
+  [120, 48e-24],
+  [130, 45e-24],
+  [140, 42e-24],
+  [150, 4e-23],
+  [160, 39e-24],
+  [170, 38e-24],
+  [180, 37e-24],
+  [190, 36e-24],
+  [200, 36e-24],
+  [220, 36e-24],
+  [240, 37e-24],
+  [260, 38e-24],
+  [280, 4e-23],
+  [300, 42e-24],
+  [320, 45e-24],
+  [340, 48e-24],
+  [360, 52e-24],
+  [380, 56e-24],
+  [400, 6e-23],
+  [430, 68e-24],
+  [460, 77e-24],
+  [500, 9e-23],
+  [550, 11e-23],
+  [600, 13e-23],
+  [650, 15e-23],
+  [700, 18e-23],
+  [750, 21e-23],
+  [800, 25e-23],
+  [850, 29e-23],
+  [900, 34e-23],
+  [950, 4e-22],
+  [1e3, 46e-23],
+  [1100, 62e-23],
+  [1200, 82e-23],
+  [1300, 11e-22],
+  [1400, 14e-22],
+  [1500, 18e-22],
+  [1600, 23e-22],
+  [1700, 3e-21],
+  [1800, 38e-22],
+  [1900, 48e-22],
+  [2e3, 6e-21],
+  [2200, 95e-22],
+  [2400, 15e-21],
+  [2600, 23e-21],
+  [2800, 35e-21],
+  [3e3, 55e-21],
+  [3500, 15e-20],
+  [4e3, 45e-20],
+  [4500, 13e-19],
+  [5e3, 4e-18]
+];
+function interpolateALIGO_ASD(f) {
+  if (f <= ALIGO_DATA[0][0]) return ALIGO_DATA[0][1];
+  if (f >= ALIGO_DATA[ALIGO_DATA.length - 1][0]) return ALIGO_DATA[ALIGO_DATA.length - 1][1];
+  for (let i = 0; i < ALIGO_DATA.length - 1; i++) {
+    const [f0, a0] = ALIGO_DATA[i];
+    const [f1, a1] = ALIGO_DATA[i + 1];
+    if (f >= f0 && f <= f1) {
+      const t = Math.log(f / f0) / Math.log(f1 / f0);
+      return Math.exp(Math.log(a0) + t * Math.log(a1 / a0));
+    }
+  }
+  return ALIGO_DATA[ALIGO_DATA.length - 1][1];
+}
+function computeOptimalSNR(strain) {
+  const fMin = 10;
+  const fMax = 5e3;
+  let rhoSq = 0;
+  for (let k = 1; k < strain.frequencies.length - 1; k++) {
+    const f = strain.frequencies[k];
+    if (f < fMin || f > fMax || strain.hc[k] <= 0) continue;
+    const asd = interpolateALIGO_ASD(f);
+    const hn = Math.sqrt(f) * asd;
+    const ratio = strain.hc[k] / hn;
+    const df = strain.frequencies[k + 1] - strain.frequencies[k];
+    rhoSq += ratio * ratio * (df / f);
+  }
+  return Math.sqrt(rhoSq);
+}
+
+// src/core/geodesic.ts
+var MAX_STEPS = 5e3;
+var MAX_STEPS_MASSIVE = 2e4;
+var MAX_DIST = 200;
+function timelikeVeff(r, rs, L) {
+  if (r <= rs) return 0;
+  return (1 - rs / r) * (1 + L * L / (r * r));
+}
+function integrateGeodesic(startPos, startVel, rs, stepSize = 0.04) {
+  const points = [];
+  const vel = startVel.clone().normalize();
+  const pos = startPos.clone();
+  const Lvec = new Vec3().crossVectors(pos, vel);
+  const L2 = Lvec.lengthSq;
+  const rHorizon = rs;
+  const halfRs = 1.5 * rs;
+  points.push({ x: pos.x, y: pos.y, z: pos.z });
+  let outcome = "orbiting";
+  const tmpPos = new Vec3();
+  const k1v = new Vec3();
+  const k2v = new Vec3();
+  const k3v = new Vec3();
+  const k4v = new Vec3();
+  for (let i = 0; i < MAX_STEPS; i++) {
+    const r = pos.length;
+    if (r <= rHorizon * 1.01) {
+      outcome = "captured";
+      break;
+    }
+    if (r > MAX_DIST) {
+      outcome = "scattered";
+      break;
+    }
+    const accel = (r5, p, out) => {
+      const factor = -halfRs * L2 / r5;
+      out.copy(p).multiplyScalar(factor);
+    };
+    const dt = stepSize;
+    const r1 = pos.length;
+    const r1_5 = r1 * r1 * r1 * r1 * r1;
+    accel(r1_5, pos, k1v);
+    tmpPos.copy(pos).addScaledVector(vel, dt * 0.5);
+    const r2 = tmpPos.length;
+    const r2_5 = r2 * r2 * r2 * r2 * r2;
+    accel(r2_5, tmpPos, k2v);
+    tmpPos.copy(pos).addScaledVector(vel, dt * 0.5).addScaledVector(k1v, dt * dt * 0.25);
+    const r3 = tmpPos.length;
+    const r3_5 = r3 * r3 * r3 * r3 * r3;
+    accel(r3_5, tmpPos, k3v);
+    tmpPos.copy(pos).addScaledVector(vel, dt).addScaledVector(k2v, dt * dt * 0.5);
+    const r4 = tmpPos.length;
+    const r4_5 = r4 * r4 * r4 * r4 * r4;
+    accel(r4_5, tmpPos, k4v);
+    pos.addScaledVector(vel, dt);
+    vel.addScaledVector(k1v, dt / 6);
+    vel.addScaledVector(k2v, dt / 3);
+    vel.addScaledVector(k3v, dt / 3);
+    vel.addScaledVector(k4v, dt / 6);
+    points.push({ x: pos.x, y: pos.y, z: pos.z });
+  }
+  return { points, outcome, L: Math.sqrt(L2), particleType: "photon" };
+}
+function integrateTimelikeGeodesic(startPos, startVel, rs, energy, stepSize = 0.03) {
+  const points = [];
+  const pos = startPos.clone();
+  const r0 = pos.length;
+  const velDir = startVel.clone().normalize();
+  const Lvec = new Vec3().crossVectors(pos, velDir);
+  const L = Lvec.length;
+  const L2 = L * L;
+  const veff0 = timelikeVeff(r0, rs, L);
+  const drdt2 = energy - veff0;
+  const vTangential = L / r0;
+  const vRadial = Math.sqrt(Math.max(0, drdt2));
+  const rHat = pos.clone().normalize();
+  const tangentDir = new Vec3().crossVectors(Lvec.clone().normalize(), rHat);
+  const radialSign = velDir.dot(rHat) < 0 ? -1 : 1;
+  const vel = tangentDir.multiplyScalar(vTangential).addScaledVector(rHat, radialSign * vRadial);
+  const rHorizon = rs;
+  const halfRs = 0.5 * rs;
+  const threeHalfRs = 1.5 * rs;
+  points.push({ x: pos.x, y: pos.y, z: pos.z });
+  let outcome = "orbiting";
+  let prevR = r0;
+  let radialTurns = 0;
+  let increasing = vel.dot(pos.clone().normalize()) > 0;
+  const tmpPos = new Vec3();
+  const k1v = new Vec3();
+  const k2v = new Vec3();
+  const k3v = new Vec3();
+  const k4v = new Vec3();
+  const accel = (p, out) => {
+    const r = p.length;
+    const r3 = r * r * r;
+    const r5 = r3 * r * r;
+    const factor = -halfRs / r3 - threeHalfRs * L2 / r5;
+    out.copy(p).multiplyScalar(factor);
+  };
+  for (let i = 0; i < MAX_STEPS_MASSIVE; i++) {
+    const r = pos.length;
+    if (r <= rHorizon * 1.01) {
+      outcome = "captured";
+      break;
+    }
+    if (r > MAX_DIST) {
+      outcome = "scattered";
+      break;
+    }
+    const nowIncreasing = r > prevR;
+    if (i > 5 && nowIncreasing !== increasing) {
+      radialTurns++;
+      increasing = nowIncreasing;
+      if (radialTurns >= 6) {
+        outcome = "bound";
+        break;
+      }
+    }
+    prevR = r;
+    const dt = stepSize;
+    accel(pos, k1v);
+    tmpPos.copy(pos).addScaledVector(vel, dt * 0.5);
+    accel(tmpPos, k2v);
+    tmpPos.copy(pos).addScaledVector(vel, dt * 0.5).addScaledVector(k1v, dt * dt * 0.25);
+    accel(tmpPos, k3v);
+    tmpPos.copy(pos).addScaledVector(vel, dt).addScaledVector(k2v, dt * dt * 0.5);
+    accel(tmpPos, k4v);
+    pos.addScaledVector(vel, dt);
+    vel.addScaledVector(k1v, dt / 6);
+    vel.addScaledVector(k2v, dt / 3);
+    vel.addScaledVector(k3v, dt / 3);
+    vel.addScaledVector(k4v, dt / 6);
+    points.push({ x: pos.x, y: pos.y, z: pos.z });
+  }
+  return { points, outcome, L, particleType: "particle" };
+}
+
+// src/core/multi-messenger.ts
+var MM_DATA = {
+  GW170817: {
+    eventName: "GW170817",
+    emCounterpart: "GRB 170817A / AT 2017gfo (kilonova)",
+    emCounterparts: [
+      {
+        name: "GRB 170817A",
+        type: "GRB",
+        delaySeconds: 1.7,
+        observatory: "Fermi GBM / INTEGRAL SPI-ACS",
+        description: "A short gamma-ray burst detected just 1.7 seconds after the gravitational wave signal, confirming the long-theorized link between neutron star mergers and short GRBs."
+      },
+      {
+        name: "AT 2017gfo",
+        type: "kilonova",
+        delaySeconds: 11 * 3600,
+        observatory: "Swope Telescope (Las Campanas)",
+        description: "The first kilonova observed with a known gravitational-wave source. Its rapid reddening revealed freshly synthesized heavy elements forged by the r-process."
+      },
+      {
+        name: "CXO J130948.0\u2013233120",
+        type: "X-ray",
+        delaySeconds: 9 * 86400,
+        observatory: "Chandra X-ray Observatory",
+        description: "X-ray emission appeared days after the merger, produced by the interaction of the relativistic jet with the surrounding interstellar medium."
+      },
+      {
+        name: "VLA J130948.0\u2013233120",
+        type: "radio",
+        delaySeconds: 16 * 86400,
+        observatory: "Karl G. Jansky VLA",
+        description: "Radio afterglow from the expanding cocoon of material around the jet, confirming the merger launched a structured relativistic outflow."
+      }
+    ],
+    hostGalaxy: "NGC 4993, 40 Mpc",
+    hostGalaxyDistanceMpc: 40,
+    h0Measurement: "70 +12/\u22128 km/s/Mpc",
+    ejectaMass: "~0.05 M\u2609",
+    grbDelay: "1.7 s"
+  }
+};
+function getMultiMessengerData(commonName) {
+  return MM_DATA[commonName] ?? null;
+}
+
+// src/core/export.ts
+var CATALOG_PAPERS = {
+  "GWTC-1": {
+    key: "LIGOScientific:2018mvr",
+    entry: `@article{LIGOScientific:2018mvr,
+  author = "{LIGO Scientific Collaboration and Virgo Collaboration}",
+  title = "{GWTC-1: A Gravitational-Wave Transient Catalog of Compact Binary Mergers Observed by LIGO and Virgo during the First and Second Observing Runs}",
+  journal = "Phys. Rev. X",
+  volume = "9",
+  pages = "031040",
+  year = "2019",
+  doi = "10.1103/PhysRevX.9.031040",
+  eprint = "1811.12907",
+  archivePrefix = "arXiv"
+}`
+  },
+  "GWTC-2": {
+    key: "LIGOScientific:2020ibl",
+    entry: `@article{LIGOScientific:2020ibl,
+  author = "{LIGO Scientific Collaboration and Virgo Collaboration}",
+  title = "{GWTC-2: Compact Binary Coalescences Observed by LIGO and Virgo During the First Half of the Third Observing Run}",
+  journal = "Phys. Rev. X",
+  volume = "11",
+  pages = "021053",
+  year = "2021",
+  doi = "10.1103/PhysRevX.11.021053",
+  eprint = "2010.14527",
+  archivePrefix = "arXiv"
+}`
+  },
+  "GWTC-2.1": {
+    key: "LIGOScientific:2021usb",
+    entry: `@article{LIGOScientific:2021usb,
+  author = "{LIGO Scientific Collaboration and Virgo Collaboration}",
+  title = "{GWTC-2.1: Deep Extended Catalog of Compact Binary Coalescences Observed by LIGO and Virgo During the First Half of the Third Observing Run}",
+  journal = "Phys. Rev. D",
+  volume = "109",
+  pages = "022001",
+  year = "2024",
+  doi = "10.1103/PhysRevD.109.022001",
+  eprint = "2108.01045",
+  archivePrefix = "arXiv"
+}`
+  },
+  "GWTC-3": {
+    key: "LIGOScientific:2021djp",
+    entry: `@article{LIGOScientific:2021djp,
+  author = "{LIGO Scientific Collaboration and Virgo Collaboration and KAGRA Collaboration}",
+  title = "{GWTC-3: Compact Binary Coalescences Observed by LIGO and Virgo During the Second Part of the Third Observing Run}",
+  journal = "Phys. Rev. X",
+  volume = "13",
+  pages = "041039",
+  year = "2023",
+  doi = "10.1103/PhysRevX.13.041039",
+  eprint = "2111.03606",
+  archivePrefix = "arXiv"
+}`
+  }
+};
+function generateParametersJSON(event) {
+  const type = classifyEvent(event);
+  const energyRadiated = event.total_mass_source - event.final_mass_source;
+  const params = {
+    event: event.commonName,
+    catalog: event.catalog_shortName,
+    type,
+    gps_time: event.GPS,
+    mass_1_source: {
+      value: event.mass_1_source,
+      lower: event.mass_1_source_lower,
+      upper: event.mass_1_source_upper,
+      unit: "M_sun"
+    },
+    mass_2_source: {
+      value: event.mass_2_source,
+      lower: event.mass_2_source_lower,
+      upper: event.mass_2_source_upper,
+      unit: "M_sun"
+    },
+    total_mass_source: { value: event.total_mass_source, unit: "M_sun" },
+    chirp_mass_source: {
+      value: event.chirp_mass_source,
+      lower: event.chirp_mass_source_lower,
+      upper: event.chirp_mass_source_upper,
+      unit: "M_sun"
+    },
+    final_mass_source: {
+      value: event.final_mass_source,
+      lower: event.final_mass_source_lower,
+      upper: event.final_mass_source_upper,
+      unit: "M_sun"
+    },
+    energy_radiated: { value: energyRadiated, unit: "M_sun_c2" },
+    luminosity_distance: {
+      value: event.luminosity_distance,
+      lower: event.luminosity_distance_lower,
+      upper: event.luminosity_distance_upper,
+      unit: "Mpc"
+    },
+    redshift: event.redshift,
+    chi_eff: event.chi_eff,
+    network_snr: event.network_matched_filter_snr,
+    false_alarm_rate: event.far,
+    p_astro: event.p_astro,
+    source: "GWOSC (https://gwosc.org)",
+    exported_by: "WarpLab (https://warplab.app)"
+  };
+  return JSON.stringify(params, null, 2);
+}
+function generateParametersCSV(event) {
+  const type = classifyEvent(event);
+  const energyRadiated = event.total_mass_source - event.final_mass_source;
+  const headers = ["parameter", "value", "lower_90", "upper_90", "unit"];
+  const rows = [
+    ["event_name", event.commonName, "", "", ""],
+    ["catalog", event.catalog_shortName, "", "", ""],
+    ["type", type, "", "", ""],
+    ["gps_time", event.GPS, "", "", "s"],
+    ["mass_1_source", event.mass_1_source, event.mass_1_source_lower, event.mass_1_source_upper, "M_sun"],
+    ["mass_2_source", event.mass_2_source, event.mass_2_source_lower, event.mass_2_source_upper, "M_sun"],
+    ["total_mass_source", event.total_mass_source, "", "", "M_sun"],
+    ["chirp_mass_source", event.chirp_mass_source, event.chirp_mass_source_lower, event.chirp_mass_source_upper, "M_sun"],
+    ["final_mass_source", event.final_mass_source, event.final_mass_source_lower, event.final_mass_source_upper, "M_sun"],
+    ["energy_radiated", energyRadiated, "", "", "M_sun_c2"],
+    ["luminosity_distance", event.luminosity_distance, event.luminosity_distance_lower, event.luminosity_distance_upper, "Mpc"],
+    ["redshift", event.redshift, "", "", ""],
+    ["chi_eff", event.chi_eff, "", "", ""],
+    ["network_snr", event.network_matched_filter_snr, "", "", ""],
+    ["false_alarm_rate", event.far, "", "", "Hz"],
+    ["p_astro", event.p_astro, "", "", ""]
+  ];
+  return [headers.join(","), ...rows.map((r) => r.join(","))].join("\n");
+}
+function generateWaveformCSV(waveform) {
+  const headers = ["time_s", "h_plus", "h_cross"];
+  const lines = [headers.join(",")];
+  const dt = 1 / waveform.sampleRate;
+  for (let i = 0; i < waveform.hPlus.length; i++) {
+    const t = (i * dt).toFixed(6);
+    lines.push(`${t},${waveform.hPlus[i].toExponential(8)},${waveform.hCross[i].toExponential(8)}`);
+  }
+  return lines.join("\n");
+}
+function generateBibTeX(event) {
+  const entries = [];
+  entries.push(`@misc{GWOSC,
+  author = "{LIGO Scientific Collaboration and Virgo Collaboration and KAGRA Collaboration}",
+  title = "{Gravitational Wave Open Science Center}",
+  howpublished = "\\url{https://gwosc.org}",
+  year = "2023",
+  note = "Event: ${event.commonName}"
+}`);
+  const catalog = event.catalog_shortName;
+  const paper = CATALOG_PAPERS[catalog];
+  if (paper) {
+    entries.push(paper.entry);
+  }
+  entries.push(`@misc{WarpLab,
+  author = "{Canton, Daniel}",
+  title = "{WarpLab: Interactive Gravitational Wave Visualizer}",
+  howpublished = "\\url{https://warplab.app}",
+  year = "2025"
+}`);
+  return entries.join("\n\n");
+}
+function generateNotebook(event) {
+  const type = classifyEvent(event);
+  const gps = event.GPS;
+  const eventName = event.commonName;
+  const notebook = {
+    nbformat: 4,
+    nbformat_minor: 5,
+    metadata: {
+      kernelspec: {
+        display_name: "Python 3",
+        language: "python",
+        name: "python3"
+      },
+      language_info: {
+        name: "python",
+        version: "3.10.0"
+      }
+    },
+    cells: [
+      {
+        cell_type: "markdown",
+        metadata: {},
+        source: [
+          `# ${eventName} \u2014 Gravitational Wave Analysis
+`,
+          `
+`,
+          `**Type:** ${type}  
+`,
+          `**Masses:** ${event.mass_1_source.toFixed(1)} + ${event.mass_2_source.toFixed(1)} M\u2609  
+`,
+          `**Distance:** ${event.luminosity_distance.toFixed(0)} Mpc  
+`,
+          `**Catalog:** ${event.catalog_shortName}  
+`,
+          `**GPS Time:** ${gps}  
+`,
+          `
+`,
+          `This notebook fetches real detector strain from [GWOSC](https://gwosc.org) and reproduces the spectrogram and template overlay.
+`,
+          `
+`,
+          `*Exported from [WarpLab](https://warplab.app)*`
+        ]
+      },
+      {
+        cell_type: "markdown",
+        metadata: {},
+        source: ["## 1. Setup\n", "Install required packages if needed."]
+      },
+      {
+        cell_type: "code",
+        metadata: {},
+        source: [
+          `# Install dependencies (uncomment if needed)
+`,
+          `# !pip install gwosc gwpy matplotlib numpy
+`,
+          `
+`,
+          `import numpy as np
+`,
+          `import matplotlib.pyplot as plt
+`,
+          `from gwpy.timeseries import TimeSeries
+`,
+          `from gwosc.datasets import event_gps
+`,
+          `
+`,
+          `EVENT = "${eventName}"
+`,
+          `GPS = ${gps}
+`,
+          `DETECTOR = "H1"  # Change to "L1" or "V1" for other detectors`
+        ],
+        execution_count: null,
+        outputs: []
+      },
+      {
+        cell_type: "markdown",
+        metadata: {},
+        source: [
+          "## 2. Fetch strain data from GWOSC\n",
+          "Download 32 seconds of strain centered on the event."
+        ]
+      },
+      {
+        cell_type: "code",
+        metadata: {},
+        source: [
+          `# Fetch 32s of strain data centered on the event
+`,
+          `strain = TimeSeries.fetch_open_data(
+`,
+          `    DETECTOR, GPS - 16, GPS + 16,
+`,
+          `    cache=True
+`,
+          `)
+`,
+          `print(f"Sample rate: {strain.sample_rate}")
+`,
+          `print(f"Duration: {strain.duration}")`
+        ],
+        execution_count: null,
+        outputs: []
+      },
+      {
+        cell_type: "markdown",
+        metadata: {},
+        source: [
+          "## 3. Q-transform spectrogram\n",
+          "Compute and plot the time-frequency spectrogram using a Q-transform."
+        ]
+      },
+      {
+        cell_type: "code",
+        metadata: {},
+        source: [
+          `# Compute Q-transform spectrogram
+`,
+          `dt = 1  # seconds around merger to plot
+`,
+          `qgram = strain.q_transform(
+`,
+          `    outseg=(GPS - dt, GPS + dt),
+`,
+          `    qrange=(4, 64),
+`,
+          `    frange=(20, 1024),
+`,
+          `    logf=True
+`,
+          `)
+`,
+          `
+`,
+          `fig, ax = plt.subplots(figsize=(10, 5))
+`,
+          `ax.imshow(qgram.T, origin="lower", aspect="auto",
+`,
+          `          extent=[qgram.x0.value, (qgram.x0 + qgram.dx * qgram.shape[0]).value,
+`,
+          `                  qgram.y0.value, (qgram.y0 + qgram.dy * qgram.shape[1]).value])
+`,
+          `ax.set_xlabel("Time [s]")
+`,
+          `ax.set_ylabel("Frequency [Hz]")
+`,
+          `ax.set_title(f"{EVENT} \u2014 Q-transform ({DETECTOR})")
+`,
+          `ax.set_yscale("log")
+`,
+          `plt.colorbar(ax.images[0], label="Normalized energy")
+`,
+          `plt.tight_layout()
+`,
+          `plt.show()`
+        ],
+        execution_count: null,
+        outputs: []
+      },
+      {
+        cell_type: "markdown",
+        metadata: {},
+        source: [
+          "## 4. Whitened strain and template overlay\n",
+          "Bandpass and whiten the data, then overlay the included waveform template."
+        ]
+      },
+      {
+        cell_type: "code",
+        metadata: {},
+        source: [
+          `# Bandpass filter and whiten
+`,
+          `white = strain.whiten(4, 2).bandpass(30, 400)
+`,
+          `
+`,
+          `# Load the template waveform from the exported CSV
+`,
+          `import os
+`,
+          `template_file = os.path.join(
+`,
+          `    os.path.dirname(os.path.abspath("__file__")),
+`,
+          `    "waveform_template.csv"
+`,
+          `)
+`,
+          `
+`,
+          `fig, ax = plt.subplots(figsize=(10, 4))
+`,
+          `
+`,
+          `# Plot whitened strain around merger
+`,
+          `t = white.times.value - GPS
+`,
+          `mask = (t > -0.5) & (t < 0.2)
+`,
+          `ax.plot(t[mask], white.value[mask], label=f"{DETECTOR} whitened", alpha=0.8)
+`,
+          `
+`,
+          `# Overlay template if available
+`,
+          `if os.path.exists(template_file):
+`,
+          `    template = np.genfromtxt(template_file, delimiter=",",
+`,
+          `                             names=True, dtype=None, encoding="utf-8")
+`,
+          `    t_templ = template["time_s"]
+`,
+          `    h_templ = template["h_plus"]
+`,
+          `    # Center template on t=0 at peak
+`,
+          `    peak_idx = np.argmax(np.abs(h_templ))
+`,
+          `    t_templ = t_templ - t_templ[peak_idx]
+`,
+          `    # Scale template to match whitened strain amplitude
+`,
+          `    scale = np.max(np.abs(white.value[mask])) / np.max(np.abs(h_templ))
+`,
+          `    ax.plot(t_templ, h_templ * scale, "--", label="Template (h+)",
+`,
+          `            alpha=0.7, color="tab:orange")
+`,
+          `
+`,
+          `ax.set_xlabel("Time relative to merger [s]")
+`,
+          `ax.set_ylabel("Strain (whitened)")
+`,
+          `ax.set_title(f"{EVENT} \u2014 Whitened strain with template overlay")
+`,
+          `ax.legend()
+`,
+          `plt.tight_layout()
+`,
+          `plt.show()`
+        ],
+        execution_count: null,
+        outputs: []
+      },
+      {
+        cell_type: "markdown",
+        metadata: {},
+        source: [
+          "## 5. Event parameters\n",
+          "Summary of parameters from the GWTC catalog."
+        ]
+      },
+      {
+        cell_type: "code",
+        metadata: {},
+        source: [
+          `# Event parameters from ${event.catalog_shortName}
+`,
+          `params = {
+`,
+          `    "Event": "${eventName}",
+`,
+          `    "Type": "${type}",
+`,
+          `    "m1 [M\u2609]": ${event.mass_1_source.toFixed(2)},
+`,
+          `    "m2 [M\u2609]": ${event.mass_2_source.toFixed(2)},
+`,
+          `    "M_total [M\u2609]": ${event.total_mass_source.toFixed(2)},
+`,
+          `    "M_chirp [M\u2609]": ${event.chirp_mass_source.toFixed(2)},
+`,
+          `    "M_final [M\u2609]": ${event.final_mass_source.toFixed(2)},
+`,
+          `    "Distance [Mpc]": ${event.luminosity_distance.toFixed(1)},
+`,
+          `    "Redshift": ${event.redshift.toFixed(4)},
+`,
+          `    "\u03C7_eff": ${event.chi_eff.toFixed(3)},
+`,
+          `    "SNR": ${event.network_matched_filter_snr.toFixed(1)},
+`,
+          `    "p_astro": ${event.p_astro.toFixed(4)},
+`,
+          `}
+`,
+          `
+`,
+          `for k, v in params.items():
+`,
+          `    print(f"{k:20s} {v}")`
+        ],
+        execution_count: null,
+        outputs: []
+      }
+    ]
+  };
+  return JSON.stringify(notebook, null, 1);
+}
+function generateREADME(event) {
+  const type = classifyEvent(event);
+  return `# ${event.commonName} \u2014 Data Export
+
+Type: ${type}
+Masses: ${event.mass_1_source.toFixed(1)} + ${event.mass_2_source.toFixed(1)} M\u2609
+Distance: ${event.luminosity_distance.toFixed(0)} Mpc
+Catalog: ${event.catalog_shortName}
+
+## Files
+
+- **parameters.json** \u2014 Full event parameters with uncertainties (JSON)
+- **parameters.csv** \u2014 Same parameters in tabular CSV format
+- **waveform_template.csv** \u2014 Synthetic IMRPhenom waveform: h+(t) and h\xD7(t) arrays
+- **notebook.ipynb** \u2014 Jupyter notebook that fetches real strain from GWOSC and reproduces the analysis
+- **CITATION.bib** \u2014 BibTeX citations for GWOSC, the catalog paper, and WarpLab
+
+## Using the notebook
+
+1. Install dependencies: \`pip install gwosc gwpy matplotlib numpy\`
+2. Open \`notebook.ipynb\` in JupyterLab or VS Code
+3. Run all cells \u2014 it will download real detector strain from GWOSC
+4. The notebook produces a Q-transform spectrogram and a whitened strain plot with the template overlay
+
+## Data source
+
+All parameters are from the Gravitational Wave Open Science Center (GWOSC):
+https://gwosc.org
+
+The waveform template is a simplified IMRPhenom analytical approximation generated by WarpLab.
+It is NOT a full numerical relativity waveform. For research use, fetch real strain from GWOSC.
+
+## Citation
+
+If you use this data in academic work, please cite the sources in CITATION.bib.
+
+---
+Exported from WarpLab (https://warplab.app)
+`;
+}
+
+// server/mcp.ts
+var server = new McpServer({
+  name: "warplab",
+  version: "1.0.0"
+});
+var catalogCache = null;
+async function getCatalog() {
+  if (!catalogCache) catalogCache = await fetchEventCatalog();
+  return catalogCache;
+}
+function findEvent(catalog, name) {
+  const lower = name.toLowerCase();
+  return catalog.find((e) => e.commonName.toLowerCase() === lower);
+}
+server.tool(
+  "search_events",
+  "Search and filter the gravitational wave event catalog from GWOSC",
+  {
+    type: z.enum(["BBH", "BNS", "NSBH"]).optional().describe("Filter by event type"),
+    mass_min: z.number().optional().describe("Minimum total mass in solar masses"),
+    mass_max: z.number().optional().describe("Maximum total mass in solar masses"),
+    distance_max: z.number().optional().describe("Maximum luminosity distance in Mpc"),
+    snr_min: z.number().optional().describe("Minimum network SNR"),
+    catalog: z.string().optional().describe("Filter by catalog (e.g. GWTC-3-confident)"),
+    limit: z.number().optional().default(20).describe("Max results (default 20)")
+  },
+  async (params) => {
+    const catalog = await getCatalog();
+    let results = catalog;
+    if (params.type) {
+      results = results.filter((e) => classifyEvent(e) === params.type);
+    }
+    if (params.mass_min != null) {
+      results = results.filter((e) => e.total_mass_source >= params.mass_min);
+    }
+    if (params.mass_max != null) {
+      results = results.filter((e) => e.total_mass_source <= params.mass_max);
+    }
+    if (params.distance_max != null) {
+      results = results.filter((e) => e.luminosity_distance <= params.distance_max);
+    }
+    if (params.snr_min != null) {
+      results = results.filter((e) => e.network_matched_filter_snr >= params.snr_min);
+    }
+    if (params.catalog) {
+      const cat = params.catalog.toLowerCase();
+      results = results.filter((e) => e.catalog_shortName.toLowerCase().includes(cat));
+    }
+    const limited = results.slice(0, params.limit);
+    const summary = limited.map((e) => ({
+      name: e.commonName,
+      type: classifyEvent(e),
+      m1: e.mass_1_source,
+      m2: e.mass_2_source,
+      total_mass: e.total_mass_source,
+      distance_Mpc: e.luminosity_distance,
+      snr: e.network_matched_filter_snr,
+      catalog: e.catalog_shortName
+    }));
+    return {
+      content: [{
+        type: "text",
+        text: `Found ${results.length} events (showing ${limited.length}):
+
+${JSON.stringify(summary, null, 2)}`
+      }]
+    };
+  }
+);
+server.tool(
+  "get_event",
+  "Get full parameters for a specific gravitational wave event",
+  {
+    name: z.string().describe("Event name (e.g. GW150914, GW170817)")
+  },
+  async (params) => {
+    const catalog = await getCatalog();
+    const event = findEvent(catalog, params.name);
+    if (!event) {
+      return { content: [{ type: "text", text: `Event "${params.name}" not found in catalog.` }] };
+    }
+    const mm = getMultiMessengerData(event.commonName);
+    const result = {
+      name: event.commonName,
+      type: classifyEvent(event),
+      catalog: event.catalog_shortName,
+      gps_time: event.GPS,
+      mass_1: { value: event.mass_1_source, lower: event.mass_1_source_lower, upper: event.mass_1_source_upper, unit: "M_sun" },
+      mass_2: { value: event.mass_2_source, lower: event.mass_2_source_lower, upper: event.mass_2_source_upper, unit: "M_sun" },
+      total_mass: event.total_mass_source,
+      chirp_mass: { value: event.chirp_mass_source, lower: event.chirp_mass_source_lower, upper: event.chirp_mass_source_upper, unit: "M_sun" },
+      final_mass: { value: event.final_mass_source, lower: event.final_mass_source_lower, upper: event.final_mass_source_upper, unit: "M_sun" },
+      distance: { value: event.luminosity_distance, lower: event.luminosity_distance_lower, upper: event.luminosity_distance_upper, unit: "Mpc" },
+      redshift: event.redshift,
+      chi_eff: event.chi_eff,
+      snr: event.network_matched_filter_snr,
+      false_alarm_rate: event.far,
+      p_astro: event.p_astro
+    };
+    if (mm) {
+      result.multi_messenger = {
+        em_counterparts: mm.emCounterparts.map((c) => ({
+          name: c.name,
+          type: c.type,
+          delay_seconds: c.delaySeconds,
+          observatory: c.observatory
+        })),
+        host_galaxy: mm.hostGalaxy,
+        h0_measurement: mm.h0Measurement,
+        ejecta_mass: mm.ejectaMass
+      };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+server.tool(
+  "generate_waveform",
+  "Generate a synthetic gravitational waveform (h+ and hx time series)",
+  {
+    event_name: z.string().optional().describe("Generate waveform for a catalog event"),
+    m1: z.number().optional().describe("Primary mass in solar masses (for custom waveform)"),
+    m2: z.number().optional().describe("Secondary mass in solar masses (for custom waveform)"),
+    chi1: z.number().optional().default(0).describe("Primary spin (-1 to 1)"),
+    chi2: z.number().optional().default(0).describe("Secondary spin (-1 to 1)"),
+    distance: z.number().optional().default(100).describe("Distance in Mpc"),
+    inclination: z.number().optional().default(0).describe("Inclination in radians"),
+    format: z.enum(["json", "csv"]).optional().default("json").describe("Output format")
+  },
+  async (params) => {
+    let waveform;
+    if (params.event_name) {
+      const catalog = await getCatalog();
+      const event = findEvent(catalog, params.event_name);
+      if (!event) {
+        return { content: [{ type: "text", text: `Event "${params.event_name}" not found.` }] };
+      }
+      waveform = generateWaveform(event);
+    } else if (params.m1 != null && params.m2 != null) {
+      waveform = generateCustomWaveform({
+        m1: params.m1,
+        m2: params.m2,
+        chi1: params.chi1 ?? 0,
+        chi2: params.chi2 ?? 0,
+        distance: params.distance ?? 100,
+        inclination: params.inclination ?? 0
+      });
+    } else {
+      return { content: [{ type: "text", text: "Provide either event_name or m1+m2 for custom waveform." }] };
+    }
+    if (params.format === "csv") {
+      return { content: [{ type: "text", text: generateWaveformCSV(waveform) }] };
+    }
+    const step = Math.max(1, Math.floor(waveform.hPlus.length / 200));
+    const sampled = {
+      event: waveform.eventName,
+      sample_rate: waveform.sampleRate,
+      duration: waveform.duration,
+      peak_index: waveform.peakIndex,
+      num_samples: waveform.hPlus.length,
+      note: step > 1 ? `Downsampled by ${step}x for display. Use format=csv for full data.` : void 0,
+      h_plus: waveform.hPlus.filter((_, i) => i % step === 0).map((v) => +v.toFixed(6)),
+      h_cross: waveform.hCross.filter((_, i) => i % step === 0).map((v) => +v.toFixed(6))
+    };
+    return { content: [{ type: "text", text: JSON.stringify(sampled, null, 2) }] };
+  }
+);
+server.tool(
+  "compute_qnm",
+  "Compute quasi-normal mode frequencies for a black hole merger remnant",
+  {
+    m1: z.number().describe("Primary mass in solar masses"),
+    m2: z.number().describe("Secondary mass in solar masses"),
+    chi1: z.number().optional().default(0).describe("Primary spin"),
+    chi2: z.number().optional().default(0).describe("Secondary spin"),
+    modes: z.array(z.string()).optional().default(["2,2,0", "2,2,1"]).describe("QNM modes to compute (e.g. ['2,2,0'])")
+  },
+  async (params) => {
+    const results = computeQNMModes(params.m1, params.m2, params.chi1, params.chi2, params.modes);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          input: { m1: params.m1, m2: params.m2, chi1: params.chi1, chi2: params.chi2 },
+          modes: results.map((m) => ({
+            mode: m.label,
+            frequency_Hz: +m.frequency.toFixed(2),
+            damping_time_ms: +(m.dampingTime * 1e3).toFixed(3),
+            quality_factor: +m.qualityFactor.toFixed(2)
+          }))
+        }, null, 2)
+      }]
+    };
+  }
+);
+server.tool(
+  "compute_snr",
+  "Compute optimal matched-filter SNR against aLIGO design sensitivity",
+  {
+    event_name: z.string().optional().describe("Compute SNR for a catalog event"),
+    m1: z.number().optional().describe("Primary mass (for custom)"),
+    m2: z.number().optional().describe("Secondary mass (for custom)"),
+    distance: z.number().optional().default(100).describe("Distance in Mpc (for custom)")
+  },
+  async (params) => {
+    let waveform;
+    if (params.event_name) {
+      const catalog = await getCatalog();
+      const event = findEvent(catalog, params.event_name);
+      if (!event) {
+        return { content: [{ type: "text", text: `Event "${params.event_name}" not found.` }] };
+      }
+      waveform = generateWaveform(event);
+    } else if (params.m1 != null && params.m2 != null) {
+      waveform = generateCustomWaveform({
+        m1: params.m1,
+        m2: params.m2,
+        chi1: 0,
+        chi2: 0,
+        distance: params.distance ?? 100,
+        inclination: 0
+      });
+    } else {
+      return { content: [{ type: "text", text: "Provide event_name or m1+m2." }] };
+    }
+    const strain = computeCharacteristicStrain(waveform);
+    const snr = computeOptimalSNR(strain);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          event: waveform.eventName,
+          optimal_snr: +snr.toFixed(2),
+          note: "SNR computed against aLIGO O4 design sensitivity (10-5000 Hz band)"
+        }, null, 2)
+      }]
+    };
+  }
+);
+server.tool(
+  "get_population_stats",
+  "Get population statistics from the gravitational wave catalog",
+  {
+    stat: z.enum(["mass", "chirp_mass", "spin", "distance", "type_counts"]).describe("Which statistic to compute")
+  },
+  async (params) => {
+    const catalog = await getCatalog();
+    if (params.stat === "type_counts") {
+      const counts = { BBH: 0, BNS: 0, NSBH: 0 };
+      for (const e of catalog) {
+        const t = classifyEvent(e);
+        if (t in counts) counts[t]++;
+      }
+      return { content: [{ type: "text", text: JSON.stringify({ total: catalog.length, ...counts }, null, 2) }] };
+    }
+    if (params.stat === "mass") {
+      const masses = catalog.map((e) => ({ name: e.commonName, m1: e.mass_1_source, m2: e.mass_2_source, total: e.total_mass_source }));
+      const totalMasses = masses.map((m) => m.total).filter((m) => m > 0);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            count: totalMasses.length,
+            min_total_mass: +Math.min(...totalMasses).toFixed(1),
+            max_total_mass: +Math.max(...totalMasses).toFixed(1),
+            median_total_mass: +totalMasses.sort((a, b) => a - b)[Math.floor(totalMasses.length / 2)].toFixed(1),
+            heaviest_events: masses.sort((a, b) => b.total - a.total).slice(0, 5)
+          }, null, 2)
+        }]
+      };
+    }
+    if (params.stat === "chirp_mass") {
+      const mc = catalog.map((e) => e.chirp_mass_source).filter((m) => m > 0);
+      mc.sort((a, b) => a - b);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            count: mc.length,
+            min: +mc[0].toFixed(2),
+            max: +mc[mc.length - 1].toFixed(2),
+            median: +mc[Math.floor(mc.length / 2)].toFixed(2),
+            p10: +mc[Math.floor(mc.length * 0.1)].toFixed(2),
+            p90: +mc[Math.floor(mc.length * 0.9)].toFixed(2)
+          }, null, 2)
+        }]
+      };
+    }
+    if (params.stat === "spin") {
+      const spins = catalog.map((e) => e.chi_eff).filter((s) => s !== 0 || true);
+      spins.sort((a, b) => a - b);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            count: spins.length,
+            min_chi_eff: +spins[0].toFixed(3),
+            max_chi_eff: +spins[spins.length - 1].toFixed(3),
+            median_chi_eff: +spins[Math.floor(spins.length / 2)].toFixed(3),
+            note: "chi_eff is the mass-weighted effective spin parameter"
+          }, null, 2)
+        }]
+      };
+    }
+    if (params.stat === "distance") {
+      const dists = catalog.map((e) => e.luminosity_distance).filter((d) => d > 0);
+      dists.sort((a, b) => a - b);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            count: dists.length,
+            min_Mpc: +dists[0].toFixed(0),
+            max_Mpc: +dists[dists.length - 1].toFixed(0),
+            median_Mpc: +dists[Math.floor(dists.length / 2)].toFixed(0),
+            nearest_events: catalog.filter((e) => e.luminosity_distance > 0).sort((a, b) => a.luminosity_distance - b.luminosity_distance).slice(0, 5).map((e) => ({ name: e.commonName, distance_Mpc: e.luminosity_distance }))
+          }, null, 2)
+        }]
+      };
+    }
+    return { content: [{ type: "text", text: "Unknown stat type." }] };
+  }
+);
+server.tool(
+  "integrate_geodesic",
+  "Trace a photon or particle geodesic around a Schwarzschild black hole",
+  {
+    start_r: z.number().describe("Starting radial distance (in units of Schwarzschild radius)"),
+    start_angle: z.number().optional().default(0).describe("Starting angle in radians"),
+    velocity_angle: z.number().optional().default(Math.PI / 2).describe("Initial velocity direction angle"),
+    schwarzschild_radius: z.number().optional().default(2).describe("Schwarzschild radius"),
+    particle_type: z.enum(["photon", "particle"]).optional().default("photon"),
+    energy: z.number().optional().default(1).describe("Specific energy for massive particles"),
+    max_points: z.number().optional().default(200).describe("Max output points")
+  },
+  async (params) => {
+    const rs = params.schwarzschild_radius ?? 2;
+    const r0 = params.start_r * rs;
+    const angle = params.start_angle ?? 0;
+    const startPos = new Vec3(r0 * Math.cos(angle), 0, r0 * Math.sin(angle));
+    const va = params.velocity_angle ?? Math.PI / 2;
+    const startVel = new Vec3(Math.cos(va), 0, Math.sin(va));
+    let result;
+    if (params.particle_type === "particle") {
+      result = integrateTimelikeGeodesic(startPos, startVel, rs, params.energy ?? 1);
+    } else {
+      result = integrateGeodesic(startPos, startVel, rs);
+    }
+    const step = Math.max(1, Math.floor(result.points.length / (params.max_points ?? 200)));
+    const points = result.points.filter((_, i) => i % step === 0).map((p) => ({ x: +p.x.toFixed(4), y: +p.y.toFixed(4), z: +p.z.toFixed(4) }));
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          outcome: result.outcome,
+          angular_momentum: +result.L.toFixed(4),
+          particle_type: result.particleType,
+          num_points: result.points.length,
+          points_shown: points.length,
+          trajectory: points
+        }, null, 2)
+      }]
+    };
+  }
+);
+server.tool(
+  "export_event",
+  "Generate event data in various formats (JSON, CSV, BibTeX, Jupyter notebook)",
+  {
+    event_name: z.string().describe("Event name"),
+    format: z.enum(["json", "csv", "bibtex", "notebook", "readme", "waveform_csv"]).describe("Export format")
+  },
+  async (params) => {
+    const catalog = await getCatalog();
+    const event = findEvent(catalog, params.event_name);
+    if (!event) {
+      return { content: [{ type: "text", text: `Event "${params.event_name}" not found.` }] };
+    }
+    let output;
+    switch (params.format) {
+      case "json":
+        output = generateParametersJSON(event);
+        break;
+      case "csv":
+        output = generateParametersCSV(event);
+        break;
+      case "bibtex":
+        output = generateBibTeX(event);
+        break;
+      case "notebook":
+        output = generateNotebook(event);
+        break;
+      case "readme":
+        output = generateREADME(event);
+        break;
+      case "waveform_csv": {
+        const wf = generateWaveform(event);
+        output = generateWaveformCSV(wf);
+        break;
+      }
+    }
+    return { content: [{ type: "text", text: output }] };
+  }
+);
+var transport = new StdioServerTransport();
+await server.connect(transport);