@aeroswarm/ingest 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,73 @@
-# Temporary Holding Version
+# @aeroswarm/ingest
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Switchable surveillance ingest sources for AeroSwarm-style backends. Every
+source emits the same `IngestEvent` union, so a backend swaps its data path —
+**direct site feed** vs **via AeroSwarm** — with config alone.
+
+```ts
+import { createFeedSource } from "@aeroswarm/ingest";          // direct
+import { KafkaSource } from "@aeroswarm/ingest/kafka";         // via AeroSwarm
+import { WsSource } from "@aeroswarm/ingest/ws";               // via AeroSwarm (track-only)
+
+const source =
+  MODE === "direct"
+    ? createFeedSource({ protocol: "asterix", port: 13217, multicastGroup: "224.1.1.109", airportId: "WARR" })
+    : new KafkaSource({ brokers: ["redpanda:9092"], groupId: "backend-djuanda" });
+
+await source.start((ev) => {
+  if (ev.kind === "track") pipeline.pushTrack(ev.event);
+  if (ev.kind === "flightplan") pipeline.pushPlan(ev.event);
+  if (ev.kind === "health") pipeline.pushHealth(ev.event);
+});
+```
+
+## Event union
+
+| `kind` | Payload | Emitted by |
+|---|---|---|
+| `track` | `FusedTrackEvent` (direct/Kafka) or `CurrentTrack` (WS) | all |
+| `trackRemoved` | `{ trackId, reason }` | WS |
+| `flightplan` | `FlightPlanEvent` (FPL/CHG/DLA/DEP/ARR/CNL) | AFTN feed, Kafka |
+| `health` | `SourceHealthEvent` (CAT23 GS status, packet rates) | ASTERIX feed, Kafka |
+| `raw` | `{ topic, key, fields }` | ASTERIX feed, Kafka (non-pipeline topics) |
+| `status` | `{ status, reason }` | WS (`source.status`, `stream.degraded/error`) |
+
+Narrow `track` payloads with `"position" in ev.event` (`FusedTrackEvent`) vs
+`"lat" in ev.event` (`CurrentTrack`).
+
+## Direct feeds — `createFeedSource(config)`
+
+| Field | `asterix` | `aftn` |
+|---|---|---|
+| `port` | UDP listen / TCP remote port | same |
+| `transport` | `"udp"` (default) \| `"tcp"` | same |
+| `host` | TCP remote host | TCP remote host |
+| `multicastGroup` / `multicastIface` | join a multicast feed | same |
+| `airportId` / `sourceId` / `feedId` | stamped on emitted events | same |
+| `allowedCats` / `forcedEditions` | decode filters | — |
+| `radarSite` | polar→WGS84 for CAT020/048 | — |
+
+`stats` mirrors the simulator-service feed counters (`packetsReceived`,
+`packetsForwarded`, `packetsUndecoded`, `gsStatus`, `lastMessage`, …).
+
+Differences vs going through AeroSwarm (honest): direct feeds emit **per-feed
+raw** FusedTrackEvents — no multi-sensor fusion, and `flightPlan` never rides
+on the track (plans arrive as separate `flightplan` events; correlate with
+`applyFlightPlanEvent` / `pickMatchingPlan` from `@aeroswarm/core`).
+
+## AeroSwarm relays
+
+**`KafkaSource`** (peer dep `kafkajs`) — consumes `aero.fused.track.v1`,
+`aero.flightplan.v1`, `aero.source.health.v1` (overridable via `topics`). The
+faithful path: standalone flight plans arrive even with no track correlation.
+
+**`WsSource`** — subscribes `/ws/tracks/live` (snapshot + diff of
+`CurrentTrack`, `flightPlan` attached when correlated). Track-only: no
+standalone plans, no health. On Node < 22 pass `WebSocketImpl` (e.g. `ws`).
+Zero dependencies otherwise — uses the global `WebSocket`.
+
+## Status
+
+- `simulator-service` still carries its own copies of these listeners; a
+  later task migrates it onto this package (the ports here are byte-for-byte
+  ports of `AsterixUdpService` / `AftnService`).

package/dist/feed/aftn.d.ts

