@pond-ts/fit 0.31.0

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export type { GeoPoint, ActivitySource, ActivityStreams, ActivityMeta, Lap, ImportedActivity, } from './types.js';
+export { metersToMiles, metersToFeet, formatDuration, formatPace, DEFAULT_UNITS, convertDistance, convertElevation, convertTemperature, convertSpeed, distanceUnitLabel, elevationUnitLabel, temperatureUnitLabel, speedUnitLabel, paceUnitLabel, } from './units.js';
+export type { UnitPreferences, DistanceUnit, ElevationUnit, TemperatureUnit, SpeedPaceUnit, } from './units.js';
+export { Distance, Elevation, Duration, Speed, Pace, Power, HeartRate, Cadence, } from './quantities.js';
+export { Activity, Section, ProfiledActivity, ProfiledSection, } from './activity/index.js';
+export type { Sample, SectionMetrics } from './activity/index.js';
+export { Track } from './track/index.js';
+export { polylineCumulative, interpolateAtDistance, polylineSlice, boundsOf, bestEffortsByDistance, segmentsInRange, } from './geo/index.js';
+export type { Segment } from './geo/index.js';
+export { computePower, powerBestEfforts } from './power/index.js';
+export type { PowerBin, PowerZone, PowerCurvePoint, PowerSummary, PowerEffort, } from './power/index.js';
+export { Profile, hydrateProfile, profileAsOf, hrZonesFrom, paceZonesFrom, powerZonesFrom, } from './profile/index.js';
+export type { AthleteProfileJson, ScalarEntry, HrZoneEntry, PaceThresholdEntry, ZoneDef, ResolvedProfile, HydratedProfile, } from './profile/index.js';
+export { zoneDistributionByValue, hrZoneDistribution, paceZoneDistribution, } from './zones/index.js';
+export type { ZoneTime } from './zones/index.js';
+export type { TrackSeries, TrackPoint, TrackColumns, Split, ProfilePoint, ProfileSample, DistanceEffort, } from './geo/index.js';
+export { computeActivitySummary, prepareActivity, summaryFromPrepared, windowChannels, buildTrackFromStreams, type ActivitySummary, type ActivitySummaryOptions, type PreparedActivity, type WindowChannelOptions, type ChannelKey, type ChannelProfile, type ChannelSample, } from './summary/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,18 @@
+export { metersToMiles, metersToFeet, formatDuration, formatPace, DEFAULT_UNITS, convertDistance, convertElevation, convertTemperature, convertSpeed, distanceUnitLabel, elevationUnitLabel, temperatureUnitLabel, speedUnitLabel, paceUnitLabel, } from './units.js';
+export { Distance, Elevation, Duration, Speed, Pace, Power, HeartRate, Cadence, } from './quantities.js';
+export { Activity, Section, ProfiledActivity, ProfiledSection, } from './activity/index.js';
+export { Track } from './track/index.js';
+// Curated flat surface — the four operator modules (geo / power / zones /
+// profile) are NOT re-exported as blanket `export * as <module>` namespaces.
+// Those published each module's entire internal surface (readColumns, raw
+// schemas, friction-probe helpers) by accident and had no shipping consumer.
+// The named exports below are the deliberate public API. Quantities, the
+// Activity/Section façade, Track, Profile, and the units helpers are kept by
+// intent — the library's headline surface plus the façade's return-type
+// closure — not because any single consumer imports them today.
+export { polylineCumulative, interpolateAtDistance, polylineSlice, boundsOf, bestEffortsByDistance, segmentsInRange, } from './geo/index.js';
+export { computePower, powerBestEfforts } from './power/index.js';
+export { Profile, hydrateProfile, profileAsOf, hrZonesFrom, paceZonesFrom, powerZonesFrom, } from './profile/index.js';
+export { zoneDistributionByValue, hrZoneDistribution, paceZoneDistribution, } from './zones/index.js';
+export { computeActivitySummary, prepareActivity, summaryFromPrepared, windowChannels, buildTrackFromStreams, } from './summary/index.js';
+//# sourceMappingURL=index.js.map

