@pond-ts/charts 0.44.1 → 0.45.0

package/CHANGELOG.md

@@ -8,7 +8,8 @@ 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/pjm17971/pond-ts/compare/v0.44.1...HEAD
+[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.45.0...HEAD
+[0.45.0]: https://github.com/pjm17971/pond-ts/compare/v0.44.1...v0.45.0
 [0.44.1]: https://github.com/pjm17971/pond-ts/compare/v0.44.0...v0.44.1
 [0.44.0]: https://github.com/pjm17971/pond-ts/compare/v0.43.0...v0.44.0
 [0.43.0]: https://github.com/pjm17971/pond-ts/compare/v0.42.0...v0.43.0
@@ -43,6 +44,98 @@ and type-level changes; patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [0.45.0] — 2026-07-14
+
+### Added
+
+- **charts:** the time axis now walks a **logical tick ladder** — clock/calendar
+  units (1s…30s, 1m…30m, 1H…12H, day / week / month / quarter / year), picking
+  the finest grain that fits the width-derived cap — and renders **two-tier labels**:
+  a first row at the tick grain (`14:00`, `Feb 02`, `Feb`, `2026`) plus a
+  **boundary row** carrying the coarser context the first row omits (the date
+  under clock ticks, the year under day/week/month ticks — never a unit the
+  first row already shows), shown once under
+  the first tick of each new period. Hour anchors are generated in **live**
+  trading time, so none lands in a collapsed gap, an early close, or a lunch
+  break. `TradingTimeScale` gains `tickBoundaries(count)`; a cramped leading
+  partial-period anchor (the `"Jun 23Jul 07"` pile-up) is dropped. Systematic
+  story matrix under `Charts/TimeAxisTicks`.
+- **financial:** the rest of the first study batch — `rollingStdev`,
+  `rollingMin`, `rollingMax`, `rollingPercentile` (linear interpolation),
+  `zScore` (rolling), `envelope` (MA ± percent, `maType` sma/ema), and
+  `percentChange` (n-bar rate of change). Same shape as the others — `column` /
+  `output` (or `prefix`) on every one, bar-count periods, length-preserving
+  warm-up — and each has a fluent method (`bars.zScore({ period: 20 })`) and a
+  **pandas oracle** case (values cross-validated bar-for-bar). This completes the
+  #449 first batch.
+- **financial:** opt-in **fluent studies** via `import '@pond-ts/financial/fluent'`
+  — mounts `sma` / `ema` / `bollinger` as chainable `TimeSeries` methods so
+  composition reads like the core operators beside it:
+  `bars.sma({ period: 20 }).ema({ period: 12 }).bollinger({ period: 20 })`.
+  Opt-in by import (the default entry leaves `TimeSeries` untouched, so a
+  non-financial series never sees `.sma()`); the methods are exactly the
+  standalone functions bound to `this`, fully typed (each appends its column to
+  the schema). Same prototype-augmentation pattern core uses for column methods.
+- **financial:** `@pond-ts/financial` gains its first **studies** — `sma`, `ema`,
+  and `bollinger` (Bollinger Bands®) — pure functions that append a column (or a
+  `${prefix}Middle/Upper/Lower` family) to a bar series. Every study takes a
+  `column` source (default `'close'`) and an `output` name, so a study runs over
+  any numeric column including another study's output; periods are **bar counts**
+  (on core's count window, gap-correct); warm-up rows are `undefined`
+  (length-preserving). Plus the `OhlcvColumns` contract + `DEFAULT_OHLCV`. (Core
+  `AppendColumn` is now exported so study return types name their appended
+  column.)
+- **core:** `smooth(col, 'ema', …)` gains the financial **`span`** rate
+  convention (`α = 2/(span+1)`, e.g. `{ span: 12 }` for a 12-period EMA) as an
+  alternative to `alpha` (exactly one required), and a length-preserving
+  **`minSamples`** warm-up that emits `undefined` for the first `N` present
+  values while **keeping the row count** — mirroring `rolling`'s `minSamples`,
+  the one warm-up convention studies use so a smoothed line aligns on its
+  source's time axis. (The existing `warmup` option is unchanged — it still
+  *drops* the head rows; `minSamples` is the length-preserving counterpart.)
+- **core:** `TimeSeries.rolling` accepts a **count-based** window —
+  `rolling({ count: N }, mapping, opts?)` reduces the last / next / centered
+  `N` _rows_ (bars) by position instead of a time span. Unlike a duration
+  window, an N-bar window stays correct across session gaps (weekends,
+  overnight) where `N` bars do not equal `N × barSize` of time — the load-
+  bearing primitive for financial N-bar studies (SMA-20, Bollinger-20, rolling
+  stdev). Honours `alignment` and `minSamples` exactly like a duration window
+  (`minSamples: N` gives the conventional first-`N-1`-rows-`undefined` warmup);
+  per-row output only (not supported with a sequence). Same amortized-O(1)-per-
+  row sweep as the duration path.
+- **charts:** `<LineChart sessionBreaks>` breaks the line at each trading-axis
+  discontinuity (a session / day / lunch close→open) instead of connecting the
+  prior close straight to the next open across the collapsed gap. For intraday
+  data on a `discontinuities` / `calendar` axis this gives the terminal look —
+  the line ends at the close and re-starts at the open, so one session's price
+  doesn't visually flow into the next. It's a **scale** break (driven by the
+  axis's collapsed gaps), orthogonal to `gaps` (a **data** break, a NaN run) —
+  set both independently. Default `false`; a no-op on a continuous axis or a
+  provider without `boundaries`. New `Charts/TradingTimeAxis/SessionBreaks`
+  story (connected vs broken) + `sessionRuns` / `gappingTicks` helpers.
+
+### Changed
+
+- **charts:** a **plain continuous time axis** now runs the same ladder as a
+  trading-calendar axis (via an internal gap-free identity provider) instead of
+  d3's multi-scale default — so a year of daily data ticks cleanly on month
+  starts (`Jul Aug … Jun` + the year underneath) rather than mixed
+  `"Jun 23" / "Sep" / "Dec"` labels, and its tick count is now width-derived
+  like the trading axis's. Month/quarter-grain anchor labels are now bare
+  months (`Feb`, was `Feb 02`) with the year on the boundary row;
+  `coarsenCalendar`'s finest granularity is renamed `'session'` → `'day'`.
+
+### Fixed
+
+- **core:** `TimeSeries.withColumn` now appends an **optional** column
+  (`required: false`) rather than a required one. It already accepted
+  `(number | undefined)[]`, but marking the column required meant a later
+  strict-intake rebuild (`smooth`, any row reconstruction) threw on the gaps —
+  so a column with a warm-up (a rolling study fed into an EMA, e.g.
+  `ema(sma(bars, …), …)`) crashed. The appended column's type is now
+  `number | undefined`, matching `smooth`'s optional append. (`OptionalNumberColumn`
+  is exported for the widened return type.)
+
 ## [0.44.1] — 2026-07-13
 
 A `@pond-ts/charts` patch: fixes trading-time axis tick density. `pond-ts`,

package/dist/ChartContainer.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
-import { scaleLinear, scaleTime } from 'd3-scale';
-import { scaleTradingTime, } from './tradingTimeScale.js';
+import { scaleLinear } from 'd3-scale';
+import { identityProvider, scaleTradingTime, } from './tradingTimeScale.js';
 import { scaleBand } from './bandScale.js';
 import { Sequence } from 'pond-ts';
 import { ContainerContext, } from './context.js';
@@ -335,10 +335,11 @@ export function ChartContainer({ range, width, rowGap = 0, showAxis = true, trac
     // The shared x-side tick count — labels, x gridlines, session dividers, and
     // `formatTime` all pass this one value, so they derive from the same instants
     // (the alignment previously held by three hardcoded constants agreeing).
-    // Trading axis: width-derived, since the trading scale's `count` caps its
-    // calendar buckets rather than targeting a tick total; floored at 2 so a
-    // pre-layout zero width still requests a drawable tick set.
-    const xTickCount = xDiscontinuities !== undefined
+    // Time axis (trading or plain — both run the logical tick ladder):
+    // width-derived, since the ladder's `count` caps its calendar buckets rather
+    // than targeting a tick total; floored at 2 so a pre-layout zero width still
+    // requests a drawable tick set. Value/category axes keep the d3 target count.
+    const xTickCount = resolvedKind === 'time'
         ? Math.max(2, Math.floor(plotWidth / TRADING_TICK_PX))
         : TIME_TICK_COUNT;
     const { xScale, formatTime } = useMemo(() => {
@@ -373,7 +374,15 @@ export function ChartContainer({ range, width, rowGap = 0, showAxis = true, trac
                 formatTime: resolveTimeFormat(s, xTickCount, timeFormat),
             };
         }
-        const s = scaleTime().domain([d0, d1]).range([0, plotWidth]);
+        // Plain continuous time axis: the same trading-time scale over the
+        // gap-free identity provider, so it runs the same logical tick ladder
+        // (month starts over a year, clock-aligned hours over an afternoon) —
+        // never d3's mixed multi-scale default. Interactions stay on continuous
+        // time math: the frame's `discontinuities` remains undefined, and identity
+        // distance/offset are plain subtraction/addition anyway.
+        const s = scaleTradingTime(identityProvider())
+            .domain([d0, d1])
+            .range([0, plotWidth]);
         return {
             xScale: s,
             formatTime: resolveTimeFormat(s, xTickCount, timeFormat),
@@ -499,6 +508,7 @@ export function ChartContainer({ range, width, rowGap = 0, showAxis = true, trac
         onHoverAnnotation,
         onEditAnnotation,
         formatTime,
+        xFormatCustom: timeFormat !== undefined,
         xTickCount,
         registerTrackerSource,
         unregisterTrackerSource,
@@ -553,6 +563,7 @@ export function ChartContainer({ range, width, rowGap = 0, showAxis = true, trac
         onHoverAnnotation,
         onEditAnnotation,
         formatTime,
+        timeFormat,
         xTickCount,
         registerTrackerSource,
         unregisterTrackerSource,

package/dist/LineChart.d.ts

@@ -49,6 +49,20 @@ export interface LineChartProps<S extends SeriesSchema = SeriesSchema, VS extend
      * `gap.connectorOpacity`.)
      */
     gaps?: GapMode;
+    /**
+     * Break the line at each **trading-axis discontinuity** (a session / day /
+     * lunch close→open) when the container renders on a trading-time axis (a
+     * `discontinuities` / `calendar` provider). **Omitted ⇒ `false`**: the line
+     * connects the last pre-close point straight to the next open across the
+     * collapsed gap (the near-vertical connector). `true` ends the line at the
+     * close and re-starts it at the open — the intraday look, where a session's
+     * price shouldn't visually flow into the next.
+     *
+     * This is a **scale** break (driven by the axis's collapsed gaps), orthogonal
+     * to {@link gaps} (a **data** break, a NaN run) — set both independently. A
+     * no-op on a continuous axis (no provider) or a provider without `boundaries`.
+     */
+    sessionBreaks?: boolean;
     /**
      * @internal Declaration position among the `<Layers>` children, injected by
      * `Layers` so z-order follows JSX order. Do not set.
@@ -61,5 +75,5 @@ export interface LineChartProps<S extends SeriesSchema = SeriesSchema, VS extend
  * (scaling against its `axis`), and renders nothing to the DOM — the row draws
  * it. The line breaks at gaps rather than spanning them.
  */
-export declare function LineChart<S extends SeriesSchema = SeriesSchema, VS extends ValueSeriesSchema = ValueSeriesSchema>({ series, column, as: semantic, axis, curve, gaps, index, }: LineChartProps<S, VS>): null;
+export declare function LineChart<S extends SeriesSchema = SeriesSchema, VS extends ValueSeriesSchema = ValueSeriesSchema>({ series, column, as: semantic, axis, curve, gaps, sessionBreaks, index, }: LineChartProps<S, VS>): null;
 //# sourceMappingURL=LineChart.d.ts.map

package/dist/LineChart.js

@@ -6,13 +6,16 @@ import { resolveCurve } from './curve.js';
 import { DEFAULT_GAP_MODE, DEFAULT_GAP_CONNECTOR_OPACITY, } from './gaps.js';
 import { ContainerContext, LayersContext } from './context.js';
 import { useSlotKey } from './use-slot-key.js';
+/** Stable empty boundary list — so `sessionBreaks={false}` keeps a referentially
+ *  constant array and the layer entry isn't rebuilt every render. */
+const NO_BREAKS = [];
 /**
  * A line draw layer. Reads `column` from `series` into a {@link ChartSeries}
  * (columnar, gaps as NaN), registers itself into the enclosing {@link Layers}
  * (scaling against its `axis`), and renders nothing to the DOM — the row draws
  * it. The line breaks at gaps rather than spanning them.
  */
-export function LineChart({ series, column, as: semantic, axis, curve, gaps = DEFAULT_GAP_MODE, index = 0, }) {
+export function LineChart({ series, column, as: semantic, axis, curve, gaps = DEFAULT_GAP_MODE, sessionBreaks = false, index = 0, }) {
     const container = useContext(ContainerContext);
     if (container === null) {
         throw new Error('<LineChart> must be rendered inside a <ChartContainer>');
@@ -33,6 +36,17 @@ export function LineChart({ series, column, as: semantic, axis, curve, gaps = DE
     // Faintness of the inferred dashed connectors (dashed / step) — theme-level,
     // falling back to the shared default so a theme without it still renders faint.
     const gapConnectorOpacity = container.theme.gap?.connectorOpacity ?? DEFAULT_GAP_CONNECTOR_OPACITY;
+    // Trading-axis session breaks: the collapse instants inside this series' span
+    // (session/day/lunch opens the axis skips). Data instants, not pixels — so the
+    // set is view-independent (pan/zoom reuse it). Only computed when opted in and
+    // the container carries a boundary-reporting discontinuity provider.
+    const sessionBreakInstants = useMemo(() => {
+        const provider = container.discontinuities;
+        if (!sessionBreaks || provider?.boundaries === undefined || cs.length < 2) {
+            return NO_BREAKS;
+        }
+        return provider.boundaries(cs.x[0], cs.x[cs.length - 1]);
+    }, [sessionBreaks, container.discontinuities, cs]);
     const entry = useMemo(() => ({
         layer: {
             yExtent: () => yExtent(cs),
@@ -67,7 +81,7 @@ export function LineChart({ series, column, as: semantic, axis, curve, gaps = DE
                     ? [{ x: e.begin(), value: v, color: style.color, label }]
                     : [];
             },
-            draw: (ctx, xScale, yScale) => drawLine(ctx, cs, xScale, yScale, style, curveFactory, gaps, gapConnectorOpacity),
+            draw: (ctx, xScale, yScale) => drawLine(ctx, cs, xScale, yScale, style, curveFactory, gaps, gapConnectorOpacity, sessionBreakInstants),
         },
         axisId: axis,
         index,
@@ -80,6 +94,7 @@ export function LineChart({ series, column, as: semantic, axis, curve, gaps = DE
         curveFactory,
         gaps,
         gapConnectorOpacity,
+        sessionBreakInstants,
         axis,
         index,
     ]);

package/dist/XAxis.js

@@ -7,6 +7,8 @@ import { resolveAxisFormat, resolveTimeFormat, } from './format.js';
 const TICK_STRIP = 22;
 /** Extra height reserved for an axis `label` line. */
 const LABEL_STRIP = 16;
+/** Extra height reserved for the boundary (second) label row. */
+const BOUNDARY_STRIP = 15;
 /**
  * Thin + truncate a **category** axis's labels so a dense axis stays legible: keep
  * every `stride`-th label (so a kept label has room), and ellipsize one that still
@@ -126,11 +128,25 @@ export function XAxis({ format, label, side = 'bottom', height, ticks: customTic
         markerLanes.set(t.id, lane);
     }
     const maxPillLane = Math.max(0, pillLaneEnds.length - 1);
+    // The boundary (second) label row — the coarser calendar unit the first-row
+    // label omits (the year under day / week / month ticks, the date under
+    // clock ticks), placed under the first tick of each new
+    // period. Only a ladder-driven time scale supplies it; explicit `ticks`, an
+    // explicit axis `format`, and a container-level `timeFormat` all opt out (a
+    // custom format owns the whole label, and custom ticks have no grain).
+    const boundaryOf = xKind === 'time' &&
+        customTicks === undefined &&
+        format === undefined &&
+        !container.xFormatCustom &&
+        'tickBoundaries' in xScale
+        ? xScale.tickBoundaries(xTickCount)
+        : undefined;
     const rawTicks = customTicks
         ? customTicks.map((t) => ({ x: xScale(t.at), label: t.label }))
         : xScale.ticks(xTickCount).map((d) => ({
             x: xScale(d),
             label: fmt(+d),
+            boundary: boundaryOf?.(+d),
         }));
     // A category axis ticks once per category; thin + truncate its labels when they
     // crowd (an explicit `customTicks` axis keeps its labels verbatim).
@@ -143,7 +159,10 @@ export function XAxis({ format, label, side = 'bottom', height, ticks: customTic
     const pillOffset = align === 'right' ? 2 : 6;
     // Per-lane vertical step for stacked pills; grow the strip to fit the stack.
     const PILL_LANE_H = theme.font.size + 6;
+    // Any boundary label in view grows the strip by one row (like pill lanes do).
+    const hasBoundary = placed.some((t) => t.boundary !== undefined);
     const stripHeight = (height ?? TICK_STRIP + (label ? LABEL_STRIP : 0)) +
+        (hasBoundary ? BOUNDARY_STRIP : 0) +
         maxPillLane * PILL_LANE_H;
     return (_jsxs("div", { style: {
             position: 'relative',
@@ -185,7 +204,14 @@ export function XAxis({ format, label, side = 'bottom', height, ticks: customTic
                                 [onTop ? 'bottom' : 'top']: `${labelOffset}px`,
                                 transform: labelTransform,
                                 whiteSpace: 'nowrap',
-                            }, children: t.label })] }, `${t.x}-${i}`));
+                            }, children: t.label }), t.boundary !== undefined && (_jsx("div", { "data-boundary-label": true, style: {
+                                position: 'absolute',
+                                left: `${labelLeft}px`,
+                                [onTop ? 'bottom' : 'top']: `${labelOffset + theme.font.size + 3}px`,
+                                transform: labelTransform,
+                                whiteSpace: 'nowrap',
+                                opacity: 0.75,
+                            }, children: t.boundary }))] }, `${t.x}-${i}`));
             }), label !== undefined && (_jsx("div", { style: {
                     position: 'absolute',
                     left: 0,

package/dist/context.d.ts

@@ -151,6 +151,10 @@ export interface ContainerFrame {
     /** Format an epoch-ms instant the same way the time axis labels its ticks —
      *  shared by `<TimeAxis>` and the cursor-time readout. */
     readonly formatTime: (epochMs: number) => string;
+    /** Whether an explicit container `timeFormat` shaped {@link formatTime}. The
+     *  x axis suppresses its boundary (second) label row when it's set — a
+     *  custom format owns the whole label, so the ladder mustn't second-line it. */
+    readonly xFormatCustom: boolean;
     /**
      * The shared **x-side tick count** — the `count` every x-side `ticks()` /
      * `tickFormat()` call passes (`<XAxis>` labels, the canvas x gridlines and

package/dist/line.d.ts

@@ -41,6 +41,30 @@ export declare function yExtent(cs: ChartSeries): [number, number] | null;
  * The generator writes path ops to `ctx`; we bracket with `beginPath`/`stroke`.
  * `cs.y` (a `Float64Array`) is the datum iterable — `y` reads the value, `x`
  * reads `cs.x[i]` by index, so there's no per-point object allocation.
+ *
+ * **`boundaries`** (default none) are discontinuity instants — a trading-axis
+ * session/day/lunch close→open where the line should *break* even though a data
+ * point sits on each side (see {@link sessionRuns}). Each run between boundaries
+ * draws as its own subpath, so the line ends at the last pre-boundary point and
+ * re-starts at the first post-boundary one — a **scale** break, orthogonal to
+ * the NaN **data** gaps (`gaps`) handled within each run. With no boundaries the
+ * output is identical to a single-pass draw.
+ */
+export declare function drawLine(ctx: CanvasRenderingContext2D, cs: ChartSeries, xScale: Scale, yScale: Scale, style: LineStyle, curve?: CurveFactory, gaps?: GapMode, gapConnectorOpacity?: number, boundaries?: readonly number[]): void;
+/**
+ * Split a sorted columnar x-axis into contiguous index runs `[start, endEx)`,
+ * cutting wherever a `boundaries` instant falls in `(x[i-1], x[i]]` — i.e. a
+ * discontinuity (a trading session / day / lunch close→open) sits between two
+ * consecutive points. A point that lands exactly on a boundary starts the new
+ * run (the open). No boundary inside the data (or an empty list) ⇒ a single run
+ * over the whole series. This is what turns `<LineChart sessionBreaks>` into a
+ * per-session polyline. Pure + O(N).
+ *
+ * The sweep relies on **ascending** boundaries; the `DiscontinuityProvider`
+ * contract doesn't guarantee order, so an unsorted list is sorted defensively
+ * (a copy, so the caller's array isn't mutated) rather than silently dropping a
+ * break. The list is tiny — one entry per session boundary — so the sort is
+ * negligible next to the row sweep.
  */
-export declare function drawLine(ctx: CanvasRenderingContext2D, cs: ChartSeries, xScale: Scale, yScale: Scale, style: LineStyle, curve?: CurveFactory, gaps?: GapMode, gapConnectorOpacity?: number): void;
+export declare function sessionRuns(x: Float64Array, length: number, boundaries: readonly number[]): Array<[number, number]>;
 //# sourceMappingURL=line.d.ts.map

package/dist/line.js

@@ -53,20 +53,39 @@ export function yExtent(cs) {
  * The generator writes path ops to `ctx`; we bracket with `beginPath`/`stroke`.
  * `cs.y` (a `Float64Array`) is the datum iterable — `y` reads the value, `x`
  * reads `cs.x[i]` by index, so there's no per-point object allocation.
+ *
+ * **`boundaries`** (default none) are discontinuity instants — a trading-axis
+ * session/day/lunch close→open where the line should *break* even though a data
+ * point sits on each side (see {@link sessionRuns}). Each run between boundaries
+ * draws as its own subpath, so the line ends at the last pre-boundary point and
+ * re-starts at the first post-boundary one — a **scale** break, orthogonal to
+ * the NaN **data** gaps (`gaps`) handled within each run. With no boundaries the
+ * output is identical to a single-pass draw.
  */
-export function drawLine(ctx, cs, xScale, yScale, style, curve = curveLinear, gaps = DEFAULT_GAP_MODE, gapConnectorOpacity = DEFAULT_GAP_CONNECTOR_OPACITY) {
-    // `none` interpolates interior gaps so the line bridges them; every other mode
-    // keeps NaN so d3 breaks the solid path (the inferred bridge, if any, is a
-    // separate overlay pass below).
-    const ys = gaps === 'none' ? bridgeGaps(cs.y, cs.length) : cs.y;
-    const gen = d3line()
-        .defined((v) => Number.isFinite(v))
-        .x((_, i) => xScale(cs.x[i]))
-        .y((v) => yScale(v))
-        .curve(curve)
-        .context(ctx);
+export function drawLine(ctx, cs, xScale, yScale, style, curve = curveLinear, gaps = DEFAULT_GAP_MODE, gapConnectorOpacity = DEFAULT_GAP_CONNECTOR_OPACITY, boundaries = []) {
+    // Split into independent index runs at each boundary; no boundary inside the
+    // data ⇒ one run over the whole series (the hot path — no slicing, so the draw
+    // is byte-identical to the pre-boundary single pass).
+    const runs = sessionRuns(cs.x, cs.length, boundaries);
+    const singleRun = runs.length === 1;
+    // Solid pass: one path across every run. Each run's generator opens with its
+    // own moveTo, so a run boundary is a clean pen-up — the session break.
     ctx.beginPath();
-    gen(ys);
+    for (const [s, e] of runs) {
+        // `none` interpolates interior gaps so the line bridges them — but only
+        // *within* a run (a session break is not a dropout to interpolate over);
+        // every other mode keeps NaN so d3 breaks the solid path (the inferred
+        // bridge, if any, is a separate overlay pass below).
+        const seg = singleRun ? cs.y : cs.y.subarray(s, e);
+        const ys = gaps === 'none' ? bridgeGaps(seg, e - s) : seg;
+        const gen = d3line()
+            .defined((v) => Number.isFinite(v))
+            .x((_, j) => xScale(cs.x[s + j]))
+            .y((v) => yScale(v))
+            .curve(curve)
+            .context(ctx);
+        gen(ys);
+    }
     ctx.strokeStyle = style.color;
     ctx.lineWidth = style.width;
     // Per-series dash (a modeled/forecast line reads dashed). Applied only when
@@ -84,8 +103,15 @@ export function drawLine(ctx, cs, xScale, yScale, style, curve = curveLinear, ga
     }
     // Overlay bridges for the inferred-gap modes. `dashed` / `step` are faint
     // dashed connectors (gapConnectorOpacity); only `fade` drops to the axis floor.
+    // Collect edges **per run** so an inferred bridge never spans a session break
+    // (the break wins — no dashed/step/fade connector across a collapsed gap).
     if (gaps === 'dashed' || gaps === 'step' || gaps === 'fade') {
-        const edges = collectGapEdges(cs.length, cs.x, (i) => cs.y[i], xScale, (i) => yScale(cs.y[i]));
+        const edges = [];
+        for (const [s, e] of runs) {
+            const runEdges = collectGapEdges(e - s, singleRun ? cs.x : cs.x.subarray(s, e), (i) => cs.y[s + i], xScale, (i) => yScale(cs.y[s + i]));
+            for (const ed of runEdges)
+                edges.push(ed);
+        }
         if (gaps === 'dashed') {
             drawGapBridges(ctx, edges, style.color, style.width, gapConnectorOpacity);
         }
@@ -97,4 +123,43 @@ export function drawLine(ctx, cs, xScale, yScale, style, curve = curveLinear, ga
         }
     }
 }
+/**
+ * Split a sorted columnar x-axis into contiguous index runs `[start, endEx)`,
+ * cutting wherever a `boundaries` instant falls in `(x[i-1], x[i]]` — i.e. a
+ * discontinuity (a trading session / day / lunch close→open) sits between two
+ * consecutive points. A point that lands exactly on a boundary starts the new
+ * run (the open). No boundary inside the data (or an empty list) ⇒ a single run
+ * over the whole series. This is what turns `<LineChart sessionBreaks>` into a
+ * per-session polyline. Pure + O(N).
+ *
+ * The sweep relies on **ascending** boundaries; the `DiscontinuityProvider`
+ * contract doesn't guarantee order, so an unsorted list is sorted defensively
+ * (a copy, so the caller's array isn't mutated) rather than silently dropping a
+ * break. The list is tiny — one entry per session boundary — so the sort is
+ * negligible next to the row sweep.
+ */
+export function sessionRuns(x, length, boundaries) {
+    if (boundaries.length === 0 || length === 0)
+        return [[0, length]];
+    const bounds = boundaries.length > 1 ? [...boundaries].sort((a, b) => a - b) : boundaries;
+    const runs = [];
+    let start = 0;
+    let bi = 0;
+    for (let i = 1; i < length; i += 1) {
+        const prev = x[i - 1];
+        const cur = x[i];
+        // Skip boundaries at or before the previous point (already behind the pen).
+        while (bi < bounds.length && bounds[bi] <= prev)
+            bi += 1;
+        if (bi < bounds.length && bounds[bi] <= cur) {
+            // A boundary sits in (prev, cur] → break the run before point i.
+            runs.push([start, i]);
+            start = i;
+            while (bi < bounds.length && bounds[bi] <= cur)
+                bi += 1;
+        }
+    }
+    runs.push([start, length]);
+    return runs;
+}
 //# sourceMappingURL=line.js.map

package/dist/tickLadder.d.ts

@@ -0,0 +1,89 @@
+import type { DiscontinuityProvider } from './tradingTimeScale.js';
+/**
+ * The logical tick ladder — grain selection for a time axis. Ticks sit on real
+ * calendar/clock units (1s…30s, 1m…30m, 1H…12H, day / week / month / quarter /
+ * year — the trading-terminal convention), never on even pixel spacing: the
+ * axis walks the ladder finest→coarsest and picks the first grain whose anchor
+ * count fits the width-derived cap. The same ladder serves a **disjoint
+ * trading-calendar** axis (session opens are the day anchors, hour anchors are
+ * generated in live time so they never land in a collapsed gap) and a **plain
+ * continuous** axis (an identity provider whose "sessions" are calendar days).
+ *
+ * Each grain also knows its **boundary grain** — the next-coarser unit its own
+ * label doesn't carry (hours → the date, days/weeks → the month, months →
+ * the year). The axis renders that as a second label row, once per boundary
+ * crossing, so a month row reads `Dec Jan Feb …` with `2026` appearing exactly
+ * where the year turns.
+ */
+/** The calendar grain a run of tick anchors is bucketed to. */
+export type TickGranularity = 'second1' | 'second5' | 'second15' | 'second30' | 'minute1' | 'minute5' | 'minute15' | 'minute30' | 'hour1' | 'hour3' | 'hour6' | 'hour12' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+/**
+ * The local-time bucket key for `t` at grain `g` — two instants in the same
+ * day / week / month / quarter / year share a key. Local time (not UTC) so it
+ * agrees with the local `scaleTime` label formatter; the exchange's own time
+ * zone is unknown to the scale (the deferred refinement), and a session open
+ * sits well inside its local day, so runtime-local grouping matches the
+ * exchange day in every ordinary case. Hour grains are never bucketed (each
+ * anchor is its own tick), so they key by identity.
+ */
+export declare function bucketKey(t: number, g: TickGranularity): number;
+/**
+ * Thin an ascending run of **session opens** down to about `count` axis ticks by
+ * **calendar grain** — the trading-terminal habit of labelling week / month /
+ * year starts rather than an arbitrary every-nth session. Picks the finest grain
+ * on the ladder (day → week → month → quarter → year) that yields at most
+ * `count` buckets and returns the first open in each; beyond yearly it decimates
+ * every-nth so the axis never crowds. Exported so the container can draw session
+ * dividers at the same instants the axis labels.
+ *
+ * `count` is a **cap**, not a target: grains jump by 4–12× up the ladder, so a
+ * small fixed count over-coarsens long spans (a mid-year-anchored 12-month daily
+ * run spans 6 quarter buckets — capped at 5 it collapses to year grain, 2
+ * ticks). Callers size the cap to the room the labels have — the container
+ * derives it from plot width — rather than passing a small constant.
+ *
+ * This is the day-and-coarser half of the ladder; {@link buildTicks} adds the
+ * sub-day rungs.
+ */
+export declare function coarsenCalendar(opens: readonly number[], count: number): {
+    ticks: number[];
+    granularity: TickGranularity;
+};
+/**
+ * The full-ladder grain selection: given the provider, the domain, and the
+ * width-derived `cap`, walk the clock rungs (1s … 30s, 1m … 30m, 1h … 12h)
+ * then day → week → month → quarter → year (then decimate) and return the
+ * first rung that fits.
+ * `opens` are the session-open anchors (`[domain start, ...boundaries]`) the
+ * caller already has. Sub-day rungs are only reachable when the opens
+ * themselves fit — a year of daily sessions never wastes time generating hour
+ * anchors.
+ */
+export declare function buildTicks(provider: DiscontinuityProvider, opens: readonly number[], domainEnd: number, cap: number): {
+    ticks: number[];
+    granularity: TickGranularity;
+};
+/**
+ * The **boundary grain** for ticks at grain `g` — the next-coarser unit a
+ * tick's own label doesn't already carry, rendered as the axis's second label
+ * row. Clock labels (`14:00`) need the date; day/week labels (`Feb 02`)
+ * already carry the month, so they need only the year — as do month/quarter
+ * labels (`Feb`); a year label already says everything.
+ */
+export declare function boundaryGrainFor(g: TickGranularity): TickGranularity | undefined;
+/** d3 time-format specifier for the **major** (first-row) label at grain `g`. */
+export declare function majorFormatFor(g: TickGranularity): string;
+/** d3 time-format specifier for the **boundary** (second-row) label at the
+ *  boundary grain `g` — a date under clock ticks, the bare year under
+ *  everything else. Never repeat a unit the first row already shows
+ *  (`Jan 2026` under a `Jan 05` tick reads as noise). */
+export declare function boundaryFormatFor(g: TickGranularity): string;
+/**
+ * Which of `ticks` (at grain `granularity`) carry a boundary label: the first
+ * tick always (the reader needs context immediately), then every tick whose
+ * boundary-grain bucket differs from the previous tick's — i.e. the first tick
+ * of each new day / year. Returns the boundary-flagged tick values;
+ * empty when the grain has no boundary row (year grain).
+ */
+export declare function boundaryTicks(ticks: readonly number[], granularity: TickGranularity): number[];
+//# sourceMappingURL=tickLadder.d.ts.map

package/dist/tickLadder.js

@@ -0,0 +1,265 @@
+const SEC_MS = 1_000;
+const MIN_MS = 60_000;
+const HOUR_MS = 3_600_000;
+/** The sub-day rungs, finest first, with their clock step — the 1/5/15/30
+ *  second and minute steps terminals use, then the hour steps. */
+const SUB_DAY_GRAINS = [
+    { g: 'second1', step: 1 * SEC_MS },
+    { g: 'second5', step: 5 * SEC_MS },
+    { g: 'second15', step: 15 * SEC_MS },
+    { g: 'second30', step: 30 * SEC_MS },
+    { g: 'minute1', step: 1 * MIN_MS },
+    { g: 'minute5', step: 5 * MIN_MS },
+    { g: 'minute15', step: 15 * MIN_MS },
+    { g: 'minute30', step: 30 * MIN_MS },
+    { g: 'hour1', step: 1 * HOUR_MS },
+    { g: 'hour3', step: 3 * HOUR_MS },
+    { g: 'hour6', step: 6 * HOUR_MS },
+    { g: 'hour12', step: 12 * HOUR_MS },
+];
+/** Whether `g` is one of the sub-day (clock-step) rungs. */
+function isSubDay(g) {
+    return g !== 'day' && SUB_DAY_GRAINS.some((r) => r.g === g);
+}
+/**
+ * The local-time bucket key for `t` at grain `g` — two instants in the same
+ * day / week / month / quarter / year share a key. Local time (not UTC) so it
+ * agrees with the local `scaleTime` label formatter; the exchange's own time
+ * zone is unknown to the scale (the deferred refinement), and a session open
+ * sits well inside its local day, so runtime-local grouping matches the
+ * exchange day in every ordinary case. Hour grains are never bucketed (each
+ * anchor is its own tick), so they key by identity.
+ */
+export function bucketKey(t, g) {
+    if (isSubDay(g))
+        return t;
+    const d = new Date(t);
+    switch (g) {
+        case 'day':
+            return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+        case 'week': {
+            const dow = (d.getDay() + 6) % 7; // 0 = Monday
+            // Local midnight of this week's Monday (Date normalizes a negative date).
+            return new Date(d.getFullYear(), d.getMonth(), d.getDate() - dow).getTime();
+        }
+        case 'month':
+            return d.getFullYear() * 12 + d.getMonth();
+        case 'quarter':
+            return d.getFullYear() * 4 + Math.floor(d.getMonth() / 3);
+        case 'year':
+            return d.getFullYear();
+        default:
+            return t;
+    }
+}
+/** The first instant of each distinct `g`-bucket in the ascending list `opens`. */
+function firstOfEachBucket(opens, g) {
+    const out = [];
+    let prev;
+    for (const t of opens) {
+        const k = bucketKey(t, g);
+        if (k !== prev) {
+            out.push(t);
+            prev = k;
+        }
+    }
+    return out;
+}
+const COARSENING_LADDER = [
+    'week',
+    'month',
+    'quarter',
+    'year',
+];
+/**
+ * Thin an ascending run of **session opens** down to about `count` axis ticks by
+ * **calendar grain** — the trading-terminal habit of labelling week / month /
+ * year starts rather than an arbitrary every-nth session. Picks the finest grain
+ * on the ladder (day → week → month → quarter → year) that yields at most
+ * `count` buckets and returns the first open in each; beyond yearly it decimates
+ * every-nth so the axis never crowds. Exported so the container can draw session
+ * dividers at the same instants the axis labels.
+ *
+ * `count` is a **cap**, not a target: grains jump by 4–12× up the ladder, so a
+ * small fixed count over-coarsens long spans (a mid-year-anchored 12-month daily
+ * run spans 6 quarter buckets — capped at 5 it collapses to year grain, 2
+ * ticks). Callers size the cap to the room the labels have — the container
+ * derives it from plot width — rather than passing a small constant.
+ *
+ * This is the day-and-coarser half of the ladder; {@link buildTicks} adds the
+ * sub-day rungs.
+ */
+export function coarsenCalendar(opens, count) {
+    if (opens.length <= count)
+        return { ticks: [...opens], granularity: 'day' };
+    for (const g of COARSENING_LADDER) {
+        const ticks = firstOfEachBucket(opens, g);
+        if (ticks.length <= count)
+            return { ticks, granularity: g };
+    }
+    // Coarser than yearly isn't a calendar grain — decimate the year starts.
+    const yearly = firstOfEachBucket(opens, 'year');
+    const step = Math.ceil(yearly.length / count);
+    return {
+        ticks: yearly.filter((_, i) => i % step === 0),
+        granularity: 'year',
+    };
+}
+/** The first clock-aligned `stepMs` multiple at or after `t`, relative to `t`'s
+ *  own local midnight — so a 3-hour step lands on 00:00 / 03:00 / 06:00 local,
+ *  whatever the session open was. Fixed-ms stepping from midnight, so on a DST
+ *  transition day the later anchors drift off the wall-clock grid by the shift
+ *  (labels stay truthful — they format the real instant); exchange-tz grain is
+ *  the already-deferred refinement. */
+function nextAligned(t, stepMs) {
+    const d = new Date(t);
+    const midnight = new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+    return midnight + Math.ceil((t - midnight) / stepMs) * stepMs;
+}
+/**
+ * The sub-day anchors at `stepMs`: each session open, plus each clock-aligned
+ * step instant strictly inside that session's **live** span. (The caller may
+ * still drop the very first anchor as a cramped lead — see {@link buildTicks}.) An instant is
+ * in-session iff live distance-then-offset round-trips it — so a lunch-break
+ * gap, an early close, or a collapsed overnight never gets an anchor, and no
+ * new provider surface is needed. Bails once `cap` is exceeded (the caller
+ * only needs to know the grain doesn't fit).
+ */
+function stepAnchors(provider, opens, domainEnd, stepMs, cap) {
+    const out = [];
+    for (let i = 0; i < opens.length; i++) {
+        const open = opens[i];
+        const end = i + 1 < opens.length ? opens[i + 1] : domainEnd;
+        out.push(open);
+        for (let t = nextAligned(open + 1, stepMs); t < end; t += stepMs) {
+            if (provider.offset(open, provider.distance(open, t)) === t) {
+                out.push(t);
+                if (out.length > cap)
+                    return out;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * The full-ladder grain selection: given the provider, the domain, and the
+ * width-derived `cap`, walk the clock rungs (1s … 30s, 1m … 30m, 1h … 12h)
+ * then day → week → month → quarter → year (then decimate) and return the
+ * first rung that fits.
+ * `opens` are the session-open anchors (`[domain start, ...boundaries]`) the
+ * caller already has. Sub-day rungs are only reachable when the opens
+ * themselves fit — a year of daily sessions never wastes time generating hour
+ * anchors.
+ */
+export function buildTicks(provider, opens, domainEnd, cap) {
+    const result = (() => {
+        if (opens.length <= cap) {
+            for (const { g, step } of SUB_DAY_GRAINS) {
+                const ticks = stepAnchors(provider, opens, domainEnd, step, cap);
+                // A clock rung must earn its labels: if it adds no intraday anchor
+                // beyond the opens themselves, it's really day grain (a row of
+                // "09:30"s under every session is a worse day axis, not a clock axis).
+                if (ticks.length <= cap && ticks.length > opens.length)
+                    return { ticks, granularity: g };
+            }
+            return { ticks: [...opens], granularity: 'day' };
+        }
+        return coarsenCalendar(opens, cap);
+    })();
+    // Round anchors to integer milliseconds: a pan/zoom domain comes from
+    // `scale.invert(pixel)` and is fractional, and a fractional anchor breaks
+    // the label pipeline — formatters pass through `new Date(ms)`, which
+    // truncates, so the instant no longer matches its own anchor set and the
+    // label falls through to the d3 multi-scale default (a bare `.259`
+    // millisecond tick). Sub-ms precision is invisible at any ladder grain.
+    result.ticks = result.ticks.map((t) => Math.round(t));
+    // Drop a cramped **leading partial-period** anchor: the first tick is the
+    // domain start, which usually sits mid-period (a "1Y back from today" view
+    // starts mid-month), so it can land arbitrarily close to the first full
+    // period start and the two labels collide (the classic "Jun 23Jul 07"
+    // pile-up). When the lead gap is under half a typical period (in **live**
+    // time, so a collapsed weekend doesn't fake a gap), the partial anchor
+    // isn't earning its label — the boundary row moves to the next tick.
+    const t = result.ticks;
+    if (t.length >= 3 &&
+        provider.distance(t[0], t[1]) < 0.5 * provider.distance(t[1], t[2])) {
+        t.shift();
+    }
+    return result;
+}
+/**
+ * The **boundary grain** for ticks at grain `g` — the next-coarser unit a
+ * tick's own label doesn't already carry, rendered as the axis's second label
+ * row. Clock labels (`14:00`) need the date; day/week labels (`Feb 02`)
+ * already carry the month, so they need only the year — as do month/quarter
+ * labels (`Feb`); a year label already says everything.
+ */
+export function boundaryGrainFor(g) {
+    if (isSubDay(g))
+        return 'day';
+    switch (g) {
+        case 'day':
+        case 'week':
+        case 'month':
+        case 'quarter':
+            return 'year';
+        default:
+            return undefined;
+    }
+}
+/** d3 time-format specifier for the **major** (first-row) label at grain `g`. */
+export function majorFormatFor(g) {
+    switch (g) {
+        case 'second1':
+        case 'second5':
+        case 'second15':
+        case 'second30':
+            return '%H:%M:%S';
+        case 'minute1':
+        case 'minute5':
+        case 'minute15':
+        case 'minute30':
+        case 'hour1':
+        case 'hour3':
+        case 'hour6':
+        case 'hour12':
+            return '%H:%M';
+        case 'day':
+        case 'week':
+            return '%b %d';
+        case 'month':
+        case 'quarter':
+            return '%b';
+        case 'year':
+            return '%Y';
+    }
+}
+/** d3 time-format specifier for the **boundary** (second-row) label at the
+ *  boundary grain `g` — a date under clock ticks, the bare year under
+ *  everything else. Never repeat a unit the first row already shows
+ *  (`Jan 2026` under a `Jan 05` tick reads as noise). */
+export function boundaryFormatFor(g) {
+    return g === 'day' ? '%b %d' : '%Y';
+}
+/**
+ * Which of `ticks` (at grain `granularity`) carry a boundary label: the first
+ * tick always (the reader needs context immediately), then every tick whose
+ * boundary-grain bucket differs from the previous tick's — i.e. the first tick
+ * of each new day / year. Returns the boundary-flagged tick values;
+ * empty when the grain has no boundary row (year grain).
+ */
+export function boundaryTicks(ticks, granularity) {
+    const bg = boundaryGrainFor(granularity);
+    if (bg === undefined)
+        return [];
+    const out = [];
+    let prev;
+    for (const t of ticks) {
+        const k = bucketKey(t, bg);
+        if (prev === undefined || k !== prev)
+            out.push(t);
+        prev = k;
+    }
+    return out;
+}
+//# sourceMappingURL=tickLadder.js.map

package/dist/tradingTimeScale.d.ts

@@ -47,12 +47,16 @@ export interface TradingCalendarLike {
  * wherever the container's `xScale` goes.
  *
  * Ticks are **calendar-aware** when the provider enumerates its gaps: `.ticks`
- * returns the session opens thinned to a calendar grain (week / month / year
- * starts, whichever fits ~`count`), and `.tickFormat` labels each anchor with a
- * **date** (`%b %d`) — or the **year** (`%Y`) when ticks are a year apart —
- * while formatting any other instant (a mid-session tick, the cursor readout)
- * with the d3 multi-scale default. Without a provider `boundaries` method it
- * falls back to interior even-spaced time ticks.
+ * walks the logical ladder (hour1 → hour3 → hour6 → hour12 → day → week →
+ * month → quarter → year) and returns the finest rung that fits `count`, and
+ * `.tickFormat` labels each anchor at that grain (`%H:%M` for hours, `%b %d`
+ * for days/weeks, `%b` for months/quarters, `%Y` for years) while formatting
+ * any other instant (the cursor readout) with the d3 multi-scale default. The
+ * coarser context a label drops lives on `.tickBoundaries` — the second-row
+ * boundary labels (the date over a clock axis, the year over a day / week /
+ * month axis), one per boundary crossing plus the first tick.
+ * Without a provider `boundaries` method it falls back to interior even-spaced
+ * time ticks.
  *
  * **Out-of-domain behavior.** Within the calendar the scale extrapolates like a
  * normal scale — a live instant *before* the domain start maps to a negative
@@ -67,37 +71,36 @@ export interface TradingTimeScale {
     invert(pixel: number): number;
     ticks(count?: number): number[];
     tickFormat(count?: number, specifier?: string): (date: Date) => string;
+    /**
+     * The **second-row** (boundary) label for a tick value, or `undefined` for
+     * ticks that don't open a new boundary period. Same grain selection as
+     * {@link ticks} at the same `count`, so the rows agree: the first tick and
+     * each tick starting a new day / year (whichever is the next-coarser
+     * unit the first-row label omits) carry the label; year-grain ticks have no
+     * second row.
+     */
+    tickBoundaries(count?: number): (value: number) => string | undefined;
     domain(): [number, number];
     domain(next: readonly [number, number]): TradingTimeScale;
     range(): [number, number];
     range(next: readonly [number, number]): TradingTimeScale;
     copy(): TradingTimeScale;
 }
-/** The calendar grain a run of session opens is bucketed to for axis ticks. */
-type TickGranularity = 'session' | 'week' | 'month' | 'quarter' | 'year';
+export { coarsenCalendar } from './tickLadder.js';
+export type { TickGranularity } from './tickLadder.js';
 /**
- * Thin an ascending run of **session opens** down to about `count` axis ticks by
- * **calendar grain** — the trading-terminal habit of labelling week / month /
- * year starts rather than an arbitrary every-nth session. Picks the finest grain
- * on the ladder (session → week → month → quarter → year) that yields at most
- * `count` buckets and returns the first open in each; beyond yearly it decimates
- * every-nth so the axis never crowds. Exported so the container can draw session
- * dividers at the same instants the axis labels.
- *
- * `count` is a **cap**, not a target: grains jump by 4–12× up the ladder, so a
- * small fixed count over-coarsens long spans (a mid-year-anchored 12-month daily
- * run spans 6 quarter buckets — capped at 5 it collapses to year grain, 2
- * ticks). Callers size the cap to the room the labels have — the container
- * derives it from plot width — rather than passing a small constant.
+ * The trivial gap-free {@link DiscontinuityProvider}: live time **is** wall
+ * time, and every local midnight is a "session open". Backing a plain
+ * continuous time axis with `scaleTradingTime(identityProvider())` runs it
+ * through the same logical tick ladder as a trading-calendar axis — calendar
+ * days are the day anchors, so a year of data ticks on month starts and an
+ * afternoon ticks on clock-aligned hours, instead of d3's mixed multi-scale
+ * default.
  */
-export declare function coarsenCalendar(opens: readonly number[], count: number): {
-    ticks: number[];
-    granularity: TickGranularity;
-};
+export declare function identityProvider(): DiscontinuityProvider;
 /**
  * Build a {@link TradingTimeScale} over the given discontinuity `provider`.
  * Configure like a d3 scale: `scaleTradingTime(provider).domain([t0, t1]).range([0, width])`.
  */
 export declare function scaleTradingTime(provider: DiscontinuityProvider): TradingTimeScale;
-export {};
 //# sourceMappingURL=tradingTimeScale.d.ts.map

package/dist/tradingTimeScale.js

@@ -1,79 +1,39 @@
 import { scaleTime } from 'd3-scale';
+import { boundaryFormatFor, boundaryGrainFor, boundaryTicks, buildTicks, majorFormatFor, } from './tickLadder.js';
+// Grain selection lives in `tickLadder.ts` (the full hour1…year ladder plus
+// the boundary-row helpers); re-exported here so existing imports keep working.
+export { coarsenCalendar } from './tickLadder.js';
 /**
- * The local-time bucket key for `t` at grain `g` — two instants in the same
- * week / month / quarter / year share a key. Local time (not UTC) so it agrees
- * with the local `scaleTime` label formatter; the exchange's own time zone is
- * unknown to the scale (the deferred refinement), and a session open sits well
- * inside its local day, so runtime-local grouping matches the exchange day in
- * every ordinary case.
+ * The trivial gap-free {@link DiscontinuityProvider}: live time **is** wall
+ * time, and every local midnight is a "session open". Backing a plain
+ * continuous time axis with `scaleTradingTime(identityProvider())` runs it
+ * through the same logical tick ladder as a trading-calendar axis — calendar
+ * days are the day anchors, so a year of data ticks on month starts and an
+ * afternoon ticks on clock-aligned hours, instead of d3's mixed multi-scale
+ * default.
  */
-function bucketKey(t, g) {
-    if (g === 'session')
-        return t; // every open its own bucket
-    const d = new Date(t);
-    switch (g) {
-        case 'week': {
-            const dow = (d.getDay() + 6) % 7; // 0 = Monday
-            // Local midnight of this week's Monday (Date normalizes a negative date).
-            return new Date(d.getFullYear(), d.getMonth(), d.getDate() - dow).getTime();
-        }
-        case 'month':
-            return d.getFullYear() * 12 + d.getMonth();
-        case 'quarter':
-            return d.getFullYear() * 4 + Math.floor(d.getMonth() / 3);
-        case 'year':
-            return d.getFullYear();
-    }
-}
-/** The first instant of each distinct `g`-bucket in the ascending list `opens`. */
-function firstOfEachBucket(opens, g) {
-    const out = [];
-    let prev;
-    for (const t of opens) {
-        const k = bucketKey(t, g);
-        if (k !== prev) {
-            out.push(t);
-            prev = k;
-        }
-    }
-    return out;
-}
-const COARSENING_LADDER = [
-    'week',
-    'month',
-    'quarter',
-    'year',
-];
-/**
- * Thin an ascending run of **session opens** down to about `count` axis ticks by
- * **calendar grain** — the trading-terminal habit of labelling week / month /
- * year starts rather than an arbitrary every-nth session. Picks the finest grain
- * on the ladder (session → week → month → quarter → year) that yields at most
- * `count` buckets and returns the first open in each; beyond yearly it decimates
- * every-nth so the axis never crowds. Exported so the container can draw session
- * dividers at the same instants the axis labels.
- *
- * `count` is a **cap**, not a target: grains jump by 4–12× up the ladder, so a
- * small fixed count over-coarsens long spans (a mid-year-anchored 12-month daily
- * run spans 6 quarter buckets — capped at 5 it collapses to year grain, 2
- * ticks). Callers size the cap to the room the labels have — the container
- * derives it from plot width — rather than passing a small constant.
- */
-export function coarsenCalendar(opens, count) {
-    if (opens.length <= count)
-        return { ticks: [...opens], granularity: 'session' };
-    for (const g of COARSENING_LADDER) {
-        const ticks = firstOfEachBucket(opens, g);
-        if (ticks.length <= count)
-            return { ticks, granularity: g };
-    }
-    // Coarser than yearly isn't a calendar grain — decimate the year starts.
-    const yearly = firstOfEachBucket(opens, 'year');
-    const step = Math.ceil(yearly.length / count);
-    return {
-        ticks: yearly.filter((_, i) => i % step === 0),
-        granularity: 'year',
+export function identityProvider() {
+    const self = {
+        clampUp: (t) => t,
+        clampDown: (t) => t,
+        distance: (from, to) => to - from,
+        offset: (v, amount) => v + amount,
+        copy: () => self,
+        boundaries: (from, to) => {
+            const out = [];
+            const d = new Date(from);
+            // First local midnight strictly after `from`; step by calendar day (not
+            // 24h) so DST transitions stay on midnight.
+            let cur = new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1);
+            while (cur.getTime() < to) {
+                if (cur.getTime() > from)
+                    out.push(cur.getTime());
+                cur = new Date(cur.getFullYear(), cur.getMonth(), cur.getDate() + 1);
+            }
+            return out;
+        },
     };
+    return self;
 }
 /**
  * Build a {@link TradingTimeScale} over the given discontinuity `provider`.
@@ -103,17 +63,35 @@ export function scaleTradingTime(provider) {
         const bounds = provider.boundaries?.(domain[0], domain[1]) ?? [];
         return [domain[0], ...bounds];
     };
+    /** Whether the provider has calendar structure to ladder on. Without a
+     *  `boundaries` method there are no anchors — the even-spacing fallback. */
+    const hasCalendar = () => provider.boundaries !== undefined;
+    /** The ladder result for this domain at `count` — the single source `ticks`,
+     *  `tickFormat`, and `tickBoundaries` all derive from, so the three agree.
+     *  Memoized on `(domain, count)`: the three callers (plus gridlines /
+     *  dividers) hit the same resolution per render, and on a wide continuous
+     *  domain re-walking every day-open is the expensive part. */
+    let laddered = null;
+    const resolved = (count) => {
+        const key = `${domain[0]}:${domain[1]}:${count}`;
+        if (laddered?.key !== key) {
+            laddered = {
+                key,
+                value: buildTicks(provider, sessionOpens(), domain[1], count),
+            };
+        }
+        return laddered.value;
+    };
     scale.ticks = (count = 10) => {
         const live = totalLive();
         if (live <= 0 || count < 1)
             return [domain[0]];
-        const opens = sessionOpens();
-        // Calendar-aware: label the session opens (each a new day), thinned to
-        // week / month / year starts by grain rather than an arbitrary every-nth
-        // session — the trading-terminal look.
-        if (opens.length > 1)
-            return coarsenCalendar(opens, count).ticks;
-        // No boundaries (a single session / no calendar): fall back to interior
+        // Calendar-aware: walk the logical ladder over the session-open anchors
+        // (hour steps inside sessions, then day / week / month / quarter / year
+        // starts) — the trading-terminal look, never an arbitrary every-nth.
+        if (hasCalendar())
+            return resolved(count).ticks;
+        // No boundaries (no calendar structure at all): fall back to interior
         // even-spaced ticks — endpoints excluded so none sits on the plot edge.
         const out = [];
         for (let i = 1; i < count; i++) {
@@ -124,20 +102,34 @@ export function scaleTradingTime(provider) {
     scale.tickFormat = (count = 10, specifier) => {
         if (specifier !== undefined)
             return base.tickFormat(count, specifier);
-        const opens = sessionOpens();
         const defFmt = base.tickFormat(count);
-        if (opens.length <= 1)
+        if (!hasCalendar())
             return defFmt; // no calendar → d3 multi-scale default
-        // Anchor label at each coarsened session-open tick: a **date** (`%b %d`), or
-        // the **year** when ticks are a year apart (a plain date would drop the year
-        // the reader needs). Any other instant — a cursor readout — uses the d3
-        // multi-scale default. Same grain as {@link ticks}, so labels and the
-        // dividers drawn at these instants agree.
-        const { ticks, granularity } = coarsenCalendar(opens, count);
+        // Anchor labels at the grain {@link ticks} chose — one uniform format per
+        // grain (hours as `%H:%M`, days/weeks as `%b %d`, months/quarters as `%b`,
+        // years as `%Y`); the coarser context the label omits is the second row
+        // ({@link tickBoundaries}). Any other instant — a cursor readout — uses
+        // the d3 multi-scale default. Same grain as {@link ticks}, so labels and
+        // the dividers drawn at these instants agree.
+        const { ticks, granularity } = resolved(count);
         const anchors = new Set(ticks);
-        const anchorFmt = base.tickFormat(count, granularity === 'year' ? '%Y' : '%b %d');
+        const anchorFmt = base.tickFormat(count, majorFormatFor(granularity));
         return (d) => (anchors.has(+d) ? anchorFmt(d) : defFmt(d));
     };
+    scale.tickBoundaries = (count = 10) => {
+        if (!hasCalendar())
+            return () => undefined;
+        const { ticks, granularity } = resolved(count);
+        const bg = boundaryGrainFor(granularity);
+        if (bg === undefined)
+            return () => undefined;
+        const fmt = base.tickFormat(count, boundaryFormatFor(bg));
+        const labelled = new Map();
+        for (const t of boundaryTicks(ticks, granularity)) {
+            labelled.set(t, fmt(new Date(t)));
+        }
+        return (value) => labelled.get(value);
+    };
     function domainFn(next) {
         if (next === undefined)
             return [domain[0], domain[1]];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pond-ts/charts",
-  "version": "0.44.1",
+  "version": "0.45.0",
   "private": false,
   "description": "Canvas-rendered, streaming-first time-series charts for pond-ts",
   "license": "MIT",
@@ -38,8 +38,8 @@
     "perf": "PERF_BENCH=1 playwright test perf.spec.ts --workers=1"
   },
   "peerDependencies": {
-    "@pond-ts/react": "^0.44.0",
-    "pond-ts": "^0.44.0",
+    "@pond-ts/react": "^0.45.0",
+    "pond-ts": "^0.45.0",
     "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {