@363045841yyt/klinechart-core 0.8.11-alpha.0 → 0.8.12

package/dist/scale/createTimeScale.js

@@ -0,0 +1,139 @@
+/**
+ * TimeScale factory — discrete bar-index ↔ screen X mapping (ROADMAP §1.1).
+ *
+ * The math is one-line in each direction; the value of this factory is the
+ * reactive plumbing (signals so adapters can subscribe) and the optional
+ * wall-clock calendar that maps bar indices ↔ timestamps.
+ *
+ *     forward:  x(i) = (i - firstVisibleIndex) * barWidth + leftPadding
+ *     inverse:  i(x) = (x - leftPadding) / barWidth + firstVisibleIndex
+ *
+ * Calendar semantics: when the user attaches a `barTimestamps` array, we treat
+ * bar index `i` as the array index. Integer indices map directly; fractional
+ * indices linearly interpolate between neighboring timestamps. Anything
+ * outside `[0, N-1]` returns `null` — the caller decides whether to clamp,
+ * extrapolate, or display a "—" label.
+ */
+import { createSignal } from '../reactivity/signal';
+import { KLineChartError } from '../errors';
+export function createTimeScale(config = {}) {
+    const initialFirstVisibleIndex = config.initialFirstVisibleIndex ?? 0;
+    const initialBarWidth = config.initialBarWidth ?? 8;
+    const initialLeftPadding = config.initialLeftPadding ?? 0;
+    if (!(initialBarWidth > 0)) {
+        throw new KLineChartError('SCALE_BAR_WIDTH_INVALID', `createTimeScale: initialBarWidth must be > 0, got ${initialBarWidth}`);
+    }
+    const firstVisibleIndex = createSignal(initialFirstVisibleIndex);
+    const barWidth = createSignal(initialBarWidth);
+    const leftPadding = createSignal(initialLeftPadding);
+    let calendar = null;
+    let disposed = false;
+    /**
+     * Post-dispose: mutator calls become silent no-ops. This matches the
+     * convention used by every other controller in @klinechart-quant/core
+     * (IndicatorSelector, Toolbar, Drawing, Alerts, Replay, VolumeProfile,
+     * Footprint, OrderBookHeatmap, AnchoredVwap, MtfOverlay). Throwing on
+     * stale references — as the original implementation did — was the API
+     * audit BLOCKER-004 (docs/audit/API_REVIEW.md) divergence; harmonized
+     * to silent-no-op here.
+     *
+     * Returns `true` when the operation should proceed (controller live),
+     * `false` when it should be skipped (post-dispose).
+     */
+    const guard = () => !disposed;
+    const scale = {
+        firstVisibleIndex,
+        barWidth,
+        leftPadding,
+        xToBarIndex(x) {
+            // We deliberately read with `.peek()` here — these methods are pure
+            // queries, they must not register the caller as a reactive subscriber.
+            const lp = leftPadding.peek();
+            const bw = barWidth.peek();
+            const fvi = firstVisibleIndex.peek();
+            return (x - lp) / bw + fvi;
+        },
+        barIndexToX(i) {
+            const lp = leftPadding.peek();
+            const bw = barWidth.peek();
+            const fvi = firstVisibleIndex.peek();
+            return (i - fvi) * bw + lp;
+        },
+        setFirstVisibleIndex(i) {
+            if (!guard())
+                return;
+            firstVisibleIndex.set(i);
+        },
+        setBarWidth(w) {
+            if (!guard())
+                return;
+            if (!(w > 0)) {
+                throw new KLineChartError('SCALE_BAR_WIDTH_INVALID', `TimeScale.setBarWidth: barWidth must be > 0, got ${w}`);
+            }
+            barWidth.set(w);
+        },
+        setLeftPadding(p) {
+            if (!guard())
+                return;
+            leftPadding.set(p);
+        },
+        setCalendar(c) {
+            if (!guard())
+                return;
+            calendar = c;
+        },
+        timeToBarIndex(timestamp) {
+            if (calendar === null)
+                return null;
+            const ts = calendar.barTimestamps;
+            const n = ts.length;
+            if (n === 0)
+                return null;
+            // Binary search for the upper bound of `timestamp` in `ts`.
+            // Returns the fractional index that interpolates linearly between
+            // bracketing bars. Outside the calendar → null.
+            if (timestamp < ts[0] || timestamp > ts[n - 1])
+                return null;
+            if (timestamp === ts[n - 1])
+                return n - 1;
+            let lo = 0;
+            let hi = n - 1;
+            while (hi - lo > 1) {
+                const mid = (lo + hi) >>> 1;
+                if (ts[mid] <= timestamp)
+                    lo = mid;
+                else
+                    hi = mid;
+            }
+            const span = ts[hi] - ts[lo];
+            if (span <= 0)
+                return lo;
+            return lo + (timestamp - ts[lo]) / span;
+        },
+        barIndexToTime(i) {
+            if (calendar === null)
+                return null;
+            const ts = calendar.barTimestamps;
+            const n = ts.length;
+            if (n === 0)
+                return null;
+            if (i < 0 || i > n - 1)
+                return null;
+            const lo = Math.floor(i);
+            const hi = Math.min(lo + 1, n - 1);
+            if (lo === hi)
+                return ts[lo];
+            const frac = i - lo;
+            return ts[lo] + (ts[hi] - ts[lo]) * frac;
+        },
+        dispose() {
+            // Signals don't allocate listeners we own; we just mark the
+            // instance as dead so writes throw and tests can assert dispose
+            // semantics. Reads remain functional as pure math.
+            disposed = true;
+            calendar = null;
+        },
+    };
+    return scale;
+}
+//# sourceMappingURL=createTimeScale.js.map

