@aeroswarm/live-server 0.0.0-stage → 0.1.2

package/dist/index.js

@@ -0,0 +1,1173 @@
+// ../core/dist/chunk-J2UTSYKD.js
+function toCurrentTrack(fused, staleAfterMs = 15e3, lostAfterMs = 9e4) {
+  const age = Date.now() - fused.updatedAt;
+  const status = age > lostAfterMs ? "lost" : age > staleAfterMs ? "stale" : "active";
+  const src = fused.sources.length > 1 ? "FUSED" : protocolToSource(fused.protocol);
+  const rawHeading = fused.velocity?.heading;
+  const headingDeg = rawHeading != null ? (rawHeading % 360 + 360) % 360 : null;
+  return {
+    trackId: fused.trackId,
+    source: src,
+    icao24: fused.identity.icao24 ?? null,
+    callsign: fused.identity.callsign ?? null,
+    squawk: fused.identity.squawk ?? null,
+    ...fused.identity.targetType !== void 0 && { targetType: fused.identity.targetType },
+    ...fused.identity.vehicleFleet !== void 0 && { vehicleFleet: fused.identity.vehicleFleet },
+    ...fused.airportId !== void 0 && { airportId: fused.airportId },
+    lat: fused.position?.lat ?? null,
+    lon: fused.position?.lon ?? null,
+    altitudeFt: fused.position?.alt ?? null,
+    groundSpeedKt: fused.velocity?.groundSpeed ?? null,
+    headingDeg,
+    verticalRateFpm: fused.velocity?.verticalRate ?? null,
+    confidence: fused.confidence.overall,
+    lastSeenAt: fused.updatedAt,
+    status
+  };
+}
+function protocolToSource(protocol) {
+  if (protocol === "asterix-cat010") return "ASTERIX_CAT010";
+  if (protocol === "asterix-cat011") return "ASTERIX_CAT011";
+  if (protocol === "asterix-cat020") return "ASTERIX_CAT020";
+  if (protocol === "asterix-cat021") return "ASTERIX_CAT021";
+  if (protocol === "asterix-cat048") return "ASTERIX_CAT048";
+  if (protocol === "asterix-cat062") return "ASTERIX_CAT062";
+  return "ADSB";
+}
+var STALE_AFTER_MS = 15e3;
+var LOST_AFTER_MS = 9e4;
+
+// src/types.ts
+var noopLogger = { info() {
+}, warn() {
+}, error() {
+} };
+function trackScore(t) {
+  return t.confidence * 1e13 + t.lastSeenAt;
+}
+function inBbox(t, bbox) {
+  if (!bbox) return true;
+  if (t.lat == null || t.lon == null) return true;
+  return t.lon >= bbox[0] && t.lat >= bbox[1] && t.lon <= bbox[2] && t.lat <= bbox[3];
+}
+function matchesFilter(t, f) {
+  if (f.airportId && t.airportId !== f.airportId) return false;
+  if (!inBbox(t, f.bbox)) return false;
+  if (f.minConfidence !== void 0 && t.confidence < f.minConfidence) return false;
+  return true;
+}
+
+// src/track-state.ts
+var DEFAULT_REMOVE_AFTER_MS = 18e5;
+function inside(lon, lat, b) {
+  return lon >= b[0] && lat >= b[1] && lon <= b[2] && lat <= b[3];
+}
+var TrackState = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.staleAfterMs = opts.staleAfterMs ?? STALE_AFTER_MS;
+    this.lostAfterMs = opts.lostAfterMs ?? LOST_AFTER_MS;
+    this.removeAfterMs = opts.removeAfterMs ?? DEFAULT_REMOVE_AFTER_MS;
+    this.now = opts.now ?? Date.now;
+  }
+  opts;
+  tracks = /* @__PURE__ */ new Map();
+  byIcao24 = /* @__PURE__ */ new Map();
+  onUpdate = /* @__PURE__ */ new Set();
+  onRemoved = /* @__PURE__ */ new Set();
+  staleAfterMs;
+  lostAfterMs;
+  removeAfterMs;
+  sweepTimer = null;
+  now;
+  statusFor(age) {
+    return age > this.lostAfterMs ? "lost" : age > this.staleAfterMs ? "stale" : "active";
+  }
+  on(event, fn) {
+    const set = event === "update" ? this.onUpdate : this.onRemoved;
+    set.add(fn);
+    return () => {
+      set.delete(fn);
+    };
+  }
+  get size() {
+    return this.tracks.size;
+  }
+  get(trackId) {
+    return this.tracks.get(trackId);
+  }
+  values() {
+    return this.tracks.values();
+  }
+  /** Apply one fused event. Returns the resulting track, or null when the event
+   *  removed a track or was ignored. */
+  ingest(fused) {
+    if (fused.lifecycle === "dropped") {
+      this.remove(fused.trackId, "dropped");
+      return null;
+    }
+    if (this.opts.interestBbox && !this.inInterestZone(fused, this.opts.interestBbox)) return null;
+    const icao24 = fused.identity?.icao24;
+    if (icao24) {
+      const existing = this.byIcao24.get(icao24);
+      if (existing && existing !== fused.trackId && this.tracks.has(existing)) {
+        this.remove(existing, "superseded");
+      }
+      this.byIcao24.set(icao24, fused.trackId);
+    }
+    let current = toCurrentTrack(fused, this.staleAfterMs, this.lostAfterMs);
+    current = { ...current, status: this.statusFor(this.now() - current.lastSeenAt) };
+    if (this.opts.attachFlightPlan) current = this.opts.attachFlightPlan(current);
+    this.tracks.set(current.trackId, current);
+    this.emitUpdate(current, false);
+    return current;
+  }
+  /** Remove a track (no-op if unknown). */
+  drop(trackId, reason = "dropped") {
+    this.remove(trackId, reason);
+  }
+  /** Recompute `status` from `lastSeenAt` and remove long-gone tracks.
+   *  Emits only on a real status change. Call every few seconds. */
+  sweep(now = this.now()) {
+    for (const [trackId, track] of [...this.tracks]) {
+      const age = now - track.lastSeenAt;
+      if (this.removeAfterMs > 0 && age > this.removeAfterMs) {
+        this.remove(trackId, "lost");
+        continue;
+      }
+      const status = this.statusFor(age);
+      if (track.status === status) continue;
+      const updated = { ...track, status };
+      this.tracks.set(trackId, updated);
+      this.emitUpdate(updated, true);
+    }
+  }
+  /** Re-attach flight plans, emitting only for tracks whose plan data changed.
+   *  Call when a plan changes so clients see it before the next radar update. */
+  refreshFlightPlans(match) {
+    const attach = this.opts.attachFlightPlan;
+    if (!attach) return;
+    for (const [trackId, track] of [...this.tracks]) {
+      if (match && !match(track)) continue;
+      const next = attach(track);
+      if (JSON.stringify(next.flightPlan) === JSON.stringify(track.flightPlan)) continue;
+      this.tracks.set(trackId, next);
+      this.emitUpdate(next, true);
+    }
+  }
+  snapshot(filter = {}) {
+    let out = [...this.tracks.values()].filter((t) => matchesFilter(t, filter));
+    out.sort((a, b) => trackScore(b) - trackScore(a));
+    if (filter.maxTracks !== void 0) out = out.slice(0, filter.maxTracks);
+    return out;
+  }
+  /** Run `sweep` on an interval. Idempotent. */
+  startSweep(intervalMs = 5e3) {
+    if (this.sweepTimer) return;
+    this.sweepTimer = setInterval(() => this.sweep(), intervalMs);
+    this.sweepTimer.unref?.();
+  }
+  stopSweep() {
+    if (this.sweepTimer) clearInterval(this.sweepTimer);
+    this.sweepTimer = null;
+  }
+  remove(trackId, reason) {
+    const track = this.tracks.get(trackId);
+    if (!track) return;
+    this.tracks.delete(trackId);
+    if (track.icao24 && this.byIcao24.get(track.icao24) === trackId) this.byIcao24.delete(track.icao24);
+    for (const fn of this.onRemoved) fn({ trackId, reason });
+  }
+  emitUpdate(track, force) {
+    for (const fn of this.onUpdate) fn(track, { force });
+  }
+  inInterestZone(fused, bbox) {
+    const lat = fused.position?.lat;
+    const lon = fused.position?.lon;
+    if (lat == null || lon == null) return true;
+    if (inside(lon, lat, bbox)) return true;
+    const heading = fused.velocity?.heading;
+    const speedKt = fused.velocity?.groundSpeed;
+    if (heading == null || speedKt == null || speedKt < 10) return false;
+    const hours = (this.opts.interestLookaheadMin ?? 90) / 60;
+    const distDeg = speedKt * 1.852 * hours / 111.32;
+    const rad = heading * Math.PI / 180;
+    const projLat = lat + distDeg * Math.cos(rad);
+    const projLon = lon + distDeg * Math.sin(rad) / Math.cos(lat * Math.PI / 180);
+    return inside(projLon, projLat, bbox);
+  }
+};
+function createTrackState(opts) {
+  return new TrackState(opts);
+}
+
+// ../core/dist/chunk-3T3CHHEM.js
+var FLIGHT_PLAN_MATCH_WINDOW_MS = 36 * 36e5;
+function normalizeCallsign(cs) {
+  const v = cs?.trim().toUpperCase().replace(/\s+/g, "");
+  return v || void 0;
+}
+function dayKey(msg, receivedAt) {
+  if (msg.dof && /^\d{6}$/.test(msg.dof)) return `20${msg.dof}`;
+  const t = msg.eobtAt ?? msg.atdAt ?? msg.ataAt ?? receivedAt;
+  return new Date(t).toISOString().slice(0, 10).replace(/-/g, "");
+}
+function flightPlanId(msg, receivedAt) {
+  const callsign = normalizeCallsign(msg.callsign);
+  if (!callsign) return null;
+  return `${callsign}|${msg.adep ?? "-"}|${msg.ades ?? "-"}|${dayKey(msg, receivedAt)}`;
+}
+function pickMatchingPlan(candidates, msg, receivedAt) {
+  const ref = msg.eobtAt ?? msg.atdAt ?? msg.ataAt ?? receivedAt;
+  let best;
+  let bestDiff = Infinity;
+  for (const c of candidates) {
+    if (msg.adep && c.adep && msg.adep !== c.adep) continue;
+    if (msg.ades && c.ades && msg.ades !== c.ades) continue;
+    const planTime = c.atdAt ?? c.eobtAt ?? c.firstSeenAt;
+    const diff = Math.abs(planTime - ref);
+    if (diff <= FLIGHT_PLAN_MATCH_WINDOW_MS && diff < bestDiff) {
+      best = c;
+      bestDiff = diff;
+    }
+  }
+  return best;
+}
+function assignDefined(target, patch) {
+  for (const [k, v] of Object.entries(patch)) {
+    if (v !== void 0 && v !== null && v !== "") target[k] = v;
+  }
+}
+function eetMs(eet) {
+  if (!eet || !/^\d{4}$/.test(eet)) return void 0;
+  return (Number(eet.slice(0, 2)) * 60 + Number(eet.slice(2, 4))) * 6e4;
+}
+function applyFlightPlanEvent(prev, ev) {
+  const m = ev.message;
+  const callsign = normalizeCallsign(m.callsign);
+  if (!callsign) return null;
+  const id = prev?.id ?? flightPlanId(m, ev.receivedAt);
+  if (!id) return null;
+  const next = {
+    status: "filed",
+    airportId: ev.airportId,
+    firstSeenAt: ev.receivedAt,
+    ...prev,
+    id,
+    callsign,
+    other: { ...prev?.other ?? {} },
+    lastMessageType: m.type,
+    messageCount: (prev?.messageCount ?? 0) + 1,
+    updatedAt: ev.receivedAt
+  };
+  assignDefined(next, { icao24: m.icao24, registration: m.registration, dof: m.dof });
+  Object.assign(next.other, m.other);
+  if (!next.adep && m.adep) next.adep = m.adep;
+  if (!next.ades && m.ades) next.ades = m.ades;
+  switch (m.type) {
+    case "FPL":
+      assignDefined(next, {
+        aircraftType: m.aircraftType,
+        wake: m.wake,
+        flightRules: m.flightRules,
+        flightType: m.flightType,
+        adep: m.adep,
+        ades: m.ades,
+        alternates: m.alternates,
+        eobtAt: m.eobtAt,
+        eet: m.eet,
+        cruiseSpeed: m.cruiseSpeed,
+        cruiseLevel: m.cruiseLevel,
+        route: m.route,
+        equipment: m.equipment
+      });
+      if (prev?.status !== "departed" && prev?.status !== "arrived") next.status = "filed";
+      break;
+    case "CHG":
+      assignDefined(next, {
+        aircraftType: m.aircraftType,
+        wake: m.wake,
+        cruiseSpeed: m.cruiseSpeed,
+        cruiseLevel: m.cruiseLevel,
+        route: m.route
+      });
+      if (m.changes?.["13"]) assignDefined(next, { adep: m.adep, eobtAt: m.eobtAt });
+      if (m.changes?.["16"]) assignDefined(next, { ades: m.ades, eet: m.eet });
+      break;
+    case "DLA":
+      assignDefined(next, { eobtAt: m.eobtAt });
+      if (next.status === "filed" || next.status === "delayed") next.status = "delayed";
+      break;
+    case "DEP":
+      next.atdAt = m.atdAt ?? ev.receivedAt;
+      next.status = "departed";
+      break;
+    case "ARR":
+      next.ataAt = m.ataAt ?? ev.receivedAt;
+      next.status = "arrived";
+      break;
+    case "CNL":
+      next.status = "cancelled";
+      break;
+  }
+  const departure = next.atdAt ?? next.eobtAt;
+  const flightTime = eetMs(next.eet);
+  next.etaAt = next.ataAt ?? (departure !== void 0 && flightTime !== void 0 ? departure + flightTime : void 0);
+  return next;
+}
+function flightPhase(plan, airportId) {
+  const icao = airportId?.trim().toUpperCase();
+  if (icao && plan.ades === icao) return "ARRIVAL";
+  if (icao && plan.adep === icao) return "DEPARTURE";
+  return plan.adep || plan.ades ? "OVERFLIGHT" : "UNKNOWN";
+}
+function summarizeFlightPlan(plan, airportId) {
+  const summary = { id: plan.id, status: plan.status, phase: flightPhase(plan, airportId) };
+  assignDefined(summary, {
+    adep: plan.adep,
+    ades: plan.ades,
+    aircraftType: plan.aircraftType,
+    registration: plan.registration,
+    eobtAt: plan.eobtAt,
+    atdAt: plan.atdAt,
+    ataAt: plan.ataAt,
+    etaAt: plan.etaAt,
+    cruiseLevel: plan.cruiseLevel,
+    route: plan.route
+  });
+  return summary;
+}
+
+// src/flightplan-store.ts
+var FlightPlanStore = class {
+  plans = /* @__PURE__ */ new Map();
+  byCallsign = /* @__PURE__ */ new Map();
+  byIcao24 = /* @__PURE__ */ new Map();
+  onChanged = /* @__PURE__ */ new Set();
+  onExpired = /* @__PURE__ */ new Set();
+  ttlMs;
+  sweepTimer = null;
+  constructor(opts = {}) {
+    this.ttlMs = opts.ttlMs ?? 48 * 36e5;
+  }
+  on(event, fn) {
+    const set = event === "changed" ? this.onChanged : this.onExpired;
+    set.add(fn);
+    return () => {
+      set.delete(fn);
+    };
+  }
+  get size() {
+    return this.plans.size;
+  }
+  get(id) {
+    return this.plans.get(id);
+  }
+  /** Fold one AFTN message into its flight. Returns the updated plan, or null if ignored. */
+  apply(ev) {
+    const m = ev.message;
+    const callsign = normalizeCallsign(m.callsign);
+    if (!callsign) return null;
+    let prev;
+    if (m.type === "FPL") {
+      const id = flightPlanId(m, ev.receivedAt);
+      prev = id ? this.plans.get(id) : void 0;
+    } else {
+      const candidates = [...this.byCallsign.get(callsign) ?? []].map((id) => this.plans.get(id)).filter((p) => p !== void 0);
+      prev = pickMatchingPlan(candidates, m, ev.receivedAt);
+    }
+    const next = applyFlightPlanEvent(prev, ev);
+    if (!next) return null;
+    if (prev) this.unindex(prev);
+    this.plans.set(next.id, next);
+    this.index(next);
+    for (const fn of this.onChanged) fn(next);
+    return next;
+  }
+  /** Restore plans (e.g. from a database after a restart). Does not emit `changed`. */
+  load(plans, now = Date.now()) {
+    const cutoff = now - this.ttlMs;
+    let loaded = 0;
+    for (const plan of plans) {
+      if (!plan?.id || plan.updatedAt < cutoff) continue;
+      const prev = this.plans.get(plan.id);
+      if (prev) this.unindex(prev);
+      this.plans.set(plan.id, plan);
+      this.index(plan);
+      loaded++;
+    }
+    return loaded;
+  }
+  /** Best plan for a live track. Every plan sharing the Mode-S address or
+   *  callsign is a candidate (an airframe flies several legs a day); the leg
+   *  in progress, or nearest in time, wins. Cancelled plans never match. */
+  find(track, now = Date.now()) {
+    const candidates = /* @__PURE__ */ new Set();
+    if (track.icao24) {
+      for (const id of this.byIcao24.get(track.icao24.toLowerCase()) ?? []) {
+        const p = this.plans.get(id);
+        if (p) candidates.add(p);
+      }
+    }
+    const callsign = normalizeCallsign(track.callsign);
+    if (callsign) {
+      for (const id of this.byCallsign.get(callsign) ?? []) {
+        const p = this.plans.get(id);
+        if (p) candidates.add(p);
+      }
+    }
+    let best;
+    let bestScore = Infinity;
+    for (const p of candidates) {
+      if (p.status === "cancelled") continue;
+      const s = Math.abs((p.ataAt ?? p.atdAt ?? p.eobtAt ?? p.firstSeenAt) - now);
+      if (s < bestScore || s === bestScore && best && p.updatedAt > best.updatedAt) {
+        best = p;
+        bestScore = s;
+      }
+    }
+    return best;
+  }
+  /** Track with its flight-plan summary attached; unchanged when none matches.
+   *  An arrow property so it can be passed unbound, e.g. `{ attachFlightPlan: store.attach }`. */
+  attach = (track) => {
+    const plan = this.find(track);
+    if (!plan) {
+      if (!track.flightPlan) return track;
+      const { flightPlan: _drop, ...rest } = track;
+      return rest;
+    }
+    return { ...track, flightPlan: summarizeFlightPlan(plan, track.airportId) };
+  };
+  /** True if `plan` could correlate with `track`. Pair with `TrackState.refreshFlightPlans`. */
+  matches(plan, track) {
+    if (plan.icao24 && track.icao24?.toLowerCase() === plan.icao24) return true;
+    return normalizeCallsign(track.callsign) === plan.callsign;
+  }
+  list(filter = {}) {
+    const callsign = normalizeCallsign(filter.callsign);
+    const out = [...this.plans.values()].filter((p) => !filter.airportId || !p.airportId || p.airportId === filter.airportId).filter((p) => !filter.status || p.status === filter.status).filter((p) => !callsign || p.callsign.includes(callsign)).sort((a, b) => b.updatedAt - a.updatedAt);
+    return filter.limit && filter.limit > 0 ? out.slice(0, filter.limit) : out;
+  }
+  /** Drop plans past the TTL; returns their ids. */
+  sweep(now = Date.now()) {
+    const cutoff = now - this.ttlMs;
+    const removed = [];
+    for (const [id, plan] of [...this.plans]) {
+      if (plan.updatedAt >= cutoff) continue;
+      this.plans.delete(id);
+      this.unindex(plan);
+      removed.push(id);
+      for (const fn of this.onExpired) fn(id);
+    }
+    return removed;
+  }
+  startSweep(intervalMs = 10 * 6e4) {
+    if (this.sweepTimer) return;
+    this.sweepTimer = setInterval(() => this.sweep(), intervalMs);
+    this.sweepTimer.unref?.();
+  }
+  stopSweep() {
+    if (this.sweepTimer) clearInterval(this.sweepTimer);
+    this.sweepTimer = null;
+  }
+  index(plan) {
+    let ids = this.byCallsign.get(plan.callsign);
+    if (!ids) this.byCallsign.set(plan.callsign, ids = /* @__PURE__ */ new Set());
+    ids.add(plan.id);
+    if (plan.icao24) {
+      let iids = this.byIcao24.get(plan.icao24);
+      if (!iids) this.byIcao24.set(plan.icao24, iids = /* @__PURE__ */ new Set());
+      iids.add(plan.id);
+    }
+  }
+  unindex(plan) {
+    const ids = this.byCallsign.get(plan.callsign);
+    ids?.delete(plan.id);
+    if (ids?.size === 0) this.byCallsign.delete(plan.callsign);
+    if (plan.icao24) {
+      const iids = this.byIcao24.get(plan.icao24);
+      iids?.delete(plan.id);
+      if (iids?.size === 0) this.byIcao24.delete(plan.icao24);
+    }
+  }
+};
+function createFlightPlanStore(opts) {
+  return new FlightPlanStore(opts);
+}
+
+// src/movement.ts
+var AIRBORNE_ALT_FT = 300;
+var GROUND_ALT_FT = 100;
+var TAKEOFF_MIN_GS_KT = 70;
+var LANDING_MAX_GS_KT = 190;
+var DEBOUNCE_MS = 12e4;
+var MovementDetector = class {
+  phases = /* @__PURE__ */ new Map();
+  /** Feed one track state; returns a movement event on a transition. */
+  update(s) {
+    const alt = s.altitudeFt ?? null;
+    const gs = s.groundSpeedKt ?? null;
+    const looksAirborne = s.onGround === false || alt !== null && alt > AIRBORNE_ALT_FT;
+    const looksGround = s.onGround === true || alt !== null && alt < GROUND_ALT_FT;
+    const phase = this.phases.get(s.trackId);
+    if (!phase) {
+      this.phases.set(s.trackId, {
+        airborne: looksAirborne && !looksGround,
+        lastAt: s.at,
+        lastMovementAt: 0
+      });
+      return null;
+    }
+    phase.lastAt = s.at;
+    let event = null;
+    const debounced = phase.lastMovementAt !== 0 && s.at - phase.lastMovementAt < DEBOUNCE_MS;
+    if (!phase.airborne && looksAirborne && !looksGround) {
+      if ((gs ?? 0) >= TAKEOFF_MIN_GS_KT && !debounced) {
+        event = this.makeEvent(s, "takeoff");
+        phase.lastMovementAt = s.at;
+      }
+      phase.airborne = true;
+    } else if (phase.airborne && looksGround) {
+      if ((gs ?? 0) <= LANDING_MAX_GS_KT && !debounced) {
+        event = this.makeEvent(s, "landing");
+        phase.lastMovementAt = s.at;
+      }
+      phase.airborne = false;
+    }
+    return event;
+  }
+  /** Forget one track (call when its track is removed). */
+  forget(trackId) {
+    this.phases.delete(trackId);
+  }
+  /** Forget tracks not updated within maxAgeMs (call periodically). */
+  sweep(maxAgeMs, now = Date.now()) {
+    for (const [id, phase] of this.phases) {
+      if (now - phase.lastAt > maxAgeMs) this.phases.delete(id);
+    }
+  }
+  get trackedCount() {
+    return this.phases.size;
+  }
+  makeEvent(s, type) {
+    return {
+      trackId: s.trackId,
+      icao24: s.icao24 ?? null,
+      callsign: s.callsign ?? null,
+      ...s.airportId ? { airportId: s.airportId } : {},
+      type,
+      at: s.at,
+      lat: s.lat,
+      lon: s.lon
+    };
+  }
+};
+function createMovementDetector() {
+  return new MovementDetector();
+}
+
+// src/fusion.ts
+var DEFAULT_SURFACE_PRIORITY = [
+  "asterix-cat010",
+  "asterix-cat011",
+  "asterix-cat020",
+  "asterix-cat021",
+  "asterix-cat062",
+  "asterix-cat048"
+];
+var DEFAULT_AIRBORNE_PRIORITY = [
+  "asterix-cat020",
+  "asterix-cat010",
+  "asterix-cat011",
+  "asterix-cat021",
+  "asterix-cat062",
+  "asterix-cat048"
+];
+function defaultFusionOptions() {
+  return {
+    surfacePriority: [...DEFAULT_SURFACE_PRIORITY],
+    airbornePriority: [...DEFAULT_AIRBORNE_PRIORITY],
+    maxSourceAgeMs: 5e3,
+    forgetAfterMs: 6e5,
+    spatial: false,
+    matchRadiusM: 150,
+    matchMaxSkewMs: 3e3,
+    disagreeM: 300
+  };
+}
+var SYNTHETIC_ID = /^[rtv]\d+-\d+-\d+$/;
+var EARTH_M = 6371e3;
+var isSyntheticId = (icao24) => SYNTHETIC_ID.test(icao24);
+function distanceM(a, b) {
+  const rad = Math.PI / 180;
+  const dLat = (b.lat - a.lat) * rad;
+  const dLon = (b.lon - a.lon) * rad;
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(a.lat * rad) * Math.cos(b.lat * rad) * Math.sin(dLon / 2) ** 2;
+  return 2 * EARTH_M * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+var sourceOf = (event) => event.sources[0];
+var keyFor = (event) => {
+  const icao24 = event.identity.icao24;
+  return isSyntheticId(icao24) ? `s:${sourceOf(event)}:${icao24}` : `m:${icao24}`;
+};
+function rank(list, event) {
+  const idx = list.findIndex(
+    (s) => s === event.protocol || s === sourceOf(event)
+  );
+  return idx < 0 ? list.length : idx;
+}
+function pickPrimary(fresh, list) {
+  const sorted = [...fresh].sort(
+    (a, b) => rank(list, a.event) - rank(list, b.event) || b.at - a.at
+  );
+  return sorted[0] ?? null;
+}
+function mergeIdentity(primary, others) {
+  const out = { ...primary.event.identity };
+  for (const other of others) {
+    const id = other.event.identity;
+    out.callsign ??= id.callsign;
+    out.squawk ??= id.squawk;
+    out.targetType ??= id.targetType;
+    out.vehicleFleet ??= id.vehicleFleet;
+    if (isSyntheticId(out.icao24) && !isSyntheticId(id.icao24)) {
+      out.icao24 = id.icao24;
+    }
+  }
+  return out;
+}
+function maxSpreadM(primary, others) {
+  const base = primary.event.position;
+  if (!base) return 0;
+  let max = 0;
+  for (const other of others) {
+    const pos = other.event.position;
+    if (pos) max = Math.max(max, distanceM(base, pos));
+  }
+  return max;
+}
+var Fuser = class {
+  opts;
+  now;
+  byKey = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
+  spatialMatches = 0;
+  ambiguous = 0;
+  disagreements = 0;
+  constructor(opts) {
+    this.opts = opts;
+    this.now = opts.now ?? (() => Date.now());
+  }
+  ingest(event) {
+    const now = this.now();
+    const src = sourceOf(event);
+    const key = keyFor(event);
+    const known = this.byKey.get(key);
+    if (event.lifecycle === "dropped") return this.drop(known, event, src, now);
+    const entry = known ?? this.matchSpatially(event, src, now) ?? this.create(event);
+    this.link(entry, key, event);
+    entry.contributions.set(src, { event, sourceId: src, at: now });
+    return this.output(entry, src, now, false);
+  }
+  forget(trackId) {
+    const entry = this.byId.get(trackId);
+    if (entry) this.remove(entry);
+  }
+  sweep() {
+    const now = this.now();
+    for (const entry of [...this.byId.values()]) {
+      for (const [src, c] of entry.contributions) {
+        if (now - c.at > this.opts.forgetAfterMs)
+          entry.contributions.delete(src);
+      }
+      if (entry.contributions.size === 0) this.remove(entry);
+    }
+  }
+  stats() {
+    const now = this.now();
+    let merged = 0;
+    for (const entry of this.byId.values()) {
+      if (this.fresh(entry, now).length > 1) merged++;
+    }
+    return {
+      aircraft: this.byId.size,
+      merged,
+      spatialMatches: this.spatialMatches,
+      ambiguous: this.ambiguous,
+      disagreements: this.disagreements
+    };
+  }
+  fresh(entry, now) {
+    return [...entry.contributions.values()].filter(
+      (c) => now - c.at <= this.opts.maxSourceAgeMs
+    );
+  }
+  create(event) {
+    const entry = {
+      id: event.trackId,
+      keys: /* @__PURE__ */ new Set(),
+      contributions: /* @__PURE__ */ new Map(),
+      realIcao24: null,
+      lastPrimary: "",
+      lastSources: ""
+    };
+    this.byId.set(entry.id, entry);
+    return entry;
+  }
+  link(entry, key, event) {
+    entry.keys.add(key);
+    this.byKey.set(key, entry);
+    if (!isSyntheticId(event.identity.icao24)) {
+      entry.realIcao24 = event.identity.icao24;
+    }
+  }
+  remove(entry) {
+    for (const key of entry.keys) this.byKey.delete(key);
+    this.byId.delete(entry.id);
+  }
+  drop(entry, event, src, now) {
+    if (!entry) return event;
+    entry.contributions.delete(src);
+    if (entry.contributions.size > 0) return this.output(entry, src, now, true);
+    this.remove(entry);
+    return { ...event, trackId: entry.id };
+  }
+  /** The partner for a track nobody else shares an id with, or null. */
+  matchSpatially(event, src, now) {
+    const pos = event.position;
+    if (!this.opts.spatial || !pos) return null;
+    const hasMode = !isSyntheticId(event.identity.icao24);
+    const found = [];
+    for (const entry of this.byId.values()) {
+      if (entry.contributions.has(src) || hasMode && entry.realIcao24)
+        continue;
+      if (this.isNear(entry, pos, now)) found.push(entry);
+    }
+    if (found.length > 1) this.ambiguous++;
+    if (found.length !== 1) return null;
+    this.spatialMatches++;
+    return found[0] ?? null;
+  }
+  isNear(entry, pos, now) {
+    for (const c of entry.contributions.values()) {
+      const other = c.event.position;
+      if (!other || now - c.at > this.opts.matchMaxSkewMs) continue;
+      if (distanceM(pos, other) <= this.opts.matchRadiusM) return true;
+    }
+    return false;
+  }
+  /**
+   * The event for the aircraft as it stands now. Null when `src` is not the
+   * sensor being shown and nothing else changed, so a lower-priority sensor
+   * does not make the picture jump.
+   */
+  output(entry, src, now, force) {
+    const fresh = this.fresh(entry, now);
+    const onGround = fresh.some((c) => c.event.position?.onGround === true);
+    const list = onGround ? this.opts.surfacePriority : this.opts.airbornePriority;
+    const primary = pickPrimary(fresh, list);
+    if (!primary) return null;
+    const sources = fresh.map((c) => c.sourceId).sort().join(",");
+    const changed = force || primary.sourceId === src || primary.sourceId !== entry.lastPrimary || sources !== entry.lastSources;
+    entry.lastPrimary = primary.sourceId;
+    entry.lastSources = sources;
+    return changed ? this.build(entry, primary, fresh) : null;
+  }
+  build(entry, primary, fresh) {
+    const others = fresh.filter((c) => c !== primary).sort((a, b) => b.at - a.at);
+    const { event } = primary;
+    const out = {
+      ...event,
+      trackId: entry.id,
+      sources: [primary.sourceId, ...others.map((c) => c.sourceId)],
+      identity: mergeIdentity(primary, others),
+      lifecycle: others.length > 0 ? "merged" : event.lifecycle
+    };
+    const velocity = event.velocity ?? others.find((c) => c.event.velocity)?.event.velocity;
+    if (velocity) out.velocity = velocity;
+    if (others.length > 0) this.scoreAgreement(out, primary, others);
+    return out;
+  }
+  scoreAgreement(out, primary, others) {
+    const spread = maxSpreadM(primary, others);
+    if (spread > this.opts.disagreeM) this.disagreements++;
+    out.confidence = {
+      ...out.confidence,
+      sourceAgreement: Math.max(0, 1 - spread / this.opts.disagreeM)
+    };
+  }
+};
+function createTrackFuser(options = {}) {
+  const base = defaultFusionOptions();
+  const given = Object.fromEntries(
+    Object.entries(options).filter(([, v]) => v !== void 0)
+  );
+  return new Fuser({ ...base, ...given });
+}
+
+// ../core/dist/chunk-ZYX6U3ZK.js
+import { z } from "zod";
+var positionSchema = z.object({
+  lat: z.number().min(-90).max(90),
+  lon: z.number().min(-180).max(180),
+  alt: z.number().optional(),
+  altSource: z.enum(["baro", "gnss", "mlat"]).optional(),
+  onGround: z.boolean().optional()
+});
+var velocitySchema = z.object({
+  groundSpeed: z.number().nonnegative().optional(),
+  heading: z.number().min(-1).max(361).optional(),
+  verticalRate: z.number().optional()
+});
+var flightPlanSummarySchema = z.object({
+  id: z.string(),
+  adep: z.string().optional(),
+  ades: z.string().optional(),
+  aircraftType: z.string().optional(),
+  registration: z.string().optional(),
+  eobtAt: z.number().optional(),
+  atdAt: z.number().optional(),
+  ataAt: z.number().optional(),
+  etaAt: z.number().optional(),
+  cruiseLevel: z.string().optional(),
+  route: z.string().optional(),
+  status: z.enum(["filed", "delayed", "departed", "arrived", "cancelled"]),
+  phase: z.enum(["ARRIVAL", "DEPARTURE", "OVERFLIGHT", "UNKNOWN"])
+});
+var currentTrackSchema = z.object({
+  trackId: z.string(),
+  source: z.enum(["ADSB", "ASTERIX_CAT010", "ASTERIX_CAT011", "ASTERIX_CAT020", "ASTERIX_CAT021", "ASTERIX_CAT048", "ASTERIX_CAT062", "FUSED"]),
+  icao24: z.string().nullable(),
+  callsign: z.string().nullable(),
+  squawk: z.string().nullable(),
+  targetType: z.enum(["aircraft", "vehicle", "unknown"]).optional(),
+  vehicleFleet: z.number().optional(),
+  airportId: z.string().optional(),
+  lat: z.number().min(-90).max(90).nullable(),
+  lon: z.number().min(-180).max(180).nullable(),
+  altitudeFt: z.number().nullable(),
+  groundSpeedKt: z.number().nullable(),
+  headingDeg: z.number().min(-1).max(361).nullable(),
+  verticalRateFpm: z.number().nullable(),
+  confidence: z.number().min(0).max(1),
+  lastSeenAt: z.number(),
+  status: z.enum(["active", "stale", "lost"]),
+  flightPlan: flightPlanSummarySchema.optional()
+});
+var streamEnvelopeSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("snapshot"),
+    seq: z.number(),
+    serverTime: z.number(),
+    payload: z.object({ tracks: z.array(currentTrackSchema) })
+  }),
+  z.object({
+    type: z.literal("track.updated"),
+    seq: z.number(),
+    serverTime: z.number(),
+    payload: z.object({ track: currentTrackSchema })
+  }),
+  z.object({
+    type: z.literal("track.removed"),
+    seq: z.number(),
+    serverTime: z.number(),
+    payload: z.object({ trackId: z.string(), reason: z.string() })
+  }),
+  z.object({
+    type: z.literal("source.status"),
+    seq: z.number(),
+    serverTime: z.number(),
+    payload: z.object({ sourceId: z.string(), status: z.enum(["healthy", "degraded", "offline"]) })
+  }),
+  z.object({
+    type: z.literal("stream.heartbeat"),
+    seq: z.number(),
+    serverTime: z.number(),
+    payload: z.object({}).strict()
+  }),
+  z.object({
+    type: z.literal("stream.degraded"),
+    seq: z.number(),
+    serverTime: z.number(),
+    payload: z.object({ reason: z.string(), sourceId: z.string().optional() })
+  }),
+  z.object({
+    type: z.literal("stream.error"),
+    seq: z.number(),
+    serverTime: z.number(),
+    payload: z.object({ code: z.string(), message: z.string().optional(), recoverable: z.boolean() })
+  })
+]);
+var sourceHeartbeatSchema = z.object({
+  sourceId: z.string(),
+  timestamp: z.number(),
+  packetsReceived: z.number().int(),
+  packetsSent: z.number().int(),
+  bufferFillRatio: z.number().min(0).max(1),
+  latencyMs: z.number().nonnegative(),
+  protocol: z.enum(["beast", "sbs", "asterix-cat021", "asterix-cat048"]),
+  receiverVersion: z.string().optional()
+});
+var wsSubscribeSchema = z.object({
+  type: z.literal("subscribe"),
+  bbox: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional(),
+  source: z.enum(["fused", "normalized"]).default("fused"),
+  minConfidence: z.number().min(0).max(1).optional(),
+  maxTracks: z.number().int().min(1).max(1e4).optional(),
+  mode: z.enum(["delta", "full"]).default("delta"),
+  maxUpdateHz: z.number().min(1).max(60).default(20),
+  encoding: z.enum(["json", "msgpack"]).default("json"),
+  airportId: z.string().min(2).max(8).optional()
+});
+var wsUpdateFilterSchema = z.object({
+  type: z.literal("update-filter"),
+  bbox: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional(),
+  minConfidence: z.number().min(0).max(1).optional(),
+  maxUpdateHz: z.number().min(1).max(60).optional(),
+  maxTracks: z.number().int().min(1).max(1e4).nullable().optional()
+});
+var apiErrorSchema = z.object({
+  ok: z.literal(false),
+  error: z.object({
+    code: z.string(),
+    message: z.string(),
+    recoverable: z.boolean()
+  })
+});
+
+// src/live-server.ts
+function toText(raw) {
+  return typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+}
+function createLiveServer(opts) {
+  const { state } = opts;
+  const log = opts.logger ?? noopLogger;
+  const defaultHz = opts.defaultUpdateHz ?? 10;
+  const maxBuffered = opts.maxBufferedBytes ?? 1048576;
+  const clients = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const counters = { messagesSent: 0, deltasSkipped: 0 };
+  function send(c, type, payload, droppable = false) {
+    if (c.closed) return false;
+    if (droppable && c.socket.getBufferedAmount && c.socket.getBufferedAmount() > maxBuffered) {
+      counters.deltasSkipped++;
+      return false;
+    }
+    const envelope = { type, seq: ++seq, serverTime: Date.now(), payload };
+    try {
+      c.socket.send(JSON.stringify(envelope));
+      counters.messagesSent++;
+      return true;
+    } catch (err) {
+      log.warn({ err }, "live ws: send failed");
+      return false;
+    }
+  }
+  function sendError(c, code, message) {
+    send(c, "stream.error", { code, message, recoverable: true });
+  }
+  function shouldPush(c, trackId, now) {
+    const last = c.lastPushed.get(trackId) ?? 0;
+    if (now - last < 1e3 / c.maxUpdateHz) return false;
+    c.lastPushed.set(trackId, now);
+    return true;
+  }
+  function sendSnapshot(c) {
+    const tracks = state.snapshot(c.filter);
+    c.visible = new Set(tracks.map((t) => t.trackId));
+    c.lastPushed.clear();
+    send(c, "snapshot", { tracks });
+  }
+  function hide(c, trackId, reason) {
+    if (!c.visible.delete(trackId)) return;
+    c.lastPushed.delete(trackId);
+    send(c, "track.removed", { trackId, reason });
+  }
+  function admit(c, track) {
+    const cap = c.filter.maxTracks;
+    if (cap === void 0 || c.visible.size < cap) return true;
+    let lowestId = null;
+    let lowest = trackScore(track);
+    for (const id of c.visible) {
+      const t = state.get(id);
+      if (!t) {
+        c.visible.delete(id);
+        continue;
+      }
+      const s = trackScore(t);
+      if (s < lowest) {
+        lowest = s;
+        lowestId = id;
+      }
+    }
+    if (c.visible.size < cap) return true;
+    if (!lowestId) return false;
+    hide(c, lowestId, "evicted");
+    return true;
+  }
+  const offUpdate = state.on("update", (track, info) => {
+    const now = Date.now();
+    for (const c of clients.values()) {
+      if (!c.subscribed) continue;
+      if (!matchesFilter(track, c.filter)) {
+        hide(c, track.trackId, "filtered");
+        continue;
+      }
+      if (!c.visible.has(track.trackId)) {
+        if (!admit(c, track)) continue;
+        c.visible.add(track.trackId);
+        c.lastPushed.set(track.trackId, now);
+      } else if (!info.force && !shouldPush(c, track.trackId, now)) {
+        continue;
+      }
+      if (!send(c, "track.updated", { track }, !info.force)) {
+        c.lastPushed.delete(track.trackId);
+      }
+    }
+  });
+  const offRemoved = state.on("removed", ({ trackId, reason }) => {
+    for (const c of clients.values()) {
+      if (!c.visible.has(trackId)) continue;
+      c.visible.delete(trackId);
+      c.lastPushed.delete(trackId);
+      send(c, "track.removed", { trackId, reason });
+    }
+  });
+  const heartbeat = setInterval(() => {
+    for (const c of clients.values()) if (c.ready) send(c, "stream.heartbeat", {});
+  }, opts.heartbeatMs ?? 15e3);
+  heartbeat.unref?.();
+  function handle(c, raw) {
+    let msg;
+    try {
+      msg = JSON.parse(toText(raw));
+    } catch {
+      sendError(c, "BAD_JSON", "Message is not valid JSON");
+      return;
+    }
+    if (msg["type"] === "subscribe") {
+      const parsed = wsSubscribeSchema.safeParse(msg);
+      if (!parsed.success) {
+        sendError(c, "BAD_SUBSCRIBE", "Invalid subscribe message");
+        return;
+      }
+      const sub = parsed.data;
+      c.filter = {
+        airportId: c.pinnedAirportId ?? sub.airportId,
+        bbox: sub.bbox,
+        minConfidence: sub.minConfidence ?? 0,
+        maxTracks: sub.maxTracks
+      };
+      c.maxUpdateHz = sub.maxUpdateHz;
+      c.subscribed = true;
+      sendSnapshot(c);
+    } else if (msg["type"] === "update-filter") {
+      const parsed = wsUpdateFilterSchema.safeParse(msg);
+      if (!parsed.success) {
+        sendError(c, "BAD_FILTER", "Invalid update-filter message");
+        return;
+      }
+      const upd = parsed.data;
+      if (upd.bbox !== void 0) c.filter.bbox = upd.bbox;
+      if (upd.minConfidence !== void 0) c.filter.minConfidence = upd.minConfidence;
+      if (upd.maxUpdateHz !== void 0) c.maxUpdateHz = upd.maxUpdateHz;
+      if (upd.maxTracks !== void 0) c.filter.maxTracks = upd.maxTracks ?? void 0;
+      if (c.subscribed) sendSnapshot(c);
+    }
+  }
+  return {
+    handlers: {
+      async open(ws, ctx) {
+        const c = {
+          socket: ws,
+          ready: false,
+          closed: false,
+          pending: [],
+          subscribed: false,
+          filter: {},
+          maxUpdateHz: defaultHz,
+          lastPushed: /* @__PURE__ */ new Map(),
+          visible: /* @__PURE__ */ new Set()
+        };
+        clients.set(ws, c);
+        if (!ctx.token) {
+          ws.close(4001, "Unauthorized: token required");
+          return;
+        }
+        let auth;
+        try {
+          auth = await opts.authenticate(ctx.token);
+        } catch (err) {
+          log.error({ err }, "live ws: authenticate threw");
+          auth = null;
+        }
+        if (c.closed) return;
+        if (!auth) {
+          ws.close(4003, "Unauthorized: invalid token");
+          return;
+        }
+        c.pinnedAirportId = auth.airportId;
+        c.filter.airportId = auth.airportId;
+        c.ready = true;
+        send(c, "stream.heartbeat", {});
+        const queued = c.pending.splice(0);
+        for (const raw of queued) handle(c, raw);
+      },
+      message(ws, raw) {
+        const c = clients.get(ws);
+        if (!c || c.closed) return;
+        if (!c.ready) {
+          c.pending.push(raw);
+          return;
+        }
+        handle(c, raw);
+      },
+      close(ws) {
+        const c = clients.get(ws);
+        if (c) c.closed = true;
+        clients.delete(ws);
+      }
+    },
+    sourceStatus(sourceId, status) {
+      for (const c of clients.values()) if (c.ready) send(c, "source.status", { sourceId, status });
+    },
+    degraded(reason, sourceId) {
+      for (const c of clients.values()) {
+        if (c.ready) send(c, "stream.degraded", sourceId ? { reason, sourceId } : { reason });
+      }
+    },
+    stats() {
+      let subscribed = 0;
+      for (const c of clients.values()) if (c.subscribed) subscribed++;
+      return { clients: clients.size, subscribed, ...counters };
+    },
+    stop() {
+      clearInterval(heartbeat);
+      offUpdate();
+      offRemoved();
+      for (const c of clients.values()) {
+        c.closed = true;
+        try {
+          c.socket.close(1001, "server shutting down");
+        } catch {
+        }
+      }
+      clients.clear();
+    }
+  };
+}
+export {
+  DEFAULT_AIRBORNE_PRIORITY,
+  DEFAULT_SURFACE_PRIORITY,
+  FlightPlanStore,
+  MovementDetector,
+  TrackState,
+  createFlightPlanStore,
+  createLiveServer,
+  createMovementDetector,
+  createTrackFuser,
+  createTrackState,
+  defaultFusionOptions,
+  isSyntheticId
+};