@invinite-org/chartlang-adapter-kit 1.4.0 → 1.6.0

package/dist/geometry/shift.js

@@ -0,0 +1,141 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+import { timeToX } from "./project.js";
+// The bar-shift projection contract shared by every adapter. A
+// `PlotEmission.xShift` (signed integer bars; `+n` right / future, `−n`
+// left / past) displaces WHERE a series point draws, not its value. The
+// canvas2d reference adapter originated this math; it is promoted here so
+// the self-scaled (canvas2d, konva), category/index (echarts), and
+// aligned/native-time (uplot, lightweight-charts) adapters all resolve a
+// shifted point identically instead of hand-porting four divergent copies.
+/**
+ * Median adjacent-bar time delta of a run, used to extrapolate the time
+ * of a bar that lies past the data edge (a future `+k` shift) or before
+ * the first bar (a far-past `−k` shift). Returns `0` for a run of fewer
+ * than two bars — a degenerate, zero-spacing run that
+ * {@link shiftedBarTime} maps to the anchor bar's own time (no NaN).
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const s = medianBarSpacing([{ time: 0 }, { time: 10 }, { time: 30 }]);
+ *     // s === 15 (median of deltas [10, 20])
+ *     void s;
+ */
+export function medianBarSpacing(bars) {
+    if (bars.length < 2)
+        return 0;
+    const deltas = [];
+    for (let i = 1; i < bars.length; i++) {
+        deltas.push(bars[i].time - bars[i - 1].time);
+    }
+    deltas.sort((a, b) => a - b);
+    const mid = deltas.length >> 1;
+    return deltas.length % 2 === 1 ? deltas[mid] : (deltas[mid - 1] + deltas[mid]) / 2;
+}
+/**
+ * Resolve the world time a series point computed at bar index `bar`
+ * should render at when displaced by `xShift` bars. The target index
+ * `j = bar + xShift`:
+ *
+ * - in range (`0 ≤ j ≤ last`) ⇒ that bar's exact `time`;
+ * - past the last bar (`j > last`) ⇒ extrapolated from the last bar's
+ *   time and `spacing` (`+k` future projection);
+ * - before the first bar (`j < 0`) ⇒ extrapolated from the first bar's
+ *   time and `spacing` (far-past `−k` projection).
+ *
+ * `xShift` omitted / `0` with an in-range `bar` returns the bar's own
+ * time, so the drawn x is byte-identical to the pre-shift
+ * `timeToX(point.time)`. An empty bar run returns `0`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const bars = [{ time: 0 }, { time: 10 }, { time: 20 }];
+ *     const t = shiftedBarTime({ bars, bar: 1, xShift: -1, spacing: 10 });
+ *     // t === 0 (bar 1 shifted one left → bar 0's time)
+ *     void t;
+ */
+export function shiftedBarTime(args) {
+    const { bars, bar, spacing } = args;
+    const last = bars.length - 1;
+    if (last < 0)
+        return 0;
+    const j = bar + (args.xShift ?? 0);
+    if (j >= 0 && j <= last)
+        return bars[j].time;
+    if (j > last)
+        return bars[last].time + (j - last) * spacing;
+    return bars[0].time + j * spacing;
+}
+/**
+ * Map a series point's `bar` + `xShift` to an x pixel coordinate:
+ * {@link shiftedBarTime} resolves the displaced world time, then
+ * {@link timeToX} projects it into the viewport. The single projection
+ * funnel every shifted-series render path (line, step-line, histogram,
+ * shape / character / arrow glyphs) routes through so the bar-offset
+ * math is defined once. Pure on world inputs only — no `ctx`.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const bars = [{ time: 0 }, { time: 10 }, { time: 20 }];
+ *     const vp = { xMin: 0, xMax: 20, yMin: 0, yMax: 1, pxWidth: 200, pxHeight: 1 };
+ *     const x = projectShiftedX({ bars, bar: 0, xShift: 1, spacing: 10 }, vp);
+ *     // x === 100 (bar 0 shifted one right → bar 1's x)
+ *     void x;
+ */
+export function projectShiftedX(args, viewport) {
+    return timeToX(shiftedBarTime(args), viewport);
+}
+/**
+ * The largest world time any of `points` reaches once its POSITIVE
+ * `xShift` is applied, never below the `xMax` seed. A self-scaled adapter
+ * widens its pane's data `xMax` by this value so a `+k` future-projected
+ * point stays inside the viewport instead of being clipped past the data
+ * edge. Only `xShift > 0` targets extend the edge — a far-past (`−k`)
+ * point is canvas-clipped at negative x and never widens the window, and
+ * an omitted / `0` shift contributes nothing. Pass the pane's current
+ * `xMax` (e.g. the last bar's time) as the seed; an empty bar run leaves
+ * the seed unchanged.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const bars = [{ time: 0 }, { time: 10 }, { time: 20 }];
+ *     const pts = [{ bar: 2, xShift: 2 }, { bar: 0, xShift: -1 }];
+ *     const xMax = maxShiftedTime(pts, bars, 10, 20);
+ *     // xMax === 40 (bar 2 shifted +2 → time 40; the −1 point is ignored)
+ *     void xMax;
+ */
+export function maxShiftedTime(points, bars, spacing, xMax) {
+    let extended = xMax;
+    for (const point of points) {
+        const xShift = point.xShift;
+        if (xShift === undefined || xShift <= 0)
+            continue;
+        const t = shiftedBarTime({ bars, bar: point.bar, xShift, spacing });
+        if (t > extended)
+            extended = t;
+    }
+    return extended;
+}
+/**
+ * The (possibly out-of-range) category index a point computed at `bar`
+ * occupies when displaced by `xShift`: `bar + (xShift ?? 0)`. A
+ * category/index adapter (ECharts) writes the value at this column,
+ * extending its category axis by `max(0, index − lastIndex)` synthetic
+ * future slots and clipping a negative `index` (no negative category) —
+ * the index analogue of {@link shiftedBarTime}'s time extrapolation.
+ *
+ * @since 1.7
+ * @stable
+ * @example
+ *     const j = shiftedBarIndex(3, 5);
+ *     // j === 8
+ *     void j;
+ */
+export function shiftedBarIndex(bar, xShift) {
+    return bar + (xShift ?? 0);
+}
+//# sourceMappingURL=shift.js.map