package/dist/scale/createTimeScale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTimeScale.js","sourceRoot":"","sources":["../../src/scale/createTimeScale.ts"],"names":[],"mappings":"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"}

package/dist/scale/index.d.ts

@@ -0,0 +1,6 @@
+export type { ScaleMode, TimeScale, PriceScale } from './types';
+export { createTimeScale, type TimeScaleConfig } from './createTimeScale';
+export { createPriceScale, type PriceScaleConfig } from './createPriceScale';
+export { computeAnchoredZoom, type AnchoredZoomOptions, type AnchoredZoomResult, } from './anchoredZoom';
+export { createOriginShiftPolicy, type OriginShiftPolicy } from './originShift';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scale/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAC/D,OAAO,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACzE,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC5E,OAAO,EACH,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GAC1B,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,uBAAuB,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAA"}

package/dist/scale/index.js

@@ -0,0 +1,5 @@
+export { createTimeScale } from './createTimeScale';
+export { createPriceScale } from './createPriceScale';
+export { computeAnchoredZoom, } from './anchoredZoom';
+export { createOriginShiftPolicy } from './originShift';
+//# sourceMappingURL=index.js.map

package/dist/scale/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/scale/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAwB,MAAM,mBAAmB,CAAA;AACzE,OAAO,EAAE,gBAAgB,EAAyB,MAAM,oBAAoB,CAAA;AAC5E,OAAO,EACH,mBAAmB,GAGtB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,uBAAuB,EAA0B,MAAM,eAAe,CAAA"}

