Latency Compensation

// arena-core.ts: constants, the shared movement function and the Pixel Arena messages.
export const ARENA_W = 1280;
export const ARENA_H = 720;
export const SPEED = 240; // px per second
export const TICK_MS = 50; // server tick, 20 Hz (also the snapshot rate)
export const FRAME_MS = 1000 / 60; // client render and input rate
export const HIT_RADIUS = 16;
export const HISTORY_MS = 1000; // lag-compensation history kept by the server
export const MAX_REWIND_MS = 200; // the server never rewinds further than this
export const RENDER_DELAY_MS = 100; // interpolation delay: two snapshots

export interface Vec {
  x: number;
  y: number;
}

/** One frame of player input. dx and dy are -1, 0 or 1; dt is the frame duration in ms. */
export interface Input {
  seq: number;
  dx: number;
  dy: number;
  dt: number;
}

export interface PlayerState extends Vec {
  id: string;
  ack: number; // lastProcessedInput
}

export type ClientMsg =
  | { t: 'input'; inputs: Input[] }
  | { t: 'fire'; seq: number; aimX: number; aimY: number; renderTime: number }
  | { t: 'ping'; c0: number };

export type ServerMsg =
  | { t: 'snap'; tick: number; time: number; players: PlayerState[] }
  | { t: 'pong'; c0: number; s1: number; s2: number }
  | { t: 'hit'; seq: number; target: string | null; rewindMs: number };

const clamp = (v: number, lo: number, hi: number) => Math.min(hi, Math.max(lo, v));

/** The single movement rule. The server and the client's prediction MUST both call exactly this. */
export function applyInput(p: Vec, i: Input): Vec {
  const len = Math.hypot(i.dx, i.dy);
  if (len === 0) return { x: p.x, y: p.y };
  const step = (SPEED * i.dt) / 1000 / len;
  return { x: clamp(p.x + i.dx * step, 0, ARENA_W), y: clamp(p.y + i.dy * step, 0, ARENA_H) };
}

/** Something the client cannot predict: a rocket's push. */
export function applyImpulse(p: Vec, v: Vec): Vec {
  return { x: clamp(p.x + v.x, 0, ARENA_W), y: clamp(p.y + v.y, 0, ARENA_H) };
}

export const dist = (a: Vec, b: Vec) => Math.hypot(a.x - b.x, a.y - b.y);
export const lerp = (a: Vec, b: Vec, f: number): Vec => ({ x: a.x + (b.x - a.x) * f, y: a.y + (b.y - a.y) * f });

