@pond-ts/fit 0.31.0

package/dist/profile/index.js

@@ -0,0 +1,217 @@
+/**
+ * The athlete profile — the **time-varying** settings an activity is read
+ * against: body weight (for W/kg), FTP (power zones), the HR-zone basis (max HR
+ * or custom bounds), and a threshold 5 k time (pace zones). Each quantity is a
+ * sparse, effective-dated series: "from this date, my FTP was 250 W."
+ *
+ * Modeled as pond `TimeSeries` keyed by the effective date and resolved with
+ * `series.atOrBefore(activityDate)` — the value in force on the day of the
+ * activity. A natural pond fit: an irregular, step-function config series with an
+ * as-of query. {@link hydrateProfile} lifts the persisted profile JSON into the
+ * series, {@link profileAsOf} resolves a date.
+ */
+import { TimeSeries, Time } from 'pond-ts';
+const SENTINEL = 1e9; // open-top edge (pond/byColumn require finite edges)
+/** HR zones (5), Z1→Z5. Strava's max-HR defaults: Z1≤65%, Z2≤81%, Z3≤89%,
+ *  Z4≤97%, Z5 above (e.g. max 198 → 129/160/176/192). */
+const HR_ZONE_LABELS = [
+    'Recovery',
+    'Endurance',
+    'Tempo',
+    'Threshold',
+    'Anaerobic',
+];
+const HR_MAX_FRACTIONS = [0.65, 0.81, 0.89, 0.97]; // Z1/Z2 … Z4/Z5 upper bounds
+/** Pace zones (6), Z1→Z6. Boundaries as multiples of 5 k pace (slower = lower
+ *  zone), approximating Strava's 5 k-time model: Z1 Recovery (slowest) →
+ *  Z6 Anaerobic (fastest). */
+const PACE_ZONE_LABELS = [
+    'Recovery',
+    'Endurance',
+    'Tempo',
+    'Threshold',
+    'VO2 Max',
+    'Anaerobic',
+];
+const PACE_PACE_MULTIPLES = [1.33, 1.15, 1.03, 0.96, 0.9]; // of 5 k pace, slow→fast boundaries
+/** HR zone scheme (bpm axis) from a max HR or explicit bounds. */
+export function hrZonesFrom(basis) {
+    const bounds = 'bounds' in basis
+        ? basis.bounds.slice(0, 4)
+        : HR_MAX_FRACTIONS.map((f) => Math.round(f * basis.maxHr));
+    return { edges: [0, ...bounds, SENTINEL], labels: HR_ZONE_LABELS };
+}
+/**
+ * Pace zone scheme over the **speed** axis (m/s, ascending) from a 5 k time.
+ * 5 k pace → boundary paces (× multiples) → boundary speeds (= dist/pace).
+ * Edges ascend in speed, so bin 0 is the slowest (Z1 Recovery) and the top bin
+ * the fastest (Z6 Anaerobic) — the labels are ordered to match.
+ */
+export function paceZonesFrom(fiveKSeconds) {
+    const fiveKSpeed = fiveKSeconds > 0 ? 5000 / fiveKSeconds : 0; // m/s at 5 k pace
+    // pace multiple m → speed = fiveKSpeed / m; larger pace multiple = slower.
+    // Build ascending speed edges from the slow→fast pace multiples.
+    const speedEdges = PACE_PACE_MULTIPLES.map((m) => fiveKSpeed / m);
+    return { edges: [0, ...speedEdges, SENTINEL], labels: PACE_ZONE_LABELS };
+}
+/** Power zones (7), Z1→Z7 (Coggan), as fractions of FTP. Z7 is open-ended. */
+const POWER_ZONE_LABELS = [
+    'Recovery',
+    'Endurance',
+    'Tempo',
+    'Threshold',
+    'VO2Max',
+    'Anaerobic',
+    'Neuromuscular',
+];
+const POWER_ZONE_FRACTIONS = [0.55, 0.75, 0.9, 1.05, 1.2, 1.5]; // of FTP, Z1/Z2 … Z6/Z7
+/** The 7 Coggan power zones as a watt-axis {@link ZoneDef}, FTP-relative. The
+ *  canonical home for the scheme (HR + pace zone builders live here too); the
+ *  power module's `powerZoneDef` delegates to this. */
+export function powerZonesFrom(ftp) {
+    return {
+        edges: [0, ...POWER_ZONE_FRACTIONS.map((f) => f * ftp), SENTINEL],
+        labels: POWER_ZONE_LABELS,
+    };
+}
+/** Date key + a throwaway seq column (pond wants ≥1 value column); the rich
+ *  payload rides in the key→entry map, not these columns. */
+const AS_OF_SCHEMA = [
+    { name: 'time', kind: 'time' },
+    { name: 'seq', kind: 'number' },
+];
+/**
+ * Build a pond `TimeSeries` keyed by each entry's effective date and return an
+ * as-of resolver. pond owns the date axis + the `atOrBefore` search (exactly
+ * the effective-dated lookup — no hand-rolled binary search); the rich/union
+ * payload rides in a key→entry map and is read back by the event's key, which
+ * keeps optional/union fields out of pond's scalar columns. Distinct dates win
+ * last (a same-day re-edit supersedes); empty → always `undefined`.
+ */
+function asOfSeries(name, entries) {
+    if (entries.length === 0)
+        return { at: () => undefined };
+    // dedupe by ms (last wins), then sort ascending — pond requires non-decreasing keys.
+    const byMs = new Map();
+    for (const e of entries) {
+        const ms = Date.parse(e.at);
+        if (Number.isFinite(ms))
+            byMs.set(ms, e);
+    }
+    const sorted = [...byMs.keys()].sort((a, b) => a - b);
+    if (sorted.length === 0)
+        return { at: () => undefined };
+    const series = new TimeSeries({
+        name,
+        schema: AS_OF_SCHEMA,
+        rows: sorted.map((ms, i) => [ms, i]),
+    });
+    return {
+        at(dateUtc) {
+            const ms = Date.parse(dateUtc);
+            if (!Number.isFinite(ms))
+                return undefined;
+            const ev = series.atOrBefore(new Time(ms));
+            return ev ? byMs.get(ev.begin()) : undefined;
+        },
+    };
+}
+/** Lift the vault JSON into pond-backed as-of resolvers. */
+export function hydrateProfile(json) {
+    return {
+        weightKg: asOfSeries('weightKg', json.weightKg ?? []),
+        ftpWatts: asOfSeries('ftpWatts', json.ftpWatts ?? []),
+        hrZone: asOfSeries('hrZone', json.hrZone ?? []),
+        paceThreshold: asOfSeries('paceThreshold', json.paceThreshold ?? []),
+    };
+}
+/** Resolve every series to the values in force on `activityDateUtc`, deriving
+ *  the HR + pace zone schemes. The one call the analytics layer makes.
+ *  Note: bare-date entries (`"2026-03-01"`) parse to UTC midnight, so an
+ *  activity timestamped late on the prior day in a positive UTC offset can pick
+ *  up a same-dated change a local day "early". Immaterial for a step-function
+ *  config series; use full datetimes in `at` if you need finer alignment. */
+export function profileAsOf(json, activityDateUtc) {
+    const h = hydrateProfile(json);
+    const weight = h.weightKg.at(activityDateUtc)?.value;
+    const ftp = h.ftpWatts.at(activityDateUtc)?.value;
+    const hr = h.hrZone.at(activityDateUtc);
+    const pace = h.paceThreshold.at(activityDateUtc);
+    const resolved = {};
+    if (typeof weight === 'number')
+        resolved.weightKg = weight;
+    if (typeof ftp === 'number')
+        resolved.ftpWatts = ftp;
+    if (hr) {
+        if ('bounds' in hr)
+            resolved.hrZones = hrZonesFrom({ bounds: hr.bounds });
+        else if (typeof hr.maxHr === 'number')
+            resolved.hrZones = hrZonesFrom({ maxHr: hr.maxHr });
+    }
+    if (pace && typeof pace.fiveKSeconds === 'number')
+        resolved.paceZones = paceZonesFrom(pace.fiveKSeconds);
+    return resolved;
+}
+// ── Profile (the value object passed into the analytics) ─────────────────────
+/**
+ * An athlete's settings resolved to a single activity date — the value object
+ * an {@link import('../activity/index.js').Activity} is read against via
+ * `activity.usingProfile(bob)`. Wraps the as-of resolution ({@link profileAsOf})
+ * and exposes the zone *ranges* (the per-channel {@link ZoneDef}s); the
+ * per-activity *data* (time-in-zone) is the profiled activity's `by…Zone()`.
+ *
+ * Immutable; carries only athlete data, never an activity's evidence — so one
+ * `Profile` is reused across every activity on its date.
+ */
+export class Profile {
+    resolved;
+    asOfDate;
+    constructor(resolved, 
+    /** The activity date this profile was resolved as-of (ISO 8601, UTC);
+     *  `undefined` for a history-less profile from {@link of}. */
+    asOfDate) {
+        this.resolved = resolved;
+        this.asOfDate = asOfDate;
+    }
+    /** Resolve the athlete's stored profile to the values in force on the
+     *  activity's date — the values used for FTP-relative power, W/kg, and zones. */
+    static asOf(json, activityDateUtc) {
+        return new Profile(profileAsOf(json, activityDateUtc), activityDateUtc);
+    }
+    /** A profile from explicit settings with **no effective-dated history** — the
+     *  "I just have an FTP / weight" case (demos, fixtures, a fallback prop, or a
+     *  settings form with nothing recorded yet). For history-aware resolution use
+     *  {@link asOf}. Power zones derive from `ftpWatts`; HR / pace zones are absent
+     *  (they need a basis, which a bare settings object doesn't carry). */
+    static of(settings) {
+        const resolved = {};
+        if (settings.ftpWatts != null)
+            resolved.ftpWatts = settings.ftpWatts;
+        if (settings.weightKg != null)
+            resolved.weightKg = settings.weightKg;
+        return new Profile(resolved);
+    }
+    /** Functional Threshold Power (watts) in force on the date, if recorded. */
+    get ftpWatts() {
+        return this.resolved.ftpWatts;
+    }
+    /** Body weight (kg) in force on the date, if recorded — drives W/kg. */
+    get weightKg() {
+        return this.resolved.weightKg;
+    }
+    /** Heart-rate zone ranges (bpm axis), if an HR basis is recorded. */
+    get heartRateZones() {
+        return this.resolved.hrZones;
+    }
+    /** Pace zone ranges (speed axis, m/s; Z1 slowest), if a threshold is recorded. */
+    get paceZones() {
+        return this.resolved.paceZones;
+    }
+    /** Power zone ranges (watt axis, Coggan), derived from FTP if recorded. */
+    get powerZones() {
+        return this.resolved.ftpWatts == null
+            ? undefined
+            : powerZonesFrom(this.resolved.ftpWatts);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/quantities.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Fitness quantity types — the ergonomic, unit-safe value layer of the activity
+ * domain.
+ *
+ * Each is an immutable value object holding ONE canonical SI number, with
+ * unit-named constructors in / accessors out — so a function returns a `Speed`
+ * and the caller asks it `.asMinsPerMile()`, never juggling "is this m or mi?".
+ * Conversion math + formatting reuse `units.ts` (one source of truth); these
+ * types are the fluent face over it. Fitness-relevant set only — not a general
+ * dimensional-analysis system.
+ */
+import { type DistanceUnit, type ElevationUnit, type SpeedPaceUnit } from './units.js';
+/** A length — canonical metres. */
+export declare class Distance {
+    readonly meters: number;
+    private constructor();
+    static meters(m: number): Distance;
+    static km(km: number): Distance;
+    static miles(mi: number): Distance;
+    get km(): number;
+    get miles(): number;
+    /** Numeric value in the chosen unit — the dynamic-unit peer of `.km` / `.miles`
+     *  (for when the unit is a runtime preference). */
+    in(unit: DistanceUnit): number;
+    /** Display string with unit label, e.g. `"12.34 mi"`. */
+    format(unit: DistanceUnit, decimals?: number): string;
+}
+/** A climb/altitude — canonical metres, shown in feet or metres (a separate type
+ *  from {@link Distance} because elevation reads in ft/m, not mi/km). */
+export declare class Elevation {
+    readonly meters: number;
+    private constructor();
+    static meters(m: number): Elevation;
+    static feet(ft: number): Elevation;
+    get feet(): number;
+    /** Numeric value in the chosen unit (dynamic-unit peer of `.feet` / `.meters`). */
+    in(unit: ElevationUnit): number;
+    /** Display string with unit label, e.g. `"1200 ft"`. */
+    format(unit: ElevationUnit, decimals?: number): string;
+}
+/** An elapsed time — canonical seconds. */
+export declare class Duration {
+    readonly seconds: number;
+    private constructor();
+    static seconds(s: number): Duration;
+    static minutes(m: number): Duration;
+    static hours(h: number): Duration;
+    get minutes(): number;
+    get hours(): number;
+    /** "h:mm:ss" / "m:ss". */
+    format(): string;
+}
+/** A speed — canonical metres/second. The inverse view is {@link Pace}. */
+export declare class Speed {
+    readonly metersPerSecond: number;
+    private constructor();
+    static metersPerSecond(v: number): Speed;
+    static kmh(v: number): Speed;
+    static mph(v: number): Speed;
+    get kmh(): number;
+    get mph(): number;
+    /** As pace (time per distance) — the same measurement, shown the other way. */
+    pace(): Pace;
+    asMinsPerMile(): string;
+    asMinsPerKm(): string;
+    /** Numeric value in the chosen unit — mph (imperial) or km/h (metric). */
+    in(unit: SpeedPaceUnit): number;
+    /** Display string with unit label, e.g. `"15.2 mph"` / `"24.5 km/h"`. */
+    format(unit: SpeedPaceUnit, decimals?: number): string;
+}
+/** A pace — canonical seconds per kilometre. The inverse view is {@link Speed}. */
+export declare class Pace {
+    readonly secondsPerKm: number;
+    private constructor();
+    static secondsPerKm(s: number): Pace;
+    static secondsPerMile(s: number): Pace;
+    get secondsPerMile(): number;
+    speed(): Speed;
+    /** "m:ss/km" (metric, default) or "m:ss/mi" (imperial). */
+    format(unit?: SpeedPaceUnit): string;
+}
+/** Mechanical power — canonical watts. */
+export declare class Power {
+    readonly watts: number;
+    private constructor();
+    static watts(w: number): Power;
+    /** Power-to-weight (W/kg) given a body weight; NaN for a non-positive weight. */
+    perKg(weightKg: number): number;
+    /** Display string, e.g. `"291 W"`. */
+    format(decimals?: number): string;
+}
+/** Heart rate — canonical beats/minute. */
+export declare class HeartRate {
+    readonly bpm: number;
+    private constructor();
+    static bpm(b: number): HeartRate;
+    /** Display string, e.g. `"152 bpm"`. */
+    format(decimals?: number): string;
+}
+/** Cadence — canonical revolutions/minute (pedal strokes, run steps/min, …). */
+export declare class Cadence {
+    readonly rpm: number;
+    private constructor();
+    static rpm(r: number): Cadence;
+    /** Display string, e.g. `"90 rpm"`. */
+    format(decimals?: number): string;
+}
+//# sourceMappingURL=quantities.d.ts.map

package/dist/quantities.js

@@ -0,0 +1,207 @@
+/**
+ * Fitness quantity types — the ergonomic, unit-safe value layer of the activity
+ * domain.
+ *
+ * Each is an immutable value object holding ONE canonical SI number, with
+ * unit-named constructors in / accessors out — so a function returns a `Speed`
+ * and the caller asks it `.asMinsPerMile()`, never juggling "is this m or mi?".
+ * Conversion math + formatting reuse `units.ts` (one source of truth); these
+ * types are the fluent face over it. Fitness-relevant set only — not a general
+ * dimensional-analysis system.
+ */
+import { METERS_PER_MILE, METERS_PER_FOOT, formatDuration, formatPace, convertDistance, convertElevation, convertSpeed, distanceUnitLabel, elevationUnitLabel, speedUnitLabel, } from './units.js';
+/** A length — canonical metres. */
+export class Distance {
+    meters;
+    constructor(meters) {
+        this.meters = meters;
+    }
+    static meters(m) {
+        return new Distance(m);
+    }
+    static km(km) {
+        return new Distance(km * 1000);
+    }
+    static miles(mi) {
+        return new Distance(mi * METERS_PER_MILE);
+    }
+    get km() {
+        return this.meters / 1000;
+    }
+    get miles() {
+        return this.meters / METERS_PER_MILE;
+    }
+    /** Numeric value in the chosen unit — the dynamic-unit peer of `.km` / `.miles`
+     *  (for when the unit is a runtime preference). */
+    in(unit) {
+        return convertDistance(this.meters, unit);
+    }
+    /** Display string with unit label, e.g. `"12.34 mi"`. */
+    format(unit, decimals = 2) {
+        return `${this.in(unit).toFixed(decimals)} ${distanceUnitLabel(unit)}`;
+    }
+}
+/** A climb/altitude — canonical metres, shown in feet or metres (a separate type
+ *  from {@link Distance} because elevation reads in ft/m, not mi/km). */
+export class Elevation {
+    meters;
+    constructor(meters) {
+        this.meters = meters;
+    }
+    static meters(m) {
+        return new Elevation(m);
+    }
+    static feet(ft) {
+        return new Elevation(ft * METERS_PER_FOOT);
+    }
+    get feet() {
+        return this.meters / METERS_PER_FOOT;
+    }
+    /** Numeric value in the chosen unit (dynamic-unit peer of `.feet` / `.meters`). */
+    in(unit) {
+        return convertElevation(this.meters, unit);
+    }
+    /** Display string with unit label, e.g. `"1200 ft"`. */
+    format(unit, decimals = 0) {
+        return `${this.in(unit).toFixed(decimals)} ${elevationUnitLabel(unit)}`;
+    }
+}
+/** An elapsed time — canonical seconds. */
+export class Duration {
+    seconds;
+    constructor(seconds) {
+        this.seconds = seconds;
+    }
+    static seconds(s) {
+        return new Duration(s);
+    }
+    static minutes(m) {
+        return new Duration(m * 60);
+    }
+    static hours(h) {
+        return new Duration(h * 3600);
+    }
+    get minutes() {
+        return this.seconds / 60;
+    }
+    get hours() {
+        return this.seconds / 3600;
+    }
+    /** "h:mm:ss" / "m:ss". */
+    format() {
+        return formatDuration(this.seconds);
+    }
+}
+/** A speed — canonical metres/second. The inverse view is {@link Pace}. */
+export class Speed {
+    metersPerSecond;
+    constructor(metersPerSecond) {
+        this.metersPerSecond = metersPerSecond;
+    }
+    static metersPerSecond(v) {
+        return new Speed(v);
+    }
+    static kmh(v) {
+        return new Speed(v / 3.6);
+    }
+    static mph(v) {
+        return new Speed(v / 2.236936);
+    }
+    get kmh() {
+        return this.metersPerSecond * 3.6;
+    }
+    get mph() {
+        return this.metersPerSecond * 2.236936;
+    }
+    /** As pace (time per distance) — the same measurement, shown the other way. */
+    pace() {
+        return Pace.secondsPerKm(this.metersPerSecond > 0 ? 1000 / this.metersPerSecond : Infinity);
+    }
+    asMinsPerMile() {
+        return this.pace().format('imperial');
+    }
+    asMinsPerKm() {
+        return this.pace().format('metric');
+    }
+    /** Numeric value in the chosen unit — mph (imperial) or km/h (metric). */
+    in(unit) {
+        return convertSpeed(this.metersPerSecond, unit);
+    }
+    /** Display string with unit label, e.g. `"15.2 mph"` / `"24.5 km/h"`. */
+    format(unit, decimals = 1) {
+        return `${this.in(unit).toFixed(decimals)} ${speedUnitLabel(unit)}`;
+    }
+}
+/** A pace — canonical seconds per kilometre. The inverse view is {@link Speed}. */
+export class Pace {
+    secondsPerKm;
+    constructor(secondsPerKm) {
+        this.secondsPerKm = secondsPerKm;
+    }
+    static secondsPerKm(s) {
+        return new Pace(s);
+    }
+    static secondsPerMile(s) {
+        return new Pace(s / (METERS_PER_MILE / 1000));
+    }
+    get secondsPerMile() {
+        return this.secondsPerKm * (METERS_PER_MILE / 1000);
+    }
+    speed() {
+        const s = this.secondsPerKm;
+        // 0 pace = infinitely fast; ∞ pace (stopped) = 0; garbage (negative/NaN) = 0.
+        const mps = s > 0 && Number.isFinite(s) ? 1000 / s : s === 0 ? Infinity : 0;
+        return Speed.metersPerSecond(mps);
+    }
+    /** "m:ss/km" (metric, default) or "m:ss/mi" (imperial). */
+    format(unit = 'metric') {
+        return formatPace(this.secondsPerKm, unit);
+    }
+}
+/** Mechanical power — canonical watts. */
+export class Power {
+    watts;
+    constructor(watts) {
+        this.watts = watts;
+    }
+    static watts(w) {
+        return new Power(w);
+    }
+    /** Power-to-weight (W/kg) given a body weight; NaN for a non-positive weight. */
+    perKg(weightKg) {
+        return weightKg > 0 ? this.watts / weightKg : NaN;
+    }
+    /** Display string, e.g. `"291 W"`. */
+    format(decimals = 0) {
+        return `${this.watts.toFixed(decimals)} W`;
+    }
+}
+/** Heart rate — canonical beats/minute. */
+export class HeartRate {
+    bpm;
+    constructor(bpm) {
+        this.bpm = bpm;
+    }
+    static bpm(b) {
+        return new HeartRate(b);
+    }
+    /** Display string, e.g. `"152 bpm"`. */
+    format(decimals = 0) {
+        return `${this.bpm.toFixed(decimals)} bpm`;
+    }
+}
+/** Cadence — canonical revolutions/minute (pedal strokes, run steps/min, …). */
+export class Cadence {
+    rpm;
+    constructor(rpm) {
+        this.rpm = rpm;
+    }
+    static rpm(r) {
+        return new Cadence(r);
+    }
+    /** Display string, e.g. `"90 rpm"`. */
+    format(decimals = 0) {
+        return `${this.rpm.toFixed(decimals)} rpm`;
+    }
+}
+//# sourceMappingURL=quantities.js.map

package/dist/summary/index.d.ts

@@ -0,0 +1,138 @@
+import type { ImportedActivity, ActivityStreams, Lap } from '../types.js';
+import * as geo from '../geo/index.js';
+import type { Split, ProfilePoint, ProfileSample } from '../geo/index.js';
+export type { Split, ProfilePoint, ProfileSample, Lap };
+/** A channel that can be plotted against distance OR time on the DATA chart. */
+export type ChannelKey = 'elevation' | 'speed' | 'heartrate' | 'power' | 'cadence' | 'temperature';
+/**
+ * One resampled point carrying BOTH axes — distance and elapsed time — so the
+ * chart can switch x-axis without recomputing. Buckets are even in distance;
+ * `timeSeconds` is the elapsed time reached at that distance, so the time axis
+ * spans 0 → total elapsed. `value` is native units (m, m/s, bpm, W, rpm, °C).
+ */
+export interface ChannelSample {
+    distanceMeters: number;
+    timeSeconds: number;
+    /** Bucket median (the robust line). */
+    value: number;
+    /** Outer band edges — central-90% percentiles (the faint variance envelope). */
+    bandLo: number;
+    bandHi: number;
+    /** Inner band edges — the inter-quartile range (the denser typical spread). */
+    innerLo: number;
+    innerHi: number;
+    /** This bucket is a SUSTAINED coast (you stopped pedalling/moving for longer
+     *  than the bridge window) on an output channel — value/band are NaN here, and
+     *  the chart draws a drop-to-baseline rather than a line. Brief coasts aren't
+     *  flagged: they stay real values and just dip the smoothed line. */
+    coast: boolean;
+}
+/**
+ * One channel resampled onto the grid. Only channels the activity actually
+ * carries appear; the display layer converts native units.
+ */
+export interface ChannelProfile {
+    key: ChannelKey;
+    points: ChannelSample[];
+}
+/** Everything the activity summary holds, computed from one activity's streams. */
+export interface ActivitySummary {
+    startTimeUtc: string;
+    pointCount: number;
+    distanceMeters: number;
+    /** Time the clock ran (last sample − first sample). */
+    elapsedTimeSeconds: number;
+    /** Time actually moving (speed above the stopped threshold). */
+    movingTimeSeconds: number;
+    elevationGainMeters: number;
+    elevationLossMeters: number;
+    /** `[[minLat, minLng], [maxLat, maxLng]]`, or null for a GPS-less activity. */
+    bounds: [[number, number], [number, number]] | null;
+    /** Douglas–Peucker-simplified `[lat, lng]` line for the map overview; empty
+     *  for a GPS-less activity (no map). */
+    polyline: Array<[number, number]>;
+    /** Distance-grid profiles, one per present channel (elevation first). */
+    channels: ChannelProfile[];
+    /** Per-kilometre splits (computed, evenly spaced). */
+    splits: Split[];
+    /** Recorded laps (device-marked), if the source carried them. */
+    laps: Lap[];
+}
+/** Options for {@link computeActivitySummary}. */
+export interface ActivitySummaryOptions {
+    /** Split interval in metres (default 1000 = per-km). */
+    splitMeters?: number;
+    /** Polyline simplification tolerance in metres (default 12). */
+    simplifyMeters?: number;
+    /** Channel-profile bucket width in metres (default 100). */
+    profileBucketMeters?: number;
+}
+/**
+ * Build the canonical pond series from an activity's streams (timeSeconds are
+ * offsets). Works for GPS and GPS-less alike: lat/lng are `undefined` when the
+ * source had no positions, so the series is then just time + the recorded
+ * channels. The sample count is the positions when present, else the longest
+ * recorded channel.
+ */
+export declare function buildTrackFromStreams(name: string, streams: ActivityStreams, startMs: number): geo.TrackSeries;
+/**
+ * The streams decoded once into the per-sample arrays every downstream metric
+ * reads — track, columns, cumulative distance, derived speed, relative time.
+ * Building the pond track + reading columns is the expensive part of the
+ * summary compute, so {@link prepareActivity} does it once and both the summary
+ * ({@link summaryFromPrepared}) and the zoom-resolution profiles
+ * ({@link windowChannels}) reuse it — no second decode per zoom. Opaque shape;
+ * treat it as a handle, not a public data contract.
+ */
+export interface PreparedActivity {
+    imported: ImportedActivity;
+    /** The canonical pond series — always present (GPS or GPS-less). `hasTrack`
+     *  says whether it carries positions. */
+    track: geo.TrackSeries;
+    cols: ReturnType<typeof geo.readColumns>;
+    cum: Float64Array;
+    step: Float64Array;
+    /** Derived instantaneous speed (m/s); NaN where no timestamp delta. */
+    speed: Float64Array;
+    /** Elapsed seconds since the first sample. */
+    timeRel: Float64Array;
+    n: number;
+    /** Whether the source carried timestamps (so speed is meaningful). */
+    hasTime: boolean;
+    /** Whether the activity has a GPS track. False for GPS-less sources (indoor /
+     *  GPS-off head units): no map, distance comes from the device stream. */
+    hasTrack: boolean;
+    /** Per-sample sustained-coast mask per output channel (speed/power/cadence),
+     *  computed ONCE here (it's window-independent and the pond-fill pass is the
+     *  expensive part) and reused by every channel build / zoom. */
+    coastMasks: Partial<Record<ChannelKey, boolean[]>>;
+}
+/** Decode an activity's streams into the shared per-sample arrays. ONE path now:
+ *  build the canonical series, read its columns; distance comes from haversine
+ *  when there are positions, else the device `distance` column (GPS-less). */
+export declare function prepareActivity(imported: ImportedActivity): PreparedActivity;
+/** Options for {@link windowChannels}. */
+export interface WindowChannelOptions {
+    startMeters: number;
+    endMeters: number;
+    /** Target number of buckets across the window (default 160). The bucket width
+     *  is the window span / this, clamped to [minBucketMeters, maxBucketMeters]. */
+    targetBuckets?: number;
+    /** Floor on bucket width, m — don't out-resolve the raw sampling (default 5). */
+    minBucketMeters?: number;
+    /** Ceiling on bucket width, m — never coarser than the overview (default 100). */
+    maxBucketMeters?: number;
+}
+/**
+ * Re-bucket the channels at high resolution within a distance window — the
+ * chart's payoff when a split/lap is locked and zoomed: the same lines, but
+ * resolved to ~10 m instead of the whole-activity 100 m grid, revealing detail
+ * the overview averages away. Distances are absolute, so the result drops into
+ * the same axis as {@link ActivitySummary.channels} and the chart's range clip.
+ */
+export declare function windowChannels(prep: PreparedActivity, opts: WindowChannelOptions): ChannelProfile[];
+/** The full activity summary from already-prepared streams (single decode). */
+export declare function summaryFromPrepared(prep: PreparedActivity, options?: ActivitySummaryOptions): ActivitySummary;
+/** Compute the full activity summary for one imported activity. */
+export declare function computeActivitySummary(imported: ImportedActivity, options?: ActivitySummaryOptions): ActivitySummary;
+//# sourceMappingURL=index.d.ts.map