@@ -0,0 +1,50 @@
+import type { IngestEventHandler, IngestSource, IngestSourceStats } from "../types.js";
+export interface AftnFeedStats extends IngestSourceStats {
+    lastMessage: {
+        type: string;
+        callsign?: string;
+        adep?: string;
+        ades?: string;
+        at: number;
+    } | null;
+}
+export interface AftnFeedConfig {
+    /** UDP listen port (udp) or remote port (tcp) */
+    port: number;
+    transport?: "udp" | "tcp";
+    /** TCP only: remote AFTN gateway host */
+    host?: string;
+    airportId?: string;
+    sourceId?: string;
+    feedId?: string;
+    multicastGroup?: string;
+    multicastIface?: string;
+}
+/** Direct AFTN/ATS feed source: UDP (one message per datagram) or a TCP
+ *  client (messages end at NNNN / ETX). Emits kind "flightplan" for every
+ *  parsed message — folding into flight plans and correlating with tracks is
+ *  the consumer's job (applyFlightPlanEvent / pickMatchingPlan in core). */
+export declare class AftnFeedSource implements IngestSource {
+    private readonly cfg;
+    readonly stats: AftnFeedStats;
+    private socket;
+    private tcpSocket;
+    private tcpBuffer;
+    private tcpReconnectTimer;
+    private shouldRun;
+    private emit;
+    constructor(cfg?: AftnFeedConfig);
+    private sourceId;
+    private resetState;
+    /** Parse one raw message and emit it. */
+    processMessage(raw: string | Buffer): void;
+    /** A UDP datagram normally holds one message; tolerate several back to back. */
+    private processDatagram;
+    start(onEvent: IngestEventHandler): void;
+    private startUdp;
+    private startTcp;
+    private connectTcp;
+    private closeSockets;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=aftn.d.ts.map

package/dist/feed/aftn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aftn.d.ts","sourceRoot":"","sources":["../../src/feed/aftn.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOvF,MAAM,WAAW,aAAc,SAAQ,iBAAiB;IACtD,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACnG;AAED,MAAM,WAAW,cAAc;IAC7B,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IAC1B,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;4EAG4E;AAC5E,qBAAa,cAAe,YAAW,YAAY;IAcrC,OAAO,CAAC,QAAQ,CAAC,GAAG;IAbhC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAI3B;IAEF,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,iBAAiB,CAA+B;IACxD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAAgC;gBAEf,GAAG,GAAE,cAA4B;IAE9D,OAAO,CAAC,QAAQ;IAEhB,OAAO,CAAC,UAAU;IASlB,yCAAyC;IACzC,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAmC1C,gFAAgF;IAChF,OAAO,CAAC,eAAe;IASvB,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAUxC,OAAO,CAAC,QAAQ;IAyBhB,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,UAAU;IAuClB,OAAO,CAAC,YAAY;IAMd,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAO5B"}

package/dist/feed/asterix.d.ts

@@ -0,0 +1,76 @@
+import type { RadarSite } from "@aeroswarm/codec";
+import type { IngestEventHandler, IngestSource, IngestSourceStats } from "../types.js";
+export interface AsterixFeedStats extends IngestSourceStats {
+    lastDecoded: {
+        category: number;
+        edition: string;
+        icao24?: string;
+        lat?: number;
+        lon?: number;
+        at: number;
+    } | null;
+    /** Latest CAT23 ground-station status report */
+    gsStatus: {
+        sac?: number;
+        sic?: number;
+        status: "healthy" | "degraded" | "offline";
+        operationalRangeNm?: number;
+        at: number;
+    } | null;
+}
+/** Per-feed configuration — every field explicit (no env fallbacks inside the
+ *  package; the host process supplies them). */
+export interface AsterixFeedConfig {
+    /** UDP listen port (udp) or remote port (tcp) */
+    port: number;
+    transport?: "udp" | "tcp";
+    /** TCP only: remote host to connect out to */
+    host?: string;
+    airportId?: string;
+    sourceId?: string;
+    feedId?: string;
+    allowedCats?: Set<number>;
+    forcedEditions?: Record<number, string>;
+    multicastGroup?: string;
+    multicastIface?: string;
+    /** Radar site position for CAT020/048 polar→WGS84 resolution */
+    radarSite?: RadarSite;
+}
+/** Direct ASTERIX feed source: UDP datagrams (unicast or multicast) or a TCP
+ *  client stream ([CAT][LEN]… blocks), decoded to FusedTrackEvents. Emits
+ *  kind "track" (fused), "health" (CAT23 ground-station status + dropped
+ *  lifecycle tracks), and "raw" (per-category field dump). */
+export declare class AsterixFeedSource implements IngestSource {
+    private readonly cfg;
+    readonly stats: AsterixFeedStats;
+    private lastHealth;
+    private socket;
+    private tcpSocket;
+    private tcpBuffer;
+    private tcpReconnectTimer;
+    private shouldRun;
+    private trackMap;
+    private sweepTimer;
+    private emit;
+    constructor(cfg?: AsterixFeedConfig);
+    private sourceId;
+    private meta;
+    private makeFused;
+    /** CAT23 report → source health event. NOGO means the ground station itself
+     *  says its data must not be used operationally. */
+    private handleGsStatus;
+    /** Decode one ASTERIX datagram/block and emit the resulting tracks. */
+    processDatagram(buf: Buffer): void;
+    private resetState;
+    start(onEvent: IngestEventHandler): void;
+    private startUdp;
+    private startTcp;
+    private connectTcp;
+    private closeSockets;
+    private emitDropped;
+    /** Evict track entries idle longer than TRACK_MAP_TTL_MS, emitting a
+     *  "dropped" lifecycle event for each. */
+    private sweepTrackMap;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=asterix.d.ts.map

package/dist/feed/asterix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asterix.d.ts","sourceRoot":"","sources":["../../src/feed/asterix.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGjE,OAAO,KAAK,EAAe,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAgBpG,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;IACzD,WAAW,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACnH,gDAAgD;IAChD,QAAQ,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC;QAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACtI;AAED;gDACgD;AAChD,MAAM,WAAW,iBAAiB;IAChC,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IAC1B,8CAA8C;IAC9C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gEAAgE;IAChE,SAAS,CAAC,EAAE,SAAS,CAAC;CACvB;AAID;;;8DAG8D;AAC9D,qBAAa,iBAAkB,YAAW,YAAY;IAwBxC,OAAO,CAAC,QAAQ,CAAC,GAAG;IAvBhC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAM9B;IAEF,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,SAAS,CAA2B;IAC5C,OAAO,CAAC,iBAAiB,CAA+B;IACxD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAKX;IACL,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,IAAI,CAAgC;gBAEf,GAAG,GAAE,iBAA+B;IAEjE,OAAO,CAAC,QAAQ;IAEhB,OAAO,CAAC,IAAI;IASZ,OAAO,CAAC,SAAS;IAoBjB;wDACoD;IACpD,OAAO,CAAC,cAAc;IAqCtB,uEAAuE;IACvE,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IA6IlC,OAAO,CAAC,UAAU;IAkBlB,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAUxC,OAAO,CAAC,QAAQ;IAyBhB,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,UAAU;YAgDJ,YAAY;IAM1B,OAAO,CAAC,WAAW;IASnB;8CAC0C;IAC1C,OAAO,CAAC,aAAa;IASf,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAU5B"}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { AsterixFeedSource } from "./feed/asterix.js";
+import type { AsterixFeedConfig, AsterixFeedStats } from "./feed/asterix.js";
+import { AftnFeedSource } from "./feed/aftn.js";
+import type { AftnFeedConfig, AftnFeedStats } from "./feed/aftn.js";
+export type { IngestEvent, IngestEventHandler, IngestSource, IngestSourceStats } from "./types.js";
+export { AsterixFeedSource, AftnFeedSource };
+export type { AsterixFeedConfig, AsterixFeedStats, AftnFeedConfig, AftnFeedStats };
+export type FeedSourceConfig = ({
+    protocol: "asterix";
+} & AsterixFeedConfig) | ({
+    protocol: "aftn";
+} & AftnFeedConfig);
+/** Direct feed factory — a UDP/TCP listener bound to this process, decoded
+ *  locally (no AeroSwarm in the path). For the "via AeroSwarm" path use
+ *  KafkaSource / WsSource from the subpath exports. */
+export declare function createFeedSource(cfg: FeedSourceConfig): AsterixFeedSource | AftnFeedSource;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpE,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACnG,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,CAAC;AAC7C,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC;AAEnF,MAAM,MAAM,gBAAgB,GACxB,CAAC;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,GAAG,iBAAiB,CAAC,GAC7C,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,cAAc,CAAC,CAAC;AAE5C;;uDAEuD;AACvD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,gBAAgB,GAAG,iBAAiB,GAAG,cAAc,CAK1F"}

package/dist/index.js

@@ -0,0 +1,605 @@
+// src/feed/asterix.ts
+import { createSocket } from "dgram";
+import { connect as tcpConnect } from "net";
+import { parseAsterix, resolveAsterixPosition, resolveAsterixAltitudeFt } from "@aeroswarm/codec";
+import { createLogger, createNanoid } from "@aeroswarm/core";
+var log = createLogger("ingest:asterix");
+var RAW_CAT21_TOPIC = "aero.raw.asterix.cat021.v1";
+var RAW_CAT10_TOPIC = "aero.raw.asterix.cat010.v1";
+var RAW_ADSB_TOPIC = "aero.raw.adsb.v1";
+var TCP_MAX_BUFFER = 64 * 1024;
+var TCP_RECONNECT_MS = 5e3;
+var TRACK_MAP_TTL_MS = 10 * 6e4;
+var TRACK_MAP_SWEEP_MS = 6e4;
+var DEFAULT_ALLOWED_CATS = /* @__PURE__ */ new Set([10, 11, 20, 21, 48, 62]);
+var AsterixFeedSource = class {
+  constructor(cfg = { port: 0 }) {
+    this.cfg = cfg;
+  }
+  cfg;
+  stats = {
+    running: false,
+    transport: "udp",
+    port: 0,
+    remote: null,
+    packetsReceived: 0,
+    packetsForwarded: 0,
+    packetsRejected: 0,
+    packetsSkipped: 0,
+    packetsUndecoded: 0,
+    lastDecoded: null,
+    gsStatus: null,
+    lastError: null
+  };
+  lastHealth = { at: 0, packets: 0 };
+  socket = null;
+  tcpSocket = null;
+  tcpBuffer = Buffer.alloc(0);
+  tcpReconnectTimer = null;
+  shouldRun = false;
+  trackMap = /* @__PURE__ */ new Map();
+  sweepTimer = null;
+  emit = () => {
+  };
+  sourceId() {
+    return this.cfg.sourceId ?? "ingest";
+  }
+  meta() {
+    return {
+      sourceType: this.stats.transport === "tcp" ? "ASTERIX_TCP" : "ASTERIX_UDP",
+      port: this.stats.port,
+      ...this.cfg.feedId && { feedId: this.cfg.feedId },
+      ingest: "@aeroswarm/ingest"
+    };
+  }
+  makeFused(trackId, icao24, callsign, lat, lon, altFt, speedKt, headingDeg, verticalRateFpm, protocol, meta) {
+    const now = Date.now();
+    return {
+      trackId,
+      sources: [this.sourceId()],
+      identity: { icao24, callsign },
+      protocol,
+      position: { lat, lon, alt: altFt, altSource: "baro" },
+      velocity: { groundSpeed: speedKt, heading: headingDeg, verticalRate: verticalRateFpm },
+      confidence: { overall: 0.85, position: 0.9, identity: 0.95, velocity: 0.8, sourceAgreement: 1, spoofRisk: 0.05 },
+      fusedAt: now,
+      updatedAt: now,
+      lifecycle: "updated",
+      meta
+    };
+  }
+  /** CAT23 report → source health event. NOGO means the ground station itself
+   *  says its data must not be used operationally. */
+  handleGsStatus(f) {
+    if (f.reportType !== void 0 && f.reportType !== 1) return;
+    const gs = f.gsStatus;
+    const status = gs?.nogo ? "offline" : gs?.odp || gs?.oxt || gs?.tsv ? "degraded" : "healthy";
+    const now = Date.now();
+    const dt = (now - this.lastHealth.at) / 1e3;
+    const packetsPerSecond = this.lastHealth.at > 0 && dt > 0 ? Math.round((this.stats.packetsReceived - this.lastHealth.packets) / dt) : 0;
+    this.lastHealth = { at: now, packets: this.stats.packetsReceived };
+    const prev = this.stats.gsStatus?.status;
+    this.stats.gsStatus = {
+      sac: f.dataSource?.sac,
+      sic: f.dataSource?.sic,
+      status,
+      operationalRangeNm: f.operationalRangeNm,
+      at: now
+    };
+    if (prev !== status) {
+      log.info({ sac: f.dataSource?.sac, sic: f.dataSource?.sic, status, prev: prev ?? "none" }, "ground station status changed");
+    }
+    this.emit({
+      kind: "health",
+      event: {
+        sourceId: this.sourceId(),
+        status,
+        timestamp: now,
+        latencyMs: 0,
+        packetLossRate: 0,
+        packetsPerSecond,
+        bufferFillRatio: 0
+      }
+    });
+  }
+  /** Decode one ASTERIX datagram/block and emit the resulting tracks. */
+  processDatagram(buf) {
+    this.stats.packetsReceived++;
+    if (buf.length < 3) {
+      this.stats.packetsSkipped++;
+      return;
+    }
+    const allowedCats = this.cfg.allowedCats ?? DEFAULT_ALLOWED_CATS;
+    try {
+      const records = parseAsterix(
+        buf,
+        this.cfg.forcedEditions && Object.keys(this.cfg.forcedEditions).length > 0 ? this.cfg.forcedEditions : void 0
+      );
+      if (records.length === 0) {
+        this.stats.packetsUndecoded++;
+        if (this.stats.packetsUndecoded === 1 || this.stats.packetsUndecoded % 1e3 === 0) {
+          log.warn(
+            { count: this.stats.packetsUndecoded, cat: buf[0], len: buf.length, head: buf.subarray(0, 16).toString("hex") },
+            "packet parsed to zero records \u2014 no ASTERIX edition decoded it"
+          );
+        }
+        return;
+      }
+      for (const rec of records) {
+        if (rec.category === 23) {
+          this.handleGsStatus(rec.fields);
+          continue;
+        }
+        if (rec.category === 34 || rec.category === 63 || rec.category === 19 || rec.category === 247) continue;
+        if (!allowedCats.has(rec.category)) {
+          this.stats.packetsSkipped++;
+          continue;
+        }
+        const f = rec.fields;
+        const isSurface = rec.category === 10 || rec.category === 11;
+        let icao24 = f.icao24;
+        if (!icao24 && f.trackNumber !== void 0) {
+          const prefix = isSurface ? "v" : rec.category === 62 ? "t" : "r";
+          icao24 = `${prefix}${f.dataSource?.sac ?? 0}-${f.dataSource?.sic ?? 0}-${f.trackNumber}`;
+        }
+        if (!icao24) {
+          this.stats.packetsSkipped++;
+          continue;
+        }
+        const pos = resolveAsterixPosition(f, this.cfg.radarSite ?? null);
+        if (!pos) {
+          this.stats.packetsSkipped++;
+          continue;
+        }
+        this.stats.lastDecoded = {
+          category: rec.category,
+          edition: rec.edition,
+          icao24,
+          lat: pos.lat,
+          lon: pos.lon,
+          at: Date.now()
+        };
+        const altFt = resolveAsterixAltitudeFt(f) ?? 0;
+        const vel = f["velocity"];
+        const callsign = f["callsign"];
+        const squawk = f["squawk"];
+        const now = Date.now();
+        let prevEntry = this.trackMap.get(icao24);
+        if ((icao24.startsWith("v") || icao24.startsWith("t") || icao24.startsWith("r")) && prevEntry?.lastPos) {
+          const dtS = (now - prevEntry.lastPos.at) / 1e3;
+          if (dtS > 0.2) {
+            const kx = 111320 * Math.cos(pos.lat * Math.PI / 180);
+            const dxM = (pos.lon - prevEntry.lastPos.lon) * kx;
+            const dyM = (pos.lat - prevEntry.lastPos.lat) * 111320;
+            const derivedKt = Math.hypot(dxM, dyM) / dtS * 1.94384;
+            const maxPlausibleKt = icao24.startsWith("v") ? 100 : 700;
+            if (derivedKt > maxPlausibleKt) prevEntry = void 0;
+          }
+        }
+        const trackId = prevEntry?.trackId ?? `ast_${createNanoid(12)}`;
+        let gs = vel?.groundSpeedKt;
+        let hdg = vel?.headingDeg;
+        if (gs !== void 0 && (gs < 0 || gs > 1200)) gs = void 0;
+        if ((gs === void 0 || hdg === void 0) && prevEntry?.lastPos) {
+          const dtS = (now - prevEntry.lastPos.at) / 1e3;
+          if (dtS > 0.2 && dtS < 30) {
+            const kx = 111320 * Math.cos(pos.lat * Math.PI / 180);
+            const dxM = (pos.lon - prevEntry.lastPos.lon) * kx;
+            const dyM = (pos.lat - prevEntry.lastPos.lat) * 111320;
+            const distM = Math.hypot(dxM, dyM);
+            const derivedKt = distM / dtS * 1.94384;
+            if (distM > 2 && derivedKt <= 700) {
+              if (hdg === void 0) hdg = (Math.atan2(dxM, dyM) * 180 / Math.PI + 360) % 360;
+              if (gs === void 0) gs = derivedKt;
+            }
+          }
+        }
+        if (gs === void 0) gs = prevEntry?.lastVel?.gs ?? 0;
+        if (hdg === void 0) hdg = prevEntry?.lastVel?.hdg ?? 0;
+        this.trackMap.set(icao24, {
+          trackId,
+          lastSeenAt: now,
+          lastVel: { gs, hdg },
+          lastPos: { lat: pos.lat, lon: pos.lon, at: now }
+        });
+        const rawTopic = rec.category === 21 ? RAW_CAT21_TOPIC : isSurface ? RAW_CAT10_TOPIC : RAW_ADSB_TOPIC;
+        this.emit({
+          kind: "raw",
+          topic: rawTopic,
+          key: icao24,
+          fields: { ...f, category: rec.category, sourceId: this.sourceId(), receivedAt: now }
+        });
+        const protocol = rec.category === 10 ? "asterix-cat010" : rec.category === 11 ? "asterix-cat011" : rec.category === 20 ? "asterix-cat020" : rec.category === 21 ? "asterix-cat021" : rec.category === 62 ? "asterix-cat062" : "asterix-cat048";
+        const fused = this.makeFused(
+          trackId,
+          icao24,
+          callsign,
+          pos.lat,
+          pos.lon,
+          altFt,
+          gs,
+          hdg,
+          0,
+          protocol,
+          { ...this.meta(), receivedAt: now }
+        );
+        if (squawk) fused.identity = { ...fused.identity, squawk };
+        if (this.cfg.airportId) fused.airportId = this.cfg.airportId;
+        if (isSurface) {
+          const targetType = f.targetType ?? (f.icao24 ? "aircraft" : "unknown");
+          fused.identity = {
+            ...fused.identity,
+            targetType,
+            ...f.vehicleFleet !== void 0 && { vehicleFleet: f.vehicleFleet }
+          };
+        }
+        this.emit({ kind: "track", event: fused });
+        this.stats.packetsForwarded++;
+      }
+    } catch (err) {
+      this.stats.packetsRejected++;
+      this.stats.lastError = err instanceof Error ? err.message : String(err);
+    }
+  }
+  resetState(patch) {
+    Object.assign(this.stats, {
+      running: true,
+      transport: "udp",
+      port: 0,
+      remote: null,
+      packetsReceived: 0,
+      packetsForwarded: 0,
+      packetsRejected: 0,
+      packetsSkipped: 0,
+      packetsUndecoded: 0,
+      lastDecoded: null,
+      gsStatus: null,
+      lastError: null,
+      ...patch
+    });
+    this.lastHealth = { at: 0, packets: 0 };
+    this.trackMap.clear();
+    if (!this.sweepTimer) {
+      this.sweepTimer = setInterval(() => this.sweepTrackMap(), TRACK_MAP_SWEEP_MS);
+    }
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────────
+  start(onEvent) {
+    this.emit = onEvent;
+    if (this.cfg.transport === "tcp") {
+      if (!this.cfg.host) throw new Error("AsterixFeedSource: host is required for TCP transport");
+      this.startTcp(this.cfg.host, this.cfg.port);
+    } else {
+      this.startUdp(this.cfg.port);
+    }
+  }
+  startUdp(port) {
+    void this.closeSockets();
+    this.shouldRun = true;
+    this.socket = createSocket({ type: "udp4", reuseAddr: true });
+    this.socket.on("message", (buf) => this.processDatagram(buf));
+    this.socket.on("error", (err) => {
+      this.stats.lastError = err.message;
+      log.warn({ err: err.message }, "asterix UDP socket error");
+    });
+    this.socket.bind(port, "0.0.0.0", () => {
+      if (this.cfg.multicastGroup) {
+        try {
+          this.socket.addMembership(this.cfg.multicastGroup, this.cfg.multicastIface || void 0);
+          log.info({ group: this.cfg.multicastGroup, iface: this.cfg.multicastIface || "auto" }, "joined multicast group");
+        } catch (err) {
+          log.error({ err, group: this.cfg.multicastGroup }, "failed to join multicast group");
+        }
+      }
+      this.resetState({ transport: "udp", port });
+      log.info({ port, multicast: this.cfg.multicastGroup || "disabled", airport: this.cfg.airportId ?? "unscoped" }, "asterix UDP listener started");
+    });
+  }
+  startTcp(host, port) {
+    void this.closeSockets();
+    this.shouldRun = true;
+    this.connectTcp(host, port);
+  }
+  connectTcp(host, port) {
+    this.tcpBuffer = Buffer.alloc(0);
+    const sock = tcpConnect({ host, port });
+    this.tcpSocket = sock;
+    sock.on("connect", () => {
+      this.resetState({ transport: "tcp", port, remote: `${host}:${port}` });
+      log.info({ host, port, airport: this.cfg.airportId ?? "unscoped" }, "asterix TCP feed connected");
+    });
+    sock.on("data", (chunk) => {
+      this.tcpBuffer = Buffer.concat([this.tcpBuffer, chunk]);
+      while (this.tcpBuffer.length >= 3) {
+        const len = this.tcpBuffer[1] << 8 | this.tcpBuffer[2];
+        if (len < 3) {
+          this.stats.packetsRejected++;
+          this.tcpBuffer = this.tcpBuffer.subarray(1);
+          continue;
+        }
+        if (this.tcpBuffer.length < len) break;
+        this.processDatagram(this.tcpBuffer.subarray(0, len));
+        this.tcpBuffer = this.tcpBuffer.subarray(len);
+      }
+      if (this.tcpBuffer.length > TCP_MAX_BUFFER) {
+        log.warn({ buffered: this.tcpBuffer.length }, "TCP buffer overflow \u2014 resyncing");
+        this.stats.packetsRejected++;
+        this.tcpBuffer = Buffer.alloc(0);
+      }
+    });
+    const scheduleReconnect = (why) => {
+      this.tcpSocket = null;
+      this.stats.running = false;
+      if (!this.shouldRun || this.tcpReconnectTimer) return;
+      log.warn({ host, port, why }, `asterix TCP feed disconnected \u2014 retrying in ${TCP_RECONNECT_MS / 1e3}s`);
+      this.tcpReconnectTimer = setTimeout(() => {
+        this.tcpReconnectTimer = null;
+        if (this.shouldRun) this.connectTcp(host, port);
+      }, TCP_RECONNECT_MS);
+    };
+    sock.on("error", (err) => {
+      this.stats.lastError = err.message;
+      scheduleReconnect(err.message);
+    });
+    sock.on("close", () => scheduleReconnect("closed"));
+  }
+  async closeSockets() {
+    if (this.tcpReconnectTimer) {
+      clearTimeout(this.tcpReconnectTimer);
+      this.tcpReconnectTimer = null;
+    }
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
+    if (this.tcpSocket) {
+      this.tcpSocket.destroy();
+      this.tcpSocket = null;
+    }
+  }
+  emitDropped(icao24, trackId, reason) {
+    const dropped = {
+      ...this.makeFused(
+        trackId,
+        icao24,
+        void 0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        "asterix-cat021",
+        { ...this.meta(), droppedAt: Date.now(), reason }
+      ),
+      lifecycle: "dropped"
+    };
+    this.emit({ kind: "track", event: dropped });
+  }
+  /** Evict track entries idle longer than TRACK_MAP_TTL_MS, emitting a
+   *  "dropped" lifecycle event for each. */
+  sweepTrackMap() {
+    const cutoff = Date.now() - TRACK_MAP_TTL_MS;
+    for (const [icao24, entry] of this.trackMap) {
+      if (entry.lastSeenAt >= cutoff) continue;
+      this.trackMap.delete(icao24);
+      this.emitDropped(icao24, entry.trackId, "stale");
+    }
+  }
+  async stop() {
+    this.shouldRun = false;
+    await this.closeSockets();
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+    for (const [icao24, entry] of this.trackMap) this.emitDropped(icao24, entry.trackId, "stopped");
+    this.trackMap.clear();
+    this.stats.running = false;
+    this.emit = () => {
+    };
+    log.info({ transport: this.stats.transport }, "asterix feed stopped");
+  }
+};
+
+// src/feed/aftn.ts
+import { createSocket as createSocket2 } from "dgram";
+import { connect as tcpConnect2 } from "net";
+import { parseAftn, splitAftnStream } from "@aeroswarm/codec";
+import { createLogger as createLogger2, createNanoid as createNanoid2 } from "@aeroswarm/core";
+var log2 = createLogger2("ingest:aftn");
+var TCP_RECONNECT_MS2 = 5e3;
+var TCP_MAX_BUFFER2 = 1e6;
+var AftnFeedSource = class {
+  constructor(cfg = { port: 0 }) {
+    this.cfg = cfg;
+  }
+  cfg;
+  stats = {
+    running: false,
+    transport: "udp",
+    port: 0,
+    remote: null,
+    packetsReceived: 0,
+    packetsForwarded: 0,
+    packetsRejected: 0,
+    packetsSkipped: 0,
+    packetsUndecoded: 0,
+    lastMessage: null,
+    lastError: null
+  };
+  socket = null;
+  tcpSocket = null;
+  tcpBuffer = "";
+  tcpReconnectTimer = null;
+  shouldRun = false;
+  emit = () => {
+  };
+  sourceId() {
+    return this.cfg.sourceId ?? "ingest";
+  }
+  resetState(patch) {
+    Object.assign(this.stats, {
+      running: true,
+      transport: "udp",
+      port: 0,
+      remote: null,
+      packetsReceived: 0,
+      packetsForwarded: 0,
+      packetsRejected: 0,
+      packetsSkipped: 0,
+      packetsUndecoded: 0,
+      lastMessage: null,
+      lastError: null,
+      ...patch
+    });
+  }
+  /** Parse one raw message and emit it. */
+  processMessage(raw) {
+    this.stats.packetsReceived++;
+    const now = Date.now();
+    const parsed = parseAftn(raw, { now });
+    if (!parsed) {
+      this.stats.packetsUndecoded++;
+      if (this.stats.packetsUndecoded === 1 || this.stats.packetsUndecoded % 1e3 === 0) {
+        const head = (typeof raw === "string" ? Buffer.from(raw, "latin1") : raw).subarray(0, 64).toString("latin1");
+        log2.warn({ count: this.stats.packetsUndecoded, head }, "no ATS message found in payload");
+      }
+      return;
+    }
+    if (!parsed.callsign) {
+      this.stats.packetsSkipped++;
+      return;
+    }
+    this.stats.lastMessage = {
+      type: parsed.type,
+      callsign: parsed.callsign,
+      adep: parsed.adep,
+      ades: parsed.ades,
+      at: now
+    };
+    this.emit({
+      kind: "flightplan",
+      event: {
+        messageId: createNanoid2(12),
+        sourceId: this.sourceId(),
+        ...this.cfg.feedId && { feedId: this.cfg.feedId },
+        ...this.cfg.airportId && { airportId: this.cfg.airportId },
+        receivedAt: now,
+        message: parsed
+      }
+    });
+    this.stats.packetsForwarded++;
+  }
+  /** A UDP datagram normally holds one message; tolerate several back to back. */
+  processDatagram(buf) {
+    const text = buf.toString("latin1");
+    const { messages, rest } = splitAftnStream(text);
+    const all = messages.length > 0 ? [...messages, ...rest.includes("(") ? [rest] : []] : [text];
+    for (const m of all) this.processMessage(m);
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────────
+  start(onEvent) {
+    this.emit = onEvent;
+    if (this.cfg.transport === "tcp") {
+      if (!this.cfg.host) throw new Error("AftnFeedSource: host is required for TCP transport");
+      this.startTcp(this.cfg.host, this.cfg.port);
+    } else {
+      this.startUdp(this.cfg.port);
+    }
+  }
+  startUdp(port) {
+    this.closeSockets();
+    this.shouldRun = true;
+    this.socket = createSocket2({ type: "udp4", reuseAddr: true });
+    this.socket.on("message", (buf) => this.processDatagram(buf));
+    this.socket.on("error", (err) => {
+      this.stats.lastError = err.message;
+      log2.warn({ err: err.message }, "aftn UDP socket error");
+    });
+    this.socket.bind(port, "0.0.0.0", () => {
+      if (this.cfg.multicastGroup) {
+        try {
+          this.socket.addMembership(this.cfg.multicastGroup, this.cfg.multicastIface || void 0);
+          log2.info({ group: this.cfg.multicastGroup, iface: this.cfg.multicastIface || "auto" }, "joined multicast group");
+        } catch (err) {
+          log2.error({ err, group: this.cfg.multicastGroup }, "failed to join multicast group");
+        }
+      }
+      this.resetState({ transport: "udp", port });
+      log2.info({ port, airport: this.cfg.airportId ?? "unscoped" }, "aftn UDP listener started");
+    });
+  }
+  startTcp(host, port) {
+    this.closeSockets();
+    this.shouldRun = true;
+    this.connectTcp(host, port);
+  }
+  connectTcp(host, port) {
+    this.tcpBuffer = "";
+    const sock = tcpConnect2({ host, port });
+    this.tcpSocket = sock;
+    sock.on("connect", () => {
+      this.resetState({ transport: "tcp", port, remote: `${host}:${port}` });
+      log2.info({ host, port, airport: this.cfg.airportId ?? "unscoped" }, "aftn TCP feed connected");
+    });
+    sock.on("data", (chunk) => {
+      const { messages, rest } = splitAftnStream(this.tcpBuffer + chunk.toString("latin1"));
+      this.tcpBuffer = rest;
+      for (const m of messages) this.processMessage(m);
+      if (this.tcpBuffer.length > TCP_MAX_BUFFER2) {
+        log2.warn({ buffered: this.tcpBuffer.length }, "aftn TCP buffer overflow \u2014 resyncing");
+        this.stats.packetsRejected++;
+        this.tcpBuffer = "";
+      }
+    });
+    const scheduleReconnect = (why) => {
+      this.tcpSocket = null;
+      this.stats.running = false;
+      if (!this.shouldRun || this.tcpReconnectTimer) return;
+      log2.warn({ host, port, why }, `aftn TCP feed disconnected \u2014 retrying in ${TCP_RECONNECT_MS2 / 1e3}s`);
+      this.tcpReconnectTimer = setTimeout(() => {
+        this.tcpReconnectTimer = null;
+        if (this.shouldRun) this.connectTcp(host, port);
+      }, TCP_RECONNECT_MS2);
+    };
+    sock.on("error", (err) => {
+      this.stats.lastError = err.message;
+      scheduleReconnect(err.message);
+    });
+    sock.on("close", () => scheduleReconnect("closed"));
+  }
+  closeSockets() {
+    if (this.tcpReconnectTimer) {
+      clearTimeout(this.tcpReconnectTimer);
+      this.tcpReconnectTimer = null;
+    }
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
+    if (this.tcpSocket) {
+      this.tcpSocket.destroy();
+      this.tcpSocket = null;
+    }
+  }
+  async stop() {
+    this.shouldRun = false;
+    this.closeSockets();
+    this.stats.running = false;
+    this.emit = () => {
+    };
+    log2.info({ transport: this.stats.transport }, "aftn feed stopped");
+  }
+};
+
+// src/index.ts
+function createFeedSource(cfg) {
+  const { protocol: _protocol, ...rest } = cfg;
+  return cfg.protocol === "asterix" ? new AsterixFeedSource(rest) : new AftnFeedSource(rest);
+}
+export {
+  AftnFeedSource,
+  AsterixFeedSource,
+  createFeedSource
+};

package/dist/ingest.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ingest.test.d.ts.map

package/dist/ingest.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingest.test.d.ts","sourceRoot":"","sources":["../src/ingest.test.ts"],"names":[],"mappings":""}

package/dist/kafka.d.ts

@@ -0,0 +1,29 @@
+import type { IngestEventHandler, IngestSource, IngestSourceStats } from "./types.js";
+export interface KafkaSourceConfig {
+    brokers: string[];
+    /** Consumer group — use one per backend so each gets the full stream */
+    groupId: string;
+    /** Topics to subscribe; default = the fused/flight-plan/health pipeline */
+    topics?: string[];
+    fromBeginning?: boolean;
+    clientId?: string;
+    /** Passed through to kafkajs Kafka({ ssl, sasl }) verbatim */
+    ssl?: unknown;
+    sasl?: unknown;
+}
+/** AeroSwarm relay source: consumes the same Kafka topics client-service
+ *  does — fused tracks, flight plans, source health — and re-emits them as
+ *  IngestEvents. The most faithful "via AeroSwarm" path: standalone flight
+ *  plans arrive even when no track correlates yet.
+ *
+ *  Requires the optional peer `kafkajs` — `import ... from "@aeroswarm/ingest/kafka"`. */
+export declare class KafkaSource implements IngestSource {
+    private readonly cfg;
+    readonly stats: IngestSourceStats;
+    private consumer;
+    private emit;
+    constructor(cfg: KafkaSourceConfig);
+    start(onEvent: IngestEventHandler): Promise<void>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=kafka.d.ts.map

package/dist/kafka.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka.d.ts","sourceRoot":"","sources":["../src/kafka.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAItF,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,wEAAwE;IACxE,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAaD;;;;;0FAK0F;AAC1F,qBAAa,WAAY,YAAW,YAAY;IAUlC,OAAO,CAAC,QAAQ,CAAC,GAAG;IAThC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAI/B;IAEF,OAAO,CAAC,QAAQ,CAAkD;IAClE,OAAO,CAAC,IAAI,CAAgC;gBAEf,GAAG,EAAE,iBAAiB;IAE7C,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IA6CjD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ5B"}

package/dist/kafka.js

@@ -0,0 +1,81 @@
+// src/kafka.ts
+import { createLogger, TOPICS } from "@aeroswarm/core";
+var log = createLogger("ingest:kafka");
+var DEFAULT_TOPICS = [TOPICS.FUSED, TOPICS.FLIGHT_PLAN, TOPICS.HEALTH];
+var KafkaSource = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  stats = {
+    running: false,
+    transport: "kafka",
+    port: 0,
+    remote: null,
+    packetsReceived: 0,
+    packetsForwarded: 0,
+    packetsRejected: 0,
+    packetsSkipped: 0,
+    packetsUndecoded: 0,
+    lastError: null
+  };
+  consumer = null;
+  emit = () => {
+  };
+  async start(onEvent) {
+    this.emit = onEvent;
+    const { Kafka } = await import("kafkajs");
+    const kafka = new Kafka({
+      clientId: this.cfg.clientId ?? "aeroswarm-ingest",
+      brokers: this.cfg.brokers,
+      ...this.cfg.ssl !== void 0 && { ssl: this.cfg.ssl },
+      ...this.cfg.sasl !== void 0 && { sasl: this.cfg.sasl }
+    });
+    const topics = this.cfg.topics ?? DEFAULT_TOPICS;
+    this.consumer = kafka.consumer({ groupId: this.cfg.groupId });
+    await this.consumer.connect();
+    await this.consumer.subscribe({ topics, fromBeginning: this.cfg.fromBeginning ?? false });
+    await this.consumer.run({
+      eachMessage: async ({ topic, message }) => {
+        this.stats.packetsReceived++;
+        if (!message.value) {
+          this.stats.packetsSkipped++;
+          return;
+        }
+        try {
+          const data = JSON.parse(message.value.toString());
+          if (topic === TOPICS.FUSED) {
+            this.emit({ kind: "track", event: data });
+          } else if (topic === TOPICS.FLIGHT_PLAN) {
+            this.emit({ kind: "flightplan", event: data });
+          } else if (topic === TOPICS.HEALTH) {
+            this.emit({ kind: "health", event: data });
+          } else {
+            this.emit({ kind: "raw", topic, key: "", fields: data });
+            this.stats.packetsReceived--;
+            return;
+          }
+          this.stats.packetsForwarded++;
+        } catch (err) {
+          this.stats.packetsRejected++;
+          this.stats.lastError = err instanceof Error ? err.message : String(err);
+        }
+      }
+    });
+    this.stats.running = true;
+    this.stats.remote = this.cfg.brokers.join(",");
+    log.info({ brokers: this.cfg.brokers, groupId: this.cfg.groupId, topics }, "kafka source started");
+  }
+  async stop() {
+    if (this.consumer) {
+      await this.consumer.disconnect();
+      this.consumer = null;
+    }
+    this.stats.running = false;
+    this.emit = () => {
+    };
+  }
+};
+export {
+  KafkaSource
+};

package/dist/types.d.ts

@@ -0,0 +1,52 @@
+import type { CurrentTrack, FlightPlanEvent, FusedTrackEvent, SourceHealthEvent } from "@aeroswarm/core";
+/** Unified event emitted by every ingest source — direct feeds (UDP/TCP) and
+ *  AeroSwarm relays (Kafka/WS) alike. Consumers switch data path by config
+ *  only; the event shape downstream never changes.
+ *
+ *  `track` carries a FusedTrackEvent from direct feeds / Kafka, and a
+ *  CurrentTrack from the WS live stream — narrow with `"position" in ev.event`
+ *  (FusedTrackEvent) vs `"lat" in ev.event` (CurrentTrack). */
+export type IngestEvent = {
+    kind: "track";
+    event: FusedTrackEvent | CurrentTrack;
+} | {
+    kind: "trackRemoved";
+    trackId: string;
+    reason: string;
+} | {
+    kind: "flightplan";
+    event: FlightPlanEvent;
+} | {
+    kind: "health";
+    event: SourceHealthEvent;
+} | {
+    kind: "raw";
+    topic: string;
+    key: string;
+    fields: Record<string, unknown>;
+} | {
+    kind: "status";
+    status: string;
+    reason?: string;
+};
+export type IngestEventHandler = (event: IngestEvent) => void;
+/** Per-source counters, kept identical in name/shape to the feed stats the
+ *  simulator-service exposes to the dashboard today. */
+export interface IngestSourceStats {
+    running: boolean;
+    transport: "udp" | "tcp" | "kafka" | "ws";
+    port: number;
+    remote: string | null;
+    packetsReceived: number;
+    packetsForwarded: number;
+    packetsRejected: number;
+    packetsSkipped: number;
+    packetsUndecoded: number;
+    lastError: string | null;
+}
+export interface IngestSource {
+    readonly stats: IngestSourceStats;
+    start(onEvent: IngestEventHandler): void | Promise<void>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;+DAM+D;AAC/D,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,eAAe,GAAG,YAAY,CAAA;CAAE,GACxD;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,eAAe,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAC5E;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;AAE9D;wDACwD;AACxD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAClC,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB"}

package/dist/ws.d.ts

@@ -0,0 +1,52 @@
+import type { IngestEventHandler, IngestSource, IngestSourceStats } from "./types.js";
+/** Minimal structural WebSocket — satisfied by the browser/Node-22 global,
+ *  the `ws` package, and undici's WebSocket alike. */
+export interface WebSocketLike {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    onopen: (() => void) | null;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onclose: ((ev: {
+        code?: number;
+        reason?: string;
+    }) => void) | null;
+    onerror: ((ev: unknown) => void) | null;
+}
+export type WebSocketCtor = new (url: string) => WebSocketLike;
+export interface WsSourceConfig {
+    /** ws(s)://<host>/ws/tracks/live — token is appended as ?token= unless the
+     *  URL already carries one */
+    url: string;
+    token?: string;
+    /** Sent in the subscribe message; a source token overrides it server-side */
+    airportId?: string;
+    bbox?: [number, number, number, number];
+    minConfidence?: number;
+    maxUpdateHz?: number;
+    maxTracks?: number;
+    reconnectMs?: number;
+    /** WebSocket constructor override — pass `ws`'s WebSocket on Node < 22 */
+    WebSocketImpl?: WebSocketCtor;
+}
+/** AeroSwarm relay source over the live WebSocket (`/ws/tracks/live`):
+ *  snapshot + diff stream of CurrentTracks — including `track.flightPlan`
+ *  when a plan correlates. Track-only by design: standalone flight plans
+ *  (no radar contact yet) and source health never cross this channel — use
+ *  KafkaSource for the full pipeline. `import ... from "@aeroswarm/ingest/ws"`. */
+export declare class WsSource implements IngestSource {
+    private readonly cfg;
+    readonly stats: IngestSourceStats;
+    private ws;
+    private reconnectTimer;
+    private shouldRun;
+    private emit;
+    constructor(cfg: WsSourceConfig);
+    private wsUrl;
+    start(onEvent: IngestEventHandler): void;
+    private connect;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=ws.d.ts.map

package/dist/ws.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws.d.ts","sourceRoot":"","sources":["../src/ws.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAMtF;sDACsD;AACtD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,MAAM,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IACpD,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IACnE,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;CACzC;AACD,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,EAAE,MAAM,KAAK,aAAa,CAAC;AAE/D,MAAM,WAAW,cAAc;IAC7B;kCAC8B;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AASD;;;;mFAImF;AACnF,qBAAa,QAAS,YAAW,YAAY;IAY/B,OAAO,CAAC,QAAQ,CAAC,GAAG;IAXhC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAI/B;IAEF,OAAO,CAAC,EAAE,CAA8B;IACxC,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAAgC;gBAEf,GAAG,EAAE,cAAc;IAEhD,OAAO,CAAC,KAAK;IAMb,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAMxC,OAAO,CAAC,OAAO;IAsET,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ5B"}

package/dist/ws.js

@@ -0,0 +1,117 @@
+// src/ws.ts
+import { createLogger } from "@aeroswarm/core";
+var log = createLogger("ingest:ws");
+var DEFAULT_RECONNECT_MS = 5e3;
+var WsSource = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  stats = {
+    running: false,
+    transport: "ws",
+    port: 0,
+    remote: null,
+    packetsReceived: 0,
+    packetsForwarded: 0,
+    packetsRejected: 0,
+    packetsSkipped: 0,
+    packetsUndecoded: 0,
+    lastError: null
+  };
+  ws = null;
+  reconnectTimer = null;
+  shouldRun = false;
+  emit = () => {
+  };
+  wsUrl() {
+    const u = new URL(this.cfg.url);
+    if (this.cfg.token && !u.searchParams.has("token")) u.searchParams.set("token", this.cfg.token);
+    return u.toString();
+  }
+  start(onEvent) {
+    this.emit = onEvent;
+    this.shouldRun = true;
+    this.connect();
+  }
+  connect() {
+    const Impl = this.cfg.WebSocketImpl ?? globalThis.WebSocket;
+    if (!Impl) {
+      this.stats.lastError = "No WebSocket implementation \u2014 pass WebSocketImpl (e.g. from the `ws` package) on Node < 22";
+      log.error(this.stats.lastError);
+      return;
+    }
+    const url = this.wsUrl();
+    this.stats.remote = url.replace(/token=[^&]+/, "token=***");
+    const ws = new Impl(url);
+    this.ws = ws;
+    ws.onopen = () => {
+      this.stats.running = true;
+      this.stats.lastError = null;
+      ws.send(JSON.stringify({
+        type: "subscribe",
+        encoding: "json",
+        ...this.cfg.airportId && { airportId: this.cfg.airportId },
+        ...this.cfg.bbox && { bbox: this.cfg.bbox },
+        ...this.cfg.minConfidence !== void 0 && { minConfidence: this.cfg.minConfidence },
+        ...this.cfg.maxUpdateHz !== void 0 && { maxUpdateHz: this.cfg.maxUpdateHz },
+        ...this.cfg.maxTracks !== void 0 && { maxTracks: this.cfg.maxTracks }
+      }));
+      log.info({ url: this.stats.remote }, "ws source connected");
+    };
+    ws.onmessage = (ev) => {
+      this.stats.packetsReceived++;
+      try {
+        const env = JSON.parse(String(ev.data));
+        if (env.type === "snapshot") {
+          for (const track of env.payload.tracks) this.emit({ kind: "track", event: track });
+          this.stats.packetsForwarded += env.payload.tracks.length;
+        } else if (env.type === "track.updated") {
+          this.emit({ kind: "track", event: env.payload.track });
+          this.stats.packetsForwarded++;
+        } else if (env.type === "track.removed") {
+          this.emit({ kind: "trackRemoved", trackId: env.payload.trackId, reason: env.payload.reason });
+        } else if (env.type === "source.status") {
+          this.emit({ kind: "status", status: env.payload.status, reason: env.payload.sourceId });
+        } else if (env.type === "stream.degraded" || env.type === "stream.error") {
+          this.emit({ kind: "status", status: env.type, reason: String(env.payload?.["reason"] ?? env.payload?.["code"] ?? "") });
+        }
+      } catch (err) {
+        this.stats.packetsRejected++;
+        this.stats.lastError = err instanceof Error ? err.message : String(err);
+      }
+    };
+    ws.onerror = (ev) => {
+      this.stats.lastError = ev instanceof Error ? ev.message : "websocket error";
+    };
+    ws.onclose = (ev) => {
+      this.stats.running = false;
+      this.ws = null;
+      if (!this.shouldRun || this.reconnectTimer) return;
+      const ms = this.cfg.reconnectMs ?? DEFAULT_RECONNECT_MS;
+      log.warn({ code: ev.code, why: ev.reason }, `ws source disconnected \u2014 retrying in ${ms / 1e3}s`);
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnectTimer = null;
+        if (this.shouldRun) this.connect();
+      }, ms);
+    };
+  }
+  async stop() {
+    this.shouldRun = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.stats.running = false;
+    this.emit = () => {
+    };
+    log.info("ws source stopped");
+  }
+};
+export {
+  WsSource
+};

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@aeroswarm/ingest",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Switchable surveillance ingest sources — direct ASTERIX/AFTN feeds (UDP/TCP) or AeroSwarm relays (Kafka/WS), one event stream",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "main": "./dist/index.js"
+    },
+    "./kafka": {
+      "import": "./dist/kafka.js",
+      "types": "./dist/kafka.d.ts",
+      "main": "./dist/kafka.js"
+    },
+    "./ws": {
+      "import": "./dist/ws.js",
+      "types": "./dist/ws.d.ts",
+      "main": "./dist/ws.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/kafka.ts src/ws.ts --format esm --clean && tsc --emitDeclarationOnly",
+    "dev": "tsup src/index.ts src/kafka.ts src/ws.ts --format esm --dts --watch",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "pnpm run typecheck && pnpm run test && pnpm run build",
+    "release": "release-it",
+    "release:dry": "release-it --dry-run",
+    "release:patch": "release-it patch --no-git.requireCleanWorkingDir",
+    "release:minor": "release-it minor --no-git.requireCleanWorkingDir",
+    "release:major": "release-it major --no-git.requireCleanWorkingDir"
+  },
+  "dependencies": {
+    "@aeroswarm/codec": "^0.1.8",
+    "@aeroswarm/core": "^0.2.9"
+  },
+  "peerDependencies": {
+    "kafkajs": "^2.2.4"
+  },
+  "peerDependenciesMeta": {
+    "kafkajs": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "kafkajs": "^2.2.4",
+    "release-it": "^18.1.2",
+    "tsup": "^8.5.1",
+    "vitest": "^4.1.6"
+  }
+}