package/dist/geometry/shift.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shift.js","sourceRoot":"","sources":["../../src/geometry/shift.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nimport { timeToX } from \"./project.js\";\nimport type { Viewport } from \"./types.js\";\n\n// The bar-shift projection contract shared by every adapter. A\n// `PlotEmission.xShift` (signed integer bars; `+n` right / future, `−n`\n// left / past) displaces WHERE a series point draws, not its value. The\n// canvas2d reference adapter originated this math; it is promoted here so\n// the self-scaled (canvas2d, konva), category/index (echarts), and\n// aligned/native-time (uplot, lightweight-charts) adapters all resolve a\n// shifted point identically instead of hand-porting four divergent copies.\n\n/**\n * Median adjacent-bar time delta of a run, used to extrapolate the time\n * of a bar that lies past the data edge (a future `+k` shift) or before\n * the first bar (a far-past `−k` shift). Returns `0` for a run of fewer\n * than two bars — a degenerate, zero-spacing run that\n * {@link shiftedBarTime} maps to the anchor bar's own time (no NaN).\n *\n * @since 1.7\n * @stable\n * @example\n *     const s = medianBarSpacing([{ time: 0 }, { time: 10 }, { time: 30 }]);\n *     // s === 15 (median of deltas [10, 20])\n *     void s;\n */\nexport function medianBarSpacing(bars: ReadonlyArray<{ readonly time: number }>): number {\n    if (bars.length < 2) return 0;\n    const deltas: number[] = [];\n    for (let i = 1; i < bars.length; i++) {\n        deltas.push(bars[i].time - bars[i - 1].time);\n    }\n    deltas.sort((a, b) => a - b);\n    const mid = deltas.length >> 1;\n    return deltas.length % 2 === 1 ? deltas[mid] : (deltas[mid - 1] + deltas[mid]) / 2;\n}\n\n/**\n * Resolve the world time a series point computed at bar index `bar`\n * should render at when displaced by `xShift` bars. The target index\n * `j = bar + xShift`:\n *\n * - in range (`0 ≤ j ≤ last`) ⇒ that bar's exact `time`;\n * - past the last bar (`j > last`) ⇒ extrapolated from the last bar's\n *   time and `spacing` (`+k` future projection);\n * - before the first bar (`j < 0`) ⇒ extrapolated from the first bar's\n *   time and `spacing` (far-past `−k` projection).\n *\n * `xShift` omitted / `0` with an in-range `bar` returns the bar's own\n * time, so the drawn x is byte-identical to the pre-shift\n * `timeToX(point.time)`. An empty bar run returns `0`.\n *\n * @since 1.7\n * @stable\n * @example\n *     const bars = [{ time: 0 }, { time: 10 }, { time: 20 }];\n *     const t = shiftedBarTime({ bars, bar: 1, xShift: -1, spacing: 10 });\n *     // t === 0 (bar 1 shifted one left → bar 0's time)\n *     void t;\n */\nexport function shiftedBarTime(args: {\n    readonly bars: ReadonlyArray<{ readonly time: number }>;\n    readonly bar: number;\n    readonly xShift: number | undefined;\n    readonly spacing: number;\n}): number {\n    const { bars, bar, spacing } = args;\n    const last = bars.length - 1;\n    if (last < 0) return 0;\n    const j = bar + (args.xShift ?? 0);\n    if (j >= 0 && j <= last) return bars[j].time;\n    if (j > last) return bars[last].time + (j - last) * spacing;\n    return bars[0].time + j * spacing;\n}\n\n/**\n * Map a series point's `bar` + `xShift` to an x pixel coordinate:\n * {@link shiftedBarTime} resolves the displaced world time, then\n * {@link timeToX} projects it into the viewport. The single projection\n * funnel every shifted-series render path (line, step-line, histogram,\n * shape / character / arrow glyphs) routes through so the bar-offset\n * math is defined once. Pure on world inputs only — no `ctx`.\n *\n * @since 1.7\n * @stable\n * @example\n *     const bars = [{ time: 0 }, { time: 10 }, { time: 20 }];\n *     const vp = { xMin: 0, xMax: 20, yMin: 0, yMax: 1, pxWidth: 200, pxHeight: 1 };\n *     const x = projectShiftedX({ bars, bar: 0, xShift: 1, spacing: 10 }, vp);\n *     // x === 100 (bar 0 shifted one right → bar 1's x)\n *     void x;\n */\nexport function projectShiftedX(\n    args: {\n        readonly bars: ReadonlyArray<{ readonly time: number }>;\n        readonly bar: number;\n        readonly xShift: number | undefined;\n        readonly spacing: number;\n    },\n    viewport: Viewport,\n): number {\n    return timeToX(shiftedBarTime(args), viewport);\n}\n\n/**\n * The largest world time any of `points` reaches once its POSITIVE\n * `xShift` is applied, never below the `xMax` seed. A self-scaled adapter\n * widens its pane's data `xMax` by this value so a `+k` future-projected\n * point stays inside the viewport instead of being clipped past the data\n * edge. Only `xShift > 0` targets extend the edge — a far-past (`−k`)\n * point is canvas-clipped at negative x and never widens the window, and\n * an omitted / `0` shift contributes nothing. Pass the pane's current\n * `xMax` (e.g. the last bar's time) as the seed; an empty bar run leaves\n * the seed unchanged.\n *\n * @since 1.7\n * @stable\n * @example\n *     const bars = [{ time: 0 }, { time: 10 }, { time: 20 }];\n *     const pts = [{ bar: 2, xShift: 2 }, { bar: 0, xShift: -1 }];\n *     const xMax = maxShiftedTime(pts, bars, 10, 20);\n *     // xMax === 40 (bar 2 shifted +2 → time 40; the −1 point is ignored)\n *     void xMax;\n */\nexport function maxShiftedTime(\n    points: ReadonlyArray<{ readonly bar: number; readonly xShift?: number }>,\n    bars: ReadonlyArray<{ readonly time: number }>,\n    spacing: number,\n    xMax: number,\n): number {\n    let extended = xMax;\n    for (const point of points) {\n        const xShift = point.xShift;\n        if (xShift === undefined || xShift <= 0) continue;\n        const t = shiftedBarTime({ bars, bar: point.bar, xShift, spacing });\n        if (t > extended) extended = t;\n    }\n    return extended;\n}\n\n/**\n * The (possibly out-of-range) category index a point computed at `bar`\n * occupies when displaced by `xShift`: `bar + (xShift ?? 0)`. A\n * category/index adapter (ECharts) writes the value at this column,\n * extending its category axis by `max(0, index − lastIndex)` synthetic\n * future slots and clipping a negative `index` (no negative category) —\n * the index analogue of {@link shiftedBarTime}'s time extrapolation.\n *\n * @since 1.7\n * @stable\n * @example\n *     const j = shiftedBarIndex(3, 5);\n *     // j === 8\n *     void j;\n */\nexport function shiftedBarIndex(bar: number, xShift: number | undefined): number {\n    return bar + (xShift ?? 0);\n}\n"]}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { KIND_BUCKET, bucketFor } from "@invinite-org/chartlang-core";
+export { KIND_BUCKET, bucketFor, feedKey } from "@invinite-org/chartlang-core";
 export type { DrawingBucket, DrawingState } from "@invinite-org/chartlang-core";
 export { defineAdapter } from "./defineAdapter.js";
 export type { DefineAdapterOpts } from "./defineAdapter.js";