package/dist/scale/originShift.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Origin-shift policy — ROADMAP §2.5, refined per the upstream PR feedback
+ * about *rebaseline drift*.
+ *
+ * Background.  GPUs run fp32 (~7 decimal digits of precision). At BTC-tier
+ * prices (~67,000) and tick sizes (~0.01) the absolute price burns most of
+ * the mantissa, and a subtraction like `(p - pMin)` inside a zoomed-in
+ * sub-dollar range produces catastrophic cancellation. The cheap fix is to
+ * subtract a "reference value" `ref` on the CPU (which is fp64 and can spare
+ * it) before uploading, so the GPU only ever sees relative deltas in the
+ * 0.1-or-so range.
+ *
+ * Why this is its own policy object, and why **threshold-based**:
+ *
+ *   The naive implementation — "every frame, set `ref = midpoint of current
+ *   visible range`" — looks right but is actively harmful on pan. Every time
+ *   the user drags one logical pixel, `ref` changes by one logical-pixel-of-
+ *   price, and *all* prices get re-quantized to a slightly different fp32
+ *   rounding. The result is a continuous, sub-pixel **shimmer** of the entire
+ *   chart that the eye perceives as soft jitter even when no actual data has
+ *   changed. (This is the bug I flagged on the upstream PR.)
+ *
+ *   The fix is to keep `ref` *stable* until the visible-range center has
+ *   drifted far enough that the fp32 budget is at risk of being exhausted —
+ *   then rebaseline once, deliberately. The visible artifact becomes a single
+ *   imperceptible discrete snap, instead of a continuous wobble.
+ *
+ *   In practice 1% of the visible range works well: at a 100-dollar range you
+ *   tolerate `ref` being 1 dollar off-center before re-snapping, which is
+ *   nowhere near the fp32 cliff but cuts rebaselines from "every frame" to
+ *   a handful per pan gesture.
+ *
+ * Edge cases worth documenting:
+ *
+ *  - `threshold === 0` forces a rebaseline on *every* call where the midpoint
+ *    differs from `ref` at all — this is the legacy "naive" behaviour, kept
+ *    for parity tests against the bug we're avoiding.
+ *
+ *  - `threshold >= 1` effectively disables rebaselining, useful when an
+ *    adapter wants to manage `ref` externally.
+ *
+ *  - A `currentRange` of zero (degenerate, visibleMin === visibleMax) is
+ *    treated as "no signal" — we don't rebaseline because we cannot compute a
+ *    meaningful normalized drift. The caller is responsible for handling the
+ *    degenerate range elsewhere.
+ */
+export interface OriginShiftPolicy {
+    /** Current reference value. Subtract this from any price before upload. */
+    readonly ref: number;
+    /** Subtract `ref` from `value`. The fp32-safe number to upload. */
+    shift(value: number): number;
+    /**
+     * Maybe rebaseline. Returns `true` iff `ref` was updated.
+     *
+     * Policy: rebaseline only when
+     *   `|currentMid - ref| / currentRange > threshold`.
+     * On rebaseline, `ref` becomes `currentMid`.
+     */
+    maybeRebaseline(currentMid: number, currentRange: number): boolean;
+}
+/**
+ * @internal — building block used by `createPriceScale`. Reachable today
+ *   via the top-level `@klinechart-quant/core` barrel but **NOT
+ *   part of the supported public API**. typedoc / api-extractor
+ *   hide it from generated docs. Prefer the controller factory
+ *   for stable user code. Closes API audit BLOCKER-002.
+ */
+export declare function createOriginShiftPolicy(initialRef: number, threshold?: number): OriginShiftPolicy;
+//# sourceMappingURL=originShift.d.ts.map

package/dist/scale/originShift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"originShift.d.ts","sourceRoot":"","sources":["../../src/scale/originShift.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,MAAM,WAAW,iBAAiB;IAC9B,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,mEAAmE;IACnE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B;;;;;;OAMG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAA;CACrE;AAID;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACnC,UAAU,EAAE,MAAM,EAClB,SAAS,GAAE,MAA0B,GACtC,iBAAiB,CAmCnB"}

package/dist/scale/originShift.js

@@ -0,0 +1,41 @@
+import { KLineChartError } from '../errors';
+const DEFAULT_THRESHOLD = 0.01;
+/**
+ * @internal — building block used by `createPriceScale`. Reachable today
+ *   via the top-level `@klinechart-quant/core` barrel but **NOT
+ *   part of the supported public API**. typedoc / api-extractor
+ *   hide it from generated docs. Prefer the controller factory
+ *   for stable user code. Closes API audit BLOCKER-002.
+ */
+export function createOriginShiftPolicy(initialRef, threshold = DEFAULT_THRESHOLD) {
+    if (!Number.isFinite(initialRef)) {
+        throw new KLineChartError('INVALID_PARAM', `createOriginShiftPolicy: initialRef must be finite, got ${initialRef}`);
+    }
+    if (!Number.isFinite(threshold) || threshold < 0) {
+        throw new KLineChartError('INVALID_PARAM', `createOriginShiftPolicy: threshold must be >= 0, got ${threshold}`);
+    }
+    let ref = initialRef;
+    const policy = {
+        get ref() {
+            return ref;
+        },
+        shift(value) {
+            return value - ref;
+        },
+        maybeRebaseline(currentMid, currentRange) {
+            // Degenerate range — refuse to rebaseline. Caller handles this elsewhere.
+            if (!Number.isFinite(currentMid) || !Number.isFinite(currentRange) || currentRange <= 0) {
+                return false;
+            }
+            const drift = Math.abs(currentMid - ref);
+            const normalized = drift / currentRange;
+            if (normalized > threshold) {
+                ref = currentMid;
+                return true;
+            }
+            return false;
+        },
+    };
+    return policy;
+}
+//# sourceMappingURL=originShift.js.map

package/dist/scale/originShift.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"originShift.js","sourceRoot":"","sources":["../../src/scale/originShift.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AA+D3C,MAAM,iBAAiB,GAAG,IAAI,CAAA;AAE9B;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACnC,UAAkB,EAClB,YAAoB,iBAAiB;IAErC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,eAAe,CAAC,eAAe,EAAE,2DAA2D,UAAU,EAAE,CAAC,CAAA;IACvH,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;QAC/C,MAAM,IAAI,eAAe,CAAC,eAAe,EAAE,wDAAwD,SAAS,EAAE,CAAC,CAAA;IACnH,CAAC;IAED,IAAI,GAAG,GAAG,UAAU,CAAA;IAEpB,MAAM,MAAM,GAAsB;QAC9B,IAAI,GAAG;YACH,OAAO,GAAG,CAAA;QACd,CAAC;QACD,KAAK,CAAC,KAAa;YACf,OAAO,KAAK,GAAG,GAAG,CAAA;QACtB,CAAC;QACD,eAAe,CAAC,UAAkB,EAAE,YAAoB;YACpD,0EAA0E;YAC1E,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,YAAY,IAAI,CAAC,EAAE,CAAC;gBACtF,OAAO,KAAK,CAAA;YAChB,CAAC;YAED,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,CAAA;YACxC,MAAM,UAAU,GAAG,KAAK,GAAG,YAAY,CAAA;YAEvC,IAAI,UAAU,GAAG,SAAS,EAAE,CAAC;gBACzB,GAAG,GAAG,UAAU,CAAA;gBAChB,OAAO,IAAI,CAAA;YACf,CAAC;YACD,OAAO,KAAK,CAAA;QAChB,CAAC;KACJ,CAAA;IAED,OAAO,MAAM,CAAA;AACjB,CAAC"}

package/dist/scale/types.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Coordinate-system interfaces for the headless core.
+ *
+ * The `TimeScale` maps **bar index** (a discrete-but-fractional sequence number)
+ * to a screen X position, per ROADMAP §1.1. Wall-clock time is a secondary
+ * label, available only when a calendar is attached.
+ *
+ * The `PriceScale` maps a (possibly very narrow) price range to screen Y per
+ * ROADMAP §1.2 — and additionally exposes an origin-shift policy so adapters
+ * can keep GPU uploads in safe fp32 territory (ROADMAP §2.5).
+ *
+ * Both scales are **reactive**: their core state is exposed as signals so the
+ * React/Vue/Angular adapter layer can subscribe without re-implementing the
+ * change-detection plumbing.
+ */
+import type { Signal } from '../reactivity/signal';
+/** Linear (arithmetic) or logarithmic Y mapping. */
+export type ScaleMode = 'linear' | 'log';
+/**
+ * Discrete bar-index ↔ screen X mapping (ROADMAP §1.1).
+ *
+ * Forward equation (the only equation a renderer needs to know):
+ *
+ *     x(i) = (i - firstVisibleIndex) * barWidth + leftPadding
+ *
+ * Inverse, used by anchored zoom and hit-testing:
+ *
+ *     i(x) = (x - leftPadding) / barWidth + firstVisibleIndex
+ *
+ * `firstVisibleIndex` is allowed to be **fractional, negative, or > N**;
+ * this is what lets the user pan to "half a bar" or scroll into the future.
+ */
+export interface TimeScale {
+    /** Inverse: screen X (logical px) → fractional bar index. */
+    xToBarIndex(x: number): number;
+    /** Forward: fractional bar index → screen X (logical px). */
+    barIndexToX(i: number): number;
+    /** Fractional, may be negative or > N. */
+    readonly firstVisibleIndex: Signal<number>;
+    /** Logical pixels per bar. Clamped by the caller (e.g. zoom) not the scale. */
+    readonly barWidth: Signal<number>;
+    /** Logical pixels added on the left edge before bar 0. */
+    readonly leftPadding: Signal<number>;
+    setFirstVisibleIndex(i: number): void;
+    setBarWidth(w: number): void;
+    setLeftPadding(p: number): void;
+    /**
+     * Attach (or detach with `null`) a wall-clock calendar so the scale can
+     * answer `timeToBarIndex` / `barIndexToTime`. Bar indices not covered by
+     * the calendar return `null` — *time is a label, not a coordinate*.
+     */
+    setCalendar(c: {
+        barTimestamps: ReadonlyArray<number>;
+    } | null): void;
+    /** wall-clock ms → fractional bar index; `null` if no calendar / out of range. */
+    timeToBarIndex(timestamp: number): number | null;
+    /** fractional bar index → wall-clock ms; `null` if no calendar / out of range. */
+    barIndexToTime(i: number): number | null;
+    /** Detach signal subscribers and release any internal listeners. */
+    dispose(): void;
+}
+/**
+ * Price → screen Y mapping (ROADMAP §1.2) plus an origin-shift policy
+ * (ROADMAP §2.5) so adapters can upload fp32-safe values to the GPU.
+ *
+ * Coordinate convention: top-origin, Y increases downward (DOM standard).
+ * A price ≥ `visibleMax` maps to y = 0, a price ≤ `visibleMin` maps to
+ * y = `height`.
+ */
+export interface PriceScale {
+    /** Forward: price → screen Y (top-origin, increases downward). */
+    priceToY(p: number): number;
+    /** Inverse: screen Y → price. */
+    yToPrice(y: number): number;
+    readonly mode: Signal<ScaleMode>;
+    readonly visibleMin: Signal<number>;
+    readonly visibleMax: Signal<number>;
+    readonly height: Signal<number>;
+    /** Set `'linear'` or `'log'`; throws on `'log'` if `visibleMin <= 0`. */
+    setMode(mode: ScaleMode): void;
+    /** Update visible range. Triggers the origin-shift rebaseline check. */
+    setVisibleRange(min: number, max: number): void;
+    setHeight(h: number): void;
+    /** Origin-shift reference; managed automatically but exposed for tests. */
+    readonly originShiftRef: Signal<number>;
+    /** Returns `p - originShiftRef.peek()` — what to upload to the GPU as fp32. */
+    toShiftedFp32(p: number): number;
+    dispose(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/scale/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scale/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAElD,oDAAoD;AACpD,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,KAAK,CAAA;AAExC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,SAAS;IACtB,6DAA6D;IAC7D,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC9B,6DAA6D;IAC7D,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAE9B,0CAA0C;IAC1C,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IAC1C,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACjC,0DAA0D;IAC1D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IAEpC,oBAAoB,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAE/B;;;;OAIG;IACH,WAAW,CAAC,CAAC,EAAE;QAAE,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;KAAE,GAAG,IAAI,GAAG,IAAI,CAAA;IAErE,kFAAkF;IAClF,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAChD,kFAAkF;IAClF,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IAExC,oEAAoE;IACpE,OAAO,IAAI,IAAI,CAAA;CAClB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACvB,kEAAkE;IAClE,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B,iCAAiC;IACjC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAE3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,CAAC,CAAA;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACnC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IAE/B,yEAAyE;IACzE,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAA;IAC9B,wEAAwE;IACxE,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/C,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAE1B,2EAA2E;IAC3E,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACvC,+EAA+E;IAC/E,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAEhC,OAAO,IAAI,IAAI,CAAA;CAClB"}

package/dist/scale/types.js

@@ -0,0 +1,17 @@
+/**
+ * Coordinate-system interfaces for the headless core.
+ *
+ * The `TimeScale` maps **bar index** (a discrete-but-fractional sequence number)
+ * to a screen X position, per ROADMAP §1.1. Wall-clock time is a secondary
+ * label, available only when a calendar is attached.
+ *
+ * The `PriceScale` maps a (possibly very narrow) price range to screen Y per
+ * ROADMAP §1.2 — and additionally exposes an origin-shift policy so adapters
+ * can keep GPU uploads in safe fp32 territory (ROADMAP §2.5).
+ *
+ * Both scales are **reactive**: their core state is exposed as signals so the
+ * React/Vue/Angular adapter layer can subscribe without re-implementing the
+ * change-detection plumbing.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/scale/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/scale/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/scene/createScene.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Scene factory — composition, ordered iteration, lifecycle.
+ *
+ * Design notes:
+ * - The layer list is stored in **registration order** in a private array.
+ *   `paintPane` performs a stable sort by `z` at paint time. We do not
+ *   maintain a sorted invariant on the array itself because:
+ *     1. Add/remove must remain O(n), and z is a number, so a sorted
+ *        insert is O(n) anyway.
+ *     2. Stable sort by z gives the documented tie-breaker (registration
+ *        order) "for free" without parallel arrays or registration counters.
+ * - The `layers` signal exposes a snapshot. Every mutation produces a NEW
+ *   array via spread or filter — never mutate the previous value. This is
+ *   the immutability contract framework adapters rely on.
+ * - After `dispose`, every public method becomes a no-op. The `disposed`
+ *   flag is checked at the top of each method; this matches the renderer's
+ *   "dispose freezes" semantic and prevents callers from leaking listeners
+ *   into a torn-down scene.
+ */
+import type { Scene } from './types';
+export declare function createScene(): Scene;
+//# sourceMappingURL=createScene.d.ts.map

package/dist/scene/createScene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createScene.d.ts","sourceRoot":"","sources":["../../src/scene/createScene.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAuB,KAAK,EAAE,MAAM,SAAS,CAAA;AAEzD,wBAAgB,WAAW,IAAI,KAAK,CA6FnC"}

package/dist/scene/createScene.js

@@ -0,0 +1,114 @@
+/**
+ * Scene factory — composition, ordered iteration, lifecycle.
+ *
+ * Design notes:
+ * - The layer list is stored in **registration order** in a private array.
+ *   `paintPane` performs a stable sort by `z` at paint time. We do not
+ *   maintain a sorted invariant on the array itself because:
+ *     1. Add/remove must remain O(n), and z is a number, so a sorted
+ *        insert is O(n) anyway.
+ *     2. Stable sort by z gives the documented tie-breaker (registration
+ *        order) "for free" without parallel arrays or registration counters.
+ * - The `layers` signal exposes a snapshot. Every mutation produces a NEW
+ *   array via spread or filter — never mutate the previous value. This is
+ *   the immutability contract framework adapters rely on.
+ * - After `dispose`, every public method becomes a no-op. The `disposed`
+ *   flag is checked at the top of each method; this matches the renderer's
+ *   "dispose freezes" semantic and prevents callers from leaking listeners
+ *   into a torn-down scene.
+ */
+import { createSignal } from '../reactivity/signal';
+export function createScene() {
+    // ---- internal state ----------------------------------------------------
+    // Mutable list held outside the signal so that signal.set always receives
+    // a fresh frozen-shape snapshot. We never expose this array directly.
+    let layerList = [];
+    let disposed = false;
+    const layersSignal = createSignal([]);
+    const publish = () => {
+        layersSignal.set(layerList.slice());
+    };
+    // ---- public API --------------------------------------------------------
+    const addLayer = (layer) => {
+        if (disposed)
+            return;
+        // Reject duplicate ids silently — protects against double-registration
+        // races where two systems (e.g. an indicator controller + a config
+        // restore) both attempt to add the same layer. The first wins.
+        if (layerList.some((existing) => existing.id === layer.id))
+            return;
+        layerList = [...layerList, layer];
+        publish();
+    };
+    const removeLayer = (id) => {
+        if (disposed)
+            return false;
+        const next = layerList.filter((layer) => layer.id !== id);
+        if (next.length === layerList.length)
+            return false;
+        layerList = next;
+        publish();
+        return true;
+    };
+    const getLayer = (id) => {
+        if (disposed)
+            return null;
+        const hit = layerList.find((layer) => layer.id === id);
+        return hit ?? null;
+    };
+    const setLayerVisibility = (id, visible) => {
+        if (disposed)
+            return false;
+        const layer = layerList.find((l) => l.id === id);
+        if (!layer)
+            return false;
+        // `visible` is a mutable field on the layer (per the interface);
+        // mutating it does not affect the `layers` signal's identity because
+        // subscribers care about membership, not field state. This matches
+        // how chart adapters batch visibility toggles (no re-render storm).
+        layer.visible = visible;
+        return true;
+    };
+    const paintPane = (ctx) => {
+        if (disposed)
+            return;
+        // Filter then stable-sort. Native Array.prototype.sort is required
+        // by ECMAScript 2019+ to be stable, so equal z values preserve the
+        // surviving registration order from the filter pass.
+        const candidates = layerList.filter((layer) => layer.paneRole === ctx.paneRole && layer.visible);
+        candidates.sort((a, b) => a.z - b.z);
+        for (const layer of candidates) {
+            layer.paint(ctx);
+        }
+    };
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        // Snapshot first because layer.dispose may attempt further mutations
+        // through a stale reference — we want predictable iteration here.
+        const snapshot = layerList;
+        layerList = [];
+        for (const layer of snapshot) {
+            try {
+                layer.dispose();
+            }
+            catch {
+                // Swallow per-layer dispose errors so one broken layer can't
+                // strand the rest. A logger would go here in production; the
+                // headless core does not own a logger contract yet.
+            }
+        }
+        layersSignal.set([]);
+    };
+    return {
+        layers: layersSignal,
+        addLayer,
+        removeLayer,
+        getLayer,
+        setLayerVisibility,
+        paintPane,
+        dispose,
+    };
+}
+//# sourceMappingURL=createScene.js.map

package/dist/scene/createScene.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createScene.js","sourceRoot":"","sources":["../../src/scene/createScene.ts"],"names":[],"mappings":"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"}

package/dist/scene/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Scene abstraction barrel.
+ *
+ * Exports the `Layer` / `Scene` types, the `createScene` factory, and the
+ * `LayerRegistry` mechanism + canonical built-in layer typeIds. This is the
+ * level above `render` and below `interaction` in the core dependency stack
+ * — see `docs/ROADMAP.md` §0.
+ */
+export type { Layer, LayerRole, PaneRole, PaintContext, Scene, } from './types';
+export { createScene } from './createScene';
+export { createLayerRegistry, BUILTIN_LAYER_TYPES, } from './layerRegistry';
+export type { LayerFactory, LayerRegistry, BuiltinLayerType, } from './layerRegistry';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scene/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EACR,KAAK,EACL,SAAS,EACT,QAAQ,EACR,YAAY,EACZ,KAAK,GACR,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,EACH,mBAAmB,EACnB,mBAAmB,GACtB,MAAM,iBAAiB,CAAA;AAExB,YAAY,EACR,YAAY,EACZ,aAAa,EACb,gBAAgB,GACnB,MAAM,iBAAiB,CAAA"}

package/dist/scene/index.js

@@ -0,0 +1,11 @@
+/**
+ * Scene abstraction barrel.
+ *
+ * Exports the `Layer` / `Scene` types, the `createScene` factory, and the
+ * `LayerRegistry` mechanism + canonical built-in layer typeIds. This is the
+ * level above `render` and below `interaction` in the core dependency stack
+ * — see `docs/ROADMAP.md` §0.
+ */
+export { createScene } from './createScene';
+export { createLayerRegistry, BUILTIN_LAYER_TYPES, } from './layerRegistry';
+//# sourceMappingURL=index.js.map

package/dist/scene/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/scene/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAUH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,EACH,mBAAmB,EACnB,mBAAmB,GACtB,MAAM,iBAAiB,CAAA"}