/** Deterministic random numbers (mulberry32), so every run prints the same table. */
export function rng(seed: number): () => number {
  let a = seed >>> 0;
  return () => {
    a = (a + 0x6d2b79f5) >>> 0;
    let t = a;
    t = Math.imul(t ^ (t >>> 15), t | 1);
    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

// sim-net.ts: a deterministic discrete-event scheduler and a lossy, jittery one-way link.
import { rng } from './arena-core.ts';

export class Scheduler {
  now = 0;
  private queue: { at: number; n: number; fn: () => void }[] = [];
  private n = 0;

  at(at: number, fn: () => void): void {
    const e = { at, n: this.n++, fn };
    let i = this.queue.length;
    while (i > 0 && (this.queue[i - 1].at > at || (this.queue[i - 1].at === at && this.queue[i - 1].n > e.n))) i--;
    this.queue.splice(i, 0, e);
  }

  /** Runs every event up to and including `until`, in time order. */
  runUntil(until: number): void {
    while (this.queue.length > 0 && this.queue[0].at <= until) {
      const e = this.queue.shift()!;
      this.now = e.at;
      e.fn();
    }
    this.now = until;
  }
}

export interface LinkConfig {
  latencyMs: number; // mean one-way delay
  jitterMs: number; // uniform +/- jitter
  loss: number; // 0..1
  reliable: boolean; // true: TCP-like (ordered, loss costs a retransmission); false: UDP-like (drop, reorder)
  retransmitMs?: number; // extra delay of a lost packet on a reliable link
  spikeEveryMs?: number; // a delay spike of spikeLenMs every spikeEveryMs
  spikeLenMs?: number;
  spikeExtraMs?: number;
  noisyEveryMs?: number; // jitter becomes noisyJitterMs for the first noisyShare of every noisyEveryMs
  noisyShare?: number;
  noisyJitterMs?: number;
}

export class SimLink<T> {
  private sched: Scheduler;
  private cfg: LinkConfig;
  private deliver: (m: T) => void;
  private random: () => number;
  private lastAt = 0;
  sent = 0;
  dropped = 0;

  constructor(sched: Scheduler, cfg: LinkConfig, seed: number, deliver: (m: T) => void) {
    this.sched = sched;
    this.cfg = cfg;
    this.deliver = deliver;
    this.random = rng(seed);
  }

  send(msg: T): void {
    this.sent++;
    const c = this.cfg;
    const noisy = c.noisyEveryMs !== undefined && this.sched.now % c.noisyEveryMs < c.noisyEveryMs * (c.noisyShare ?? 0.5);
    const jitter = noisy ? (c.noisyJitterMs ?? c.jitterMs) : c.jitterMs;
    let delay = Math.max(1, c.latencyMs + (this.random() * 2 - 1) * jitter);
    if (c.spikeEveryMs && this.sched.now % c.spikeEveryMs < (c.spikeLenMs ?? 0)) {
      delay += this.random() * (c.spikeExtraMs ?? 0);
    }
    if (this.random() < c.loss) {
      if (!c.reliable) {
        this.dropped++;
        return;
      }
      delay += c.retransmitMs ?? 200;
    }
    let at = this.sched.now + delay;
    if (c.reliable) at = Math.max(at, this.lastAt); // head-of-line blocking: never overtake
    this.lastAt = at;
    const copy = JSON.parse(JSON.stringify(msg)) as T;
    this.sched.at(at, () => this.deliver(copy));
  }
}

// arena-server.ts: the authoritative world. Transport-agnostic: feed it messages and call tick().
import {
  applyImpulse, applyInput, dist, HISTORY_MS, HIT_RADIUS, lerp, MAX_REWIND_MS, TICK_MS,
  type ClientMsg, type Input, type PlayerState, type ServerMsg, type Vec,
} from './arena-core.ts';

const MAX_INPUT_DT_MS = 25; // one 60 Hz frame is 16.7 ms
const MAX_QUEUED_INPUTS = 30; // 3 per tick is normal; a burst after a stall is bigger
const clampAxis = (v: number) => Math.min(1, Math.max(-1, Number(v) || 0));

interface Stamp extends Vec {
  t: number;
}
interface Player extends Vec {
  id: string;
  ack: number; // lastProcessedInput
  queue: Input[];
  send?: (m: ServerMsg) => void;
  script?: (t: number) => { dx: number; dy: number }; // a bot drives itself
  impulses: Vec[];
  history: Stamp[];
}

export interface ServerOptions {
  lagCompensation: boolean;
  maxRewindMs?: number;
}

export class ArenaServer {
  tickNo = 0;
  readonly players = new Map<string, Player>();
  opts: ServerOptions;
  constructor(opts: ServerOptions) {
    this.opts = opts;
  }

  join(id: string, at: Vec, send?: (m: ServerMsg) => void, script?: Player['script']): void {
    this.players.set(id, { id, ...at, ack: 0, queue: [], send, script, impulses: [], history: [] });
  }

  /** A hit by something the client cannot predict (a rocket, a push). Applied at the end of the next tick. */
  knockback(id: string, v: Vec): void {
    this.players.get(id)?.impulses.push(v);
  }

  receive(id: string, m: ClientMsg, now: number): void {
    const p = this.players.get(id);
    if (!p) return;
    if (m.t === 'input') {
      const last = p.queue.length > 0 ? p.queue[p.queue.length - 1].seq : p.ack;
      for (const i of m.inputs) {
        // redundant or reordered copies are dropped here; a client never chooses its own speed or step size
        if (!Number.isInteger(i.seq) || i.seq <= last || p.queue.length >= MAX_QUEUED_INPUTS) continue;
        p.queue.push({ seq: i.seq, dx: clampAxis(i.dx), dy: clampAxis(i.dy), dt: Math.min(MAX_INPUT_DT_MS, Math.max(0, Number(i.dt) || 0)) });
      }
    } else if (m.t === 'ping') {
      p.send?.({ t: 'pong', c0: m.c0, s1: now, s2: now });
    } else if (m.t === 'fire') {
      if ([m.aimX, m.aimY, m.renderTime].every(Number.isFinite)) this.fire(p, m, now);
    }
  }

  tick(now: number): void {
    this.tickNo++;
    for (const p of this.players.values()) {
      if (p.script) {
        const d = p.script(now);
        Object.assign(p, applyInput(p, { seq: 0, dx: d.dx, dy: d.dy, dt: TICK_MS }));
      }
      for (const i of p.queue) {
        Object.assign(p, applyInput(p, i));
        p.ack = i.seq;
      }
      p.queue.length = 0;
      for (const v of p.impulses) {
        Object.assign(p, applyImpulse(p, v));
      }
      p.impulses.length = 0;
      p.history.push({ t: now, x: p.x, y: p.y });
      while (p.history[0].t < now - HISTORY_MS) p.history.shift();
    }
    const players: PlayerState[] = [...this.players.values()].map((p) => ({ id: p.id, x: p.x, y: p.y, ack: p.ack }));
    for (const p of this.players.values()) p.send?.({ t: 'snap', tick: this.tickNo, time: now, players });
  }

  /** Where `p` was at server time t (linear interpolation between the stored ticks). */
  positionAt(p: Player, t: number): Vec {
    const h = p.history;
    if (h.length === 0 || t >= h[h.length - 1].t) return h.length ? h[h.length - 1] : p;
    if (t <= h[0].t) return h[0];
    let i = h.length - 1;
    while (h[i - 1].t > t) i--;
    return lerp(h[i - 1], h[i], (t - h[i - 1].t) / (h[i].t - h[i - 1].t));
  }

  private fire(shooter: Player, m: Extract<ClientMsg, { t: 'fire' }>, now: number): void {
    const max = this.opts.maxRewindMs ?? MAX_REWIND_MS;
    // The client says which server time its screen showed; the server refuses to rewind past the cap.
    const rewindTo = this.opts.lagCompensation ? Math.min(now, Math.max(now - max, m.renderTime)) : now;
    const dx = m.aimX - shooter.x;
    const dy = m.aimY - shooter.y;
    const len = Math.hypot(dx, dy) || 1;
    let target: string | null = null;
    let best = Infinity;
    for (const o of this.players.values()) {
      if (o === shooter) continue;
      const q = this.positionAt(o, rewindTo);
      const along = ((q.x - shooter.x) * dx + (q.y - shooter.y) * dy) / len;
      const miss = along < 0 ? dist(q, shooter) : Math.abs(((q.x - shooter.x) * dy - (q.y - shooter.y) * dx) / len);
      if (miss <= HIT_RADIUS && along < best) {
        best = along;
        target = o.id;
      }
    }
    shooter.send?.({ t: 'hit', seq: m.seq, target, rewindMs: now - rewindTo });
  }
}

// clock-sync.ts: NTP-style offset estimation from ping/pong round trips.
export interface Sample {
  offset: number; // add to the local clock to get server time
  rtt: number;
}
export type Strategy = 'last' | 'mean' | 'minRtt';

export class ClockSync {
  private samples: Sample[] = [];
  private keep: number;
  constructor(keep = 8) {
    this.keep = keep;
  }

  /** t0: client send, t1: server receive, t2: server send, t3: client receive. */
  add(t0: number, t1: number, t2: number, t3: number): void {
    this.samples.push({ offset: (t1 - t0 + (t2 - t3)) / 2, rtt: t3 - t0 - (t2 - t1) });
    if (this.samples.length > this.keep) this.samples.shift();
  }

  get ready(): boolean {
    return this.samples.length > 0;
  }

  get rtt(): number {
    return Math.min(...this.samples.map((s) => s.rtt));
  }

  offset(strategy: Strategy = 'minRtt'): number {
    const s = this.samples;
    if (strategy === 'last') return s[s.length - 1].offset;
    if (strategy === 'mean') return s.reduce((a, b) => a + b.offset, 0) / s.length;
    return s.reduce((best, x) => (x.rtt < best.rtt ? x : best)).offset; // the least-delayed sample
  }
}

// snapshot-delay.ts: how far behind the server clock the client renders remote players.
import { RENDER_DELAY_MS, TICK_MS } from './arena-core.ts';

export interface DelayPolicy {
  /** Called for every snapshot: when it arrived (server-time estimate) and when the server stamped it. */
  onSnapshot(arrival: number, stamp: number): void;
  delay(): number;
}

export class FixedDelay implements DelayPolicy {
  private ms: number;
  constructor(ms = RENDER_DELAY_MS) {
    this.ms = ms;
  }
  onSnapshot(): void {}
  delay(): number {
    return this.ms;
  }
}

/** A jitter buffer: one tick plus four times the RFC 3550 smoothed interarrival jitter. */
export class AdaptiveDelay implements DelayPolicy {
  private jitter = 0;
  private lastTransit: number | null = null;
  private min: number;
  private max: number;
  private k: number;
  constructor(min = 2 * TICK_MS, max = 400, k = 4) {
    this.min = min;
    this.max = max;
    this.k = k;
  }

  onSnapshot(arrival: number, stamp: number): void {
    const transit = arrival - stamp;
    if (this.lastTransit !== null) this.jitter += (Math.abs(transit - this.lastTransit) - this.jitter) / 16;
    this.lastTransit = transit;
  }

  delay(): number {
    return Math.min(this.max, Math.max(this.min, TICK_MS + this.k * this.jitter));
  }
}

// arena-client.ts: prediction, reconciliation, interpolation, extrapolation and clock sync, each switchable.
import {
  applyInput, FRAME_MS, lerp, type ClientMsg, type Input, type PlayerState, type ServerMsg, type Vec,
} from './arena-core.ts';
import { ClockSync, type Strategy } from './clock-sync.ts';
import { FixedDelay, type DelayPolicy } from './snapshot-delay.ts';

export interface Toggles {
  prediction: boolean; // apply my own input immediately
  reconciliation: 'off' | 'snap' | 'replay'; // what to do with the server's answer
  smoothing: boolean; // fade corrections out instead of jumping
  interpolation: boolean; // render remote players in the past, between two snapshots
  extrapolation: boolean; // guess forward when there is nothing newer to show
  redundancy: number; // how many unacknowledged inputs each message repeats
  clock: Strategy;
}

export const ALL_ON: Toggles = {
  prediction: true, reconciliation: 'replay', smoothing: false, interpolation: true, extrapolation: true,
  redundancy: 1, clock: 'minRtt',
};

interface Snap extends Vec {
  t: number;
}
const MAX_EXTRAPOLATION_MS = 100;

export class ArenaClient {
  seq = 0;
  readonly sync = new ClockSync();
  private pending: Input[] = [];
  private predicted: Vec = { x: 0, y: 0 };
  private server: Vec = { x: 0, y: 0 }; // my last authoritative position
  private offsetFade: Vec = { x: 0, y: 0 }; // correction still to be faded out
  private buffers = new Map<string, Snap[]>();
  private lastHit: ((m: Extract<ServerMsg, { t: 'hit' }>) => void) | undefined;
  underruns = 0;
  maxJump = 0; // biggest single correction applied to my own position (px)

  readonly id: string;
  toggles: Toggles;
  private send: (m: ClientMsg) => void;
  private clock: () => number; // the local clock, in ms; it has no relation to server time
  private delayPolicy: DelayPolicy;

  constructor(
    id: string,
    send: (m: ClientMsg) => void,
    clock: () => number,
    toggles: Toggles = ALL_ON,
    delayPolicy: DelayPolicy = new FixedDelay(),
  ) {
    this.id = id;
    this.send = send;
    this.clock = clock;
    this.toggles = toggles;
    this.delayPolicy = delayPolicy;
  }

  spawn(at: Vec): void {
    this.predicted = { ...at };
    this.server = { ...at };
  }

  serverNow(): number {
    return this.clock() + (this.sync.ready ? this.sync.offset(this.toggles.clock) : 0);
  }

  ping(): void {
    this.send({ t: 'ping', c0: this.clock() });
  }

  /** Called once per rendered frame with the keys currently held. */
  frame(dx: number, dy: number): void {
    const input: Input = { seq: ++this.seq, dx, dy, dt: FRAME_MS };
    this.pending.push(input);
    if (this.toggles.prediction) this.predicted = applyInput(this.predicted, input);
    const repeat = this.pending.slice(-Math.max(1, this.toggles.redundancy));
    this.send({ t: 'input', inputs: repeat });
    const f = Math.pow(0.5, FRAME_MS / 100); // halve the remaining correction every 100 ms
    this.offsetFade = { x: this.offsetFade.x * f, y: this.offsetFade.y * f };
  }

  onMessage(m: ServerMsg): void {
    if (m.t === 'pong') {
      this.sync.add(m.c0, m.s1, m.s2, this.clock());
    } else if (m.t === 'snap') {
      const arrival = this.serverNow();
      this.delayPolicy.onSnapshot(arrival, m.time);
      for (const p of m.players) p.id === this.id ? this.onOwnState(p) : this.push(p, m.time);
    } else if (m.t === 'hit') {
      this.lastHit?.(m);
    }
  }

  private onOwnState(p: PlayerState): void {
    this.server = { x: p.x, y: p.y };
    this.pending = this.pending.filter((i) => i.seq > p.ack); // acknowledged inputs are done
    const mode = this.toggles.reconciliation;
    if (!this.toggles.prediction || mode === 'off') {
      if (!this.toggles.prediction) this.predicted = { ...this.server };
      return;
    }
    const before = this.displayed();
    let s: Vec = { ...this.server };
    if (mode === 'replay') for (const i of this.pending) s = applyInput(s, i); // re-apply what the server has not seen
    this.predicted = s;
    if (this.toggles.smoothing) {
      this.offsetFade = { x: before.x - s.x, y: before.y - s.y };
    }
    const after = this.displayed();
    this.maxJump = Math.max(this.maxJump, Math.hypot(after.x - before.x, after.y - before.y));
  }

  private push(p: Vec & { id: string }, t: number): void {
    const b = this.buffers.get(p.id) ?? [];
    if (b.length > 0 && t <= b[b.length - 1].t) return; // late duplicate
    b.push({ t, x: p.x, y: p.y });
    while (b.length > 40) b.shift();
    this.buffers.set(p.id, b);
  }

  /** Where my own avatar is drawn. */
  displayed(): Vec {
    const base = this.toggles.prediction ? this.predicted : this.server;
    return { x: base.x + this.offsetFade.x, y: base.y + this.offsetFade.y };
  }

  /**
   * The server time that remote players are drawn at: now, minus the time a snapshot spends in flight
   * (half the best round trip), minus the interpolation delay (two snapshots, or what the jitter buffer asks for).
   */
  renderTime(): number {
    const flight = this.sync.ready ? this.sync.rtt / 2 : 0;
    return this.serverNow() - flight - this.delayPolicy.delay();
  }

  /** Where a remote player is drawn. */
  displayedRemote(id: string): Vec | null {
    const b = this.buffers.get(id);
    if (!b || b.length === 0) return null;
    const newest = b[b.length - 1];
    const now = this.serverNow();
    if (!this.toggles.interpolation) {
      return this.toggles.extrapolation ? this.extrapolate(b, now) : { x: newest.x, y: newest.y };
    }
    const t = this.renderTime();
    if (t <= b[0].t) return { x: b[0].x, y: b[0].y };
    if (t >= newest.t) {
      this.underruns++; // the buffer ran dry: nothing newer than the render time
      return this.toggles.extrapolation ? this.extrapolate(b, t) : { x: newest.x, y: newest.y };
    }
    let i = b.length - 1;
    while (b[i - 1].t > t) i--;
    return lerp(b[i - 1], b[i], (t - b[i - 1].t) / (b[i].t - b[i - 1].t));
  }

  private extrapolate(b: Snap[], t: number): Vec {
    const n = b[b.length - 1];
    if (b.length < 2) return { x: n.x, y: n.y };
    const o = b[b.length - 2];
    const dt = Math.min(MAX_EXTRAPOLATION_MS, Math.max(0, t - n.t));
    const k = dt / (n.t - o.t);
    return { x: n.x + (n.x - o.x) * k, y: n.y + (n.y - o.y) * k };
  }

  /** Fire a hitscan shot at a point on screen; the server is told which server time the screen showed. */
  fire(aim: Vec, onResult?: (m: Extract<ServerMsg, { t: 'hit' }>) => void): void {
    this.lastHit = onResult;
    const renderTime = this.toggles.interpolation ? this.renderTime() : this.serverNow();
    this.send({ t: 'fire', seq: this.seq, aimX: aim.x, aimY: aim.y, renderTime });
  }
}

// world.ts: wires one server and one or more clients together over simulated links.
import { FRAME_MS, rng, TICK_MS, type ClientMsg, type ServerMsg, type Vec } from './arena-core.ts';
import { ArenaClient, ALL_ON, type Toggles } from './arena-client.ts';
import { ArenaServer } from './arena-server.ts';
import { SimLink, Scheduler, type LinkConfig } from './sim-net.ts';
import { FixedDelay, type DelayPolicy } from './snapshot-delay.ts';

export const CLOCK_OFFSET = 3_700_123.4; // the client clock starts about an hour after the server's
export const CLOCK_DRIFT = 30e-6; // 30 ppm

export interface WorldOptions {
  up: LinkConfig; // client to server
  down: LinkConfig; // server to client
  toggles?: Partial<Toggles>;
  lagCompensation?: boolean;
  maxRewindMs?: number;
  delay?: DelayPolicy;
  seed?: number;
}

/** A direction that changes every 300 to 900 ms; deterministic for a given seed. */
export function randomWalker(seed: number, idleChance = 0.15): (t: number) => { dx: number; dy: number } {
  const r = rng(seed);
  const dirs = [[1, 0], [-1, 0], [0, 1], [0, -1], [1, 1], [-1, 1], [1, -1], [-1, -1]];
  const segs: { until: number; dx: number; dy: number }[] = [];
  for (let t = 0; t < 400_000; ) {
    t += 300 + r() * 600;
    const d = r() < idleChance ? [0, 0] : dirs[Math.floor(r() * dirs.length)];
    segs.push({ until: t, dx: d[0], dy: d[1] });
  }
  let i = 0;
  return (t) => {
    if (i > 0 && segs[i - 1].until > t) i = 0;
    while (segs[i].until < t) i++;
    return segs[i];
  };
}

/** A winding path that reverses at random: a target that is hard to hit. */
export function strafer(seed: number): (t: number) => { dx: number; dy: number } {
  const r = rng(seed);
  const flips: number[] = [];
  let sign = 1;
  for (let t = 0; t < 400_000; ) {
    t += 400 + r() * 500;
    flips.push(t);
  }
  return (t) => {
    sign = 1;
    for (const f of flips) {
      if (f > t) break;
      sign = -sign;
    }
    const a = (2 * Math.PI * t) / 6000 + 1.2 * Math.sin(t / 700);
    return { dx: sign * Math.cos(a), dy: sign * Math.sin(a) };
  };
}

export class World {
  readonly sched = new Scheduler();
  readonly server: ArenaServer;
  readonly clients = new Map<string, ArenaClient>();
  readonly tickLog = new Map<string, { t: number; x: number; y: number }[]>();
  private opts: WorldOptions;
  private n = 0;

  constructor(opts: WorldOptions) {
    this.opts = opts;
    this.server = new ArenaServer({ lagCompensation: opts.lagCompensation ?? true, maxRewindMs: opts.maxRewindMs });
    const tick = () => {
      this.server.tick(this.sched.now);
      for (const p of this.server.players.values()) {
        const log = this.tickLog.get(p.id) ?? [];
        log.push({ t: this.sched.now, x: p.x, y: p.y });
        this.tickLog.set(p.id, log);
      }
      this.sched.at(this.sched.now + TICK_MS, tick);
    };
    this.sched.at(TICK_MS, tick);
  }

  /** The local clock of a client: an hour off and drifting. */
  clockOf(): () => number {
    return () => this.sched.now * (1 + CLOCK_DRIFT) + CLOCK_OFFSET;
  }

  addBot(id: string, at: Vec, script: (t: number) => { dx: number; dy: number }): void {
    this.server.join(id, at, undefined, script);
  }

  addClient(
    id: string, at: Vec, input: (t: number) => { dx: number; dy: number },
    toggles: Partial<Toggles> = {}, delay: DelayPolicy = this.opts.delay ?? new FixedDelay(),
    onFrame?: (c: ArenaClient, t: number) => void,
  ): ArenaClient {
    const seed = (this.opts.seed ?? 1) * 1000 + ++this.n * 17;
    let client: ArenaClient;
    const up = new SimLink<ClientMsg>(this.sched, this.opts.up, seed + 1, (m) => this.server.receive(id, m, this.sched.now));
    const down = new SimLink<ServerMsg>(this.sched, this.opts.down, seed + 2, (m) => client.onMessage(m));
    client = new ArenaClient(id, (m) => up.send(m), this.clockOf(), { ...ALL_ON, ...this.opts.toggles, ...toggles }, delay);
    this.server.join(id, at, (m) => down.send(m));
    this.clients.set(id, client);
    client.spawn(at); // the client starts where the server put it
    // Clock sync: a burst of 8 pings, then one per second.
    for (let k = 0; k < 8; k++) this.sched.at(50 + k * 100, () => client.ping());
    const pingLoop = () => {
      client.ping();
      this.sched.at(this.sched.now + 1000, pingLoop);
    };
    this.sched.at(1000, pingLoop);
    const frame = () => {
      const d = input(this.sched.now);
      client.frame(d.dx, d.dy);
      onFrame?.(client, this.sched.now);
      this.sched.at(this.sched.now + FRAME_MS, frame);
    };
    this.sched.at(FRAME_MS, frame);
    return client;
  }

  /** The server path of `id`, sampled continuously (linear between the logged ticks). */
  truth(id: string, t: number): Vec {
    const log = this.tickLog.get(id)!;
    const k = Math.min(log.length - 2, Math.max(0, Math.floor(t / TICK_MS) - 1));
    const a = log[k];
    const b = log[k + 1];
    const f = Math.min(1, Math.max(0, (t - a.t) / (b.t - a.t)));
    return { x: a.x + (b.x - a.x) * f, y: a.y + (b.y - a.y) * f };
  }
}

export function stats(xs: number[]): { mean: number; p95: number; max: number } {
  const s = [...xs].sort((a, b) => a - b);
  return { mean: xs.reduce((a, b) => a + b, 0) / xs.length, p95: s[Math.floor(s.length * 0.95)], max: s[s.length - 1] };
}