@pond-ts/fit 0.52.0 → 0.53.1

package/CHANGELOG.md

@@ -8,7 +8,9 @@ The `@pond-ts` packages — `pond-ts`, `@pond-ts/react`, `@pond-ts/charts`,
 tag, so this file covers them all. Pre-1.0: minor bumps may include new features
 and type-level changes; patch bumps are strictly additive.
 
-[Unreleased]: https://github.com/pond-ts/pond/compare/v0.52.0...HEAD
+[Unreleased]: https://github.com/pond-ts/pond/compare/v0.53.1...HEAD
+[0.53.1]: https://github.com/pond-ts/pond/compare/v0.53.0...v0.53.1
+[0.53.0]: https://github.com/pond-ts/pond/compare/v0.52.0...v0.53.0
 [0.52.0]: https://github.com/pond-ts/pond/compare/v0.51.0...v0.52.0
 [0.51.0]: https://github.com/pond-ts/pond/compare/v0.50.0...v0.51.0
 [0.50.0]: https://github.com/pond-ts/pond/compare/v0.49.0...v0.50.0
@@ -52,6 +54,126 @@ and type-level changes; patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [0.53.1] — 2026-07-25
+
+### Fixed
+
+- **charts:** **An `<XAxis format>` again owns its own cursor / marker pills**
+  under a container with `origin` set. The elapsed axis supplies a _default_
+  finer readout (`00:05:12` under `00:05` ticks), but it was being delivered
+  through the same frame field as an explicit `cursorFormat` — so it outranked
+  an axis-level `format`, inverting the documented pill precedence
+  (`cursorFormat → axis format → container`). The visible symptom was the
+  two-strip pattern the docs recommend: a wall-clock strip declared as
+  `<XAxis format="%H:%M">` labelled its ticks `11:33` and pilled them
+  `00:05:12`. A real `cursorFormat` still outranks an axis `format`, unchanged.
+  A container **`timeFormat`** was inverted the same way one rung down — its
+  documented back-compat is to shape the readout when no `cursorFormat` is set,
+  and the elapsed default was overruling it. Fixed with the same precedence.
+
+- **charts:** **A duration axis no longer stacks ticks on one pixel across a
+  collapsed session.** The duration ladder strides in wall-clock time, so on a
+  trading axis several ticks could land inside closed time — where the scale
+  maps all of them to the same seam pixel, stroking labels over labels and
+  gridlines over gridlines. Coinciding ticks are now dropped, so a seam shows
+  one label rather than four — and the one kept is the **last** of the group,
+  the session open that genuinely sits on that pixel (`1d 00:00`), rather than
+  the first, which falls inside the collapsed night (`12:00` = 21:30, market
+  shut). Continuous axes are unaffected (their ticks are tens of pixels apart
+  by construction).
+
+Both found by an adversarial review of the v0.53.0 duration axis
+([#540](https://github.com/pond-ts/pond/issues/540)), which also corrected the
+duration-axis docs: the trading-calendar caveat described uneven spacing where
+the real behaviour is thinning around seams, a far-off `origin` (`origin={0}`
+on a 2026 axis ⇒ `20468d 10:00` on every tick) was undocumented, and one row of
+the label-shape table quoted a sample spacing where it meant a tick step.
+
+## [0.53.0] — 2026-07-25
+
+### Changed
+
+- **fit (breaking):** **Power bins and zones now use pond's canonical bin
+  edges**, so they feed `@pond-ts/charts` with no mapping step:
+
+  ```tsx
+  <BarChart bins={power.distribution} column="seconds" />
+  <BarChart bins={power.zones} column="seconds" orientation="horizontal" ordinal />
+  ```
+
+  Each type previously spoke its own dialect for the same concept —
+  `PowerBin.wattsFrom` (with **no upper edge at all**), `ZoneTime.lo`/`hi`, and
+  `PowerZone.minWatts`/`maxWatts` — while core's `byColumn` and charts' `BinRecord`
+  both use `{ start, end, …aggregates }`. Every caller had to hand-map before
+  drawing, even though the internals already computed the canonical shape and
+  discarded it.
+
+  **Migration** (pre-1.0, so the old names are gone rather than deprecated):
+
+  | Was                   | Now                                    |
+  | --------------------- | -------------------------------------- |
+  | `PowerBin.wattsFrom`  | `PowerBin.start` (+ new `end`)         |
+  | `ZoneTime.lo` / `.hi` | `ZoneTime.start` / `.end`, `openEnded` |
+  | `PowerZone.minWatts`  | `PowerZone.start`                      |
+  | `PowerZone.maxWatts`  | `PowerZone.end`, `openEnded`           |
+
+  Only **`PowerZone.maxWatts`** — a zone's upper edge — is affected. The
+  identically-named `PowerSummary.maxWatts` and the per-lap / per-section peak
+  power are a different concept and are unchanged.
+
+  `end` is now **always finite and always `> start`** — the guarantee core
+  enforces (`byColumn` throws on a zero-width bin) and charts need (an infinite
+  edge blows up an axis domain). The open-ended top band, which previously
+  carried only `Infinity`, gets a **drawable stand-in** edge: wide enough to
+  cover the highest value observed, and at least as wide as the band below it.
+  Treat it as a drawing bound rather than data, and test for the band with the
+  new **`openEnded`** flag rather than comparing an edge against `Infinity`
+  (`openEnded` is now also strictly positional — only the final band can carry
+  it). Rounding zone edges to whole watts no longer collapses bands at very low
+  FTPs.
+
+### Added
+
+- **charts:** **Duration (elapsed) x axis** — `<ChartContainer origin>` labels
+  the shared x axis as offsets from a zero point instead of absolute values, so
+  a workout / lab run / load test reads `00:00 00:05 00:10` rather than
+  `10:35 10:40 10:45`:
+
+  ```tsx
+  <ChartContainer width={620} origin="data">
+    …
+    <XAxis label="Elapsed" />
+  </ChartContainer>
+  ```
+
+  `'data'` zeroes at the start of the data (and stays there as you pan); a
+  **number** sets an explicit zero point — a gun, a trigger, a lap — with ticks
+  before it reading negative (`-00:05`). Ticks are placed at round durations
+  **measured from the origin** (a ride starting at 10:33:17 ticks 10:33:17,
+  10:38:17, …), off a clock ladder (…15s, 30s, 1m, 2m, 5m, …, 12h, then whole
+  days) rather than the 1-2-5 ladder — the part a formatter alone can't do.
+  Labels pick their shape from the step and the axis's magnitude
+  (`00:00.500` · `00:15` · `01:01:30` · `1d 12:00` · `5d`), gridlines follow the
+  same ticks, and the cursor / marker pills read one grain finer (`00:05:12`).
+
+  It's a **labelling** mode, not a data transform: `range`, `<Marker at>`,
+  `onRegionSelect`, `trackerPosition` all stay in absolute axis units. The same
+  prop works on a **value** x axis (distance travelled, not distance recorded).
+  An explicit format still wins — on a time axis a d3 _time_ specifier can only
+  describe an instant, so it labels the wall clock, which is the lever for
+  stacking a wall-clock strip under a duration strip on one shared tick set; on
+  a value axis a number specifier formats the offset. Ignored on a category
+  axis; on a trading calendar the durations are wall-clock, so ticks spanning a
+  collapsed session gap sit unevenly.
+
+- **fit:** `computePower` takes an options object — **`{ binWatts }`** sets the
+  width of the `distribution` buckets (default `1`, unchanged). 1 W bins draw as
+  hairlines, so pass the width you intend to render rather than re-bucketing the
+  output yourself. It throws `RangeError` on a non-positive or non-finite
+  `binWatts`. New exported type `ComputePowerOptions`, also accepted by the
+  activity façade: `Activity.power(ftp, options)` and
+  `ProfiledActivity.power(options)`.
+
 ## [0.52.0] — 2026-07-23
 
 ### Changed

package/dist/activity/index.d.ts

@@ -19,7 +19,7 @@
 import type { ActivityMeta, ImportedActivity } from '../types.js';
 import type { TrackSeries, DistanceEffort } from '../geo/index.js';
 import { type PreparedActivity, type ActivitySummary, type ActivitySummaryOptions, type WindowChannelOptions, type ChannelProfile } from '../summary/index.js';
-import { type PowerSummary, type PowerCurvePoint, type PowerEffort, type PowerZone } from '../power/index.js';
+import { type PowerSummary, type PowerCurvePoint, type PowerEffort, type PowerZone, type ComputePowerOptions } from '../power/index.js';
 import { type ZoneTime } from '../zones/index.js';
 import { Profile, type ZoneDef } from '../profile/index.js';
 import { Distance, Elevation, Duration, Speed, Pace, Power, HeartRate, Cadence } from '../quantities.js';
@@ -145,8 +145,9 @@ export declare class Activity {
      *  computed from the series over that window. Clamped to the activity. */
     range(from: Duration, to: Duration, label?: string): Section;
     /** Power summary (NP, IF, TSS, distribution, zones, curve) at the given FTP —
-     *  `undefined` when no power was recorded. `elapsedSeconds` drives TSS. */
-    power(ftp: number): PowerSummary | undefined;
+     *  `undefined` when no power was recorded. `options.binWatts` sets the
+     *  histogram bucket width (default 1 W). */
+    power(ftp: number, options?: ComputePowerOptions): PowerSummary | undefined;
     /** Mean-maximal power curve; `[]` when no power. */
     powerCurve(durations?: number[]): PowerCurvePoint[];
     /** Power best efforts at the canonical durations (+ W/kg if `weightKg`); `[]`
@@ -190,8 +191,9 @@ export declare class ProfiledActivity {
     private readonly profile;
     constructor(activity: Activity, 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(): PowerSummary | undefined;
+     *  profile's FTP. `undefined` when no power was recorded or no FTP is known.
+     *  `options.binWatts` sets the histogram bucket width (default 1 W). */
+    power(options?: ComputePowerOptions): PowerSummary | undefined;
     /** Time in each Coggan power zone (FTP-relative); `[]` with no power or no FTP. */
     byPowerZone(): PowerZone[];
     /** Time in each heart-rate zone; `[]` with no HR or no HR zones on the profile. */

package/dist/activity/index.js

@@ -262,15 +262,16 @@ export class Activity {
         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) {
+     *  `undefined` when no power was recorded. `options.binWatts` sets the
+     *  histogram bucket width (default 1 W). */
+    power(ftp, options) {
         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);
+        return computePower(this.prep.cols.timeSec, watts, ftp, elapsed, options);
     }
     /** Mean-maximal power curve; `[]` when no power. */
     powerCurve(durations) {
@@ -467,10 +468,11 @@ export class ProfiledActivity {
         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() {
+     *  profile's FTP. `undefined` when no power was recorded or no FTP is known.
+     *  `options.binWatts` sets the histogram bucket width (default 1 W). */
+    power(options) {
         const ftp = this.profile.ftpWatts;
-        return ftp == null ? undefined : this.activity.power(ftp);
+        return ftp == null ? undefined : this.activity.power(ftp, options);
     }
     /** Time in each Coggan power zone (FTP-relative); `[]` with no power or no FTP. */
     byPowerZone() {

package/dist/index.d.ts

@@ -8,7 +8,7 @@ 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 type { PowerBin, PowerZone, PowerCurvePoint, PowerSummary, PowerEffort, ComputePowerOptions, } 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';

package/dist/power/index.d.ts

@@ -19,10 +19,22 @@ export declare function intensityFactor(normalizedPowerW: number, ftp: number):
  * 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. */
+/**
+ * One bucket of the power histogram.
+ *
+ * Carries pond's canonical bin edges (`start` / `end`, watts) — the same
+ * `{ start, end, …aggregates }` shape core's `byColumn` returns — so the array
+ * feeds `@pond-ts/charts` directly:
+ *
+ * ```tsx
+ * <BarChart bins={power.distribution} column="seconds" />
+ * ```
+ */
 export interface PowerBin {
     /** Inclusive lower edge of the bin, watts. */
-    wattsFrom: number;
+    start: number;
+    /** Exclusive upper edge of the bin, watts (`start + binWatts`). */
+    end: number;
     /** Seconds spent in this bin. */
     seconds: number;
 }
@@ -34,13 +46,37 @@ export interface PowerBin {
  * 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. */
+/**
+ * One FTP-based training zone.
+ *
+ * Like {@link PowerBin}, carries pond's canonical `start` / `end` edges so the
+ * array feeds `@pond-ts/charts` unmapped. Zone widths are very unequal, so a
+ * zone chart usually wants uniform slots rather than true watt widths:
+ *
+ * ```tsx
+ * <BarChart bins={power.zones} column="seconds" orientation="horizontal" ordinal />
+ * ```
+ */
 export interface PowerZone {
     zone: number;
     label: string;
-    minWatts: number;
-    /** Upper edge, watts; `Infinity` for the top zone. */
-    maxWatts: number;
+    /**
+     * Lower edge, watts (whole watts). Zones are **inclusive-upper**, so this
+     * edge belongs to the zone below — except on Z1, whose floor is inclusive.
+     */
+    start: number;
+    /**
+     * Upper edge, watts — **always finite, always `> start`**. Z1–Z6 report their
+     * real edge. Z7 is open-ended and has none, so its `end` is a **drawable
+     * stand-in**, never `Infinity`: wide enough to cover the ride's peak wattage,
+     * and at least as wide as Z6. Treat it as a drawing bound, not as data.
+     */
+    end: number;
+    /**
+     * `true` on Z7, whose real upper edge is unbounded — `end` is a drawable
+     * stand-in. Label it `"375+ W"` rather than as a range.
+     */
+    openEnded: boolean;
     seconds: number;
     /** Fraction of total in-zone time [0, 1]. */
     fraction: number;
@@ -88,15 +124,27 @@ export interface PowerSummary {
     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. */
+    /**
+     * Time per power bucket, `binWatts` wide (default **1 W** — the finest base,
+     * which a caller can re-aggregate). Pass `binWatts` to get display-ready
+     * buckets straight out: 1 W bins draw as hairlines, so a chart usually wants
+     * 10–25 W.
+     */
     distribution: PowerBin[];
     zones: PowerZone[];
     curve: PowerCurvePoint[];
 }
+/** Options for {@link computePower}. */
+export interface ComputePowerOptions {
+    /**
+     * Width of each {@link PowerSummary.distribution} bucket, watts. Defaults to
+     * `1` — the finest base. Set it to the width you intend to draw (10 / 15 /
+     * 25) rather than re-bucketing the 1 W output yourself.
+     */
+    binWatts?: number;
+}
 /** Compute the full power summary. `elapsedSeconds` drives TSS. */
-export declare function computePower(timeSec: Float64Array, watts: Float64Array, ftp: number, elapsedSeconds: number): PowerSummary;
+export declare function computePower(timeSec: Float64Array, watts: Float64Array, ftp: number, elapsedSeconds: number, options?: ComputePowerOptions): 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. */

package/dist/power/index.js

@@ -125,7 +125,11 @@ export function powerDistribution(timeSec, watts, binWatts = 25) {
     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 }));
+    return seconds.map((s, b) => ({
+        start: b * binWatts,
+        end: (b + 1) * binWatts,
+        seconds: s,
+    }));
 }
 /**
  * Time in each of the 7 Coggan power zones for the given FTP. Like
@@ -137,14 +141,25 @@ export function zoneDistribution(timeSec, watts, ftp) {
     // 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,
-    }));
+    // Report whole watts (Coggan edges land on halves at most FTPs), but keep the
+    // edges strictly ascending as we round: at a tiny FTP several zones round to
+    // the same integer, which would collapse a band to zero width. Each zone
+    // starts where the previous ended, so the set stays contiguous and drawable.
+    let prevEnd = -Infinity;
+    return zoneDistributionByValue(watts, intervals(timeSec), zones).map((z) => {
+        const start = prevEnd === -Infinity ? Math.round(z.start) : prevEnd;
+        const end = Math.max(Math.round(z.end), start + 1);
+        prevEnd = end;
+        return {
+            zone: z.zone,
+            label: z.label,
+            start,
+            end,
+            openEnded: z.openEnded,
+            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
@@ -234,7 +249,13 @@ export function powerCurve(timeSec, watts, durations) {
     return out;
 }
 /** Compute the full power summary. `elapsedSeconds` drives TSS. */
-export function computePower(timeSec, watts, ftp, elapsedSeconds) {
+export function computePower(timeSec, watts, ftp, elapsedSeconds, options = {}) {
+    const { binWatts = 1 } = options;
+    if (!Number.isFinite(binWatts) || binWatts <= 0) {
+        // Without this the failure surfaces from `byColumn` as a complaint about
+        // `width` — an internal the caller never named.
+        throw new RangeError(`computePower: binWatts must be a positive finite number; got ${binWatts}`);
+    }
     const np = normalizedPower(timeSec, watts);
     return {
         averageWatts: averagePower(watts),
@@ -244,8 +265,7 @@ export function computePower(timeSec, watts, ftp, elapsedSeconds) {
         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),
+        distribution: powerDistribution(timeSec, watts, binWatts),
         zones: zoneDistribution(timeSec, watts, ftp),
         curve: powerCurve(timeSec, watts),
     };

package/dist/zones/index.d.ts

@@ -1,13 +1,38 @@
 import type { ZoneDef } from '../profile/index.js';
-/** One zone's time + share. `hi` is `Infinity` for the open top. */
+/**
+ * One zone's time + share.
+ *
+ * Carries pond's canonical bin edges (`start` / `end`) so the array feeds
+ * `@pond-ts/charts` (`<BarChart bins>` / `stacksFromBins`) with no mapping
+ * step — the same `{ start, end, …aggregates }` shape core's `byColumn`
+ * returns, and the same guarantee core enforces: **finite, with
+ * `end > start`.** (An infinite edge blows up a chart's axis domain; a
+ * zero-width bin is what `byColumn` itself rejects as unrepresentable.)
+ */
 export interface ZoneTime {
     /** 1-based zone number (Z1 = the lowest band). */
     zone: number;
     label: string;
-    /** Inclusive lower edge, in the value axis (watts / bpm / m·s⁻¹). */
-    lo: number;
-    /** Upper edge; `Infinity` for the top zone. */
-    hi: number;
+    /**
+     * Lower edge, in the value axis (watts / bpm / m·s⁻¹). Bands are
+     * **inclusive-upper** (`(start, end]`), so this edge belongs to the band
+     * below — except on Z1, whose floor is inclusive.
+     */
+    start: number;
+    /**
+     * Upper edge — **always finite, always `> start`**. On a closed band this is
+     * the real edge. The open-ended band has none, so `end` is a **drawable
+     * stand-in**, never `Infinity`: wide enough to cover the highest value
+     * observed, and at least as wide as the band below. Treat it as a drawing
+     * bound, not as data — it can exceed anything actually recorded (and a
+     * device's out-of-range sentinel sample will stretch it).
+     */
+    end: number;
+    /**
+     * `true` on the open-ended top band, whose real upper edge is unbounded —
+     * `end` is a drawable stand-in. Label it `"{start}+"` rather than as a range.
+     */
+    openEnded: boolean;
     seconds: number;
     /** Share of total in-zone time, [0, 1]. */
     fraction: number;

package/dist/zones/index.js

@@ -28,9 +28,15 @@ const SENTINEL = 1e9; // the open-top edge ZoneDef carries
 export function zoneDistributionByValue(values, dt, zones) {
     const { edges, labels } = zones;
     const rows = [];
+    // Track the highest value actually seen (clamped the same way it's binned) —
+    // it's the finite upper edge we give the open-top zone so it can be drawn.
+    let observedMax = -Infinity;
     for (let i = 0; i < values.length; i++) {
         const v = values[i];
-        rows.push([i, Number.isFinite(v) ? Math.max(0, v) : undefined, dt[i] ?? 0]);
+        const clamped = Number.isFinite(v) ? Math.max(0, v) : undefined;
+        if (clamped !== undefined && clamped > observedMax)
+            observedMax = clamped;
+        rows.push([i, clamped, dt[i] ?? 0]);
     }
     const bins = new TimeSeries({
         name: 'zones',
@@ -39,14 +45,44 @@ export function zoneDistributionByValue(values, dt, zones) {
     }).byColumn('val', { edges, inclusive: '(]' }, { seconds: { from: 'dt', using: 'sum' } });
     const secs = bins.map((b) => b.seconds ?? 0);
     const total = secs.reduce((a, b) => a + b, 0) || 1;
-    return labels.map((label, z) => ({
-        zone: z + 1,
-        label,
-        lo: edges[z],
-        hi: (edges[z + 1] ?? SENTINEL) >= SENTINEL ? Infinity : edges[z + 1],
-        seconds: secs[z] ?? 0,
-        fraction: (secs[z] ?? 0) / total,
-    }));
+    const last = labels.length - 1;
+    return labels.map((label, z) => {
+        const start = edges[z];
+        const rawEnd = edges[z + 1] ?? SENTINEL;
+        // Only the FINAL band can be open-ended. The sentinel is a magnitude, so a
+        // caller whose real edges reach past it would otherwise flag an interior
+        // band open too — and then overlap the band above it.
+        const openEnded = z === last && rawEnd >= SENTINEL;
+        return {
+            zone: z + 1,
+            label,
+            start,
+            end: openEnded ? openTopEnd(start, edges, z, observedMax) : rawEnd,
+            openEnded,
+            seconds: secs[z] ?? 0,
+            fraction: (secs[z] ?? 0) / total,
+        };
+    });
+}
+/**
+ * A finite, drawable upper edge for the open-ended top band, which has no real
+ * one. Wide enough to cover the highest value observed, and never narrower than
+ * the band below it — a zero-width bin is what `byColumn` rejects as
+ * unrepresentable, and it would vanish from a chart even while holding time.
+ */
+function openTopEnd(start, edges, z, observedMax) {
+    const below = z > 0 ? start - edges[z - 1] : 0;
+    const end = Math.max(observedMax, start + (below > 0 ? below : 1));
+    // At absurd magnitudes (≥2^53) adding a width is a no-op, so fall back to the
+    // next representable double — `end > start` is a guarantee, not a best effort.
+    return end > start ? end : nextUp(start);
+}
+/** The smallest double strictly greater than `x` (`x >= 0`). */
+function nextUp(x) {
+    if (x === 0)
+        return Number.MIN_VALUE;
+    const up = x * (1 + Number.EPSILON);
+    return up > x ? up : x + Math.abs(x) * Number.EPSILON * 2;
 }
 /** Time in each HR zone (bpm axis). `hrZones` from `profile.profileAsOf`. */
 export function hrZoneDistribution(timeSec, heartrate, hrZones) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pond-ts/fit",
-  "version": "0.52.0",
+  "version": "0.53.1",
   "private": false,
   "description": "Fitness & activity domain library on pond-ts — quantities, canonical activity series, and analytics (geo, power, zones, splits)",
   "license": "MIT",
@@ -37,7 +37,7 @@
     "verify": "npm run format:check && npm run build && npm test"
   },
   "peerDependencies": {
-    "pond-ts": "^0.52.0"
+    "pond-ts": "^0.53.0"
   },
   "devDependencies": {
     "typescript": "^5.6.3",