feat(rail): add a Rail layer with keyless live trains

Live trains from 30 keyless operator feeds: GPS positions from 29 and
Irish Rail's station reports, shown as the operators publish them. 28
work out of the box; Renfe long and medium distance and KTMB appear once
their pack is built, because their vehicles name no route.

Packs are opt-in (scripts/build-rail-paths.mjs): the operator's own
route lines, stop names, next stops and trip-update delays for live
trains. Nothing downloads when the app starts, no train is placed from a
timetable, and no request carries a deployer's key.
This commit is contained in:
Denis Groshev committed 2026-11-11 16:06:22 +01:00
1 parent 14db73f201
commit 830c080803
114 files changed
+26639 -26

No files matched your search

+741
View File
@@ -0,0 +1,741 @@
import {
dayNumberOf,
formatClock,
isTimeZone,
parseServiceDate,
serviceDayOriginMs,
} from './railTimeZones.js';
/**
* @module railSchedule
* @description Timetable tier of the Rail layer: which trains run now
* according to the operator's static GTFS, where along their line the
* timetable puts them (only to match a live train to its run, never drawn),
* and the stop list a train card shows.
*
* Schedule packs come from scripts/build-rail-paths.mjs (`<feedId>.schedule.json`).
* Service calendars are resolved to concrete dates at build time, so this
* module never evaluates a calendar. Stop times are seconds after the service
* day's GTFS origin (noon minus 12 h, agency time zone) and may exceed 24 h.
*
* Realtime delays follow GTFS-RT TripUpdate semantics:
*
* delays = { [tripId]: { delaySec?, startDate?, relationship?, stops?: [{
* stopId? | stopSequence?, relationship?,
* arrival?: { time?, delay? }, departure?: { time?, delay? } }] } }
*
* (the trip records of src/data/railTripUpdates.js, keyed by trip id). A
* trip `relationship` of 'CANCELED' or 'DELETED' drops the run from
* activeTrips; a stop `relationship` of 'SKIPPED' (or `skipped: true`) is
* passed without a stop, and one of 'NO_DATA' has no prediction: that stop
* and the stops after it keep their timetable times until the next update.
*
* `time` is POSIX seconds (milliseconds are accepted too), `delay` seconds.
* A stop update's delay carries on to later stops until the next update;
* stops before the first update use the trip's `delaySec` (else the
* timetable). `startDate` ('YYYYMMDD' or 'YYYY-MM-DD') pins the entry to one
* run of a trip that runs on several days.
*
* Clock strings are 24-hour 'HH:MM' in each STATION's own time zone.
*
* Pure: no Cesium, no DOM, no I/O.
*/
/** Schedule-pack format this module reads. */
export const RAIL_SCHEDULE_PACK_VERSION = 1;
/** Earliest a delayed or early train is looked for around its timetable (ms). */
const EARLY_SLACK_MS = 60 * 60_000;
const LATE_SLACK_MS = 12 * 60 * 60_000;
const MINUS = '−';
/** TripUpdate relationships under which a scheduled run does not run. */
const CANCELED = new Set(['CANCELED', 'DELETED']);
/**
* A relative time chip as the Launches layer writes its countdown: `T−4`
* for an event four minutes ahead, `T+3` for one three minutes past. Minutes
* round up toward the event (Math.ceil, as the Launches countdown rounds its
* seconds), so `T−1` shows until the moment itself and `T+0` for the first
* minute after. An hour or more reads `T−1:05`.
* @param {number} deltaMs Event time minus now.
* @returns {string}
*/
export function formatRelative(deltaMs) {
if (!Number.isFinite(deltaMs)) return '';
const minutes = Math.ceil(deltaMs / 60_000);
const sign = deltaMs > 0 ? MINUS : '+';
const total = Math.abs(minutes);
const text =
total >= 60
? `${Math.floor(total / 60)}:${String(total % 60).padStart(2, '0')}`
: String(total);
return `T${sign}${text}`;
}
const isIndex = (value, length) =>
Number.isInteger(value) && value >= 0 && value < length;
/** Largest delay a live report may state, either way (s): a day. */
const LIVE_DELAY_MAX_S = 86_400;
/**
* The delay a live train's own report states (`delaySec`: Irish Rail's
* public message, SIRI VM's `Delay`), for a feed that publishes no trip
* updates; null when it states none, or more than a day either way (a unit
* error, not a late train).
* @param {{delaySec?: unknown}|null|undefined} record
* @returns {number|null} Seconds, positive when late.
*/
export function liveDelaySec(record) {
const value = record?.delaySec;
return typeof value === 'number' &&
Number.isFinite(value) &&
Math.abs(value) <= LIVE_DELAY_MAX_S
? value
: null;
}
/**
* Validate and index a decoded schedule pack.
* @param {object} raw The JSON body of `<feedId>.schedule.json`.
* @returns {object} A schedule for the functions below.
*/
export function createSchedule(raw) {
if (
!raw ||
raw.version !== RAIL_SCHEDULE_PACK_VERSION ||
typeof raw.feedId !== 'string' ||
!Array.isArray(raw.stops) ||
!Array.isArray(raw.patterns) ||
!Array.isArray(raw.profiles) ||
!raw.trips ||
typeof raw.trips !== 'object' ||
!raw.services ||
typeof raw.services !== 'object'
)
throw new TypeError('Malformed rail schedule pack');
const timezone = isTimeZone(raw.timezone) ? raw.timezone : 'UTC';
const stops = raw.stops.map((stop, index) => ({
index,
id: String(stop?.id ?? ''),
name: String(stop?.name ?? ''),
lat: Number(stop?.lat),
lon: Number(stop?.lon),
parent: isIndex(stop?.parent, raw.stops.length) ? stop.parent : null,
platform: stop?.platform ? String(stop.platform) : null,
ownZone: isTimeZone(stop?.tz) ? stop.tz : null,
}));
for (const stop of stops) {
const parent = stop.parent === null ? null : stops[stop.parent];
stop.timezone = stop.ownZone ?? parent?.ownZone ?? timezone;
delete stop.ownZone;
Object.freeze(stop);
}
const stopIndexById = new Map(stops.map((stop) => [stop.id, stop.index]));
const patterns = raw.patterns.map((pattern, index) => {
const list = Array.isArray(pattern?.stops) ? pattern.stops : [];
const n = list.length;
if (n < 2 || !list.every((value) => isIndex(value, stops.length)))
throw new TypeError(`Malformed rail schedule pattern ${index}`);
const dist =
Array.isArray(pattern.dist) && pattern.dist.length === n
? pattern.dist.map(Number)
: new Array(n).fill(0);
const seq =
Array.isArray(pattern.seq) && pattern.seq.length === n
? pattern.seq.map(Number)
: list.map((_, k) => k + 1);
return Object.freeze({
index,
shape: Number.isInteger(pattern.shape) ? pattern.shape : null,
stops: Object.freeze(list.slice()),
seq: Object.freeze(seq),
dist: Object.freeze(dist),
pass: Object.freeze(
Array.isArray(pattern.pass) && pattern.pass.length === n
? pattern.pass.map((value) => value === 1)
: new Array(n).fill(false),
),
});
});
const origins = new Map();
const originOf = (date) => {
let origin = origins.get(date);
if (origin === undefined) {
origin = serviceDayOriginMs(date, timezone);
origins.set(date, origin);
}
return origin;
};
const trips = new Map();
const instances = [];
let maxDurationMs = 0;
for (const [tripId, value] of Object.entries(raw.trips)) {
const pattern = patterns[value?.pattern];
const profile = raw.profiles[value?.profile];
if (!pattern || !Array.isArray(profile)) continue;
if (profile.length !== pattern.stops.length * 2) continue;
const startSec = Number(value.startSec);
if (!Number.isFinite(startSec)) continue;
const trip = Object.freeze({
id: tripId,
pattern,
offsets: profile,
startSec,
routeId: value.route == null ? null : String(value.route),
service: String(value.service ?? ''),
headsign: value.headsign ? String(value.headsign) : null,
name: value.name ? String(value.name) : null,
direction: Number.isInteger(value.direction) ? value.direction : null,
});
trips.set(tripId, trip);
const dates = raw.services[trip.service];
if (!Array.isArray(dates)) continue;
const durationMs = profile[profile.length - 1] * 1000;
if (durationMs > maxDurationMs) maxDurationMs = durationMs;
for (const date of dates) {
if (!parseServiceDate(date)) continue;
const startMs = originOf(date) + startSec * 1000;
if (Number.isFinite(startMs))
instances.push({
trip,
serviceDate: date,
startMs,
endMs: startMs + durationMs,
});
}
}
instances.sort((a, b) => a.startMs - b.startMs);
const runsByTrip = new Map();
for (const instance of instances) {
let list = runsByTrip.get(instance.trip.id);
if (!list) runsByTrip.set(instance.trip.id, (list = []));
list.push(instance);
}
return Object.freeze({
feedId: raw.feedId,
/**
* The `builtAt` of the path pack this timetable's shape indices point
* into (written by the same build), or null in packs that predate it.
*/
pathsBuiltAt:
typeof raw.pathsBuiltAt === 'string' ? raw.pathsBuiltAt : null,
timezone,
window: raw.window ?? null,
routes: raw.routes && typeof raw.routes === 'object' ? raw.routes : {},
stops: Object.freeze(stops),
patterns: Object.freeze(patterns),
trips,
stopIndexById,
instances: Object.freeze(instances),
runsByTrip,
instanceStarts: Float64Array.from(
instances,
(instance) => instance.startMs,
),
maxDurationMs,
});
}
/**
* When the last run a decoded schedule pack holds arrives (epoch ms): past
* it the pack's window has ended, and it names no train that can still be
* running. Each trip counts on the latest date of its service. Read from the
* raw pack, without indexing it (the server checks a pack it reads only for
* its routes). Null when the pack names no window (`window.to`), so its end
* is not known; -Infinity when it holds no run.
* @param {object} raw The JSON body of `<feedId>.schedule.json`.
* @returns {number|null}
*/
export function schedulePackEndMs(raw) {
if (!parseServiceDate(raw?.window?.to)) return null;
const trips = raw?.trips && typeof raw.trips === 'object' ? raw.trips : {};
const services =
raw?.services && typeof raw.services === 'object' ? raw.services : {};
const profiles = Array.isArray(raw?.profiles) ? raw.profiles : [];
const zone = isTimeZone(raw?.timezone) ? raw.timezone : 'UTC';
/** Service id → the origin of its latest date (-Infinity: no date). */
const lastOrigin = new Map();
const latestOrigin = (service) => {
let origin = lastOrigin.get(service);
if (origin !== undefined) return origin;
const dates = Object.hasOwn(services, service) ? services[service] : null;
let latest = -Infinity;
let latestDate = null;
for (const date of Array.isArray(dates) ? dates : []) {
const day = dayNumberOf(date);
if (day > latest) {
latest = day;
latestDate = date;
}
}
origin = latestDate === null ? NaN : serviceDayOriginMs(latestDate, zone);
if (!Number.isFinite(origin)) origin = -Infinity;
lastOrigin.set(service, origin);
return origin;
};
let end = -Infinity;
for (const trip of Object.values(trips)) {
const profile = profiles[trip?.profile];
const startSec = Number(trip?.startSec);
if (!Array.isArray(profile) || !Number.isFinite(startSec)) continue;
const origin = latestOrigin(String(trip.service ?? ''));
if (origin === -Infinity) continue;
const durationSec = Number(profile[profile.length - 1]) || 0;
end = Math.max(end, origin + (startSec + durationSec) * 1000);
}
return end;
}
/** First index whose start is greater than `ms`. */
function upperBound(starts, ms) {
let lo = 0;
let hi = starts.length;
while (lo < hi) {
const mid = (lo + hi) >> 1;
if (starts[mid] <= ms) lo = mid + 1;
else hi = mid;
}
return lo;
}
/** The public view of one run of a trip. */
function runOf(instance) {
const { trip } = instance;
return {
tripId: trip.id,
serviceDate: instance.serviceDate,
routeId: trip.routeId,
headsign: trip.headsign,
name: trip.name,
direction: trip.direction,
pattern: trip.pattern.index,
shape: trip.pattern.shape,
scheduledStartMs: instance.startMs,
scheduledEndMs: instance.endMs,
};
}
/** The delay entry for a run, honouring a `startDate` pin. */
function delayFor(delays, run) {
const entry =
delays && Object.hasOwn(delays, run.tripId) ? delays[run.tripId] : null;
if (!entry || typeof entry !== 'object') return null;
if (entry.startDate != null) {
const pinned = parseServiceDate(entry.startDate);
const own = parseServiceDate(run.serviceDate);
if (
!pinned ||
!own ||
pinned.year !== own.year ||
pinned.month !== own.month ||
pinned.day !== own.day
)
return null;
}
return entry;
}
const toMs = (time) => {
const value = Number(time);
if (!Number.isFinite(value) || value <= 0) return NaN;
return value > 1e11 ? value : value * 1000;
};
/** The pattern index each stop update applies to, in order. */
function matchUpdates(schedule, pattern, updates) {
const byIndex = new Map();
let from = 0;
for (const update of updates) {
if (!update || typeof update !== 'object') continue;
let found = -1;
for (let pass = 0; pass < 2 && found < 0; pass++) {
const start = pass === 0 ? from : 0;
for (let k = start; k < pattern.stops.length; k++) {
if (stopMatches(schedule, pattern, k, update)) {
found = k;
break;
}
}
}
if (found < 0) continue;
byIndex.set(found, update);
from = found + 1;
}
return byIndex;
}
function stopMatches(schedule, pattern, k, update) {
if (update.stopSequence != null && update.stopSequence !== '')
return Number(update.stopSequence) === pattern.seq[k];
if (update.stopId == null) return false;
const id = String(update.stopId);
const stop = schedule.stops[pattern.stops[k]];
if (stop.id === id) return true;
if (stop.parent !== null && schedule.stops[stop.parent].id === id)
return true;
const other = schedule.stopIndexById.get(id);
if (other === undefined) return false;
const otherParent = schedule.stops[other].parent;
return otherParent !== null && otherParent === (stop.parent ?? stop.index);
}
/** Whether a stop update carries this StopTimeUpdate relationship. */
function stopRelationshipIs(update, relationship) {
return (
update.relationship === relationship ||
update.scheduleRelationship === relationship
);
}
/**
* Scheduled and expected times of every stop of a run.
* @returns {{schedArr: number[], schedDep: number[], arr: number[],
* dep: number[], skipped: boolean[], hasRealtime: boolean}}
*/
function runTimes(schedule, instance, delays) {
const { trip } = instance;
const n = trip.pattern.stops.length;
const schedArr = new Array(n);
const schedDep = new Array(n);
for (let k = 0; k < n; k++) {
schedArr[k] = instance.startMs + trip.offsets[2 * k] * 1000;
schedDep[k] = instance.startMs + trip.offsets[2 * k + 1] * 1000;
}
const arr = schedArr.slice();
const dep = schedDep.slice();
const skipped = new Array(n).fill(false);
const entry = delayFor(delays, {
tripId: trip.id,
serviceDate: instance.serviceDate,
});
if (!entry)
return { schedArr, schedDep, arr, dep, skipped, hasRealtime: false };
const updates = matchUpdates(
schedule,
trip.pattern,
Array.isArray(entry.stops) ? entry.stops : [],
);
let carried = Number.isFinite(Number(entry.delaySec))
? Number(entry.delaySec)
: 0;
for (let k = 0; k < n; k++) {
const update = updates.get(k);
let arrDelay = carried;
let depDelay = carried;
if (update && stopRelationshipIs(update, 'NO_DATA')) {
// No prediction (GTFS-RT NO_DATA): the delay carried so far no longer
// holds, here or at the stops after it.
carried = 0;
arrDelay = 0;
depDelay = 0;
} else if (update) {
if (update.skipped === true || stopRelationshipIs(update, 'SKIPPED'))
skipped[k] = true;
const a = update.arrival ?? null;
const d = update.departure ?? null;
const aTime = toMs(a?.time);
const dTime = toMs(d?.time);
const aDelay = Number(a?.delay);
const dDelay = Number(d?.delay);
let arrivalGiven = true;
if (Number.isFinite(aTime)) arrDelay = (aTime - schedArr[k]) / 1000;
else if (a && a.delay != null && Number.isFinite(aDelay))
arrDelay = aDelay;
else arrivalGiven = false;
if (Number.isFinite(dTime)) depDelay = (dTime - schedDep[k]) / 1000;
else if (d && d.delay != null && Number.isFinite(dDelay))
depDelay = dDelay;
else if (arrivalGiven) depDelay = arrDelay;
else depDelay = carried;
if (!arrivalGiven && (Number.isFinite(dTime) || (d && d.delay != null)))
arrDelay = Math.min(carried, depDelay);
carried = depDelay;
}
arr[k] = schedArr[k] + arrDelay * 1000;
dep[k] = schedDep[k] + depDelay * 1000;
}
// Predictions are not always consistent; time never runs backwards.
for (let k = 0; k < n; k++) {
if (k > 0 && arr[k] < dep[k - 1]) arr[k] = dep[k - 1];
if (dep[k] < arr[k]) dep[k] = arr[k];
}
return { schedArr, schedDep, arr, dep, skipped, hasRealtime: true };
}
/** The instance of `trip` (a run object or a trip id) meant at `nowMs`. */
function resolveInstance(schedule, trip, nowMs, delays) {
const pinned = trip && typeof trip === 'object';
const runs = schedule.runsByTrip.get(
String((pinned ? trip.tripId : trip) ?? ''),
);
if (!runs) return null;
if (pinned && trip.serviceDate != null) {
const match = runs.find(
(instance) => instance.serviceDate === trip.serviceDate,
);
if (match) return match;
}
let best = null;
let bestScore = Infinity;
for (const instance of runs) {
const times = runTimes(schedule, instance, delays);
const start = times.dep[0];
const end = times.arr[times.arr.length - 1];
// Running now wins; else the nearest run, upcoming before past.
const score =
nowMs >= start && nowMs <= end
? -1
: nowMs < start
? start - nowMs
: (nowMs - end) * 2;
if (score < bestScore) {
bestScore = score;
best = instance;
}
}
return best;
}
/**
* Trains the timetable has running at `nowMs`: from the departure at the
* first stop to the arrival at the last, shifted by realtime delays.
* @param {object} schedule From createSchedule.
* @param {number} nowMs
* @param {{delays?: object, beforeMs?: number, afterMs?: number}} [options]
* `beforeMs` / `afterMs` widen the window (a train waiting at its origin,
* one just arrived).
* @returns {object[]} Runs: {tripId, serviceDate, routeId, headsign, name,
* direction, pattern, shape, scheduledStartMs, scheduledEndMs,
* expectedStartMs, expectedEndMs}.
*/
export function activeTrips(
schedule,
nowMs,
{ delays = null, beforeMs = 0, afterMs = 0 } = {},
) {
if (!schedule || !Number.isFinite(nowMs)) return [];
const lead = Math.max(0, beforeMs);
const tail = Math.max(0, afterMs);
const last = upperBound(
schedule.instanceStarts,
nowMs + lead + EARLY_SLACK_MS,
);
const floor = nowMs - tail - LATE_SLACK_MS - schedule.maxDurationMs;
const out = [];
for (let i = last - 1; i >= 0; i--) {
const instance = schedule.instances[i];
if (instance.startMs < floor) break;
const run = runOf(instance);
let start = instance.startMs + instance.trip.offsets[1] * 1000;
let end = instance.endMs;
const entry = delayFor(delays, run);
if (entry && CANCELED.has(entry.relationship)) continue;
if (entry) {
const times = runTimes(schedule, instance, delays);
start = times.dep[0];
end = times.arr[times.arr.length - 1];
} else if (instance.endMs < nowMs - tail) continue;
if (nowMs < start - lead || nowMs > end + tail) continue;
run.expectedStartMs = start;
run.expectedEndMs = end;
out.push(run);
}
return out.reverse();
}
/**
* Where the timetable puts a train at `nowMs`, along its pattern's shape.
* Between two stops the arc runs linearly in time from the departure to the
* next arrival; during a dwell it holds at the stop. Before the first
* departure it waits at the origin, after the last arrival at the terminus.
*
* @param {object} schedule From createSchedule.
* @param {object|string} trip A run from activeTrips, or a trip id.
* @param {number} nowMs
* @param {object} [delays]
* @returns {{tripId: string, serviceDate: string, shape: number|null,
* s: number, prevStop: number, nextStop: number,
* prevStopId: string|null, nextStopId: string|null, dwell: boolean,
* state: 'before'|'running'|'arrived', fraction: number, delaySec: number,
* lat?: number, lon?: number}|null} Stop fields are pattern indices (-1 for
* none). `lat`/`lon` interpolate between the stops and are set only when
* the pattern has no shape.
*/
export function scheduledPosition(schedule, trip, nowMs, delays = null) {
if (!schedule || !Number.isFinite(nowMs)) return null;
const instance = resolveInstance(schedule, trip, nowMs, delays);
if (!instance) return null;
const { pattern } = instance.trip;
const times = runTimes(schedule, instance, delays);
// Skipped stops are passed without a stop: their times do not pace the run.
const nodes = [];
for (let k = 0; k < pattern.stops.length; k++)
if (!times.skipped[k]) nodes.push(k);
if (nodes.length < 2)
nodes.splice(0, nodes.length, 0, pattern.stops.length - 1);
const result = {
tripId: instance.trip.id,
serviceDate: instance.serviceDate,
shape: pattern.shape,
s: 0,
prevStop: -1,
nextStop: -1,
prevStopId: null,
nextStopId: null,
dwell: false,
state: 'running',
fraction: 0,
delaySec: 0,
};
const first = nodes[0];
const lastNode = nodes[nodes.length - 1];
let at = -1;
let from = -1;
let to = -1;
if (nowMs < times.dep[first]) {
result.state = 'before';
at = first;
result.prevStop = -1;
result.nextStop = first;
} else if (nowMs >= times.arr[lastNode]) {
result.state = 'arrived';
at = lastNode;
result.prevStop = lastNode;
result.nextStop = -1;
} else {
for (let j = 0; j < nodes.length; j++) {
const k = nodes[j];
if (nowMs >= times.arr[k] && nowMs < times.dep[k]) {
at = k;
result.prevStop = k;
result.nextStop = j + 1 < nodes.length ? nodes[j + 1] : -1;
break;
}
if (
j + 1 < nodes.length &&
nowMs >= times.dep[k] &&
nowMs < times.arr[nodes[j + 1]]
) {
from = k;
to = nodes[j + 1];
break;
}
}
}
if (at >= 0) {
result.dwell = true;
result.s = pattern.dist[at];
result.fraction = 0;
result.delaySec = Math.round(
(result.state === 'arrived'
? times.arr[at] - times.schedArr[at]
: times.dep[at] - times.schedDep[at]) / 1000,
);
} else {
const span = times.arr[to] - times.dep[from];
const fraction =
span > 0 ? Math.min(1, Math.max(0, (nowMs - times.dep[from]) / span)) : 1;
result.prevStop = from;
result.nextStop = to;
result.fraction = fraction;
result.s =
pattern.dist[from] + (pattern.dist[to] - pattern.dist[from]) * fraction;
result.delaySec = Math.round((times.arr[to] - times.schedArr[to]) / 1000);
}
if (result.prevStop >= 0)
result.prevStopId = schedule.stops[pattern.stops[result.prevStop]].id;
if (result.nextStop >= 0)
result.nextStopId = schedule.stops[pattern.stops[result.nextStop]].id;
if (pattern.shape === null) {
const a =
schedule.stops[
pattern.stops[result.prevStop >= 0 ? result.prevStop : result.nextStop]
];
const b = result.dwell ? a : schedule.stops[pattern.stops[result.nextStop]];
result.lat = a.lat + (b.lat - a.lat) * result.fraction;
result.lon = a.lon + (b.lon - a.lon) * result.fraction;
}
return result;
}
/**
* A run's stop list for a train card.
*
* `state` is 'passed' once the train has left (or, at the terminus, reached)
* the stop, 'next' for the first stop not yet passed (with `atStop` while the
* train dwells there) and 'upcoming' after it. `relative` is the chip from
* formatRelative: for a passed stop the departure (terminus: arrival), for
* the stop the train stands at its departure, else the arrival.
*
* @param {object} schedule
* @param {object|string} trip A run from activeTrips, or a trip id.
* @param {number} nowMs
* @param {object} [delays]
* @returns {object[]} Per stop: {index, stopId, name, platform, parentId,
* parentName, lat, lon, timezone, scheduledArrivalMs,
* scheduledDepartureMs, expectedArrivalMs, expectedDepartureMs,
* arrivalDelaySec, departureDelaySec, scheduledArrival,
* scheduledDeparture, expectedArrival, expectedDeparture (local 'HH:MM'),
* passThrough, skipped, realtime, state, atStop, relative, relativeMs}.
*/
export function tripStops(schedule, trip, nowMs, delays = null) {
if (!schedule || !Number.isFinite(nowMs)) return [];
const instance = resolveInstance(schedule, trip, nowMs, delays);
if (!instance) return [];
const { pattern } = instance.trip;
const times = runTimes(schedule, instance, delays);
const n = pattern.stops.length;
const out = [];
let nextFound = false;
for (let k = 0; k < n; k++) {
const stop = schedule.stops[pattern.stops[k]];
const parent = stop.parent === null ? null : schedule.stops[stop.parent];
const zone = stop.timezone;
const terminus = k === n - 1;
const leftAt = terminus ? times.arr[k] : times.dep[k];
let state;
let atStop = false;
if (nowMs >= leftAt) state = 'passed';
else if (!nextFound) {
state = 'next';
nextFound = true;
atStop = nowMs >= times.arr[k] && !times.skipped[k];
} else state = 'upcoming';
const eventMs =
state === 'passed'
? leftAt
: atStop || k === 0
? times.dep[k]
: times.arr[k];
out.push({
index: k,
stopId: stop.id,
name: stop.name || parent?.name || stop.id,
platform: stop.platform,
parentId: parent?.id ?? null,
parentName: parent?.name ?? null,
lat: stop.lat,
lon: stop.lon,
timezone: zone,
scheduledArrivalMs: times.schedArr[k],
scheduledDepartureMs: times.schedDep[k],
expectedArrivalMs: times.arr[k],
expectedDepartureMs: times.dep[k],
arrivalDelaySec: Math.round((times.arr[k] - times.schedArr[k]) / 1000),
departureDelaySec: Math.round((times.dep[k] - times.schedDep[k]) / 1000),
scheduledArrival: formatClock(times.schedArr[k], zone),
scheduledDeparture: formatClock(times.schedDep[k], zone),
expectedArrival: formatClock(times.arr[k], zone),
expectedDeparture: formatClock(times.dep[k], zone),
passThrough: pattern.pass[k],
skipped: times.skipped[k],
realtime: times.hasRealtime,
state,
atStop,
relativeMs: eventMs - nowMs,
relative: formatRelative(eventMs - nowMs),
});
}
return out;
}