@aeroswarm/client 0.0.0-stage → 0.1.12

package/dist/index.js

@@ -0,0 +1,803 @@
+// src/sdk/websocket/index.ts
+import { streamEnvelopeSchema, currentTrackSchema } from "@aeroswarm/core/validation";
+var AeroWsClient = class {
+  constructor(url, token, maxReconnectDelay = 3e4, heartbeatTimeoutMs = 35e3) {
+    this.url = url;
+    this.token = token;
+    this.maxReconnectDelay = maxReconnectDelay;
+    this.heartbeatTimeoutMs = heartbeatTimeoutMs;
+  }
+  url;
+  token;
+  maxReconnectDelay;
+  heartbeatTimeoutMs;
+  ws = null;
+  attempt = 0;
+  stopped = false;
+  lastSubscribe = null;
+  callbacks = {};
+  lastSeq = -1;
+  lastHeartbeat = Date.now();
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  status = "idle";
+  connect(opts, callbacks) {
+    this.lastSubscribe = opts;
+    this.callbacks = callbacks;
+    this.stopped = false;
+    this._clearReconnectTimer();
+    this._setStatus("connecting");
+    this._connect();
+  }
+  updateFilter(opts) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.ws.send(JSON.stringify({ type: "update-filter", ...opts }));
+  }
+  disconnect() {
+    this.stopped = true;
+    this._clearHeartbeatTimer();
+    this._clearReconnectTimer();
+    this._dropSocket();
+    this._setStatus("offline");
+  }
+  /**
+   * Force a fresh connection now, skipping any backoff wait. Re-subscribes with
+   * the last `connect()` options (the server then sends a new snapshot).
+   * Also resumes after `disconnect()`. No-op if `connect()` was never called.
+   * Returns false in that no-op case.
+   */
+  reconnect() {
+    if (!this.lastSubscribe) return false;
+    this.stopped = false;
+    this.attempt = 0;
+    this._clearHeartbeatTimer();
+    this._clearReconnectTimer();
+    this._dropSocket();
+    this._setStatus("reconnecting");
+    this._connect();
+    return true;
+  }
+  getStatus() {
+    return this.status;
+  }
+  _setStatus(s) {
+    if (this.status === s) return;
+    this.status = s;
+    this.callbacks.onStatusChange?.(s);
+  }
+  /** Close the current socket without letting its onclose schedule a reconnect. */
+  _dropSocket() {
+    const ws = this.ws;
+    this.ws = null;
+    if (!ws) return;
+    ws.onopen = ws.onmessage = ws.onclose = ws.onerror = null;
+    ws.close();
+  }
+  _connect() {
+    const wsUrl = `${this.url}?token=${encodeURIComponent(this.token)}`;
+    this._dropSocket();
+    try {
+      this.ws = new WebSocket(wsUrl);
+      this.ws.binaryType = "arraybuffer";
+    } catch {
+      this._scheduleReconnect();
+      return;
+    }
+    this.ws.onopen = () => {
+      this.attempt = 0;
+      this.lastSeq = -1;
+      this._setStatus("connected");
+      this._resetHeartbeatTimer();
+      if (this.lastSubscribe) {
+        this.ws.send(JSON.stringify({
+          type: "subscribe",
+          encoding: "json",
+          ...this.lastSubscribe
+        }));
+      }
+    };
+    this.ws.onmessage = (event) => {
+      this._handleRaw(event.data);
+    };
+    this.ws.onclose = () => {
+      this._clearHeartbeatTimer();
+      if (!this.stopped) {
+        this._setStatus("reconnecting");
+        this._scheduleReconnect();
+      }
+    };
+    this.ws.onerror = () => {
+      this.callbacks.onError?.({
+        code: "WS_ERROR",
+        message: "WebSocket connection error",
+        recoverable: true
+      });
+    };
+  }
+  _handleRaw(raw) {
+    this._resetHeartbeatTimer();
+    let parsed;
+    try {
+      const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+      parsed = JSON.parse(text);
+    } catch {
+      return;
+    }
+    let msg;
+    const result = streamEnvelopeSchema.safeParse(parsed);
+    if (!result.success) {
+      const raw2 = parsed;
+      if (raw2["type"] === "snapshot" && Array.isArray(raw2["payload"]?.["tracks"])) {
+        const rawTracks = raw2["payload"]["tracks"];
+        const goodTracks = rawTracks.map((t) => currentTrackSchema.safeParse(t)).filter((r) => r.success).map((r) => r.data);
+        if (goodTracks.length > 0) this.callbacks.onSnapshot?.(goodTracks);
+      }
+      return;
+    }
+    msg = result.data;
+    if (msg.seq <= this.lastSeq && this.lastSeq > 0) return;
+    if (msg.seq > this.lastSeq + 10 && this.lastSeq > 0) {
+      this._requestSnapshot();
+    }
+    this.lastSeq = msg.seq;
+    switch (msg.type) {
+      case "snapshot":
+        this.callbacks.onSnapshot?.(msg.payload.tracks);
+        break;
+      case "track.updated":
+        this.callbacks.onTrackUpdate?.(msg.payload.track);
+        break;
+      case "track.removed":
+        this.callbacks.onTrackRemoved?.(msg.payload);
+        break;
+      case "source.status":
+        this.callbacks.onSourceStatus?.(msg.payload);
+        break;
+      case "stream.heartbeat":
+        this.lastHeartbeat = Date.now();
+        break;
+      case "stream.degraded":
+        this._setStatus("degraded");
+        this.callbacks.onDegraded?.(msg.payload.reason);
+        break;
+      case "stream.error":
+        this.callbacks.onError?.({
+          code: msg.payload.code,
+          message: msg.payload.message ?? msg.payload.code,
+          recoverable: msg.payload.recoverable
+        });
+        break;
+    }
+  }
+  _requestSnapshot() {
+    if (!this.lastSubscribe || !this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.ws.send(JSON.stringify({ type: "subscribe", ...this.lastSubscribe }));
+  }
+  _resetHeartbeatTimer() {
+    this._clearHeartbeatTimer();
+    this.heartbeatTimer = setInterval(() => {
+      if (Date.now() - this.lastHeartbeat > this.heartbeatTimeoutMs) {
+        this._setStatus("degraded");
+        this.callbacks.onDegraded?.("heartbeat_timeout");
+      }
+    }, this.heartbeatTimeoutMs / 2);
+  }
+  _clearHeartbeatTimer() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  _scheduleReconnect() {
+    const delay = Math.min(1e3 * 2 ** this.attempt, this.maxReconnectDelay);
+    this.attempt++;
+    this._clearReconnectTimer();
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (!this.stopped) this._connect();
+    }, delay);
+  }
+  _clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+
+// src/sdk/websocket/replay.ts
+var toIso = (v) => v instanceof Date ? v.toISOString() : v;
+var AeroReplayClient = class {
+  constructor(wsBase, token, wsPath = "/ws/tracks/replay") {
+    this.wsBase = wsBase;
+    this.token = token;
+    this.wsPath = wsPath;
+  }
+  wsBase;
+  token;
+  wsPath;
+  /** Open a replay stream. Returns a handle for transport control. */
+  stream(opts, callbacks) {
+    const params = new URLSearchParams({ token: this.token });
+    if (opts.airportId) params.set("airportId", opts.airportId);
+    if (opts.sessionId) params.set("sessionId", opts.sessionId);
+    const ws = new WebSocket(`${this.wsBase}${this.wsPath}?${params.toString()}`);
+    let sessionId = opts.sessionId ?? null;
+    let closedByUser = false;
+    ws.onopen = () => {
+      if (!opts.sessionId) {
+        ws.send(JSON.stringify({
+          type: "replay.start",
+          from: toIso(opts.from),
+          to: toIso(opts.to),
+          speed: opts.speed ?? 1
+        }));
+      }
+    };
+    ws.onmessage = (ev) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(ev.data));
+      } catch {
+        return;
+      }
+      const payload = msg.payload ?? {};
+      switch (msg.type) {
+        case "snapshot": {
+          if (typeof payload["sessionId"] === "string") sessionId = payload["sessionId"];
+          callbacks.onSnapshot?.(payload["tracks"] ?? [], sessionId ?? "");
+          break;
+        }
+        case "track.updated":
+          callbacks.onTrackUpdate?.(payload["track"]);
+          break;
+        case "track.removed":
+          callbacks.onTrackRemoved?.({
+            trackId: String(payload["trackId"] ?? ""),
+            reason: String(payload["reason"] ?? "")
+          });
+          break;
+        case "replay.progress": {
+          const progress = payload;
+          sessionId = progress.sessionId ?? sessionId;
+          callbacks.onProgress?.(progress);
+          break;
+        }
+        case "replay.done":
+          callbacks.onDone?.(String(payload["sessionId"] ?? sessionId ?? ""));
+          break;
+      }
+    };
+    ws.onerror = () => {
+      if (!closedByUser) callbacks.onError?.(new Error("replay websocket error"));
+    };
+    ws.onclose = (ev) => {
+      if (!closedByUser && ev.code >= 4e3) {
+        callbacks.onError?.(new Error(`replay websocket closed: ${ev.reason || ev.code}`));
+      }
+    };
+    const send = (body) => {
+      if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(body));
+    };
+    return {
+      get sessionId() {
+        return sessionId;
+      },
+      pause: () => send({ type: "replay.pause" }),
+      resume: () => send({ type: "replay.resume" }),
+      seek: (at) => send({ type: "replay.seek", at: toIso(at) }),
+      stop: () => {
+        closedByUser = true;
+        send({ type: "replay.stop" });
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+    };
+  }
+};
+
+// src/sdk/api/trpc.ts
+import { createTRPCProxyClient, httpBatchLink } from "@trpc/client";
+function createAeroTrpcClient(endpoint, token) {
+  const base = endpoint.replace(/\/$/, "");
+  return createTRPCProxyClient({
+    links: [
+      httpBatchLink({
+        url: `${base}/trpc`,
+        headers: () => ({ "x-aero-token": token }),
+        methodOverride: "POST"
+      })
+    ]
+  });
+}
+
+// src/sdk/api/rest.ts
+var AeroRestClient = class {
+  constructor(endpoint, token) {
+    this.endpoint = endpoint;
+    this.token = token;
+  }
+  endpoint;
+  token;
+  async req(method, path, body) {
+    const res = await fetch(`${this.endpoint}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "x-aero-token": this.token
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) throw new Error(`${method} ${path} \u2192 ${res.status}`);
+    return res.json();
+  }
+  createSource(body) {
+    return this.req("POST", "/v1/sources", body);
+  }
+  listSources() {
+    return this.req("GET", "/v1/sources");
+  }
+  deleteSource(id) {
+    return this.req("DELETE", `/v1/sources/${id}`);
+  }
+  createWebhook(body) {
+    return this.req("POST", "/v1/webhooks", body);
+  }
+  getTracksCurrent(params) {
+    const search = new URLSearchParams();
+    if (params?.bbox) search.set("bbox", params.bbox.join(","));
+    if (params?.minConfidence != null) search.set("minConfidence", String(params.minConfidence));
+    const qs = search.size ? `?${search.toString()}` : "";
+    return this.req("GET", `/v1/tracks/current${qs}`);
+  }
+  /** Flight plans received from AFTN feeds (FPL/CHG/DLA/DEP/ARR/CNL folded per flight). */
+  listFlightPlans(params) {
+    const search = new URLSearchParams();
+    if (params?.airportId) search.set("airportId", params.airportId);
+    if (params?.status) search.set("status", params.status);
+    if (params?.callsign) search.set("callsign", params.callsign);
+    if (params?.limit != null) search.set("limit", String(params.limit));
+    const qs = search.size ? `?${search.toString()}` : "";
+    return this.req("GET", `/v1/flight-plans${qs}`);
+  }
+  getFlightPlan(id) {
+    return this.req("GET", `/v1/flight-plans/${encodeURIComponent(id)}`);
+  }
+  /** Raw AFTN messages (every parsed ATS message, newest first — the input
+   *  side of the flight-plan pipeline). */
+  listAftnMessages(params) {
+    const search = new URLSearchParams();
+    if (params?.airportId) search.set("airportId", params.airportId);
+    if (params?.limit != null) search.set("limit", String(params.limit));
+    const qs = search.size ? `?${search.toString()}` : "";
+    return this.req("GET", `/v1/aftn/messages${qs}`);
+  }
+  health() {
+    return this.req("GET", "/health");
+  }
+};
+
+// src/sdk/api/graphql.ts
+var AeroGraphQLClient = class {
+  constructor(endpoint, token) {
+    this.endpoint = endpoint;
+    this.token = token;
+  }
+  endpoint;
+  token;
+  async query(query, variables) {
+    const res = await fetch(`${this.endpoint}/graphql`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-aero-token": this.token
+      },
+      body: JSON.stringify({ query, variables })
+    });
+    if (!res.ok) throw new Error(`GraphQL ${res.status}: ${await res.text().catch(() => "")}`);
+    const json = await res.json();
+    if (json.errors?.length) throw new Error(JSON.stringify(json.errors));
+    return json.data;
+  }
+};
+
+// src/sdk/cache/index.ts
+import { isRenderableTrack } from "@aeroswarm/core/utils";
+
+// src/shared/label/index.ts
+var LABEL_COLORS = {
+  ARRIVAL: "#FACC15",
+  // yellow
+  DEPARTURE: "#22C55E",
+  // green
+  GROUND_VEHICLE: "#3B82F6",
+  // blue
+  LOST: "#FFFFFF",
+  // white
+  UNKNOWN: "#FFFFFF"
+  // white — no flight plan
+};
+function getLabelCategory(track) {
+  if (track.status === "lost") return "LOST";
+  if (track.targetType === "vehicle") return "GROUND_VEHICLE";
+  switch (track.flightPlan?.phase) {
+    case "ARRIVAL":
+      return "ARRIVAL";
+    case "DEPARTURE":
+      return "DEPARTURE";
+    default:
+      return "UNKNOWN";
+  }
+}
+function withLabel(track) {
+  const labelCategory = getLabelCategory(track);
+  return { ...track, labelCategory, labelColor: LABEL_COLORS[labelCategory] };
+}
+
+// src/sdk/cache/index.ts
+var TypedEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, fn) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(fn);
+    return () => this.listeners.get(event)?.delete(fn);
+  }
+  emit(event, payload) {
+    this.listeners.get(event)?.forEach((fn) => fn(payload));
+  }
+};
+var TrackCache = class extends TypedEmitter {
+  tracks = /* @__PURE__ */ new Map();
+  /** Merges into the cached track and returns the labeled result. A "lost"
+   *  track is evicted from the cache but still returned (labelCategory LOST). */
+  applyUpdate(track) {
+    const merged = withLabel({ ...this.tracks.get(track.trackId), ...track });
+    if (track.status === "lost") {
+      this.tracks.delete(track.trackId);
+      this.emit("removed", { trackId: track.trackId });
+      return merged;
+    }
+    this.tracks.set(track.trackId, merged);
+    this.emit("update", merged);
+    return merged;
+  }
+  applyRemoved(ev) {
+    this.tracks.delete(ev.trackId);
+    this.emit("removed", ev);
+  }
+  applySnapshot(tracks) {
+    this.tracks.clear();
+    for (const t of tracks) {
+      if (isRenderableTrack(t)) this.tracks.set(t.trackId, withLabel(t));
+    }
+    const all = Array.from(this.tracks.values());
+    this.emit("snapshot", all);
+    return all;
+  }
+  getAll() {
+    return Array.from(this.tracks.values());
+  }
+  get(id) {
+    return this.tracks.get(id);
+  }
+  get size() {
+    return this.tracks.size;
+  }
+  clear() {
+    this.tracks.clear();
+  }
+  getRenderable() {
+    return this.getAll().filter(isRenderableTrack);
+  }
+};
+
+// src/sdk/index.ts
+var AeroSwarm = class _AeroSwarm {
+  constructor(opts) {
+    this.opts = opts;
+    this.trpc = createAeroTrpcClient(opts.endpoint, opts.token);
+    this.rest = new AeroRestClient(opts.endpoint, opts.token);
+    this.graphql = new AeroGraphQLClient(opts.endpoint, opts.token);
+    this.cache = new TrackCache();
+    const wsBase = (opts.wsEndpoint ?? opts.endpoint).replace(/^http/, "ws");
+    this.wsClient = new AeroWsClient(
+      `${wsBase}/ws/tracks/live`,
+      opts.token,
+      opts.maxReconnectDelay ?? 3e4
+    );
+  }
+  opts;
+  trpc;
+  rest;
+  graphql;
+  cache;
+  wsClient;
+  _status = "idle";
+  _lastUpdateAt = null;
+  _error = null;
+  _sourceStatus = {};
+  // ── Federated history resolution ──────────────────────────────────────
+  // An airport can serve its own replay/history through a backend mounting
+  // @aeroswarm/replay-server instead of AeroSwarm's own (see
+  // docs/development/federation/). `airports.list()`'s `historyEndpoint`
+  // field drives this automatically; every federatable call also accepts
+  // an explicit `endpoint` to bypass the registry entirely ("connect
+  // manual"). Priority: explicit endpoint > registry > AeroSwarm itself.
+  airportsCache = null;
+  static AIRPORTS_CACHE_TTL_MS = 6e4;
+  /** Resolves which base URL (if any) should serve a federated call.
+   *  Returns null to mean "use AeroSwarm's own endpoint" — the normal,
+   *  unfederated path, which is also what a lookup failure falls back to
+   *  (a broken airports.list() call must never brick replay/history for
+   *  everyone else). */
+  async resolveHistoryEndpoint(airportId, override) {
+    if (override) return override.replace(/\/$/, "");
+    if (!airportId) return null;
+    try {
+      const now = Date.now();
+      if (!this.airportsCache || now - this.airportsCache.fetchedAt > _AeroSwarm.AIRPORTS_CACHE_TTL_MS) {
+        const { airports } = await this.airports.list();
+        this.airportsCache = {
+          byId: new Map(airports.map((a) => [a.id, a.historyEndpoint])),
+          fetchedAt: now
+        };
+      }
+      const endpoint = this.airportsCache.byId.get(airportId) ?? null;
+      return endpoint ? endpoint.replace(/\/$/, "") : null;
+    } catch {
+      return null;
+    }
+  }
+  async federatedFetch(base, path, query) {
+    const url = new URL(`${base}${path}`);
+    for (const [k, v] of Object.entries(query ?? {})) if (v !== void 0) url.searchParams.set(k, v);
+    const res = await fetch(url, { headers: { Authorization: `Bearer ${this.opts.token}` } });
+    if (!res.ok) throw new Error(`Federated request failed: ${res.status} ${res.statusText} (${url.pathname})`);
+    return res.json();
+  }
+  tracks = {
+    subscribe: (opts, callbacks) => {
+      this.wsClient.connect(
+        { encoding: this.opts.encoding ?? "json", ...opts },
+        {
+          ...callbacks,
+          onStatusChange: (s) => {
+            this._status = s;
+            callbacks.onStatusChange?.(s);
+          },
+          onSnapshot: (tracks) => {
+            const labeled = this.cache.applySnapshot(tracks);
+            this._lastUpdateAt = Date.now();
+            callbacks.onSnapshot?.(labeled);
+          },
+          onTrackUpdate: (track) => {
+            const labeled = this.cache.applyUpdate(track);
+            this._lastUpdateAt = Date.now();
+            callbacks.onTrackUpdate?.(labeled);
+          },
+          onTrackRemoved: (ev) => {
+            this.cache.applyRemoved(ev);
+            callbacks.onTrackRemoved?.(ev);
+          },
+          onSourceStatus: (ev) => {
+            this._sourceStatus[ev.sourceId] = ev.status;
+            callbacks.onSourceStatus?.(ev);
+          },
+          onError: (err) => {
+            this._error = err;
+            callbacks.onError?.(err);
+          }
+        }
+      );
+      return () => this.wsClient.disconnect();
+    },
+    updateFilter: (opts) => this.wsClient.updateFilter(opts),
+    /** Drop the live socket and reconnect immediately (no backoff wait),
+     *  re-subscribing with the last options. Returns false if nothing has
+     *  been subscribed yet. */
+    reconnect: () => this.wsClient.reconnect(),
+    stream: (opts) => {
+      const queue = [];
+      let resolve = null;
+      let done = false;
+      this.wsClient.connect({ encoding: "json", ...opts }, {
+        onSnapshot: (tracks) => {
+          this.cache.applySnapshot(tracks);
+        },
+        onTrackUpdate: (raw) => {
+          const t = this.cache.applyUpdate(raw);
+          if (resolve) {
+            resolve({ value: t, done: false });
+            resolve = null;
+          } else queue.push(t);
+        },
+        onStatusChange: (s) => {
+          if (s === "offline") done = true;
+        }
+      });
+      return {
+        [Symbol.asyncIterator]: () => ({
+          next: () => {
+            if (queue.length) return Promise.resolve({ value: queue.shift(), done: false });
+            if (done) return Promise.resolve({ value: void 0, done: true });
+            return new Promise((r) => {
+              resolve = r;
+            });
+          },
+          return: async () => {
+            this.wsClient.disconnect();
+            return { value: void 0, done: true };
+          }
+        })
+      };
+    },
+    snapshot: (input) => this.trpc.tracks.snapshot.query(input ?? {}),
+    /** Persisted position history for one track. If the airport has a
+     *  `historyEndpoint` (or `endpoint` is passed explicitly), this calls
+     *  that backend's `@aeroswarm/replay-server` instead of AeroSwarm's
+     *  own local database — see docs/development/federation/003-*.md. */
+    history: async (input) => {
+      const base = await this.resolveHistoryEndpoint(input.airportId, input.endpoint);
+      if (base) {
+        return this.federatedFetch(base, `/tracks/${encodeURIComponent(input.trackId)}/history`, {
+          limit: input.limit?.toString()
+        });
+      }
+      return this.trpc.tracks.history.query(input);
+    }
+  };
+  /** Flight plans received from AFTN feeds. Live tracks that correlate with a
+   *  plan (Mode-S address, else callsign) also carry `track.flightPlan`. */
+  flightPlans = {
+    list: (input) => this.rest.listFlightPlans(input).then((r) => r.data.flightPlans),
+    get: (id) => this.rest.getFlightPlan(id).then((r) => r.data.flightPlan)
+  };
+  /** Raw AFTN/ATS messages received by AFTN feeds — the input side of the
+   *  flight-plan pipeline (newest first, capped by the service). */
+  aftn = {
+    messages: (input) => this.rest.listAftnMessages(input).then((r) => r.data.messages)
+  };
+  sources = {
+    /** Registers a source and returns its token, tied to `airportId` — a
+     *  source is a sensor physically at one airport, so this is required.
+     *  Anything that later authenticates with the returned token (WS
+     *  live/replay, tRPC calls) is scoped to that airport automatically,
+     *  with no need to keep passing `airportId` on every subsequent call.
+     *  For access spanning multiple airports, use the viewer/dashboard
+     *  token instead — it's never auto-scoped. */
+    create: (body) => this.rest.createSource(body),
+    health: (sourceId) => this.trpc.sources.health.query({ sourceId }),
+    list: (input) => this.trpc.sources.list.query(input ?? {}),
+    /** Reassigning `airportId` (including to `null` to clear it) re-caches
+     *  the source's token immediately, so the new scoping takes effect
+     *  without waiting out the token cache's TTL. */
+    update: (input) => this.trpc.sources.update.mutate(input),
+    delete: (id) => this.trpc.sources.delete.mutate({ id })
+  };
+  /** Airport registry (multi-airport tenancy). */
+  airports = {
+    list: () => this.trpc.airports.list.query(),
+    create: (input) => this.trpc.airports.create.mutate(input),
+    update: (input) => this.trpc.airports.update.mutate(input),
+    delete: (input) => this.trpc.airports.delete.mutate(input),
+    /** Surface geometry (runway/taxiway/apron GeoJSON) for the map. */
+    surface: (input) => this.trpc.airports.surface.query(input),
+    setSurface: (input) => this.trpc.airports.setSurface.mutate(input)
+  };
+  replay = {
+    /** Data-availability calendar: which days have recorded tracks.
+     *  Use this to populate/validate replay date pickers — days not in
+     *  the list have no data. Federates to the airport's own backend when
+     *  it has a `historyEndpoint` (or `endpoint` is passed explicitly) —
+     *  see docs/development/federation/003-*.md. */
+    days: async (input) => {
+      const base = await this.resolveHistoryEndpoint(input?.airportId, input?.endpoint);
+      if (base) {
+        return this.federatedFetch(base, "/replay/days", {
+          lookbackDays: input?.lookbackDays?.toString()
+        });
+      }
+      return this.trpc.replay.days.query(input ?? {});
+    },
+    range: async (input) => {
+      const base = await this.resolveHistoryEndpoint(input.airportId, input.endpoint);
+      if (base) {
+        const summary = await this.federatedFetch(
+          base,
+          "/replay/range",
+          { from: input.from, to: input.to }
+        );
+        return { from: input.from, to: input.to, ...summary };
+      }
+      return this.trpc.replay.range.query(input);
+    },
+    // replay.window / replay.seek (bulk sample download for client-side
+    // interpolation) were removed — they were never part of the federation
+    // contract, and `replay.stream`'s server-paced WS (with server-side
+    // seek/re-snapshot) covers every use they had at a fraction of the
+    // payload. See docs/development/federation/005-*.md.
+    /** Server-paced WS playback: streams historical tracks at `speed`× in
+     *  the same envelope format as the live stream. Returns a transport
+     *  handle (pause/resume/seek/stop) — a Promise, since resolving which
+     *  backend serves this airport (see docs/development/federation/003-*.md)
+     *  is async. See `AeroReplayClient` for the raw wire protocol if you
+     *  want to speak WS manually instead. */
+    stream: async (opts, callbacks) => {
+      const federatedBase = await this.resolveHistoryEndpoint(opts.airportId, opts.endpoint);
+      if (federatedBase) {
+        const wsBase2 = federatedBase.replace(/^http/, "ws");
+        const { airportId: _drop, ...rest } = opts;
+        return new AeroReplayClient(wsBase2, this.opts.token, "/replay").stream(rest, callbacks);
+      }
+      const wsBase = (this.opts.wsEndpoint ?? this.opts.endpoint).replace(/^http/, "ws");
+      return new AeroReplayClient(wsBase, this.opts.token).stream(opts, callbacks);
+    }
+  };
+  /** Movement analytics: takeoffs/landings per hour + peak hour, recorded
+   *  by the pipeline's movement detector. */
+  analytics = {
+    movements: (input) => this.trpc.analytics.movements.query(input ?? {})
+  };
+  /** Route conformance: pre-defined ground routes + live track clearances.
+   *  Assign a route to a track and the safety engine can detect when it
+   *  strays beyond the route's corridor. */
+  routes = {
+    list: (input) => this.trpc.routes.list.query(input ?? {}),
+    create: (input) => this.trpc.routes.create.mutate(input),
+    delete: (input) => this.trpc.routes.delete.mutate(input),
+    assign: (input) => this.trpc.routes.assign.mutate(input),
+    unassign: (input) => this.trpc.routes.unassign.mutate(input),
+    assignments: () => this.trpc.routes.assignments.query()
+  };
+  webhooks = {
+    list: () => this.trpc.webhooks.list.query(),
+    create: (body) => this.trpc.webhooks.create.mutate(body),
+    delete: (input) => this.trpc.webhooks.delete.mutate(input)
+  };
+  system = {
+    stats: () => this.trpc.system.stats.query(),
+    infraHealth: () => this.trpc.system.infraHealth.query(),
+    ingestHistory: () => this.trpc.system.ingestHistory.query(),
+    getConfig: () => this.trpc.system.getConfig.query(),
+    setConfig: (input) => this.trpc.system.setConfig.mutate(input),
+    clearTable: (input) => this.trpc.system.clearTable.mutate(input)
+  };
+  getStatus() {
+    return this._status;
+  }
+  getLastUpdateAt() {
+    return this._lastUpdateAt;
+  }
+  getError() {
+    return this._error;
+  }
+  getSourceStatus() {
+    return { ...this._sourceStatus };
+  }
+  disconnect() {
+    this.wsClient.disconnect();
+  }
+  reconnect() {
+    return this.wsClient.reconnect();
+  }
+};
+
+// src/shared/utils/index.ts
+import { isRenderableTrack as isRenderableTrack2, haversineKm, isInsideBbox, toCurrentTrack, clamp } from "@aeroswarm/core/utils";
+export {
+  AeroReplayClient,
+  AeroSwarm,
+  AeroWsClient,
+  LABEL_COLORS,
+  TrackCache,
+  clamp,
+  getLabelCategory,
+  haversineKm,
+  isInsideBbox,
+  isRenderableTrack2 as isRenderableTrack,
+  toCurrentTrack,
+  withLabel
+};
+//# sourceMappingURL=index.js.map