@@ -9,6 +9,9 @@ export { mockCandleSource } from "./mocks/index.js";
 export type { MockCandleSourceMode, MockCandleSourceOpts } from "./mocks/index.js";
 export { BufferingAdapter, PassThroughAdapter } from "./base/index.js";
 export { decomposeDrawing, priceToY, timeToX, worldPointToPixel } from "./geometry/index.js";
-export type { DrawPrimitive, FillStyle, Point2, StrokeStyle, Viewport, } from "./geometry/index.js";
+export { maxShiftedTime, medianBarSpacing, projectShiftedX, RENDER_BAND, shiftedBarIndex, shiftedBarTime, sortByRenderOrder, } from "./geometry/index.js";
+export type { DrawPrimitive, FillStyle, Point2, RenderOrderKey, StrokeStyle, Viewport, } from "./geometry/index.js";
+export { attachInteraction, createViewController, onDblCore, onDragCore, onWheelCore, yRangeInWindow, } from "./interaction/index.js";
+export type { InteractionHandlers, ViewController, ViewControllerOpts, WindowYInput, XWindow, } from "./interaction/index.js";
 export type { Adapter, AdapterSymInfo, AlertChannel, AlertConditionEmission, AlertEmission, Capabilities, CandleEvent, DiagnosticCode, DrawingCounts, DrawingEmission, DrawingKind, InputKind, LogEmission, PlotEmission, PlotKind, PlotOverride, PlotSlotDescriptor, PlotStyle, RunnerEmissions, RuntimeDiagnostic, SymInfoField, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AACtE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACxE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC5F,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,YAAY,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7F,YAAY,EACR,aAAa,EACb,SAAS,EACT,MAAM,EACN,WAAW,EACX,QAAQ,GACX,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACR,OAAO,EACP,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,aAAa,EACb,YAAY,EACZ,WAAW,EACX,cAAc,EACd,aAAa,EACb,eAAe,EACf,WAAW,EACX,SAAS,EACT,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,kBAAkB,EAClB,SAAS,EACT,eAAe,EACf,iBAAiB,EACjB,YAAY,GACf,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAC/E,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACxE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC5F,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,YAAY,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACnF,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7F,OAAO,EACH,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,eAAe,EACf,cAAc,EACd,iBAAiB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACR,aAAa,EACb,SAAS,EACT,MAAM,EACN,cAAc,EACd,WAAW,EACX,QAAQ,GACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACH,iBAAiB,EACjB,oBAAoB,EACpB,SAAS,EACT,UAAU,EACV,WAAW,EACX,cAAc,GACjB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACR,mBAAmB,EACnB,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,OAAO,GACV,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACR,OAAO,EACP,cAAc,EACd,YAAY,EACZ,sBAAsB,EACtB,aAAa,EACb,YAAY,EACZ,WAAW,EACX,cAAc,EACd,aAAa,EACb,eAAe,EACf,WAAW,EACX,SAAS,EACT,WAAW,EACX,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,kBAAkB,EAClB,SAAS,EACT,eAAe,EACf,iBAAiB,EACjB,YAAY,GACf,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,10 +1,12 @@
 // Copyright (c) 2026 Invinite. Licensed under the MIT License.
 // See the LICENSE file in the repo root for full license text.
-export { KIND_BUCKET, bucketFor } from "@invinite-org/chartlang-core";
+export { KIND_BUCKET, bucketFor, feedKey } from "@invinite-org/chartlang-core";
 export { defineAdapter } from "./defineAdapter.js";
 export { PHASE_5_PLOT_KINDS, capabilities } from "./capabilities/index.js";
 export { decodeDrawing, validateEmission } from "./validation/index.js";
 export { mockCandleSource } from "./mocks/index.js";
 export { BufferingAdapter, PassThroughAdapter } from "./base/index.js";
 export { decomposeDrawing, priceToY, timeToX, worldPointToPixel } from "./geometry/index.js";
+export { maxShiftedTime, medianBarSpacing, projectShiftedX, RENDER_BAND, shiftedBarIndex, shiftedBarTime, sortByRenderOrder, } from "./geometry/index.js";
+export { attachInteraction, createViewController, onDblCore, onDragCore, onWheelCore, yRangeInWindow, } from "./interaction/index.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAE/D,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEtE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAExE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nexport { KIND_BUCKET, bucketFor } from \"@invinite-org/chartlang-core\";\nexport type { DrawingBucket, DrawingState } from \"@invinite-org/chartlang-core\";\nexport { defineAdapter } from \"./defineAdapter.js\";\nexport type { DefineAdapterOpts } from \"./defineAdapter.js\";\nexport { PHASE_5_PLOT_KINDS, capabilities } from \"./capabilities/index.js\";\nexport { decodeDrawing, validateEmission } from \"./validation/index.js\";\nexport type { ValidationFail, ValidationOk, ValidationResult } from \"./validation/index.js\";\nexport { mockCandleSource } from \"./mocks/index.js\";\nexport type { MockCandleSourceMode, MockCandleSourceOpts } from \"./mocks/index.js\";\nexport { BufferingAdapter, PassThroughAdapter } from \"./base/index.js\";\nexport { decomposeDrawing, priceToY, timeToX, worldPointToPixel } from \"./geometry/index.js\";\nexport type {\n    DrawPrimitive,\n    FillStyle,\n    Point2,\n    StrokeStyle,\n    Viewport,\n} from \"./geometry/index.js\";\nexport type {\n    Adapter,\n    AdapterSymInfo,\n    AlertChannel,\n    AlertConditionEmission,\n    AlertEmission,\n    Capabilities,\n    CandleEvent,\n    DiagnosticCode,\n    DrawingCounts,\n    DrawingEmission,\n    DrawingKind,\n    InputKind,\n    LogEmission,\n    PlotEmission,\n    PlotKind,\n    PlotOverride,\n    PlotSlotDescriptor,\n    PlotStyle,\n    RunnerEmissions,\n    RuntimeDiagnostic,\n    SymInfoField,\n} from \"./types.js\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAE/D,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAE/E,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAExE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7F,OAAO,EACH,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,eAAe,EACf,cAAc,EACd,iBAAiB,GACpB,MAAM,qBAAqB,CAAC;AAS7B,OAAO,EACH,iBAAiB,EACjB,oBAAoB,EACpB,SAAS,EACT,UAAU,EACV,WAAW,EACX,cAAc,GACjB,MAAM,wBAAwB,CAAC","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nexport { KIND_BUCKET, bucketFor, feedKey } from \"@invinite-org/chartlang-core\";\nexport type { DrawingBucket, DrawingState } from \"@invinite-org/chartlang-core\";\nexport { defineAdapter } from \"./defineAdapter.js\";\nexport type { DefineAdapterOpts } from \"./defineAdapter.js\";\nexport { PHASE_5_PLOT_KINDS, capabilities } from \"./capabilities/index.js\";\nexport { decodeDrawing, validateEmission } from \"./validation/index.js\";\nexport type { ValidationFail, ValidationOk, ValidationResult } from \"./validation/index.js\";\nexport { mockCandleSource } from \"./mocks/index.js\";\nexport type { MockCandleSourceMode, MockCandleSourceOpts } from \"./mocks/index.js\";\nexport { BufferingAdapter, PassThroughAdapter } from \"./base/index.js\";\nexport { decomposeDrawing, priceToY, timeToX, worldPointToPixel } from \"./geometry/index.js\";\nexport {\n    maxShiftedTime,\n    medianBarSpacing,\n    projectShiftedX,\n    RENDER_BAND,\n    shiftedBarIndex,\n    shiftedBarTime,\n    sortByRenderOrder,\n} from \"./geometry/index.js\";\nexport type {\n    DrawPrimitive,\n    FillStyle,\n    Point2,\n    RenderOrderKey,\n    StrokeStyle,\n    Viewport,\n} from \"./geometry/index.js\";\nexport {\n    attachInteraction,\n    createViewController,\n    onDblCore,\n    onDragCore,\n    onWheelCore,\n    yRangeInWindow,\n} from \"./interaction/index.js\";\nexport type {\n    InteractionHandlers,\n    ViewController,\n    ViewControllerOpts,\n    WindowYInput,\n    XWindow,\n} from \"./interaction/index.js\";\nexport type {\n    Adapter,\n    AdapterSymInfo,\n    AlertChannel,\n    AlertConditionEmission,\n    AlertEmission,\n    Capabilities,\n    CandleEvent,\n    DiagnosticCode,\n    DrawingCounts,\n    DrawingEmission,\n    DrawingKind,\n    InputKind,\n    LogEmission,\n    PlotEmission,\n    PlotKind,\n    PlotOverride,\n    PlotSlotDescriptor,\n    PlotStyle,\n    RunnerEmissions,\n    RuntimeDiagnostic,\n    SymInfoField,\n} from \"./types.js\";\n"]}

