@aeroswarm/client 0.0.0-stage → 0.1.11

package/dist/react/index.js

@@ -0,0 +1,1171 @@
+// src/react/context/index.tsx
+import { createContext, useContext, useMemo } from "react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+// 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;
+  status = "idle";
+  connect(opts, callbacks) {
+    this.lastSubscribe = opts;
+    this.callbacks = callbacks;
+    this.stopped = false;
+    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.ws?.close();
+    this.ws = null;
+    this._setStatus("offline");
+  }
+  getStatus() {
+    return this.status;
+  }
+  _setStatus(s) {
+    if (this.status === s) return;
+    this.status = s;
+    this.callbacks.onStatusChange?.(s);
+  }
+  _connect() {
+    const wsUrl = `${this.url}?token=${encodeURIComponent(this.token)}`;
+    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++;
+    setTimeout(() => {
+      if (!this.stopped) this._connect();
+    }, delay);
+  }
+};
+
+// 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}`);
+  }
+  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";
+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();
+  applyUpdate(track) {
+    if (track.status === "lost") {
+      this.tracks.delete(track.trackId);
+      this.emit("removed", { trackId: track.trackId });
+      return;
+    }
+    const merged = { ...this.tracks.get(track.trackId), ...track };
+    this.tracks.set(track.trackId, merged);
+    this.emit("update", 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, t);
+    }
+    this.emit("snapshot", Array.from(this.tracks.values()));
+  }
+  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) => {
+            this.cache.applySnapshot(tracks);
+            this._lastUpdateAt = Date.now();
+            callbacks.onSnapshot?.(tracks);
+          },
+          onTrackUpdate: (track) => {
+            this.cache.applyUpdate(track);
+            this._lastUpdateAt = Date.now();
+            callbacks.onTrackUpdate?.(track);
+          },
+          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),
+    stream: (opts) => {
+      const queue = [];
+      let resolve = null;
+      let done = false;
+      this.wsClient.connect({ encoding: "json", ...opts }, {
+        onTrackUpdate: (t) => {
+          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);
+    }
+  };
+  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();
+  }
+};
+
+// src/react/context/index.tsx
+import { jsx } from "react/jsx-runtime";
+var AeroSwarmContext = createContext(null);
+function useAeroSwarmContext() {
+  const ctx = useContext(AeroSwarmContext);
+  if (!ctx) throw new Error("useAeroSwarmContext must be used inside <AeroSwarmProvider>");
+  return ctx;
+}
+function AeroSwarmProvider({
+  children,
+  queryClient: externalQc,
+  ...sdkOpts
+}) {
+  const client = useMemo(
+    () => new AeroSwarm(sdkOpts),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [sdkOpts.endpoint, sdkOpts.token]
+  );
+  const qc = useMemo(
+    () => externalQc ?? new QueryClient({
+      defaultOptions: {
+        queries: {
+          staleTime: 1e4,
+          refetchInterval: 3e4
+        }
+      }
+    }),
+    [externalQc]
+  );
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: qc, children: /* @__PURE__ */ jsx(AeroSwarmContext.Provider, { value: { client }, children }) });
+}
+
+// src/react/hooks/use-track-history.ts
+import { useCallback, useEffect, useRef } from "react";
+var DR_MIN_SPEED_KT = 10;
+var MAX_SPEED_KT = 1200;
+var GAP_RESET_MS = 3e4;
+var DR_MAX_MS = 18e4;
+function deadReckon(baseLat, baseLon, speedKt, headingDeg, elapsedMs) {
+  const elapsedSec = elapsedMs / 1e3;
+  const distanceNm = speedKt * elapsedSec / 3600;
+  const headingRad = headingDeg * (Math.PI / 180);
+  const dlat = distanceNm / 60 * Math.cos(headingRad);
+  const dlon = distanceNm / (60 * Math.cos(baseLat * (Math.PI / 180))) * Math.sin(headingRad);
+  return { lat: baseLat + dlat, lon: baseLon + dlon };
+}
+function useTrackHistory(options) {
+  const {
+    maxHistoryPoints = 500,
+    minDeltaDeg = 1e-4,
+    maxJumpDeg = 5,
+    onFrame
+  } = options;
+  const currentPositions = useRef(/* @__PURE__ */ new Map());
+  const lastActualPos = useRef(/* @__PURE__ */ new Map());
+  const history = useRef(/* @__PURE__ */ new Map());
+  const lastSeen = useRef(/* @__PURE__ */ new Map());
+  const lastUpdPerf = useRef(/* @__PURE__ */ new Map());
+  const interp = useRef(/* @__PURE__ */ new Map());
+  const velocity = useRef(/* @__PURE__ */ new Map());
+  const drState = useRef(/* @__PURE__ */ new Map());
+  const rafRef = useRef(null);
+  const onFrameRef = useRef(onFrame);
+  onFrameRef.current = onFrame;
+  const maxHistoryPointsRef = useRef(maxHistoryPoints);
+  maxHistoryPointsRef.current = maxHistoryPoints;
+  const minDeltaDegRef = useRef(minDeltaDeg);
+  minDeltaDegRef.current = minDeltaDeg;
+  const maxJumpDegRef = useRef(maxJumpDeg);
+  maxJumpDegRef.current = maxJumpDeg;
+  function emitFrame() {
+    onFrameRef.current({
+      currentPositions: currentPositions.current,
+      history: history.current,
+      lastSeen: lastSeen.current,
+      isMoving: /* @__PURE__ */ new Set([...interp.current.keys(), ...drState.current.keys()])
+    });
+  }
+  function needsRaf() {
+    if (interp.current.size > 0) return true;
+    for (const [id, dr] of drState.current) {
+      if (interp.current.has(id)) continue;
+      const vel = velocity.current.get(id);
+      if (vel && vel.speedKt >= DR_MIN_SPEED_KT) return true;
+      if (performance.now() - dr.baseTime > DR_MAX_MS) drState.current.delete(id);
+    }
+    return false;
+  }
+  function ensureRaf() {
+    if (rafRef.current !== null || !needsRaf()) return;
+    const tick = (perfNow) => {
+      for (const [id, tw] of interp.current) {
+        const p = Math.min((perfNow - tw.startedAt) / tw.durationMs, 1);
+        const ease = p < 1 ? p * (2 - p) : 1;
+        const lat = tw.fromLat + (tw.toLat - tw.fromLat) * ease;
+        const lon = tw.fromLon + (tw.toLon - tw.fromLon) * ease;
+        currentPositions.current.set(id, { lat, lon });
+        if (p >= 1) {
+          interp.current.delete(id);
+          const vel = velocity.current.get(id);
+          if (vel && vel.speedKt >= DR_MIN_SPEED_KT) {
+            drState.current.set(id, { baseLat: lat, baseLon: lon, baseTime: perfNow });
+          }
+        }
+      }
+      for (const [id, dr] of drState.current) {
+        if (interp.current.has(id)) continue;
+        const vel = velocity.current.get(id);
+        if (!vel || vel.speedKt < DR_MIN_SPEED_KT) continue;
+        const elapsed = perfNow - dr.baseTime;
+        if (elapsed > DR_MAX_MS) {
+          drState.current.delete(id);
+          continue;
+        }
+        currentPositions.current.set(id, deadReckon(
+          dr.baseLat,
+          dr.baseLon,
+          vel.speedKt,
+          vel.headingDeg,
+          elapsed
+        ));
+      }
+      emitFrame();
+      rafRef.current = needsRaf() ? requestAnimationFrame(tick) : null;
+    };
+    rafRef.current = requestAnimationFrame(tick);
+  }
+  const processUpdate = useCallback((t) => {
+    if (t.lat == null || t.lon == null) return;
+    if (t.lat < -90 || t.lat > 90 || t.lon < -180 || t.lon > 180) return;
+    const perfNow = performance.now();
+    const wallNow = Date.now();
+    const id = t.trackId;
+    const lon = t.lon;
+    const lat = t.lat;
+    lastSeen.current.set(id, wallNow);
+    if (t.groundSpeedKt != null && t.headingDeg != null) {
+      const spd = t.groundSpeedKt;
+      const hdg = t.headingDeg;
+      if (spd >= 0 && spd <= MAX_SPEED_KT) {
+        if (spd >= DR_MIN_SPEED_KT || !velocity.current.has(id)) {
+          velocity.current.set(id, { speedKt: spd, headingDeg: hdg });
+        }
+      }
+    }
+    const prevActual = lastActualPos.current.get(id);
+    const prevUpdPerf = lastUpdPerf.current.get(id);
+    if (prevActual && prevUpdPerf && perfNow > prevUpdPerf) {
+      const dtSec = (perfNow - prevUpdPerf) / 1e3;
+      const dlatDeg = lat - prevActual.lat;
+      const dlonDeg = lon - prevActual.lon;
+      const dlatNm = dlatDeg * 60;
+      const dlonNm = dlonDeg * 60 * Math.cos(lat * Math.PI / 180);
+      const distNm = Math.sqrt(dlatNm * dlatNm + dlonNm * dlonNm);
+      const derivedSpd = distNm / dtSec * 3600;
+      if (dtSec >= 0.25 && derivedSpd >= DR_MIN_SPEED_KT && derivedSpd <= MAX_SPEED_KT) {
+        const derivedHdg = (Math.atan2(dlonNm, dlatNm) * 180 / Math.PI + 360) % 360;
+        const existing = velocity.current.get(id);
+        if (!existing || existing.speedKt < DR_MIN_SPEED_KT) {
+          velocity.current.set(id, { speedKt: derivedSpd, headingDeg: derivedHdg });
+        }
+      }
+    }
+    const cur = currentPositions.current.get(id);
+    const lastActual = lastActualPos.current.get(id);
+    if (!cur) {
+      currentPositions.current.set(id, { lat, lon });
+      lastActualPos.current.set(id, { lat, lon });
+      history.current.set(id, []);
+      lastUpdPerf.current.set(id, perfNow);
+      const vel = velocity.current.get(id);
+      if (vel && vel.speedKt >= DR_MIN_SPEED_KT) {
+        drState.current.set(id, { baseLat: lat, baseLon: lon, baseTime: perfNow });
+      }
+      emitFrame();
+      ensureRaf();
+      return;
+    }
+    if (prevUpdPerf !== void 0 && perfNow - prevUpdPerf > GAP_RESET_MS) {
+      history.current.set(id, []);
+      currentPositions.current.set(id, { lat, lon });
+      lastActualPos.current.set(id, { lat, lon });
+      lastUpdPerf.current.set(id, perfNow);
+      interp.current.delete(id);
+      drState.current.delete(id);
+      emitFrame();
+      ensureRaf();
+      return;
+    }
+    const minD = minDeltaDegRef.current;
+    const maxJ = maxJumpDegRef.current;
+    const checkLat = lastActual?.lat ?? cur.lat;
+    const checkLon = lastActual?.lon ?? cur.lon;
+    if (Math.abs(checkLat - lat) < minD && Math.abs(checkLon - lon) < minD) return;
+    if (lastActual && (Math.abs(lat - lastActual.lat) > maxJ || Math.abs(lon - lastActual.lon) > maxJ)) return;
+    lastActualPos.current.set(id, { lat, lon });
+    const prevPerf = lastUpdPerf.current.get(id) ?? perfNow;
+    const interval = Math.max(100, Math.min(perfNow - prevPerf, 5e3));
+    lastUpdPerf.current.set(id, perfNow);
+    const maxHP = maxHistoryPointsRef.current;
+    const hist = history.current.get(id) ?? [];
+    const last = hist.at(-1);
+    const dupThreshold = minD * 0.5;
+    if (!last || Math.abs(last[0] - cur.lon) > dupThreshold || Math.abs(last[1] - cur.lat) > dupThreshold) {
+      hist.push([cur.lon, cur.lat]);
+      if (hist.length > maxHP) hist.shift();
+      history.current.set(id, hist);
+    }
+    drState.current.delete(id);
+    interp.current.set(id, {
+      fromLat: cur.lat,
+      fromLon: cur.lon,
+      toLat: lat,
+      toLon: lon,
+      startedAt: perfNow,
+      durationMs: Math.min(interval * 0.95, 3e3)
+    });
+    emitFrame();
+    ensureRaf();
+  }, []);
+  const processRemove = useCallback((trackId) => {
+    currentPositions.current.delete(trackId);
+    lastActualPos.current.delete(trackId);
+    history.current.delete(trackId);
+    lastSeen.current.delete(trackId);
+    lastUpdPerf.current.delete(trackId);
+    interp.current.delete(trackId);
+    velocity.current.delete(trackId);
+    drState.current.delete(trackId);
+    emitFrame();
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (rafRef.current !== null) {
+        cancelAnimationFrame(rafRef.current);
+        rafRef.current = null;
+      }
+    };
+  }, []);
+  const reemit = useCallback(() => {
+    emitFrame();
+  }, []);
+  return { processUpdate, processRemove, reemit };
+}
+
+// src/react/hooks/index.ts
+import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2 } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { useShallow } from "zustand/react/shallow";
+
+// src/react/store/index.ts
+import { create } from "zustand";
+
+// src/shared/utils/index.ts
+import { isRenderableTrack as isRenderableTrack2, haversineKm, isInsideBbox, toCurrentTrack, clamp } from "@aeroswarm/core/utils";
+
+// src/react/store/index.ts
+var useTrackStore = create()((set, get) => ({
+  tracks: /* @__PURE__ */ new Map(),
+  status: "idle",
+  sourceStatus: {},
+  lastUpdateAt: null,
+  error: null,
+  isDegraded: false,
+  degradedReason: null,
+  applyUpdate(track) {
+    const next = new Map(get().tracks);
+    next.set(track.trackId, { ...next.get(track.trackId), ...track });
+    set({ tracks: next, lastUpdateAt: Date.now() });
+  },
+  applyBatch(updates, removedIds) {
+    if (updates.length === 0 && removedIds.length === 0) return;
+    const next = new Map(get().tracks);
+    for (const track of updates) {
+      next.set(track.trackId, { ...next.get(track.trackId), ...track });
+    }
+    for (const id of removedIds) next.delete(id);
+    set({ tracks: next, lastUpdateAt: Date.now() });
+  },
+  applyRemoved({ trackId }) {
+    const next = new Map(get().tracks);
+    next.delete(trackId);
+    set({ tracks: next });
+  },
+  applySnapshot(tracks) {
+    const next = /* @__PURE__ */ new Map();
+    for (const t of tracks) {
+      if (isRenderableTrack2(t)) next.set(t.trackId, t);
+    }
+    set({ tracks: next, lastUpdateAt: Date.now() });
+  },
+  setStatus(s) {
+    set({
+      status: s,
+      isDegraded: s === "degraded",
+      degradedReason: s === "connected" ? null : get().degradedReason
+    });
+  },
+  setSourceStatus(sourceId, status) {
+    set({ sourceStatus: { ...get().sourceStatus, [sourceId]: status } });
+  },
+  setError(err) {
+    set({ error: err });
+  },
+  setDegraded(reason) {
+    set({
+      isDegraded: reason !== null,
+      degradedReason: reason,
+      status: reason !== null ? "degraded" : get().status
+    });
+  },
+  pruneStale(maxAgeMs) {
+    const cutoff = Date.now() - maxAgeMs;
+    const removed = [];
+    const next = new Map(get().tracks);
+    for (const [id, t] of next) {
+      if ((t.lastSeenAt ?? 0) < cutoff) {
+        next.delete(id);
+        removed.push(id);
+      }
+    }
+    if (removed.length > 0) set({ tracks: next });
+    return removed;
+  },
+  clear() {
+    set({ tracks: /* @__PURE__ */ new Map(), lastUpdateAt: null });
+  }
+}));
+var selectAllTracks = (s) => Array.from(s.tracks.values());
+var selectTrack = (id) => (s) => s.tracks.get(id);
+var selectTrackCount = (s) => s.tracks.size;
+var selectStatus = (s) => s.status;
+var selectIsDegraded = (s) => s.isDegraded;
+var selectLastUpdateAt = (s) => s.lastUpdateAt;
+var selectError = (s) => s.error;
+var selectRenderableTracks = (s) => Array.from(s.tracks.values()).filter(isRenderableTrack2);
+
+// src/react/hooks/index.ts
+function useAeroTracks(opts = {}) {
+  const { client } = useAeroSwarmContext();
+  const tracks = useTrackStore(useShallow(selectRenderableTracks));
+  const allTracks = useTrackStore(useShallow(selectAllTracks));
+  const status = useTrackStore(selectStatus);
+  const isDegraded = useTrackStore(selectIsDegraded);
+  const lastUpdateAt = useTrackStore(selectLastUpdateAt);
+  const error = useTrackStore(selectError);
+  const unsubRef = useRef2(null);
+  const { isLoading } = useQuery({
+    queryKey: ["aero-snapshot", opts.bbox?.join(","), opts.source, opts.minConfidence],
+    enabled: opts.enabled !== false,
+    staleTime: 5e3,
+    queryFn: async () => {
+      const result = await client.tracks.snapshot({
+        bbox: opts.bbox,
+        minConfidence: opts.minConfidence
+      });
+      useTrackStore.getState().applySnapshot(result.tracks ?? []);
+      return result;
+    }
+  });
+  useEffect2(() => {
+    if (opts.enabled === false) return;
+    const actions = useTrackStore.getState();
+    unsubRef.current = client.tracks.subscribe(
+      {
+        bbox: opts.bbox,
+        source: opts.source ?? "fused",
+        minConfidence: opts.minConfidence,
+        maxUpdateHz: opts.maxUpdateHz ?? 20,
+        mode: "delta"
+      },
+      {
+        onStatusChange: (s) => actions.setStatus(s),
+        onSnapshot: (t) => actions.applySnapshot(t),
+        onTrackUpdate: (t) => actions.applyUpdate(t),
+        onTrackRemoved: (ev) => actions.applyRemoved(ev),
+        onSourceStatus: (ev) => actions.setSourceStatus(ev.sourceId, ev.status),
+        onDegraded: (r) => actions.setDegraded(r),
+        onError: (e) => actions.setError(e)
+      }
+    );
+    return () => {
+      unsubRef.current?.();
+      useTrackStore.getState().setStatus("idle");
+    };
+  }, [opts.bbox?.join(","), opts.source, opts.minConfidence, opts.maxUpdateHz, opts.enabled]);
+  return {
+    tracks,
+    allTracks,
+    status,
+    isConnected: status === "connected",
+    isLoading,
+    isDegraded,
+    lastUpdateAt,
+    error,
+    trackCount: tracks.length
+  };
+}
+var useTracks = useAeroTracks;
+function useAeroTrack(trackId) {
+  const track = useTrackStore(useMemo2(() => selectTrack(trackId), [trackId]));
+  return { track };
+}
+function useAeroSnapshot(opts = {}) {
+  const { client } = useAeroSwarmContext();
+  return useQuery({
+    queryKey: ["aero-snapshot-only", opts.bbox?.join(","), opts.source],
+    enabled: opts.enabled !== false,
+    queryFn: () => client.tracks.snapshot({ bbox: opts.bbox, minConfidence: opts.minConfidence })
+  });
+}
+function useSourceHealth(sourceId) {
+  const { client } = useAeroSwarmContext();
+  return useQuery({
+    queryKey: ["aero-source-health", sourceId],
+    refetchInterval: 15e3,
+    queryFn: () => sourceId ? client.sources.health(sourceId) : client.sources.list()
+  });
+}
+function useTrackCount() {
+  return useTrackStore(selectTrackCount);
+}
+function useAeroStatus() {
+  return {
+    status: useTrackStore(selectStatus),
+    isDegraded: useTrackStore(selectIsDegraded),
+    lastUpdateAt: useTrackStore(selectLastUpdateAt),
+    error: useTrackStore(selectError)
+  };
+}
+function useReplayStatus(sessionId, opts = {}) {
+  const { client } = useAeroSwarmContext();
+  return useQuery({
+    queryKey: ["aero-replay-status", sessionId],
+    enabled: opts.enabled !== false,
+    refetchInterval: opts.refetchInterval ?? 1e3,
+    queryFn: () => client.replay?.status?.query?.({ sessionId }) ?? Promise.resolve({ status: "idle" })
+  });
+}
+function useReplayStop() {
+  const { client } = useAeroSwarmContext();
+  return useQuery({
+    queryKey: ["aero-replay-stop"],
+    enabled: false,
+    queryFn: () => client.replay?.stop?.query?.({ sessionId: "" }) ?? Promise.resolve({ success: true })
+  });
+}
+function useWebhooks(opts = {}) {
+  const { client } = useAeroSwarmContext();
+  return useQuery({
+    queryKey: ["aero-webhooks"],
+    enabled: opts.enabled !== false,
+    queryFn: () => client.webhooks?.list?.query?.() ?? Promise.resolve({ webhooks: [] })
+  });
+}
+function useLineage(eventId, opts = {}) {
+  const { client } = useAeroSwarmContext();
+  return useQuery({
+    queryKey: ["aero-lineage", eventId],
+    enabled: opts.enabled !== false && !!eventId,
+    queryFn: () => client.lineage?.get?.query?.({ eventId }) ?? Promise.resolve({ lineage: null })
+  });
+}
+function useLineageTrace(trackId, opts = {}) {
+  const { client } = useAeroSwarmContext();
+  return useQuery({
+    queryKey: ["aero-lineage-trace", trackId],
+    enabled: opts.enabled !== false && !!trackId,
+    queryFn: () => client.lineage?.trace?.query?.({ trackId }) ?? Promise.resolve({ trace: [] })
+  });
+}
+export {
+  AeroSwarmProvider,
+  selectAllTracks,
+  selectError,
+  selectIsDegraded,
+  selectLastUpdateAt,
+  selectRenderableTracks,
+  selectStatus,
+  selectTrack,
+  selectTrackCount,
+  useAeroSnapshot,
+  useAeroStatus,
+  useAeroSwarmContext,
+  useAeroTrack,
+  useAeroTracks,
+  useLineage,
+  useLineageTrace,
+  useReplayStatus,
+  useReplayStop,
+  useSourceHealth,
+  useTrackCount,
+  useTrackHistory,
+  useTrackStore,
+  useTracks,
+  useWebhooks
+};
+//# sourceMappingURL=index.js.map