@motionstudies/core 0.1.0-alpha.5 → 0.1.0-alpha.7

package/README.md

@@ -5,7 +5,7 @@ Shared packages for the Motion Studies transport instrument. The source workspac
 - `@motionstudies/core`: transport contracts, indexing, interpolation and visual theme contracts; no browser or Node dependencies.
 - `@motionstudies/three`: `NationalNetworkScene`, `HubPulseScene`, `StationFlowScene`, camera framing and label-mode contracts. React, React Three Fiber and Three.js are peers; rendering internals are not public subpaths.
 - `@motionstudies/web`: picker, button tooltips, theme application, mounting, progressive loaders, observed operations and recording. Import `tokens.css` and `mobile-picker.css` for isolated widgets. `shell.css` is an optional full-page study shell scoped to `.motion-study`; `mountMotionStudy` applies that class. Fonts and edition layouts belong to consumers.
-- `@motionstudies/data`: Node-only GTFS readers, network chunking, merging and station ranking. ZIP reading requires `unzip` on the host. Source selection, provenance overrides and compilation commands belong to each edition.
+- `@motionstudies/data`: Node-only GTFS readers, ADS-B heatmap compilation, air endpoint enrichment, network chunking, merging and station ranking. ZIP reading requires `unzip` on the host. Source selection, provenance overrides and compilation commands belong to each edition.
 
 ```tsx
 import { MobilePicker } from '@motionstudies/web/components/MobilePicker'
@@ -25,6 +25,16 @@ Build release candidates with `npm run build:packages`. Distribution manifests a
 
 Source workspace manifests always stay private. `npm run check:release` builds public candidates, tests their packed consumer and records the tested tarball hashes; `npm run release:dry-run` inspects the publication without writing to npm. The manual main-branch `release.yml` workflow publishes those same tarballs with public access and provenance. See [release instructions](https://github.com/emmettl/motionstudies/blob/main/docs/RELEASING.md) for bootstrap-token and trusted-publisher setup. All four shared packages are MIT-licensed; each distribution includes `LICENSE`.
 
+## Now and browser location
+
+`useNowClock` from `@motionstudies/web/use-now-clock` follows the wall clock on each animation frame, so returning from a suspended tab catches up immediately. Call `start()` from a Now button, set the consumer's playback rate to 1, and render its `time` while `active`. With `NationalNetworkScene`, pass `isPlaying={false}` while this external clock owns time. Call `stop()` before pausing, seeking or changing speed, and retain the last clock time for ordinary playback. Clear moving vehicle selections on entry to keep the camera still; panning and zooming remain available.
+
+Supply a resolver `(instant: Date) => number | null` that maps the instant into the edition's service-time coordinates. The edition owns timezone, service date, daylight-saving rules and source coverage. Now is appropriate when the data gives a meaningful sense of this place at this time; exact live vehicle positions are not required. An edition may explicitly map the current local clock onto a suitable representative weekday or seasonal timetable, with a quiet label such as “Typical weekday · realtime pace”. Historical or modelled sources need that same meaningful relationship to the present; merely having timestamps is insufficient. Return null outside the chosen data's coverage: the hook stops, retains the last valid time and exposes `unavailable`. Do not silently relabel a recording as live or wrap a partial study window. Timetable and observed-data labels remain the consumer's responsibility; 1× playback does not imply a live vehicle feed.
+
+`useBrowserLocation` from `@motionstudies/web/use-browser-location` requests a single position only when `locate()` is called. It exposes `location`, `status` and `clear()`; it neither stores nor sends coordinates. Render localized messages for denied, timeout and unavailable states. Clearing or unmounting discards late responses. A secure browser context and user permission are required.
+
+Pass an in-coverage position as `NationalNetworkScene`'s `userLocation` for a steady glowing dot. Use the existing `focus-location` camera command once after locating, with `[longitude, latitude]` and a suitable `distanceScale`. Validate coverage in the consumer and preserve the view when the user is outside it. Show the reported `accuracy` in accessible text; the dot is an approximate position. The marker hides in diagram layouts. The lab's **Now** specimen uses a clearly labelled synthetic UTC timetable and covers clock, permission and out-of-coverage behavior. Public editions still require independent adoption and releases.
+
 ## Selection labels
 
 `NationalNetworkScene` gives the selected station first label priority, followed by the selected route's terminal stops (including branches), then intermediate stops. Selected services use their own endpoints. Priority precedes retained labels and ordinary rank/tier admission; clearing selection restores edition ranking. This is built in for every consumer, including geographic and diagram layouts. Supply complete enabled infrastructure as `referenceSnapshot` to preserve endpoints through timetable gaps; its stop indexes need not match the active snapshot. See the [edition behaviour contract](https://github.com/emmettl/motionstudies/blob/main/docs/EDITIONS.md#selection-and-station-labels).
@@ -73,3 +83,19 @@ Empty messages also appear on the flaps, in the widest column (the destination/o
 Rail and other transport consumers can share the same time filtering through `movementBoardWindow(study, horizon)` and `movementsForBoard(entries, window, maxRows)` from `@motionstudies/core/domain/movement-board`. Format the returned numeric times when mapping them into `SplitFlapBoard` cells. The lab's rail board follows the same study clock and horizon as its airport card.
 
 `@motionstudies/data/air-endpoints` provides offline `enrichAirEndpoints` for existing air manifests, chunks and opening snapshots. Supply cached same-date global ADSB.lol heatmaps, an OurAirports CSV and the service date's local UTC offset. It associates only unambiguous low-altitude endpoints near a reference airport; cruise-only traces and uncertain routes stay unknown. Optional `AirEndpoint` origin/destination fields carry airport identity, observed boundary time and `observed-endpoint` evidence. `airportBoardMovements` maps full manifest entries to board rows without confusing playback chunk boundaries with flight endpoints. Input hashes and source/licence attribution are recorded in fixture metadata. These fields describe inferred observations, never flight schedules, gates or live status.
+
+## Optional live airport feed
+
+`AirportBoard` from `@motionstudies/web/components/AirportBoard` adds Study/Now controls around an existing `AirportHeroCard` configuration. Pass `studyCard` with the usual card props and `live={{ baseUrl, edition, airport }}` for the shared service. Import `airport-hero-card.css`. `labels` localizes the wrapper's control and availability messages. The lower-level `useAirportFeed` hook and core `domain/live-airport` contract are also public exports.
+
+Live timestamps are Unix seconds and use the airport's timezone for display, independently of recorded service time. The wrapper does not pass live flight IDs to the recorded scene's selection callback. The recorded card remains mounted while hidden; the edition still owns playback and can pause its study when appropriate. Only Now mode fetches flight boards; checking capabilities does not query the paid provider. Stale results carry their retrieval time and disappear when expired. Source data never falls back to synthetic or recorded flights under a live label.
+
+See [service architecture and operations](../docs/LIVE-AIRPORTS.md). The Worker is deployed separately; npm publication and edition adoption remain explicit release steps.
+
+## Shared recorded air compilation
+
+`@motionstudies/data/adsb-heatmap` consolidates the offline heatmap pipeline previously copied between editions. `ingestAdsbHeatmaps` reads cached gzip slices, decodes observations, filters transport-scale tracks, splits flights, and writes either an opening snapshot or an indexed day with overlapping chunks. Source hashes, chunk hashes and ODbL attribution accompany the output. It makes no network requests.
+
+The same `decodeAdsbHeatmap` now powers `enrichAirEndpoints`; endpoint inference retains full coordinate precision, while playback compilation retains the existing five-decimal coordinates. `transportAirTracks` and `chunkAirSnapshot` are also available for consumers that assemble their own pipeline. All functions have public TypeScript declarations and work in the packed Node package.
+
+Editions supply geographic bounds, service date, explicit UTC offset, optional timezone, input files and output paths. Flight IDs and chunk overlap retain the existing contracts. The default splits known callsign changes and gaps over 30 minutes. Set `splitTracks: false` only when reproducing a legacy opening snapshot with one ID per aircraft. See [adoption and compatibility](../docs/AIR-DATA.md).

package/domain/live-airport.d.ts

@@ -0,0 +1,42 @@
+/** Live boards use Unix seconds throughout, independent of an edition's recorded service day. */
+export interface LiveAirportMovement {
+    readonly id: string;
+    readonly service: string;
+    readonly scheduledTime?: number;
+    /** Provider revision: may be estimated or actual; do not relabel as confirmed. */
+    readonly revisedTime?: number;
+    readonly place?: string;
+    readonly gate?: string;
+    readonly status?: string;
+    readonly tone?: 'neutral' | 'accent' | 'warning';
+}
+export interface LiveAirportSnapshot {
+    readonly airport: {
+        readonly iata: string;
+        readonly name: string;
+        readonly city: string;
+        readonly timeZone: string;
+    };
+    readonly fetchedAt: number;
+    readonly freshUntil: number;
+    readonly expiresAt: number;
+    readonly windowStart: number;
+    readonly windowEnd: number;
+    readonly departures: readonly LiveAirportMovement[];
+    readonly arrivals: readonly LiveAirportMovement[];
+}
+export type AirportFeedReason = 'disabled' | 'not-configured' | 'subscription' | 'budget' | 'provider' | 'rate-limit';
+export interface AirportFeedResponse {
+    readonly version: 1;
+    readonly status: 'fresh' | 'stale' | 'unavailable' | 'disabled';
+    readonly reason?: AirportFeedReason;
+    readonly retryAfterSeconds: number;
+    readonly snapshot?: LiveAirportSnapshot;
+}
+export interface AirportFeedCapabilities {
+    readonly version: 1;
+    readonly enabled: boolean;
+    readonly airports: readonly string[];
+}
+/** Validate the network boundary before publishing data to a card. */
+export declare function isAirportFeedResponse(value: unknown): value is AirportFeedResponse;

package/domain/live-airport.js

@@ -0,0 +1,32 @@
+const record = (value) => !!value && typeof value === 'object';
+const finite = (value) => typeof value === 'number' && Number.isFinite(value);
+function movement(value) {
+    return record(value) && typeof value.id === 'string' && typeof value.service === 'string'
+        && ['scheduledTime', 'revisedTime'].every((key) => value[key] === undefined || finite(value[key]))
+        && ['place', 'gate', 'status'].every((key) => value[key] === undefined || typeof value[key] === 'string')
+        && (value.tone === undefined || ['neutral', 'accent', 'warning'].includes(String(value.tone)));
+}
+/** Validate the network boundary before publishing data to a card. */
+export function isAirportFeedResponse(value) {
+    if (!record(value) || value.version !== 1 || !['fresh', 'stale', 'unavailable', 'disabled'].includes(String(value.status))
+        || !finite(value.retryAfterSeconds) || value.retryAfterSeconds < 0)
+        return false;
+    if (value.status === 'disabled' || value.status === 'unavailable')
+        return value.snapshot === undefined;
+    const s = value.snapshot;
+    try {
+        if (!record(s) || !record(s.airport) || typeof s.airport.timeZone !== 'string')
+            return false;
+        new Intl.DateTimeFormat('en', { timeZone: s.airport.timeZone }).format(0);
+    }
+    catch {
+        return false;
+    }
+    return record(s) && record(s.airport)
+        && ['iata', 'name', 'city', 'timeZone'].every((key) => typeof s.airport[key] === 'string')
+        && ['fetchedAt', 'freshUntil', 'expiresAt', 'windowStart', 'windowEnd'].every((key) => finite(s[key]))
+        && Number(s.fetchedAt) <= Number(s.freshUntil) && Number(s.freshUntil) <= Number(s.expiresAt)
+        && Number(s.windowStart) < Number(s.windowEnd)
+        && Array.isArray(s.departures) && s.departures.every(movement)
+        && Array.isArray(s.arrivals) && s.arrivals.every(movement);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@motionstudies/core",
-  "version": "0.1.0-alpha.5",
+  "version": "0.1.0-alpha.7",
   "private": false,
   "type": "module",
   "description": "Transport contracts and motion primitives for Motion Studies.",
@@ -144,6 +144,11 @@
       "types": "./domain/train-time-index.d.ts",
       "import": "./domain/train-time-index.js",
       "default": "./domain/train-time-index.js"
+    },
+    "./domain/live-airport": {
+      "types": "./domain/live-airport.d.ts",
+      "import": "./domain/live-airport.js",
+      "default": "./domain/live-airport.js"
     }
   },
   "files": [