Class ReplayUpstream

tracker/src/upstream.ts:128–200

 * relative timing, shifted to the present so staleness math behaves.
 */
export class ReplayUpstream implements Upstream {
  private aircraft = new Map<string, Aircraft>();
  private config: Config = DEFAULT_CONFIG;
  private timers: ReturnType<typeof setTimeout>[] = [];
  private running = false;

  constructor(
    private file: string,
    private events: UpstreamEvents = {},
    private speed = 1,
  ) {}

  start(): void {
    if (this.running) return;
    this.running = true;
    const lines = readFileSync(this.file, "utf8").split("\n").filter(Boolean);
    const snaps: { t: number; aircraft: Aircraft[] }[] = [];
    for (const line of lines) {
      try {
        const rec = JSON.parse(line);
        if (rec.kind === "snapshot") snaps.push({ t: rec.t, aircraft: rec.aircraft });
      } catch {
        // tolerate partial lines from crashed sessions
      }
    }
    if (!snaps.length) {
      console.error(`[replay] no snapshots in ${this.file}`);
      return;
    }
    console.log(`[replay] ${snaps.length} snapshots from ${this.file}`);
    const t0 = snaps[0].t;
    const wall0 = Date.now();
    for (const snap of snaps) {
      const delay = (snap.t - t0) / this.speed;
      this.timers.push(
        setTimeout(() => {
          const now = Date.now();
          const shift = now - snap.t; // re-stamp into the present
          this.aircraft.clear();
          const shifted = snap.aircraft.map((ac) => ({
            ...ac,
            ts: (ac.ts ?? snap.t) + shift,
          }));
          for (const ac of shifted) this.aircraft.set(ac.hex, ac);
          this.events.onSnapshot?.(wall0 + delay * this.speed, shifted);
        }, delay),
      );
    }
  }

  stop(): void {
    for (const t of this.timers) clearTimeout(t);
    this.timers = [];
    this.running = false;
  }

  isConnected(): boolean {
    return this.running;