wickchart 1.7.0 → 2.0.2

package/types/wick-chart.d.ts

@@ -1,4 +1,3 @@
-import { PresenceTracker } from './core.js';
 declare const HTMLElementBase: {
     new (): {};
 };
@@ -22,10 +21,6 @@ declare class WickChart extends HTMLElementBase {
         index: any;
         x: number;
         y: any;
-    } | {
-        index: number;
-        x: number;
-        y: number;
     };
     _dt: number;
     _ly: {
@@ -51,6 +46,11 @@ declare class WickChart extends HTMLElementBase {
             h: number;
         };
     };
+    _priceW: any;
+    _pwNarrow: {
+        want: any;
+        t: number;
+    };
     _cache: {
         v: number;
         map: {};
@@ -103,24 +103,13 @@ declare class WickChart extends HTMLElementBase {
         p2: number;
         period: number;
     };
-    _coviewName: any;
-    _coviewCh: BroadcastChannel;
-    _coviewPeer: string;
-    _coviewLast: number;
-    _ghost: {
-        index: number;
-        yFrac: any;
-        at: number;
-    };
+    _coviewCh: any;
+    _ghost: any;
     _ghostTimer: number;
-    _coviewLabel: any;
-    _presence: PresenceTracker;
+    _presence: any;
     _coviewBeat: number;
-    _coviewViewLast: number;
-    _sonify: boolean;
-    _actx: any;
-    _lastToneIdx: number;
-    _playToken: number;
+    _scenario: any;
+    _riskPlan: any;
     _measure: {
         iA: any;
         pA: number;
@@ -129,9 +118,6 @@ declare class WickChart extends HTMLElementBase {
         done: boolean;
     };
     _measuring: boolean;
-    _walkTimer: number;
-    _storyToken: number;
-    _story: object[];
     _brush: boolean;
     _brushSel: {
         i0: number;
@@ -212,29 +198,6 @@ declare class WickChart extends HTMLElementBase {
     _tz: string;
     _vwapAnchor: string;
     _overlays: any[];
-    _scenario: {
-        path: {
-            h: number;
-            price: number;
-        }[];
-        horizon: number;
-        cone: boolean;
-        levels: number[];
-        color: string | null;
-        label: string;
-    };
-    _riskPlan: {
-        entry: number;
-        stop: number;
-        risk: number;
-        direction: 'long' | 'short';
-        levels: {
-            k: number;
-            price: number;
-        }[];
-        maxK: number;
-        label: string;
-    };
     _onResize: () => void;
     _onPointerDown: (e: any) => void;
     _onPointerMove: (e: any) => void;
@@ -533,8 +496,7 @@ declare class WickChart extends HTMLElementBase {
      */
     /** @param {import('./core.js').IndicatorDef} def */
     static registerIndicator(name: any, def: import('./core.js').IndicatorDef): void;
-    /** The tag this class registers as. (<hab-chart> is a deprecated alias
-     *  registered from the HabChart subclass, not this name.) */
+    /** The tag this class registers as. */
     static get elementName(): string;
     get data(): any[];
     /**
@@ -615,8 +577,7 @@ declare class WickChart extends HTMLElementBase {
      * WickScript predicate (`when`) on every streamed bar and fire on its
      * false→true edge — e.g. `when: 'crossup(rsi(close,14), 30)'` or
      * `when: 'volume > sma(volume,20) * 3'`. Scripted events carry the
-     * triggering close as `price` plus the `when` source (deprecated
-     * `hab:alert` alias still dispatched).
+     * triggering close as `price` plus the `when` source.
      * @param {{id?: string, price?: number, direction?: 'above'|'below'|'cross',
      *          when?: string, once?: boolean}} alert
      * @returns {string|null} the alert id (null when no valid price/when,
@@ -656,96 +617,13 @@ declare class WickChart extends HTMLElementBase {
     addOverlay(ov: any): string | null;
     removeOverlay(id: any): void;
     clearOverlays(): void;
-    /**
-     * Scenario projection into future space: a ghost path of future prices
-     * plus optional σ-bands (vol cone) from realized volatility.
-     *
-     *   chart.setScenario({ path: [64000, 65500, 68000], label: 'bull case' });
-     *   chart.setScenario({ horizon: 48, cone: true });   // cone-only
-     *
-     * The path is an array of prices (or {price} objects) for future bars
-     * 1..N; horizon defaults to the path length (1–500). `cone` (default
-     * true) draws ±levels·σ bands widening with √h from the current realized
-     * vol; `color` accepts up|down|accent or safe CSS colors. Setting a
-     * scenario reserves future space on the right; analysis data — excluded
-     * from getState/setState.
-     * @param {object} spec
-     * @returns {object|null} the normalized scenario, or null when invalid
-     */
-    setScenario(spec: object): object | null;
-    clearScenario(): void;
-    /** @returns {object|null} a copy of the active scenario */
+    /** @returns {object|null} a copy of the active scenario (set through the
+     *  `_scenario` seam by the wickchart-scenario plugin; reserves future
+     *  space via _rightMargin) */
     get scenario(): object | null;
-    /**
-     * Risk plan: an R-multiple grid anchored at entry/stop. 1R = |entry −
-     * stop| (the risk unit); reward lines are drawn at kR beyond the entry
-     * with the risk/reward zones shaded, so sizing and take-profit choices
-     * read directly off the chart.
-     *
-     *   chart.setRiskPlan({ entry: 64500, stop: 63800, multiples: [1, 2, 3] });
-     *   chart.setRiskPlan({ entry: 64500, stop: 63800, targets: [65900, 67300] });
-     *
-     * Direction is derived (stop below entry ⇒ long). Targets convert to
-     * their R multiple; `multiples` win when both are given. Invalid specs
-     * clear the plan (replace semantics, like setScenario); excluded from
-     * getState/setState — it is app state, not chart state.
-     * @param {object} spec
-     * @returns {object|null} the normalized plan, or null when invalid
-     */
-    setRiskPlan(spec: object): object | null;
-    clearRiskPlan(): void;
-    /** @returns {object|null} a copy of the active risk plan */
+    /** @returns {object|null} a copy of the active risk plan (set through
+     *  the `_riskPlan` seam by the wickchart-scenario plugin) */
     get riskPlan(): object | null;
-    /** σ-cone for the active scenario, cached per data version. */
-    _scenarioConeCache(): any;
-    /** Tool manifest for LLM control — JSON-safe copy of AI_TOOLS. */
-    aiTools(): any;
-    /** System prompt for agent control — paste into any LLM alongside aiTools(). */
-    aiPrompt(): string;
-    /** Grounding context for a model: current state + visible-window summary. */
-    aiContext(): {
-        state: import("./core.js").ChartState;
-        window: object;
-    };
-    /**
-     * Apply a list of {tool, args} ops (typically LLM output) through the
-     * validated dispatcher in core. Never throws — each op resolves
-     * {ok, tool, result} or {ok: false, tool, error} so an agent can
-     * self-correct.
-     * @param {any} ops
-     * @returns {Array<object>}
-     */
-    applyAI(ops: any): Array<object>;
-    /**
-     * Ask an AI to operate the chart. Builds the payload {system,
-     * instruction, chart, tools}; with a `run` async function (your model
-     * call — the chart itself never touches the network), applies the
-     * returned ops and resolves {payload, ops, results}. Without `run`,
-     * returns the payload for manual wiring — send it anywhere, then call
-     * chart.applyAI(ops) with the model's answer.
-     *
-     *   const { results } = await chart.ask('add RSI and mark the demand zone', {
-     *     run: async (payload) => (await callMyLLM(payload)).ops,
-     *   });
-     *
-     * @param {string} instruction natural-language request
-     * @param {{run?: (payload: object) => Promise<any>}} [opts]
-     */
-    ask(instruction: string, opts?: {
-        run?: (payload: object) => Promise<any>;
-    }): Promise<{
-        payload: {
-            system: string;
-            instruction: string;
-            chart: {
-                state: import("./core.js").ChartState;
-                window: object;
-            };
-            tools: any;
-        };
-        ops: any;
-        results: object[];
-    }>;
     /** Check alerts against an incoming bar (prev close → new close).
      *  Scripted (`when`) alerts evaluate their predicate series, cached per
      *  data version, and fire on the false→true edge. */
@@ -802,6 +680,17 @@ declare class WickChart extends HTMLElementBase {
     _computeDt(): void;
     _updateAria(): void;
     _invalidate(): void;
+    /**
+     * Price-axis width with tick-noise immunity. The width is measured from
+     * the live last close, and digits in a proportional font measure
+     * differently ("1" is narrower than "8") — so on every tick the ceil()
+     * can flip a pixel, dragging the axis separator and with it every candle
+     * sideways (visibly shaking on high-frequency pairs). Grow at once so a
+     * wider label never clips; adopt a narrower width only after it has held
+     * for 750ms, and only when it's a real change (≥2px) rather than
+     * digit-width noise, so a flapping price can never wobble the layout.
+     */
+    _axisWidth(want: any): any;
     _prec(v: any): any;
     _palette(): {
         overlay: any;
@@ -980,84 +869,11 @@ declare class WickChart extends HTMLElementBase {
     _pointerMove(e: any): void;
     _pointerUp(e: any): void;
     _yToPrice(y: any): number;
+    /** Dispatch a `wick:name` event on the element. */
+    _fire(name: any, detail: any): void;
     _wheel(e: any): void;
     _keydown(e: any): void;
-    /** Lazily-created shared AudioContext (enable within a user gesture). */
-    _audio(): any;
-    /** Short sine blip; `when` schedules against AudioContext time. */
-    _tone(freq: any, dur?: number, when?: number): void;
-    /** One tone for a bar's close, pitched by its position on the y-scale. */
-    _sonifyBar(i: any): void;
-    /** One tone per crosshair bar change (dedupes y-only moves). */
-    _maybeSonify(idx: any): void;
-    /**
-     * Play the visible range as a pitch sweep (~4s), riding the crosshair —
-     * the audible equivalent of running your eye along the price line.
-     */
-    playRange(): void;
     _emitCrosshair(hover: any): void;
-    /** Join/leave the co-view channel named by the `co-view` attribute. */
-    _setupCoView(): void;
-    /** Broadcast our visible range for presence; throttled unless forced. */
-    _coviewSendView(force: any): void;
-    _coviewSend(msg: any): void;
-    _onCoMessage(m: any): void;
-    /** Dispatch `wick:name` (canonical) plus the deprecated `hab:name` alias,
-     *  so 0.x listeners keep working until 2.0. */
-    _fire(name: any, detail: any): void;
-    /**
-     * Live co-view peers: who else is in the room and the time window each
-     * one is looking at — [{ id, name, range: {from, to}, at }], oldest
-     * sighting first. Peers fade out ~12 s after their last sighting.
-     * @returns {object[]}
-     */
-    getPeers(): object[];
-    /**
-     * Narrated timeline for a window (default: the visible range) — pivot
-     * highs/lows, volume spikes, gaps, RSI divergences plus derived legs
-     * ("+12.4% over 38 bars"), sorted by index. Pure data, perfect for
-     * caption UIs or the walk player.
-     *   chart.narrate();                        // visible range
-     *   chart.narrate({ from, to });            // times in ms (s accepted)
-     * @param {{from?: number, to?: number}} [range]
-     * @returns {{i: number, time: number, type: string, side: string, note: string,
-     *            legPct?: number, legBars?: number}[]}
-     */
-    narrate(range?: {
-        from?: number;
-        to?: number;
-    }): {
-        i: number;
-        time: number;
-        type: string;
-        side: string;
-        note: string;
-        legPct?: number;
-        legBars?: number;
-    }[];
-    /**
-     * Walk the chart through history like a story: the viewport slides
-     * from `from` to `to` while `wick:walk` events announce every step and
-     * the narrator's events (spikes, gaps, pivots, legs) as they're crossed.
-     * Any user interaction — pointer, wheel, keys, double-click — stops it.
-     *   chart.walk({ from: 0, to: 500, speed: 120, step: 10 });
-     *   chart.addEventListener('wick:walk', (e) => showCaption(e.detail));
-     *   // detail: { phase: 'step'|'end'|'stop', index, events: [...], from, to }
-     * @param {{from?: number, to?: number, speed?: number, step?: number}} [opts]
-     *        from/to are bar indices (default: last ~500 bars → the end)
-     * @returns {boolean} true when the walk started
-     */
-    walk(opts?: {
-        from?: number;
-        to?: number;
-        speed?: number;
-        step?: number;
-    }): boolean;
-    /**
-     * Stop the running walk (if any). Fires a final `wick:walk`
-     * { phase: 'stop' } unless called internally.
-     */
-    stopWalk(silent: any): void;
     /**
      * Commit a brush selection over [i0, i1]: stores it (draws the band
      * and delta chip) and fires `wick:brush` with the range statistics.
@@ -1069,55 +885,6 @@ declare class WickChart extends HTMLElementBase {
     clearBrush(): void;
     /** @returns {object|null} the committed selection { i0, i1, stats } */
     get brushSelection(): object | null;
-    /**
-     * Capture the current chart state as a story scene: view, series type,
-     * indicators, overlays, scenario and risk plan, plus a title/note.
-     * Build guided tours by capturing several and playing them back.
-     *   const story = [
-     *     chart.captureScene('Overview', 'The full picture'),
-     *     { title: 'The breakout', range: { from, to }, indicators: 'sma:20' },
-     *   ];
-     *   chart.playStory(story);
-     * @param {string} [title]
-     * @param {string} [note]
-     * @returns {object} scene (plain data — snapshot of the moment)
-     */
-    captureScene(title?: string, note?: string): object;
-    /** @returns {object[]|null} a copy of the last played story */
-    getStory(): object[] | null;
-    /**
-     * Play a story: each scene applies its state (type / indicators /
-     * overlays / scenario / risk plan — set or clear), the camera eases
-     * to its range, then holds for its dwell. `wick:story` events narrate:
-     *   { phase: 'scene' | 'end' | 'stop', index, total, scene, title, note }
-     * Any user interaction — pointer, wheel, keys, double-click — stops it.
-     * @param {object[]} story scenes (invalid entries dropped, max 20)
-     * @param {{dwell?: number, panMs?: number, loop?: boolean}} [opts]
-     *        panMs clamps 100–5000 (default 900); loop replays forever
-     * @returns {boolean} true when playback started
-     */
-    playStory(story: object[], opts?: {
-        dwell?: number;
-        panMs?: number;
-        loop?: boolean;
-    }): boolean;
-    /**
-     * Stop story playback (if running). Fires a final `wick:story`
-     * { phase: 'stop' } unless called internally.
-     */
-    stopStory(silent: any): void;
-    /** Apply a scene's state (only the fields it carries). */
-    _applyScene(sc: any): void;
-    /** Map a scene's time range to bar indices (null when not applicable). */
-    _sceneTarget(sc: any): {
-        i0: number;
-        i1: number;
-    };
-    /** Ease the viewport to { i0, i1 } over `ms`; resolves early if the
-     *  token changes (superseded or stopped). rAF when available. */
-    _storyTween(target: any, ms: any, token: any): Promise<any>;
-    /** Interrupt narrated playback (walk / story) on user input. */
-    _stopPlayback(): void;
     _emitRange(): void;
 }
 export default WickChart;

package/types/wick-feed.d.ts

@@ -15,10 +15,10 @@ declare class WickFeed extends HTMLElementBase {
     _scheduleRestart(): void;
     _teardown(): void;
     _setStatus(status: any, detail: any): void;
-    /** Dispatch `wick-feed:name` plus the deprecated `hab-feed:name` alias. */
+    /** Dispatch `wick-feed:name`. */
     _fire(name: any, detail: any): void;
     /** Resolve the target chart (by `for` id, else the first chart element —
-     *  <wick-chart> or the deprecated <hab-chart>). */
+     *  <wick-chart>). */
     _resolveChart(): Element;
     _restart(): void;
     _synthetic(gen: any, chart: any, key: any, tfId: any, limit: any, live: any, status?: string): void;