51 lines
2.3 KiB
TypeScript
51 lines
2.3 KiB
TypeScript
// ISS-129 (v0.57.0): in-process fan-out registry for the SSE state stream (/api/events). The app
|
|
// runs as one long-lived server process (`next start`; instrumentation.ts already keeps background
|
|
// sim state alive) — no new dependencies, no WS upgrade needed. The Map lives on globalThis because
|
|
// Next.js gives instrumentation.ts (where broadcast() fires from the background tick) and route
|
|
// handlers (where subscribe() happens in /api/events) separate module instances; a plain `let` would
|
|
// give each its own empty map and no push would ever be delivered. v1.4.0 (ISS-112): subscribers are
|
|
// keyed by PLAYER ID — the engine projects one snapshot per connected player and pushes each frame
|
|
// only to that player's group, so every client sees its own account row in every pushed frame.
|
|
|
|
type Push = (text: string) => void;
|
|
|
|
const g = globalThis as unknown as { __flightSseSubscribersByPlayer?: Map<string, Set<Push>> };
|
|
const subscribers: Map<string, Set<Push>> = (g.__flightSseSubscribersByPlayer ??= new Map());
|
|
|
|
export function subscribe(playerId: string, fn: Push): () => void {
|
|
let group = subscribers.get(playerId);
|
|
if (!group) {
|
|
group = new Set();
|
|
subscribers.set(playerId, group);
|
|
}
|
|
group.add(fn);
|
|
return () => {
|
|
const s = subscribers.get(playerId);
|
|
if (!s) return; // already unsubscribed — idempotent
|
|
s.delete(fn);
|
|
if (s.size === 0) subscribers.delete(playerId); // drop the empty group so projections stop for it
|
|
};
|
|
}
|
|
|
|
// v1.4.0 (ISS-112): which player ids currently have at least one connected stream — the engine
|
|
// projects exactly these per tick (N is tiny; a projection is skipped when nobody listens).
|
|
export function subscribedPlayerIds(): string[] {
|
|
return [...subscribers.keys()];
|
|
}
|
|
|
|
// Call each subscriber safely — one dead stream must not take the others down. `frames` maps
|
|
// player id → pre-serialized frame text (the engine projects per player, this only fans out).
|
|
export function broadcast(frames: Map<string, string>): void {
|
|
for (const [playerId, text] of frames) {
|
|
const group = subscribers.get(playerId);
|
|
if (!group) continue; // unsubscribed between projection and push — fine
|
|
for (const fn of [...group]) {
|
|
try {
|
|
fn(text);
|
|
} catch {
|
|
// subscriber's stream is gone; its own cleanup unsubscribes it
|
|
}
|
|
}
|
|
}
|
|
}
|