package/dist/interaction/domWiring.d.ts

@@ -0,0 +1,90 @@
+import type { ViewController } from "./viewController.js";
+/**
+ * The per-frame projection + data context {@link attachInteraction} needs
+ * to translate pixel gestures into world-x transforms. The adapter supplies
+ * these closing over its latest overlay `Viewport`, so the math always uses
+ * the current frame's scale.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     declare const view: import("./viewController.js").ViewController;
+ *     const h: InteractionHandlers = {
+ *         controller: view,
+ *         pxToWorldX: (px) => px,
+ *         worldXPerPx: () => 1,
+ *         dataBounds: () => ({ xMin: 0, xMax: 100 }),
+ *         requestRender: () => {},
+ *     };
+ *     void h;
+ */
+export type InteractionHandlers = {
+    /** The controller whose window the gestures mutate. */
+    readonly controller: ViewController;
+    /** Map a plot-area pixel x to a world x for the current frame. */
+    readonly pxToWorldX: (px: number) => number;
+    /** World-x units per pixel for the current frame (pan delta scale). */
+    readonly worldXPerPx: () => number;
+    /** The current data x extent (grows as bars stream in). */
+    readonly dataBounds: () => {
+        readonly xMin: number;
+        readonly xMax: number;
+    };
+    /** Re-render the adapter after a gesture mutates the window. */
+    readonly requestRender: () => void;
+    /** Override the wheel zoom sensitivity (default {@link DEFAULT_ZOOM_STEP}). */
+    readonly zoomStep?: number;
+};
+/**
+ * Apply one wheel notch: zoom the controller about the world-x under the
+ * cursor, then request a render. Pure on `(offsetX, deltaY)` so it is unit
+ * tested without a DOM event.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     declare const h: InteractionHandlers;
+ *     onWheelCore(h, 50, -120); // zoom in about pixel x=50
+ */
+export declare function onWheelCore(h: InteractionHandlers, offsetX: number, deltaY: number): void;
+/**
+ * Apply one drag step: pan the controller by the pixel delta converted to
+ * world x (dragging right reveals earlier data), then request a render.
+ * Pure on `dxPx`.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     declare const h: InteractionHandlers;
+ *     onDragCore(h, 12); // pan left by 12 px
+ */
+export declare function onDragCore(h: InteractionHandlers, dxPx: number): void;
+/**
+ * Apply a double-click: reset the controller to auto-follow, then request a
+ * render.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     declare const h: InteractionHandlers;
+ *     onDblCore(h);
+ */
+export declare function onDblCore(h: InteractionHandlers): void;
+/**
+ * Wire wheel-zoom, drag-pan, and double-click-reset on `el`, driving the
+ * supplied {@link InteractionHandlers}. Returns a detach function that
+ * removes every listener (call it from the adapter's `dispose`). The
+ * `addEventListener` plumbing is the only DOM-bound part; the decision
+ * logic lives in {@link onWheelCore} / {@link onDragCore} / {@link
+ * onDblCore}, which are unit tested directly.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     declare const el: HTMLElement;
+ *     declare const h: InteractionHandlers;
+ *     const detach = attachInteraction(el, h);
+ *     detach();
+ */
+export declare function attachInteraction(el: HTMLElement, h: InteractionHandlers): () => void;
+//# sourceMappingURL=domWiring.d.ts.map