package/dist/intervals.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Per-sample time interval `dt`, clamped to `[0, maxGap]` so recording pauses
+ * don't inflate time-weighted sums (a stop is a gap, not 20 min at the last
+ * value). Shared by every time-weighted reduction — power work/zones and the
+ * HR/pace zone distributions. Deliberate modelling choice: it engages on
+ * real sampling gaps (e.g. one 13 s gap on the Vineman ride), which is why total
+ * work still matches Strava. Conservative; not yet caller-tunable.
+ */
+export declare function intervals(timeSec: Float64Array, maxGap?: number): Float64Array;
+//# sourceMappingURL=intervals.d.ts.map

package/dist/intervals.js

@@ -0,0 +1,17 @@
+/**
+ * Per-sample time interval `dt`, clamped to `[0, maxGap]` so recording pauses
+ * don't inflate time-weighted sums (a stop is a gap, not 20 min at the last
+ * value). Shared by every time-weighted reduction — power work/zones and the
+ * HR/pace zone distributions. Deliberate modelling choice: it engages on
+ * real sampling gaps (e.g. one 13 s gap on the Vineman ride), which is why total
+ * work still matches Strava. Conservative; not yet caller-tunable.
+ */
+export function intervals(timeSec, maxGap = 10) {
+    const dt = new Float64Array(timeSec.length);
+    for (let i = 1; i < timeSec.length; i++) {
+        const d = timeSec[i] - timeSec[i - 1];
+        dt[i] = d > 0 ? Math.min(d, maxGap) : 0;
+    }
+    return dt;
+}
+//# sourceMappingURL=intervals.js.map

package/dist/power/index.d.ts

