warplab 1.0.0

package/dist-server/cli.js

@@ -0,0 +1,1276 @@
+#!/usr/bin/env node
+
+// 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 z = 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 }
+    };
+    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/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"
+  }
+};
+
+// 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/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function flag(name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx === -1) return void 0;
+  return args[idx + 1];
+}
+function hasFlag(name) {
+  return args.includes(`--${name}`);
+}
+var catalogCache = null;
+async function getCatalog() {
+  if (!catalogCache) {
+    process.stderr.write("Fetching catalog from GWOSC...\n");
+    catalogCache = await fetchEventCatalog();
+    process.stderr.write(`Loaded ${catalogCache.length} events.
+`);
+  }
+  return catalogCache;
+}
+function findEvent(catalog, name) {
+  const lower = name.toLowerCase();
+  return catalog.find((e) => e.commonName.toLowerCase() === lower);
+}
+function printJSON(obj) {
+  console.log(JSON.stringify(obj, null, 2));
+}
+async function main() {
+  if (!command || command === "help" || command === "--help") {
+    console.log(`WarpLab CLI \u2014 Gravitational Wave Physics Tools
+
+Usage: warplab <command> [options]
+
+Commands:
+  search    Search events [--type BBH|BNS|NSBH] [--mass-min N] [--mass-max N] [--snr-min N] [--limit N]
+  info      Get event details <event-name>
+  waveform  Generate waveform <event-name> | --m1 N --m2 N [--format json|csv]
+  qnm       Compute QNM frequencies <event-name> | --m1 N --m2 N
+  snr       Compute optimal SNR <event-name> | --m1 N --m2 N
+  export    Export event data <event-name> [--format json|csv|bibtex|notebook|readme|waveform]
+  stats     Population statistics [--stat mass|chirp_mass|spin|distance|type_counts]
+  help      Show this help
+`);
+    return;
+  }
+  if (command === "search") {
+    const catalog = await getCatalog();
+    let results = catalog;
+    const type = flag("type");
+    if (type) results = results.filter((e) => classifyEvent(e) === type);
+    const massMin = flag("mass-min");
+    if (massMin) results = results.filter((e) => e.total_mass_source >= +massMin);
+    const massMax = flag("mass-max");
+    if (massMax) results = results.filter((e) => e.total_mass_source <= +massMax);
+    const snrMin = flag("snr-min");
+    if (snrMin) results = results.filter((e) => e.network_matched_filter_snr >= +snrMin);
+    const limit = +(flag("limit") ?? "20");
+    const limited = results.slice(0, limit);
+    if (hasFlag("table")) {
+      console.log("Name              Type  m1      m2      Dist(Mpc)  SNR");
+      console.log("\u2500".repeat(65));
+      for (const e of limited) {
+        console.log(
+          `${e.commonName.padEnd(18)}${classifyEvent(e).padEnd(6)}${e.mass_1_source.toFixed(1).padStart(6)}  ${e.mass_2_source.toFixed(1).padStart(6)}  ${e.luminosity_distance.toFixed(0).padStart(9)}  ${e.network_matched_filter_snr.toFixed(1).padStart(5)}`
+        );
+      }
+      console.log(`
+${results.length} total, ${limited.length} shown`);
+    } else {
+      printJSON(limited.map((e) => ({
+        name: e.commonName,
+        type: classifyEvent(e),
+        m1: e.mass_1_source,
+        m2: e.mass_2_source,
+        distance_Mpc: e.luminosity_distance,
+        snr: e.network_matched_filter_snr
+      })));
+    }
+    return;
+  }
+  if (command === "info") {
+    const name = args[1];
+    if (!name) {
+      console.error("Usage: warplab info <event-name>");
+      process.exit(1);
+    }
+    const catalog = await getCatalog();
+    const event = findEvent(catalog, name);
+    if (!event) {
+      console.error(`Event "${name}" not found.`);
+      process.exit(1);
+    }
+    printJSON({
+      name: event.commonName,
+      type: classifyEvent(event),
+      catalog: event.catalog_shortName,
+      m1: event.mass_1_source,
+      m2: event.mass_2_source,
+      total_mass: event.total_mass_source,
+      chirp_mass: event.chirp_mass_source,
+      final_mass: event.final_mass_source,
+      distance_Mpc: event.luminosity_distance,
+      redshift: event.redshift,
+      chi_eff: event.chi_eff,
+      snr: event.network_matched_filter_snr,
+      p_astro: event.p_astro
+    });
+    return;
+  }
+  if (command === "waveform") {
+    const format = flag("format") ?? "json";
+    let waveform;
+    if (args[1] && !args[1].startsWith("--")) {
+      const catalog = await getCatalog();
+      const event = findEvent(catalog, args[1]);
+      if (!event) {
+        console.error(`Event "${args[1]}" not found.`);
+        process.exit(1);
+      }
+      waveform = generateWaveform(event);
+    } else {
+      const m1 = flag("m1");
+      const m2 = flag("m2");
+      if (!m1 || !m2) {
+        console.error("Usage: warplab waveform <event> OR --m1 N --m2 N");
+        process.exit(1);
+      }
+      waveform = generateCustomWaveform({
+        m1: +m1,
+        m2: +m2,
+        chi1: +(flag("chi1") ?? "0"),
+        chi2: +(flag("chi2") ?? "0"),
+        distance: +(flag("distance") ?? "100"),
+        inclination: +(flag("inclination") ?? "0")
+      });
+    }
+    if (format === "csv") {
+      console.log(generateWaveformCSV(waveform));
+    } else {
+      printJSON({
+        event: waveform.eventName,
+        sample_rate: waveform.sampleRate,
+        duration: waveform.duration,
+        num_samples: waveform.hPlus.length
+      });
+    }
+    return;
+  }
+  if (command === "qnm") {
+    let m1, m2, chi1 = 0, chi2 = 0;
+    if (args[1] && !args[1].startsWith("--")) {
+      const catalog = await getCatalog();
+      const event = findEvent(catalog, args[1]);
+      if (!event) {
+        console.error(`Event "${args[1]}" not found.`);
+        process.exit(1);
+      }
+      m1 = event.mass_1_source;
+      m2 = event.mass_2_source;
+      chi1 = event.chi_eff * (m1 + m2) / (2 * m1);
+    } else {
+      if (!flag("m1") || !flag("m2")) {
+        console.error("Usage: warplab qnm <event> OR --m1 N --m2 N");
+        process.exit(1);
+      }
+      m1 = +flag("m1");
+      m2 = +flag("m2");
+      chi1 = +(flag("chi1") ?? "0");
+      chi2 = +(flag("chi2") ?? "0");
+    }
+    const modes = computeQNMModes(m1, m2, chi1, chi2);
+    printJSON(modes.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)
+    })));
+    return;
+  }
+  if (command === "snr") {
+    let waveform;
+    if (args[1] && !args[1].startsWith("--")) {
+      const catalog = await getCatalog();
+      const event = findEvent(catalog, args[1]);
+      if (!event) {
+        console.error(`Event "${args[1]}" not found.`);
+        process.exit(1);
+      }
+      waveform = generateWaveform(event);
+    } else {
+      if (!flag("m1") || !flag("m2")) {
+        console.error("Usage: warplab snr <event> OR --m1 N --m2 N");
+        process.exit(1);
+      }
+      waveform = generateCustomWaveform({
+        m1: +flag("m1"),
+        m2: +flag("m2"),
+        chi1: 0,
+        chi2: 0,
+        distance: +(flag("distance") ?? "100"),
+        inclination: 0
+      });
+    }
+    const strain = computeCharacteristicStrain(waveform);
+    const snr = computeOptimalSNR(strain);
+    printJSON({ event: waveform.eventName, optimal_snr: +snr.toFixed(2) });
+    return;
+  }
+  if (command === "export") {
+    const name = args[1];
+    if (!name) {
+      console.error("Usage: warplab export <event-name> [--format json|csv|bibtex|notebook|readme|waveform]");
+      process.exit(1);
+    }
+    const catalog = await getCatalog();
+    const event = findEvent(catalog, name);
+    if (!event) {
+      console.error(`Event "${name}" not found.`);
+      process.exit(1);
+    }
+    const format = flag("format") ?? "json";
+    switch (format) {
+      case "json":
+        console.log(generateParametersJSON(event));
+        break;
+      case "csv":
+        console.log(generateParametersCSV(event));
+        break;
+      case "bibtex":
+        console.log(generateBibTeX(event));
+        break;
+      case "notebook":
+        console.log(generateNotebook(event));
+        break;
+      case "readme":
+        console.log(generateREADME(event));
+        break;
+      case "waveform":
+        console.log(generateWaveformCSV(generateWaveform(event)));
+        break;
+      default:
+        console.error(`Unknown format: ${format}`);
+        process.exit(1);
+    }
+    return;
+  }
+  if (command === "stats") {
+    const stat = flag("stat") ?? "type_counts";
+    const catalog = await getCatalog();
+    if (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]++;
+      }
+      printJSON({ total: catalog.length, ...counts });
+    } else if (stat === "mass") {
+      const masses = catalog.map((e) => e.total_mass_source).filter((m) => m > 0).sort((a, b) => a - b);
+      printJSON({ count: masses.length, min: +masses[0].toFixed(1), max: +masses[masses.length - 1].toFixed(1), median: +masses[Math.floor(masses.length / 2)].toFixed(1) });
+    } else if (stat === "chirp_mass") {
+      const mc = catalog.map((e) => e.chirp_mass_source).filter((m) => m > 0).sort((a, b) => a - b);
+      printJSON({ count: mc.length, min: +mc[0].toFixed(2), max: +mc[mc.length - 1].toFixed(2), median: +mc[Math.floor(mc.length / 2)].toFixed(2) });
+    } else if (stat === "spin") {
+      const spins = catalog.map((e) => e.chi_eff).sort((a, b) => a - b);
+      printJSON({ count: spins.length, min: +spins[0].toFixed(3), max: +spins[spins.length - 1].toFixed(3), median: +spins[Math.floor(spins.length / 2)].toFixed(3) });
+    } else if (stat === "distance") {
+      const dists = catalog.map((e) => e.luminosity_distance).filter((d) => d > 0).sort((a, b) => a - b);
+      printJSON({ 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) });
+    }
+    return;
+  }
+  console.error(`Unknown command: ${command}. Run "warplab help" for usage.`);
+  process.exit(1);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});