package/dist/interaction/domWiring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domWiring.d.ts","sourceRoot":"","sources":["../../src/interaction/domWiring.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAQ1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,uDAAuD;IACvD,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,kEAAkE;IAClE,QAAQ,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;IAC5C,uEAAuE;IACvE,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,CAAC;IACnC,2DAA2D;IAC3D,QAAQ,CAAC,UAAU,EAAE,MAAM;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5E,gEAAgE;IAChE,QAAQ,CAAC,aAAa,EAAE,MAAM,IAAI,CAAC;IACnC,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAKzF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAIrE;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAGtD;AAED;;;;;;;;;;;;;;;GAeG;AAEH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,mBAAmB,GAAG,MAAM,IAAI,CAwCrF"}

package/dist/interaction/domWiring.js

@@ -0,0 +1,113 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+// Wheel notch → zoom factor sensitivity. A positive `deltaY` (scroll down)
+// yields a factor > 1 (zoom out); negative (scroll up) yields < 1 (zoom in).
+// `Math.exp` keeps both directions symmetric, so zoom-out always exists —
+// the bug the native-default drag-zoom-in lacked.
+const DEFAULT_ZOOM_STEP = 0.0015;
+/**
+ * Apply one wheel notch: zoom the controller about the world-x under the
+ * cursor, then request a render. Pure on `(offsetX, deltaY)` so it is unit
+ * tested without a DOM event.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     declare const h: InteractionHandlers;
+ *     onWheelCore(h, 50, -120); // zoom in about pixel x=50
+ */
+export function onWheelCore(h, offsetX, deltaY) {
+    const factor = Math.exp(deltaY * (h.zoomStep ?? DEFAULT_ZOOM_STEP));
+    const { xMin, xMax } = h.dataBounds();
+    h.controller.zoomAt(h.pxToWorldX(offsetX), factor, xMin, xMax);
+    h.requestRender();
+}
+/**
+ * Apply one drag step: pan the controller by the pixel delta converted to
+ * world x (dragging right reveals earlier data), then request a render.
+ * Pure on `dxPx`.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     declare const h: InteractionHandlers;
+ *     onDragCore(h, 12); // pan left by 12 px
+ */
+export function onDragCore(h, dxPx) {
+    const { xMin, xMax } = h.dataBounds();
+    h.controller.panBy(-dxPx * h.worldXPerPx(), xMin, xMax);
+    h.requestRender();
+}
+/**
+ * Apply a double-click: reset the controller to auto-follow, then request a
+ * render.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     declare const h: InteractionHandlers;
+ *     onDblCore(h);
+ */
+export function onDblCore(h) {
+    h.controller.reset();
+    h.requestRender();
+}
+/**
+ * Wire wheel-zoom, drag-pan, and double-click-reset on `el`, driving the
+ * supplied {@link InteractionHandlers}. Returns a detach function that
+ * removes every listener (call it from the adapter's `dispose`). The
+ * `addEventListener` plumbing is the only DOM-bound part; the decision
+ * logic lives in {@link onWheelCore} / {@link onDragCore} / {@link
+ * onDblCore}, which are unit tested directly.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     declare const el: HTMLElement;
+ *     declare const h: InteractionHandlers;
+ *     const detach = attachInteraction(el, h);
+ *     detach();
+ */
+/* v8 ignore start -- DOM event plumbing; the pure cores above carry the coverage */
+export function attachInteraction(el, h) {
+    let dragging = false;
+    let lastX = 0;
+    const onWheel = (e) => {
+        e.preventDefault();
+        onWheelCore(h, e.offsetX, e.deltaY);
+    };
+    const onPointerDown = (e) => {
+        dragging = true;
+        lastX = e.clientX;
+        el.setPointerCapture(e.pointerId);
+    };
+    const onPointerMove = (e) => {
+        if (!dragging)
+            return;
+        const dx = e.clientX - lastX;
+        lastX = e.clientX;
+        onDragCore(h, dx);
+    };
+    const onPointerUp = (e) => {
+        dragging = false;
+        if (el.hasPointerCapture(e.pointerId))
+            el.releasePointerCapture(e.pointerId);
+    };
+    const onDblClick = () => {
+        onDblCore(h);
+    };
+    el.addEventListener("wheel", onWheel, { passive: false });
+    el.addEventListener("pointerdown", onPointerDown);
+    el.addEventListener("pointermove", onPointerMove);
+    el.addEventListener("pointerup", onPointerUp);
+    el.addEventListener("dblclick", onDblClick);
+    return () => {
+        el.removeEventListener("wheel", onWheel);
+        el.removeEventListener("pointerdown", onPointerDown);
+        el.removeEventListener("pointermove", onPointerMove);
+        el.removeEventListener("pointerup", onPointerUp);
+        el.removeEventListener("dblclick", onDblClick);
+    };
+}
+/* v8 ignore stop */
+//# sourceMappingURL=domWiring.js.map