@@ -0,0 +1,126 @@
+import { type ZoneDef } from '../profile/index.js';
+/** Mean of the finite samples. */
+export declare function averagePower(watts: Float64Array): number;
+/** Max finite sample. */
+export declare function maxPower(watts: Float64Array): number;
+/** Total mechanical work in kilojoules: Σ power·dt / 1000. */
+export declare function totalWorkKj(timeSec: Float64Array, watts: Float64Array): number;
+/**
+ * Normalized Power: 30 s rolling mean of power, raised to the 4th, averaged,
+ * 4th-rooted. The rolling step is pond-native — we build a time-keyed power
+ * series and call `rolling('30s', { watts: 'mean' })`, then read the smoothed
+ * column back via `toFloat64Array()`. The 4th-power reduction is array-side.
+ */
+export declare function normalizedPower(timeSec: Float64Array, watts: Float64Array): number;
+/** Intensity Factor = NP / FTP. */
+export declare function intensityFactor(normalizedPowerW: number, ftp: number): number;
+/**
+ * Training load (TSS): `duration · NP · IF / (FTP · 3600) · 100`. Pass the
+ * activity's elapsed seconds (the convention that matches Strava's number).
+ */
+export declare function trainingLoad(normalizedPowerW: number, ftp: number, durationSeconds: number): number;
+/** One bucket of the power histogram. */
+export interface PowerBin {
+    /** Inclusive lower edge of the bin, watts. */
+    wattsFrom: number;
+    /** Seconds spent in this bin. */
+    seconds: number;
+}
+/**
+ * Time spent in each `binWatts`-wide power bucket — a histogram over the POWER
+ * value axis. Pond-native: `byColumn` buckets rows by the watts value and sums
+ * each bin's per-sample seconds. We emit bins from 0 up to the highest occupied
+ * (the old grid: low-power bins that
+ * happen to be empty still appear as 0 s). Sub-zero samples clamp to bin 0.
+ */
+export declare function powerDistribution(timeSec: Float64Array, watts: Float64Array, binWatts?: number): PowerBin[];
+/** One FTP-based training zone. */
+export interface PowerZone {
+    zone: number;
+    label: string;
+    minWatts: number;
+    /** Upper edge, watts; `Infinity` for the top zone. */
+    maxWatts: number;
+    seconds: number;
+    /** Fraction of total in-zone time [0, 1]. */
+    fraction: number;
+}
+/**
+ * Time in each of the 7 Coggan power zones for the given FTP. Like
+ * {@link powerDistribution} this is value-axis bucketing — here with
+ * FTP-relative edges rather than even bins.
+ */
+export declare function zoneDistribution(timeSec: Float64Array, watts: Float64Array, ftp: number): PowerZone[];
+/** The 7 Coggan power zones as a watt-axis {@link ZoneDef} (FTP-relative).
+ *  Delegates to {@link powerZonesFrom} — the scheme's canonical home is the
+ *  profile module, alongside the HR + pace zone builders. */
+export declare function powerZoneDef(ftp: number): ZoneDef;
+/** A point on the mean-maximal power curve. */
+export interface PowerCurvePoint {
+    durationSeconds: number;
+    /** Best average power sustained over any window of this length, watts. */
+    watts: number;
+    /** Inclusive sample range of the window that achieved it — for focusing the
+     *  chart/map on where the peak happened. The caller maps these to distance /
+     *  time via the prepared `cum` / `timeSec`. Absent only if no window qualified. */
+    startIndex?: number;
+    endIndex?: number;
+}
+/**
+ * A dense, log-spaced set of durations (1 s → `total`, ~`steps` points) so the
+ * power curve reads as a smooth line rather than a few segments. Deduped to
+ * whole seconds.
+ */
+export declare function logDurations(total: number, steps?: number): number[];
+/**
+ * The mean-maximal power curve: for each duration, the highest average power
+ * sustained over any window of that length. Computed from a cumulative-work
+ * prefix sum with a two-pointer scan per duration — O(n) each. This is the
+ * sweep pond's single-window `rolling` doesn't do in one call (see friction).
+ */
+export declare function powerCurve(timeSec: Float64Array, watts: Float64Array, durations?: number[]): PowerCurvePoint[];
+/** Everything the power view needs, computed from a power-equipped activity. */
+export interface PowerSummary {
+    averageWatts: number;
+    maxWatts: number;
+    normalizedWatts: number;
+    intensityFactor: number;
+    trainingLoad: number;
+    totalWorkKj: number;
+    ftp: number;
+    /** Time per power bucket at the **finest (1 W)** resolution — the canonical
+     *  base the UI re-aggregates to wider bins (10/15/25 W). Always 1 W so the
+     *  display contract doesn't depend on a compute-time bin choice. */
+    distribution: PowerBin[];
+    zones: PowerZone[];
+    curve: PowerCurvePoint[];
+}
+/** Compute the full power summary. `elapsedSeconds` drives TSS. */
+export declare function computePower(timeSec: Float64Array, watts: Float64Array, ftp: number, elapsedSeconds: number): PowerSummary;
+/** Canonical durations (s) for the power best-efforts table: 5 s … 1 h. */
+export declare const BEST_EFFORT_DURATIONS: number[];
+/** One row of the power best-efforts table. */
+export interface PowerEffort {
+    durationSeconds: number;
+    /** Best average power sustained over any window of this length, watts. */
+    watts: number;
+    /** Power-to-weight, when a body weight (as of the activity date) is known. */
+    wattsPerKg?: number;
+    /** Inclusive sample range of the window that achieved it — for focusing the
+     *  chart/map on where the effort happened (maps to distance/time via the
+     *  prepared `cum` / `timeSec`). Carried through from the {@link powerCurve}
+     *  point; absent only if no window qualified. */
+    startIndex?: number;
+    endIndex?: number;
+}
+/**
+ * Power best efforts: the mean-maximal power at each canonical duration — the
+ * {@link powerCurve} sampled at the table's durations — plus W/kg when a body
+ * weight is supplied (resolved from the athlete profile as of the activity
+ * date). Same cumulative-work two-pointer as the curve; clamped non-increasing.
+ */
+export declare function powerBestEfforts(timeSec: Float64Array, watts: Float64Array, opts?: {
+    weightKg?: number;
+    durations?: number[];
+}): PowerEffort[];
+//# sourceMappingURL=index.d.ts.map

package/dist/power/index.js

