@pond-ts/charts 0.44.0 → 0.45.0

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,31 +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.
+ * 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