package/dist/interaction/domWiring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domWiring.js","sourceRoot":"","sources":["../../src/interaction/domWiring.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nimport type { ViewController } from \"./viewController.js\";\n\n// Wheel notch → zoom factor sensitivity. A positive `deltaY` (scroll down)\n// yields a factor > 1 (zoom out); negative (scroll up) yields < 1 (zoom in).\n// `Math.exp` keeps both directions symmetric, so zoom-out always exists —\n// the bug the native-default drag-zoom-in lacked.\nconst DEFAULT_ZOOM_STEP = 0.0015;\n\n/**\n * The per-frame projection + data context {@link attachInteraction} needs\n * to translate pixel gestures into world-x transforms. The adapter supplies\n * these closing over its latest overlay `Viewport`, so the math always uses\n * the current frame's scale.\n *\n * @since 1.6\n * @stable\n * @example\n *     declare const view: import(\"./viewController.js\").ViewController;\n *     const h: InteractionHandlers = {\n *         controller: view,\n *         pxToWorldX: (px) => px,\n *         worldXPerPx: () => 1,\n *         dataBounds: () => ({ xMin: 0, xMax: 100 }),\n *         requestRender: () => {},\n *     };\n *     void h;\n */\nexport type InteractionHandlers = {\n    /** The controller whose window the gestures mutate. */\n    readonly controller: ViewController;\n    /** Map a plot-area pixel x to a world x for the current frame. */\n    readonly pxToWorldX: (px: number) => number;\n    /** World-x units per pixel for the current frame (pan delta scale). */\n    readonly worldXPerPx: () => number;\n    /** The current data x extent (grows as bars stream in). */\n    readonly dataBounds: () => { readonly xMin: number; readonly xMax: number };\n    /** Re-render the adapter after a gesture mutates the window. */\n    readonly requestRender: () => void;\n    /** Override the wheel zoom sensitivity (default {@link DEFAULT_ZOOM_STEP}). */\n    readonly zoomStep?: number;\n};\n\n/**\n * Apply one wheel notch: zoom the controller about the world-x under the\n * cursor, then request a render. Pure on `(offsetX, deltaY)` so it is unit\n * tested without a DOM event.\n *\n * @since 1.6\n * @stable\n * @example\n *     declare const h: InteractionHandlers;\n *     onWheelCore(h, 50, -120); // zoom in about pixel x=50\n */\nexport function onWheelCore(h: InteractionHandlers, offsetX: number, deltaY: number): void {\n    const factor = Math.exp(deltaY * (h.zoomStep ?? DEFAULT_ZOOM_STEP));\n    const { xMin, xMax } = h.dataBounds();\n    h.controller.zoomAt(h.pxToWorldX(offsetX), factor, xMin, xMax);\n    h.requestRender();\n}\n\n/**\n * Apply one drag step: pan the controller by the pixel delta converted to\n * world x (dragging right reveals earlier data), then request a render.\n * Pure on `dxPx`.\n *\n * @since 1.6\n * @stable\n * @example\n *     declare const h: InteractionHandlers;\n *     onDragCore(h, 12); // pan left by 12 px\n */\nexport function onDragCore(h: InteractionHandlers, dxPx: number): void {\n    const { xMin, xMax } = h.dataBounds();\n    h.controller.panBy(-dxPx * h.worldXPerPx(), xMin, xMax);\n    h.requestRender();\n}\n\n/**\n * Apply a double-click: reset the controller to auto-follow, then request a\n * render.\n *\n * @since 1.6\n * @stable\n * @example\n *     declare const h: InteractionHandlers;\n *     onDblCore(h);\n */\nexport function onDblCore(h: InteractionHandlers): void {\n    h.controller.reset();\n    h.requestRender();\n}\n\n/**\n * Wire wheel-zoom, drag-pan, and double-click-reset on `el`, driving the\n * supplied {@link InteractionHandlers}. Returns a detach function that\n * removes every listener (call it from the adapter's `dispose`). The\n * `addEventListener` plumbing is the only DOM-bound part; the decision\n * logic lives in {@link onWheelCore} / {@link onDragCore} / {@link\n * onDblCore}, which are unit tested directly.\n *\n * @since 1.6\n * @stable\n * @example\n *     declare const el: HTMLElement;\n *     declare const h: InteractionHandlers;\n *     const detach = attachInteraction(el, h);\n *     detach();\n */\n/* v8 ignore start -- DOM event plumbing; the pure cores above carry the coverage */\nexport function attachInteraction(el: HTMLElement, h: InteractionHandlers): () => void {\n    let dragging = false;\n    let lastX = 0;\n\n    const onWheel = (e: WheelEvent): void => {\n        e.preventDefault();\n        onWheelCore(h, e.offsetX, e.deltaY);\n    };\n    const onPointerDown = (e: PointerEvent): void => {\n        dragging = true;\n        lastX = e.clientX;\n        el.setPointerCapture(e.pointerId);\n    };\n    const onPointerMove = (e: PointerEvent): void => {\n        if (!dragging) return;\n        const dx = e.clientX - lastX;\n        lastX = e.clientX;\n        onDragCore(h, dx);\n    };\n    const onPointerUp = (e: PointerEvent): void => {\n        dragging = false;\n        if (el.hasPointerCapture(e.pointerId)) el.releasePointerCapture(e.pointerId);\n    };\n    const onDblClick = (): void => {\n        onDblCore(h);\n    };\n\n    el.addEventListener(\"wheel\", onWheel, { passive: false });\n    el.addEventListener(\"pointerdown\", onPointerDown);\n    el.addEventListener(\"pointermove\", onPointerMove);\n    el.addEventListener(\"pointerup\", onPointerUp);\n    el.addEventListener(\"dblclick\", onDblClick);\n\n    return (): void => {\n        el.removeEventListener(\"wheel\", onWheel);\n        el.removeEventListener(\"pointerdown\", onPointerDown);\n        el.removeEventListener(\"pointermove\", onPointerMove);\n        el.removeEventListener(\"pointerup\", onPointerUp);\n        el.removeEventListener(\"dblclick\", onDblClick);\n    };\n}\n/* v8 ignore stop */\n"]}

