@pond-ts/fit 0.31.0

package/dist/activity/index.js

@@ -0,0 +1,652 @@
+import * as geo from '../geo/index.js';
+import { prepareActivity, summaryFromPrepared, windowChannels, } from '../summary/index.js';
+import { computePower, powerCurve, powerBestEfforts, normalizedPower, averagePower, maxPower, zoneDistribution, } from '../power/index.js';
+import { hrZoneDistribution, paceZoneDistribution, } from '../zones/index.js';
+import { Distance, Elevation, Duration, Speed, Power, HeartRate, Cadence, } from '../quantities.js';
+// ── small array helpers (validity-aware, gap-safe) ──────────────────────────
+/** Copy a per-sample array to Float64 with non-finite → NaN; `undefined` if the
+ *  channel is absent or has no finite sample (so callers can branch on presence). */
+function clean(values) {
+    if (!values)
+        return undefined;
+    const out = new Float64Array(values.length);
+    let any = false;
+    for (let i = 0; i < values.length; i++) {
+        const v = values[i];
+        if (typeof v === 'number' && Number.isFinite(v)) {
+            out[i] = v;
+            any = true;
+        }
+        else
+            out[i] = NaN;
+    }
+    return any ? out : undefined;
+}
+/** Mean of the finite samples in `[lo, hi)`; `undefined` if none. */
+function meanIn(arr, lo, hi) {
+    if (!arr)
+        return undefined;
+    let sum = 0;
+    let n = 0;
+    for (let i = lo; i < hi; i++) {
+        const v = arr[i];
+        if (Number.isFinite(v)) {
+            sum += v;
+            n += 1;
+        }
+    }
+    return n > 0 ? sum / n : undefined;
+}
+/** Max of the finite samples in `[lo, hi)`; `undefined` if none. */
+function maxIn(arr, lo, hi) {
+    if (!arr)
+        return undefined;
+    let hiV = -Infinity;
+    for (let i = lo; i < hi; i++) {
+        const v = arr[i];
+        if (Number.isFinite(v) && v > hiV)
+            hiV = v;
+    }
+    return hiV > -Infinity ? hiV : undefined;
+}
+/** Smallest index `i` with `timeRel[i] >= t` (binary search; clamped to range). */
+function indexAtElapsed(timeRel, t) {
+    let lo = 0;
+    let hi = timeRel.length - 1;
+    if (t <= timeRel[0])
+        return 0;
+    if (t >= timeRel[hi])
+        return hi;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (timeRel[mid] < t)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+/**
+ * A range of an activity with its own analytics — a split, a lap, or a slice.
+ * Quantity-typed views over a {@link SectionMetrics} bundle; nothing computes
+ * here (the producer already did), so accessors are pure getters.
+ */
+export class Section {
+    m;
+    constructor(m) {
+        this.m = m;
+    }
+    get label() {
+        return this.m.label;
+    }
+    /** Elapsed `[from, to]` window into the activity, in seconds — the time anchor
+     *  a contiguous Focus / range annotation maps onto. */
+    get fromSeconds() {
+        return this.m.fromSec;
+    }
+    get toSeconds() {
+        return this.m.toSec;
+    }
+    /** Cumulative-distance window [start, end] into the activity (metres) — the
+     *  anchor for a map-segment highlight, the distance-axis peer of from/toSeconds. */
+    get startMeters() {
+        return this.m.startMeters;
+    }
+    get endMeters() {
+        return this.m.endMeters;
+    }
+    distance() {
+        return Distance.meters(this.m.distanceMeters);
+    }
+    duration() {
+        return Duration.seconds(this.m.durationSeconds);
+    }
+    movingTime() {
+        return Duration.seconds(this.m.movingSeconds);
+    }
+    elevationGain() {
+        return Elevation.meters(this.m.elevationGainMeters);
+    }
+    elevationLoss() {
+        return this.m.elevationLossMeters == null
+            ? undefined
+            : Elevation.meters(this.m.elevationLossMeters);
+    }
+    normalizedPower() {
+        return this.m.normalizedWatts == null
+            ? undefined
+            : Power.watts(this.m.normalizedWatts);
+    }
+    avgPower() {
+        return this.m.avgWatts == null ? undefined : Power.watts(this.m.avgWatts);
+    }
+    maxPower() {
+        return this.m.maxWatts == null ? undefined : Power.watts(this.m.maxWatts);
+    }
+    avgHeartRate() {
+        return this.m.avgHeartrate == null
+            ? undefined
+            : HeartRate.bpm(this.m.avgHeartrate);
+    }
+    maxHeartRate() {
+        return this.m.maxHeartrate == null
+            ? undefined
+            : HeartRate.bpm(this.m.maxHeartrate);
+    }
+    avgCadence() {
+        return this.m.avgCadence == null
+            ? undefined
+            : Cadence.rpm(this.m.avgCadence);
+    }
+    /** Average speed — the recorded average when present, else distance ÷ moving
+     *  time. `undefined` only when neither is available (no distance / no time). */
+    avgSpeed() {
+        if (this.m.avgSpeedMps != null)
+            return Speed.metersPerSecond(this.m.avgSpeedMps);
+        const t = this.m.movingSeconds;
+        return t > 0 && this.m.distanceMeters > 0
+            ? Speed.metersPerSecond(this.m.distanceMeters / t)
+            : undefined;
+    }
+    maxSpeed() {
+        return this.m.maxSpeedMps == null
+            ? undefined
+            : Speed.metersPerSecond(this.m.maxSpeedMps);
+    }
+    /** Average pace — the inverse view of {@link avgSpeed}. */
+    pace() {
+        return this.avgSpeed()?.pace();
+    }
+}
+/**
+ * The activity façade. Construct from an imported activity (`fromStreams`); read
+ * the canonical series (`timeSeries`), slice it (`splits` / `laps` / `range`),
+ * sample it (`at`), and run analytics (`power` / `powerCurve` / `bestEfforts` /
+ * `hrZones`). Immutable; derived results memoize on first call.
+ */
+export class Activity {
+    prep;
+    _summary;
+    /** NaN-for-missing power, lazily cleaned; `null` once we know there is none. */
+    _watts;
+    /** Splits memoized per interval (metres) — the summary recompute isn't cheap. */
+    _splits = new Map();
+    constructor(prep) {
+        this.prep = prep;
+    }
+    /** Build from an imported activity (streams + metadata + optional laps) — the
+     *  Strava / fixture path. `fromFit` / `fromGpx` / `fromTcx` land with ingest. */
+    static fromStreams(imported) {
+        return new Activity(prepareActivity(imported));
+    }
+    /** Session metadata — id, name, sport, start, totals. */
+    get meta() {
+        return this.prep.imported.activity;
+    }
+    /** Whether the activity carries GPS positions (a map; otherwise indoor / GPS-off). */
+    get hasTrack() {
+        return this.prep.hasTrack;
+    }
+    /** Whether a power channel was recorded. */
+    get hasPower() {
+        return this.watts() != null;
+    }
+    /** The canonical pond series (the escape hatch to the functional/pond layer). */
+    timeSeries() {
+        return this.prep.track;
+    }
+    /** The prepared per-sample columns + derived series — for consumers still on
+     *  the functional path (e.g. the chart) while they migrate to the façade. */
+    prepared() {
+        return this.prep;
+    }
+    /** The full journey summary (totals, channels, polyline, splits, laps). */
+    summary(options = {}) {
+        // memoize only the default summary; a custom-options call recomputes.
+        if (Object.keys(options).length === 0) {
+            return (this._summary ??= summaryFromPrepared(this.prep));
+        }
+        return summaryFromPrepared(this.prep, options);
+    }
+    /** Channels re-bucketed over a distance window `[startMeters, endMeters]` — the
+     *  chart-zoom resolution path, finer than the whole-activity profile from
+     *  {@link summary}. The façade home for the functional `windowChannels`. */
+    windowChannels(options) {
+        return windowChannels(this.prep, options);
+    }
+    /** Total moving / elapsed / distance, quantity-typed. */
+    distance() {
+        return Distance.meters(this.summary().distanceMeters);
+    }
+    elapsedTime() {
+        return Duration.seconds(this.summary().elapsedTimeSeconds);
+    }
+    movingTime() {
+        return Duration.seconds(this.summary().movingTimeSeconds);
+    }
+    /** Even-distance splits (per-km, per-mile, …) as Sections, in order. */
+    splits(interval) {
+        const key = interval.meters;
+        const cached = this._splits.get(key);
+        if (cached)
+            return cached;
+        const splits = this.summary({ splitMeters: key }).splits;
+        let fromSec = 0;
+        let fromMeters = 0;
+        const sections = splits.map((s) => {
+            const sec = sectionFromSplit(s, fromSec, fromMeters);
+            fromSec += s.durationSeconds;
+            fromMeters += s.distanceMeters;
+            return new Section(sec);
+        });
+        this._splits.set(key, sections);
+        return sections;
+    }
+    /** Device-recorded laps as Sections (empty if the source recorded none). */
+    laps() {
+        const laps = this.prep.imported.laps ?? [];
+        const startMs = Date.parse(this.meta.startTimeUtc);
+        let acc = 0; // fallback elapsed cursor when a lap has no start time
+        return laps.map((lap) => {
+            const sec = sectionFromLap(lap, startMs, acc);
+            acc = sec.toSec;
+            return new Section(sec);
+        });
+    }
+    /** An arbitrary slice `[from, to]` (elapsed time) as a Section, with metrics
+     *  computed from the series over that window. Clamped to the activity. */
+    range(from, to, label = 'Range') {
+        const { timeRel, cols, step } = this.prep;
+        const lo = indexAtElapsed(timeRel, from.seconds);
+        const hi = indexAtElapsed(timeRel, to.seconds);
+        return new Section(this.metricsForRange(lo, hi, label, cols, step, timeRel));
+    }
+    /** Power summary (NP, IF, TSS, distribution, zones, curve) at the given FTP —
+     *  `undefined` when no power was recorded. `elapsedSeconds` drives TSS. */
+    power(ftp) {
+        const watts = this.watts();
+        if (!watts)
+            return undefined;
+        // elapsed = last − first sample, straight off the prepared relative-time axis
+        // (timeRel[n−1]); avoids forcing the full journey summary just to read TSS.
+        const elapsed = this.prep.n > 0 ? (this.prep.timeRel[this.prep.n - 1] ?? 0) : 0;
+        return computePower(this.prep.cols.timeSec, watts, ftp, elapsed);
+    }
+    /** Mean-maximal power curve; `[]` when no power. */
+    powerCurve(durations) {
+        const watts = this.watts();
+        return watts ? powerCurve(this.prep.cols.timeSec, watts, durations) : [];
+    }
+    /** Power best efforts at the canonical durations (+ W/kg if `weightKg`); `[]`
+     *  when no power. */
+    bestEfforts(opts = {}) {
+        const watts = this.watts();
+        return watts ? powerBestEfforts(this.prep.cols.timeSec, watts, opts) : [];
+    }
+    /** Distance best efforts — fastest time over each canonical distance window
+     *  (400 m … marathon), with avg HR. Needs a time axis; `[]` otherwise. */
+    distanceBestEfforts(distances) {
+        if (!this.prep.hasTime)
+            return [];
+        return geo.bestEffortsByDistance(this.prep.cum, this.prep.cols.timeSec, distances, clean(this.prep.cols.hr));
+    }
+    /** Time-in-zone for heart rate against the given zone definition; `[]` with no HR. */
+    hrZones(def) {
+        const hr = clean(this.prep.cols.hr);
+        return hr ? hrZoneDistribution(this.prep.cols.timeSec, hr, def) : [];
+    }
+    /** Time-in-zone for pace (from the derived speed) against `def`; `[]` with no time. */
+    paceZones(def) {
+        if (!this.prep.hasTime)
+            return [];
+        return paceZoneDistribution(this.prep.cols.timeSec, this.prep.speed, def);
+    }
+    /** Bind an athlete {@link Profile} for the analytics that need FTP / body
+     *  weight / zone definitions — power summary, time-in-zone, W/kg. Returns a
+     *  {@link ProfiledActivity} whose slices (`splits` / `range` / `laps`) stay
+     *  bound to the same profile (turtles all the way down). The bare `Activity`
+     *  keeps only the profile-agnostic methods. */
+    usingProfile(profile) {
+        return new ProfiledActivity(this, profile);
+    }
+    /** Channel values interpolated at one elapsed instant — the scrub / annotation
+     *  anchor sample. Linear between the bracketing samples. */
+    at(t) {
+        const { timeRel, cols, cum, speed } = this.prep;
+        const tc = Math.max(timeRel[0], Math.min(t.seconds, timeRel[timeRel.length - 1]));
+        const hi = indexAtElapsed(timeRel, tc);
+        const lo = hi > 0 ? hi - 1 : 0;
+        const span = timeRel[hi] - timeRel[lo];
+        const f = span > 0 ? (tc - timeRel[lo]) / span : 0;
+        const lerp = (a) => {
+            if (!a)
+                return undefined;
+            const x = a[lo];
+            const y = a[hi];
+            if (!Number.isFinite(x) || !Number.isFinite(y))
+                return Number.isFinite(y) ? y : x;
+            return x + (y - x) * f;
+        };
+        const out = { atSeconds: tc };
+        const dist = lerp(cum);
+        if (dist != null && Number.isFinite(dist))
+            out.distance = Distance.meters(dist);
+        const ele = lerp(cols.ele);
+        if (ele != null && Number.isFinite(ele))
+            out.elevation = Elevation.meters(ele);
+        const hr = lerp(cols.hr);
+        if (hr != null && Number.isFinite(hr))
+            out.heartRate = HeartRate.bpm(hr);
+        const pw = lerp(cols.power);
+        if (pw != null && Number.isFinite(pw))
+            out.power = Power.watts(pw);
+        const cad = lerp(cols.cadence);
+        if (cad != null && Number.isFinite(cad))
+            out.cadence = Cadence.rpm(cad);
+        const sp = lerp(speed);
+        if (sp != null && Number.isFinite(sp))
+            out.speed = Speed.metersPerSecond(sp);
+        return out;
+    }
+    // ── internals ──
+    /** Cleaned (NaN-for-missing) power column, memoized; `undefined` if no power. */
+    watts() {
+        if (this._watts === undefined)
+            this._watts = clean(this.prep.cols.power) ?? null;
+        return this._watts ?? undefined;
+    }
+    /** Compute a range's metrics from the columns over `[lo, hi]` (inclusive). */
+    metricsForRange(lo, hi, label, cols, step, timeRel) {
+        const a = Math.min(lo, hi);
+        const b = Math.max(lo, hi);
+        const end = b + 1; // exclusive bound for the slice
+        const timeSlice = cols.timeSec.slice(a, end);
+        const stepSlice = step.slice(a, end);
+        const { gainMeters, lossMeters } = geo.elevationGainLoss(cols.ele.slice(a, end));
+        const distanceMeters = (this.prep.cum[b] ?? 0) - (this.prep.cum[a] ?? 0);
+        const durationSeconds = timeRel[b] - timeRel[a];
+        const movingSeconds = geo.movingTimeSeconds(stepSlice, timeSlice);
+        const watts = this.watts();
+        const wattsSlice = watts?.slice(a, end);
+        const m = {
+            label,
+            fromSec: timeRel[a],
+            toSec: timeRel[b],
+            startMeters: this.prep.cum[a] ?? 0,
+            endMeters: this.prep.cum[b] ?? 0,
+            distanceMeters,
+            durationSeconds,
+            movingSeconds,
+            elevationGainMeters: gainMeters,
+            elevationLossMeters: lossMeters,
+        };
+        // Only when the window actually has a finite watt: averagePower/normalizedPower
+        // return 0 (not undefined) on an all-missing slice, which would fabricate a
+        // "0 W" reading over a power gap — and diverge from splits(), where the same
+        // window reports `undefined`. Gate on presence so the two agree.
+        if (wattsSlice && wattsSlice.some((v) => Number.isFinite(v))) {
+            m.normalizedWatts = normalizedPower(timeSlice, wattsSlice);
+            m.avgWatts = averagePower(wattsSlice);
+            m.maxWatts = maxPower(wattsSlice);
+        }
+        m.avgHeartrate = meanIn(clean(cols.hr), a, end);
+        m.maxHeartrate = maxIn(clean(cols.hr), a, end);
+        m.avgCadence = meanIn(clean(cols.cadence), a, end);
+        if (this.prep.hasTime) {
+            m.avgSpeedMps =
+                movingSeconds > 0 ? distanceMeters / movingSeconds : undefined;
+            m.maxSpeedMps = maxIn(this.prep.speed, a, end);
+        }
+        return m;
+    }
+}
+/** Normalize a computed {@link Split} to the shared metric bundle. Splits report
+ *  elapsed duration only (no separate moving time). */
+function sectionFromSplit(s, fromSec, fromMeters) {
+    return {
+        label: `Split ${s.index}`,
+        fromSec,
+        toSec: fromSec + s.durationSeconds,
+        startMeters: fromMeters,
+        endMeters: fromMeters + s.distanceMeters,
+        distanceMeters: s.distanceMeters,
+        durationSeconds: s.durationSeconds,
+        movingSeconds: s.durationSeconds,
+        elevationGainMeters: s.elevationGainMeters,
+        elevationLossMeters: s.elevationLossMeters,
+        normalizedWatts: s.normalizedWatts,
+        avgWatts: s.avgWatts,
+        maxWatts: s.maxWatts,
+        avgHeartrate: s.avgHeartrate,
+        maxHeartrate: s.maxHeartrate,
+        avgCadence: s.avgCadence,
+        avgSpeedMps: s.avgSpeedMps,
+        maxSpeedMps: s.maxSpeedMps,
+    };
+}
+/** Normalize a recorded {@link Lap} to the shared metric bundle. The lap's elapsed
+ *  window is its start (from its timestamp, else the running cursor) + elapsed. */
+function sectionFromLap(lap, startMs, cursorSec) {
+    const fromSec = lap.startTimeUtc && Number.isFinite(Date.parse(lap.startTimeUtc))
+        ? (Date.parse(lap.startTimeUtc) - startMs) / 1000
+        : cursorSec;
+    return {
+        label: `Lap ${lap.index}`,
+        fromSec,
+        toSec: fromSec + lap.elapsedSeconds,
+        startMeters: lap.startDistanceMeters,
+        endMeters: lap.startDistanceMeters + lap.distanceMeters,
+        distanceMeters: lap.distanceMeters,
+        durationSeconds: lap.elapsedSeconds,
+        movingSeconds: lap.movingSeconds,
+        elevationGainMeters: lap.elevationGainMeters ?? 0,
+        normalizedWatts: undefined, // not recorded per lap; compute via range() if needed
+        avgWatts: lap.avgWatts,
+        maxWatts: lap.maxWatts,
+        avgHeartrate: lap.avgHeartrate,
+        maxHeartrate: lap.maxHeartrate,
+        avgSpeedMps: lap.avgSpeedMps,
+        maxSpeedMps: lap.maxSpeedMps,
+    };
+}
+// ── Profile-bound view ──────────────────────────────────────────────────────
+/**
+ * An {@link Activity} bound to an athlete {@link Profile} — the home for the
+ * analytics that need FTP / body weight / zone definitions. Obtained via
+ * `activity.usingProfile(bob)`. Its slices (`splits` / `range` / `laps`) return
+ * {@link ProfiledSection}s carrying the same profile, so the binding flows all
+ * the way down. The bare {@link Activity} keeps only the profile-agnostic
+ * methods, so a missing FTP / weight is a type-level absence, not a runtime
+ * `undefined`.
+ */
+export class ProfiledActivity {
+    activity;
+    profile;
+    constructor(activity, profile) {
+        this.activity = activity;
+        this.profile = profile;
+    }
+    /** Full power summary (NP, IF, TSS, distribution, zones, curve) at the
+     *  profile's FTP. `undefined` when no power was recorded or no FTP is known. */
+    power() {
+        const ftp = this.profile.ftpWatts;
+        return ftp == null ? undefined : this.activity.power(ftp);
+    }
+    /** Time in each Coggan power zone (FTP-relative); `[]` with no power or no FTP. */
+    byPowerZone() {
+        const ftp = this.profile.ftpWatts;
+        if (ftp == null)
+            return [];
+        const prep = this.activity.prepared();
+        const watts = clean(prep.cols.power);
+        return watts ? zoneDistribution(prep.cols.timeSec, watts, ftp) : [];
+    }
+    /** Time in each heart-rate zone; `[]` with no HR or no HR zones on the profile. */
+    byHeartRateZone() {
+        const zones = this.profile.heartRateZones;
+        return zones ? this.activity.hrZones(zones) : [];
+    }
+    /** Time in each pace zone; `[]` with no time axis or no pace zones on the profile. */
+    byPaceZone() {
+        const zones = this.profile.paceZones;
+        return zones ? this.activity.paceZones(zones) : [];
+    }
+    /** Power best efforts (+ W/kg from the profile's body weight); `[]` with no power. */
+    bestEfforts(durations) {
+        const opts = {};
+        if (this.profile.weightKg != null)
+            opts.weightKg = this.profile.weightKg;
+        if (durations)
+            opts.durations = durations;
+        return this.activity.bestEfforts(opts);
+    }
+    /** Even-distance splits as profile-bound sections. */
+    splits(interval) {
+        return this.activity
+            .splits(interval)
+            .map((s) => new ProfiledSection(this.activity, s, this.profile));
+    }
+    /** Device-recorded laps as profile-bound sections (empty if none recorded). */
+    laps() {
+        return this.activity
+            .laps()
+            .map((s) => new ProfiledSection(this.activity, s, this.profile));
+    }
+    /** An arbitrary `[from, to]` slice as a profile-bound section. */
+    range(from, to, label = 'Range') {
+        return new ProfiledSection(this.activity, this.activity.range(from, to, label), this.profile);
+    }
+}
+/**
+ * A {@link Section} bound to a {@link Profile} — adds the FTP / weight / zone
+ * analytics over the section's own window. Profile-agnostic metrics delegate to
+ * the underlying section; the zone / power methods recompute over the section's
+ * `[fromSeconds, toSeconds]` slice of the parent activity.
+ */
+export class ProfiledSection {
+    activity;
+    section;
+    profile;
+    _window;
+    constructor(activity, section, profile) {
+        this.activity = activity;
+        this.section = section;
+        this.profile = profile;
+    }
+    /** The underlying profile-agnostic section. */
+    get unprofiled() {
+        return this.section;
+    }
+    // ── profile-agnostic — delegate to the underlying section ──
+    get label() {
+        return this.section.label;
+    }
+    get fromSeconds() {
+        return this.section.fromSeconds;
+    }
+    get toSeconds() {
+        return this.section.toSeconds;
+    }
+    get startMeters() {
+        return this.section.startMeters;
+    }
+    get endMeters() {
+        return this.section.endMeters;
+    }
+    distance() {
+        return this.section.distance();
+    }
+    duration() {
+        return this.section.duration();
+    }
+    movingTime() {
+        return this.section.movingTime();
+    }
+    elevationGain() {
+        return this.section.elevationGain();
+    }
+    elevationLoss() {
+        return this.section.elevationLoss();
+    }
+    normalizedPower() {
+        return this.section.normalizedPower();
+    }
+    avgPower() {
+        return this.section.avgPower();
+    }
+    maxPower() {
+        return this.section.maxPower();
+    }
+    avgHeartRate() {
+        return this.section.avgHeartRate();
+    }
+    maxHeartRate() {
+        return this.section.maxHeartRate();
+    }
+    avgCadence() {
+        return this.section.avgCadence();
+    }
+    avgSpeed() {
+        return this.section.avgSpeed();
+    }
+    maxSpeed() {
+        return this.section.maxSpeed();
+    }
+    pace() {
+        return this.section.pace();
+    }
+    // ── profile-dependent — recomputed over this section's window ──
+    /** Power summary over the section's window; `undefined` with no power / no FTP. */
+    power() {
+        const ftp = this.profile.ftpWatts;
+        const w = this.window();
+        return ftp != null && w.watts
+            ? computePower(w.timeSec, w.watts, ftp, this.toSeconds - this.fromSeconds)
+            : undefined;
+    }
+    /** Time in each power zone over the section's window; `[]` with no power / FTP. */
+    byPowerZone() {
+        const ftp = this.profile.ftpWatts;
+        const w = this.window();
+        return ftp != null && w.watts
+            ? zoneDistribution(w.timeSec, w.watts, ftp)
+            : [];
+    }
+    /** Time in each HR zone over the section's window; `[]` with no HR / HR zones. */
+    byHeartRateZone() {
+        const zones = this.profile.heartRateZones;
+        const w = this.window();
+        return zones && w.heartRate
+            ? hrZoneDistribution(w.timeSec, w.heartRate, zones)
+            : [];
+    }
+    /** Time in each pace zone over the section's window; `[]` with no time / pace zones. */
+    byPaceZone() {
+        const zones = this.profile.paceZones;
+        const w = this.window();
+        return zones && w.speed
+            ? paceZoneDistribution(w.timeSec, w.speed, zones)
+            : [];
+    }
+    /** Slice the parent columns to `[fromSeconds, toSeconds]`, computed once. */
+    window() {
+        if (this._window)
+            return this._window;
+        const prep = this.activity.prepared();
+        const a = indexAtElapsed(prep.timeRel, this.fromSeconds);
+        const b = indexAtElapsed(prep.timeRel, this.toSeconds);
+        const lo = Math.min(a, b);
+        const end = Math.max(a, b) + 1;
+        const w = { timeSec: prep.cols.timeSec.slice(lo, end) };
+        const watts = clean(prep.cols.power)?.slice(lo, end);
+        if (watts)
+            w.watts = watts;
+        const hr = clean(prep.cols.hr)?.slice(lo, end);
+        if (hr)
+            w.heartRate = hr;
+        if (prep.hasTime)
+            w.speed = prep.speed.slice(lo, end);
+        return (this._window = w);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs-fallback.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+// @pond-ts/fit ships as ES modules only. This stub is the `require` target in
+// the package's `exports` map so that CommonJS consumers get a clear,
+// actionable error instead of Node's cryptic `ERR_PACKAGE_PATH_NOT_EXPORTED`.
+//
+// It is copied verbatim into `dist/` during `prepack` (see package.json) so it
+// rides along in the published tarball; the source of truth lives at the
+// package root and is never touched by `tsc`.
+
+throw new Error(
+  '@pond-ts/fit is an ES module package and cannot be loaded with require(). ' +
+    "Use `import { Activity } from '@pond-ts/fit'` instead, or a dynamic " +
+    "`await import('@pond-ts/fit')` from CommonJS. See https://nodejs.org/api/esm.html.",
+);