@@ -0,0 +1,279 @@
+/**
+ * Power analytics for a ride with a real power meter — normalized power, the
+ * power distribution + FTP zones, the mean-maximal power curve, work, and
+ * training load. How each maps onto pond:
+ *   - **Normalized power** is a 30 s rolling mean → pond's `rolling` (see
+ *     `normalizedPower`).
+ *   - **Power distribution / zones** bucket over the *power value* axis (not
+ *     time) → pond's `byColumn` over the watts column (see `zones`).
+ *   - **The power curve** is a rolling-*mean*-then-*max* swept over MANY window
+ *     sizes — pond's `rolling` is single-window, so the sweep is done here. A
+ *     multi-window rolling primitive is a candidate pond enhancement.
+ */
+import { TimeSeries } from 'pond-ts';
+import { intervals } from '../intervals.js';
+import { zoneDistributionByValue } from '../zones/index.js';
+import { powerZonesFrom } from '../profile/index.js';
+const POWER_SCHEMA = [
+    { name: 'time', kind: 'time' },
+    { name: 'watts', kind: 'number' },
+];
+/** Schema for the value-axis power histograms (distribution + zones): the
+ *  power value to bin on, plus the per-sample seconds we sum into each bin.
+ *  `watts` is optional so a non-finite sample rides as `undefined` and pond's
+ *  `byColumn` drops it from binning (matches the old `if (!finite) continue`). */
+const POWER_BIN_SCHEMA = [
+    { name: 'time', kind: 'time' },
+    { name: 'watts', kind: 'number', required: false },
+    { name: 'dt', kind: 'number' },
+];
+const finite = (v) => Number.isFinite(v);
+/** Mean of the finite samples. */
+export function averagePower(watts) {
+    let sum = 0;
+    let n = 0;
+    for (const w of watts)
+        if (finite(w)) {
+            sum += w;
+            n += 1;
+        }
+    return n ? sum / n : 0;
+}
+/** Max finite sample. */
+export function maxPower(watts) {
+    let max = 0;
+    for (const w of watts)
+        if (finite(w) && w > max)
+            max = w;
+    return max;
+}
+/** Total mechanical work in kilojoules: Σ power·dt / 1000. */
+export function totalWorkKj(timeSec, watts) {
+    const dt = intervals(timeSec);
+    let j = 0;
+    for (let i = 0; i < watts.length; i++)
+        if (finite(watts[i]))
+            j += watts[i] * dt[i];
+    return j / 1000;
+}
+/**
+ * Normalized Power: 30 s rolling mean of power, raised to the 4th, averaged,
+ * 4th-rooted. The rolling step is pond-native — we build a time-keyed power
+ * series and call `rolling('30s', { watts: 'mean' })`, then read the smoothed
+ * column back via `toFloat64Array()`. The 4th-power reduction is array-side.
+ */
+export function normalizedPower(timeSec, watts) {
+    const rows = [];
+    for (let i = 0; i < watts.length; i++) {
+        if (finite(watts[i]))
+            rows.push([Math.round(timeSec[i] * 1000), watts[i]]);
+    }
+    if (rows.length === 0)
+        return 0;
+    const series = new TimeSeries({ name: 'power', schema: POWER_SCHEMA, rows });
+    // pond 0.29 added a `'mean'` alias matching the column API's `.mean()` (the
+    // old `'avg'`/`.mean()` split — F-reducer-naming — is resolved).
+    const rolled = series.rolling('30s', { watts: 'mean' });
+    const smoothed = rolled.column('watts').toFloat64Array();
+    let sum = 0;
+    let n = 0;
+    for (const v of smoothed)
+        if (finite(v)) {
+            sum += v ** 4;
+            n += 1;
+        }
+    return n ? (sum / n) ** 0.25 : 0;
+}
+/** Intensity Factor = NP / FTP. */
+export function intensityFactor(normalizedPowerW, ftp) {
+    return ftp > 0 ? normalizedPowerW / ftp : 0;
+}
+/**
+ * Training load (TSS): `duration · NP · IF / (FTP · 3600) · 100`. Pass the
+ * activity's elapsed seconds (the convention that matches Strava's number).
+ */
+export function trainingLoad(normalizedPowerW, ftp, durationSeconds) {
+    if (ftp <= 0)
+        return 0;
+    const intensity = normalizedPowerW / ftp;
+    return (((durationSeconds * normalizedPowerW * intensity) / (ftp * 3600)) * 100);
+}
+/**
+ * Time spent in each `binWatts`-wide power bucket — a histogram over the POWER
+ * value axis. Pond-native: `byColumn` buckets rows by the watts value and sums
+ * each bin's per-sample seconds. We emit bins from 0 up to the highest occupied
+ * (the old grid: low-power bins that
+ * happen to be empty still appear as 0 s). Sub-zero samples clamp to bin 0.
+ */
+export function powerDistribution(timeSec, watts, binWatts = 25) {
+    const dt = intervals(timeSec);
+    const rows = [];
+    for (let i = 0; i < watts.length; i++) {
+        const w = watts[i];
+        rows.push([i, finite(w) ? Math.max(0, w) : undefined, dt[i]]);
+    }
+    const bins = new TimeSeries({
+        name: 'pdist',
+        schema: POWER_BIN_SCHEMA,
+        rows,
+    }).byColumn('watts', { width: binWatts, origin: 0 }, { seconds: { from: 'dt', using: 'sum' } });
+    // byColumn emits lowest→highest OCCUPIED bin; the old grid runs from bin 0, so
+    // scatter onto 0..maxBin with empty bins as 0 s.
+    const maxBin = bins.length
+        ? Math.round(bins[bins.length - 1].start / binWatts)
+        : -1;
+    const seconds = new Array(maxBin + 1).fill(0);
+    for (const b of bins)
+        seconds[Math.round(b.start / binWatts)] = b.seconds ?? 0;
+    return seconds.map((s, b) => ({ wattsFrom: b * binWatts, seconds: s }));
+}
+/**
+ * Time in each of the 7 Coggan power zones for the given FTP. Like
+ * {@link powerDistribution} this is value-axis bucketing — here with
+ * FTP-relative edges rather than even bins.
+ */
+export function zoneDistribution(timeSec, watts, ftp) {
+    // FTP-relative Coggan zones as a watt-axis ZoneDef, then the shared value-axis
+    // engine (the same one HR + pace use — see ../zones). PowerZone keeps its
+    // watts-named shape, so the display contract is unchanged.
+    const zones = powerZoneDef(ftp);
+    return zoneDistributionByValue(watts, intervals(timeSec), zones).map((z) => ({
+        zone: z.zone,
+        label: z.label,
+        minWatts: Math.round(z.lo),
+        maxWatts: z.hi === Infinity ? Infinity : Math.round(z.hi),
+        seconds: z.seconds,
+        fraction: z.fraction,
+    }));
+}
+/** The 7 Coggan power zones as a watt-axis {@link ZoneDef} (FTP-relative).
+ *  Delegates to {@link powerZonesFrom} — the scheme's canonical home is the
+ *  profile module, alongside the HR + pace zone builders. */
+export function powerZoneDef(ftp) {
+    return powerZonesFrom(ftp);
+}
+/**
+ * A dense, log-spaced set of durations (1 s → `total`, ~`steps` points) so the
+ * power curve reads as a smooth line rather than a few segments. Deduped to
+ * whole seconds.
+ */
+export function logDurations(total, steps = 140) {
+    if (total < 1 || steps < 2)
+        return [1];
+    const lnMax = Math.log(total);
+    const out = [];
+    let prev = 0;
+    for (let i = 0; i < steps; i++) {
+        const d = Math.round(Math.exp((lnMax * i) / (steps - 1)));
+        if (d > prev) {
+            out.push(d);
+            prev = d;
+        }
+    }
+    return out;
+}
+/**
+ * The mean-maximal power curve: for each duration, the highest average power
+ * sustained over any window of that length. Computed from a cumulative-work
+ * prefix sum with a two-pointer scan per duration — O(n) each. This is the
+ * sweep pond's single-window `rolling` doesn't do in one call (see friction).
+ */
+export function powerCurve(timeSec, watts, durations) {
+    const n = watts.length;
+    // cumulative work and time over finite samples (gap-clamped)
+    const dt = intervals(timeSec);
+    const cumWork = new Float64Array(n + 1);
+    const cumTime = new Float64Array(n + 1);
+    for (let i = 0; i < n; i++) {
+        const w = finite(watts[i]) ? watts[i] : 0;
+        cumWork[i + 1] = cumWork[i] + w * dt[i];
+        cumTime[i + 1] = cumTime[i] + dt[i];
+    }
+    const totalTime = cumTime[n];
+    const ds = durations ?? logDurations(totalTime);
+    const out = [];
+    for (const d of ds) {
+        if (d > totalTime)
+            break;
+        let best = 0;
+        let bestLo = -1;
+        let bestHi = -1;
+        let lo = 0;
+        for (let hi = 1; hi <= n; hi++) {
+            // shrink to the SMALLEST window ending at hi whose span is still ≥ d
+            while (lo + 1 < hi && cumTime[hi] - cumTime[lo + 1] >= d)
+                lo++;
+            const span = cumTime[hi] - cumTime[lo];
+            // only a window that actually lasts ≥ d counts as a d-second effort
+            // (no sub-d slack — that would bias short windows upward at gaps)
+            if (span >= d) {
+                const avg = (cumWork[hi] - cumWork[lo]) / span;
+                if (avg > best) {
+                    best = avg;
+                    bestLo = lo;
+                    bestHi = hi;
+                }
+            }
+        }
+        // mean-maximal power is non-increasing in duration by definition (best over
+        // ≥d windows ⊇ best over ≥d' windows for d'>d); clamp to kill the tiny
+        // upward blips the discrete window-snapping can produce between close
+        // durations. The window still points at THIS duration's own best stretch.
+        const prev = out[out.length - 1]?.watts ?? Infinity;
+        const point = {
+            durationSeconds: d,
+            watts: Math.min(best, prev),
+        };
+        if (bestLo >= 0) {
+            // cumWork[hi]-cumWork[lo] sums samples lo..hi-1 → inclusive [lo, hi-1].
+            point.startIndex = bestLo;
+            point.endIndex = bestHi - 1;
+        }
+        out.push(point);
+    }
+    return out;
+}
+/** Compute the full power summary. `elapsedSeconds` drives TSS. */
+export function computePower(timeSec, watts, ftp, elapsedSeconds) {
+    const np = normalizedPower(timeSec, watts);
+    return {
+        averageWatts: averagePower(watts),
+        maxWatts: maxPower(watts),
+        normalizedWatts: np,
+        intensityFactor: intensityFactor(np, ftp),
+        trainingLoad: trainingLoad(np, ftp, elapsedSeconds),
+        totalWorkKj: totalWorkKj(timeSec, watts),
+        ftp,
+        // 1 W base; the UI aggregates to its chosen bin width (see PowerSummary).
+        distribution: powerDistribution(timeSec, watts, 1),
+        zones: zoneDistribution(timeSec, watts, ftp),
+        curve: powerCurve(timeSec, watts),
+    };
+}
+/** Canonical durations (s) for the power best-efforts table: 5 s … 1 h. */
+export const BEST_EFFORT_DURATIONS = [
+    5, 15, 30, 60, 120, 180, 300, 480, 600, 900, 1200, 1800, 2700, 3600,
+];
+/**
+ * Power best efforts: the mean-maximal power at each canonical duration — the
+ * {@link powerCurve} sampled at the table's durations — plus W/kg when a body
+ * weight is supplied (resolved from the athlete profile as of the activity
+ * date). Same cumulative-work two-pointer as the curve; clamped non-increasing.
+ */
+export function powerBestEfforts(timeSec, watts, opts = {}) {
+    const ds = opts.durations ?? BEST_EFFORT_DURATIONS;
+    return powerCurve(timeSec, watts, ds).map((p) => {
+        const e = {
+            durationSeconds: p.durationSeconds,
+            watts: Math.round(p.watts),
+        };
+        if (opts.weightKg && opts.weightKg > 0)
+            e.wattsPerKg = p.watts / opts.weightKg;
+        if (p.startIndex != null)
+            e.startIndex = p.startIndex;
+        if (p.endIndex != null)
+            e.endIndex = p.endIndex;
+        return e;
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/profile/index.d.ts

@@ -0,0 +1,125 @@
+/** One effective-dated scalar entry: "from `at`, the value was `value`." */
+export interface ScalarEntry {
+    /** ISO 8601 date (or datetime) the value took effect. */
+    at: string;
+    value: number;
+}
+/** HR-zone basis: either a max HR (zones derived from %s) or explicit bounds
+ *  (the four Z1/Z2, Z2/Z3, Z3/Z4, Z4/Z5 boundaries in bpm). */
+export type HrZoneEntry = {
+    at: string;
+    maxHr: number;
+} | {
+    at: string;
+    bounds: [number, number, number, number];
+};
+/** Pace-zone basis: a recent 5 k time in seconds (zones are relative to it). */
+export interface PaceThresholdEntry {
+    at: string;
+    fiveKSeconds: number;
+}
+/** The whole athlete profile as stored in the vault. Every series is optional —
+ *  a fresh vault has none, and each fills in as the athlete records it. */
+export interface AthleteProfileJson {
+    weightKg?: ScalarEntry[];
+    ftpWatts?: ScalarEntry[];
+    hrZone?: HrZoneEntry[];
+    paceThreshold?: PaceThresholdEntry[];
+}
+/**
+ * A zone scheme over a value axis: ascending `edges` (length = nZones + 1, the
+ * last a large sentinel for the open top) and the `labels` per zone (Z1 first).
+ * The axis is bpm for HR and **m/s for pace** (we bucket speed, not pace, so a
+ * stop doesn't blow the reciprocal up — Z1 = slowest). Power reuses the same
+ * shape over watts.
+ */
+export interface ZoneDef {
+    edges: number[];
+    labels: string[];
+}
+/** Resolved athlete settings for one activity date — `undefined` where the
+ *  athlete hasn't recorded that series yet. */
+export interface ResolvedProfile {
+    weightKg?: number;
+    ftpWatts?: number;
+    hrZones?: ZoneDef;
+    paceZones?: ZoneDef;
+}
+/** HR zone scheme (bpm axis) from a max HR or explicit bounds. */
+export declare function hrZonesFrom(basis: {
+    maxHr: number;
+} | {
+    bounds: number[];
+}): ZoneDef;
+/**
+ * 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 declare function paceZonesFrom(fiveKSeconds: number): ZoneDef;
+/** 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 declare function powerZonesFrom(ftp: number): ZoneDef;
+/** A hydrated, date-keyed view of one series, answering "value as of date D". */
+interface AsOf<T> {
+    at(dateUtc: string): T | undefined;
+}
+/** A profile hydrated into as-of resolvers — built once per activity render. */
+export interface HydratedProfile {
+    weightKg: AsOf<ScalarEntry>;
+    ftpWatts: AsOf<ScalarEntry>;
+    hrZone: AsOf<HrZoneEntry>;
+    paceThreshold: AsOf<PaceThresholdEntry>;
+}
+/** Lift the vault JSON into pond-backed as-of resolvers. */
+export declare function hydrateProfile(json: AthleteProfileJson): HydratedProfile;
+/** 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 declare function profileAsOf(json: AthleteProfileJson, activityDateUtc: string): ResolvedProfile;
+/**
+ * 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 declare class Profile {
+    private readonly resolved;
+    /** The activity date this profile was resolved as-of (ISO 8601, UTC);
+     *  `undefined` for a history-less profile from {@link of}. */
+    readonly asOfDate?: string | undefined;
+    private constructor();
+    /** 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: AthleteProfileJson, activityDateUtc: string): Profile;
+    /** 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: {
+        ftpWatts?: number;
+        weightKg?: number;
+    }): Profile;
+    /** Functional Threshold Power (watts) in force on the date, if recorded. */
+    get ftpWatts(): number | undefined;
+    /** Body weight (kg) in force on the date, if recorded — drives W/kg. */
+    get weightKg(): number | undefined;
+    /** Heart-rate zone ranges (bpm axis), if an HR basis is recorded. */
+    get heartRateZones(): ZoneDef | undefined;
+    /** Pace zone ranges (speed axis, m/s; Z1 slowest), if a threshold is recorded. */
+    get paceZones(): ZoneDef | undefined;
+    /** Power zone ranges (watt axis, Coggan), derived from FTP if recorded. */
+    get powerZones(): ZoneDef | undefined;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map