package/dist/interaction/index.d.ts

@@ -0,0 +1,5 @@
+export { createViewController, yRangeInWindow } from "./viewController.js";
+export type { ViewController, ViewControllerOpts, WindowYInput, XWindow, } from "./viewController.js";
+export { attachInteraction, onDblCore, onDragCore, onWheelCore } from "./domWiring.js";
+export type { InteractionHandlers } from "./domWiring.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/interaction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interaction/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC3E,YAAY,EACR,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,OAAO,GACV,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACvF,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/interaction/index.js

@@ -0,0 +1,5 @@
+// Copyright (c) 2026 Invinite. Licensed under the MIT License.
+// See the LICENSE file in the repo root for full license text.
+export { createViewController, yRangeInWindow } from "./viewController.js";
+export { attachInteraction, onDblCore, onDragCore, onWheelCore } from "./domWiring.js";
+//# sourceMappingURL=index.js.map

package/dist/interaction/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/interaction/index.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,+DAA+D;AAE/D,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAO3E,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC","sourcesContent":["// Copyright (c) 2026 Invinite. Licensed under the MIT License.\n// See the LICENSE file in the repo root for full license text.\n\nexport { createViewController, yRangeInWindow } from \"./viewController.js\";\nexport type {\n    ViewController,\n    ViewControllerOpts,\n    WindowYInput,\n    XWindow,\n} from \"./viewController.js\";\nexport { attachInteraction, onDblCore, onDragCore, onWheelCore } from \"./domWiring.js\";\nexport type { InteractionHandlers } from \"./domWiring.js\";\n"]}

package/dist/interaction/viewController.d.ts

@@ -0,0 +1,132 @@
+/**
+ * A visible window into the world x axis (bar times in UTC ms). The two
+ * self-scaled adapters (canvas2d, konva) resolve one per frame from a
+ * {@link ViewController} and feed `xMin`/`xMax` into their `Viewport`.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     const win: XWindow = { xMin: 0, xMax: 100 };
+ *     void win;
+ */
+export type XWindow = {
+    readonly xMin: number;
+    readonly xMax: number;
+};
+/**
+ * Construction options for {@link createViewController}. `minSpan` is the
+ * smallest world-x span a zoom-in can reach (so the window never collapses
+ * to a point); `maxSpanFactor` is the largest span a zoom-out can reach as
+ * a multiple of the current data span (default `1` ⇒ cannot zoom out past
+ * "all data visible").
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     const opts: ViewControllerOpts = { minSpan: 1, maxSpanFactor: 1 };
+ *     void opts;
+ */
+export type ViewControllerOpts = {
+    readonly minSpan?: number;
+    readonly maxSpanFactor?: number;
+};
+/**
+ * Stateful, library-agnostic pan/zoom controller for an adapter that
+ * computes its own x scale every frame. It holds a user x-window plus a
+ * `userInteracted` flag: until the user wheels or drags, {@link
+ * ViewController.resolveXWindow} returns the auto-follow window (the full
+ * data range, or the framed `autoFollowXMin` window); after the first
+ * interaction it returns the held window (re-clamped as data grows), so
+ * live frames stop snapping the view back. The first {@link
+ * ViewController.zoomAt}/{@link ViewController.panBy} seeds the held window
+ * from the window last returned by {@link ViewController.resolveXWindow}
+ * (what the user is currently looking at), so leaving auto-follow keeps the
+ * framed view rather than jumping to the full data range.
+ *
+ * All transforms are pure functions of the current state + the supplied
+ * data bounds — there is no DOM or library coupling. The example adapters
+ * wire DOM events to {@link ViewController.zoomAt} / {@link
+ * ViewController.panBy} / {@link ViewController.reset} via {@link
+ * attachInteraction}.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     const view = createViewController();
+ *     view.resolveXWindow(0, 100); // { xMin: 0, xMax: 100 } (auto-follow)
+ *     view.panBy(10, 0, 100);
+ *     view.userInteracted; // true
+ */
+export type ViewController = {
+    /** `true` once the user has zoomed or panned (auto-follow is paused). */
+    readonly userInteracted: boolean;
+    /**
+     * The x-window to render this frame. While not interacted (auto-follow),
+     * returns `[autoFollowXMin ?? dataXMin, dataXMax]` — pass `autoFollowXMin`
+     * (e.g. the time of the Nth-from-last bar) to frame only the most recent
+     * bars by default while keeping the full history scrollable; omit it to
+     * fit all data. After the first interaction it returns the held window
+     * clamped into the current data bounds (`autoFollowXMin` is then ignored).
+     */
+    resolveXWindow(dataXMin: number, dataXMax: number, autoFollowXMin?: number): XWindow;
+    /**
+     * Zoom by `factor` (`<1` in, `>1` out) about a world-x pivot. The first
+     * call seeds the held window from the last resolved window (the current
+     * view), falling back to the full data range if nothing has rendered yet.
+     */
+    zoomAt(pivotX: number, factor: number, dataXMin: number, dataXMax: number): void;
+    /** Pan the window by a signed world-x delta. */
+    panBy(deltaWorldX: number, dataXMin: number, dataXMax: number): void;
+    /** Clear the held window + flag so the view auto-follows again. */
+    reset(): void;
+};
+/**
+ * Build a {@link ViewController}. Pass `opts` to tune the zoom-in floor
+ * (`minSpan`) and zoom-out ceiling (`maxSpanFactor`); both default to a
+ * "1 ms floor, all-data ceiling" policy.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     const view = createViewController({ minSpan: 2, maxSpanFactor: 1 });
+ *     view.zoomAt(50, 0.5, 0, 100); // zoom in 2× about x=50
+ *     void view.resolveXWindow(0, 100);
+ */
+export declare function createViewController(opts?: ViewControllerOpts): ViewController;
+/**
+ * One candidate row for {@link yRangeInWindow}: a world `x` (bar time) plus
+ * the low / high values to fold into the y range when `x` is inside the
+ * window. Bars pass `{ x: time, lo: low, hi: high }`; a scalar series point
+ * passes `lo === hi === value`.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     const c: WindowYInput = { x: 10, lo: 99, hi: 101 };
+ *     void c;
+ */
+export type WindowYInput = {
+    readonly x: number;
+    readonly lo: number;
+    readonly hi: number;
+};
+/**
+ * Fold the y range of every candidate whose `x` falls inside `win` — the
+ * shared "auto-fit the price scale to the visible window" helper (matching
+ * lightweight-charts' auto price scale). Non-finite `lo`/`hi` rows are
+ * skipped. Returns `undefined` when no finite in-window candidate is seen,
+ * so the caller keeps its own degenerate-range fallback. Horizontal lines
+ * (no `x`) are folded in by the caller, not here.
+ *
+ * @since 1.6
+ * @stable
+ * @example
+ *     const r = yRangeInWindow([{ x: 5, lo: 1, hi: 3 }], { xMin: 0, xMax: 10 });
+ *     // r === { yMin: 1, yMax: 3 }
+ *     void r;
+ */
+export declare function yRangeInWindow(candidates: Iterable<WindowYInput>, win: XWindow): {
+    readonly yMin: number;
+    readonly yMax: number;
+} | undefined;
+//# sourceMappingURL=viewController.d.ts.map

package/dist/interaction/viewController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewController.d.ts","sourceRoot":"","sources":["../../src/interaction/viewController.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,OAAO,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvE;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACnC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,cAAc,GAAG;IACzB,yEAAyE;IACzE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC;;;;;;;OAOG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACrF;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjF,gDAAgD;IAChD,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACrE,mEAAmE;IACnE,KAAK,IAAI,IAAI,CAAC;CACjB,CAAC;AAsCF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE,kBAAkB,GAAG,cAAc,CAsE9E;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC1B,UAAU,EAAE,QAAQ,CAAC,YAAY,CAAC,EAClC,GAAG,EAAE,OAAO,GACb;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAW9D"}