wickchart 1.7.0 → 2.0.0

package/src/wick-feed.js

@@ -19,7 +19,6 @@
  *   streaming. Status is reflected in the `status` attribute and via
  *   `wick-feed:status` events (loading / live / polling / fallback / loaded /
  *   waiting / idle). `wick-feed:fallback` fires when a live source degrades.
- *   (The 0.x event names `hab-feed:*` still fire as deprecated aliases.)
  * ========================================================================== */
 
 import './wick-chart.js';
@@ -41,6 +40,7 @@ import {
   normalizeTrades,
 } from './feeds.js';
 
+
 const LIVE_TICK_MS = 650;
 
 const HTMLElementBase = typeof HTMLElement !== 'undefined' ? HTMLElement : class {};
@@ -99,21 +99,19 @@ class WickFeed extends HTMLElementBase {
     this._fire('status', { status, ...detail });
   }
 
-  /** Dispatch `wick-feed:name` plus the deprecated `hab-feed:name` alias. */
+  /** Dispatch `wick-feed:name`. */
   _fire(name, detail) {
     this.dispatchEvent(new CustomEvent('wick-feed:' + name, { detail }));
-    this.dispatchEvent(new CustomEvent('hab-feed:' + name, { detail }));
   }
-
   /** Resolve the target chart (by `for` id, else the first chart element —
-   *  <wick-chart> or the deprecated <hab-chart>). */
+   *  <wick-chart>). */
   _resolveChart() {
     const id = this.getAttribute('for');
     if (id) {
       const el = document.getElementById(id);
       return el && (el.tagName === 'WICK-CHART' || el.tagName === 'HAB-CHART') ? el : null;
     }
-    return document.querySelector('wick-chart') || document.querySelector('hab-chart');
+    return document.querySelector('wick-chart');
   }
 
   _restart() {
@@ -459,12 +457,6 @@ if (typeof customElements !== 'undefined') {
   if (!customElements.get('wick-feed')) {
     customElements.define('wick-feed', WickFeed);
   }
-  // 0.x alias: same element under its old tag name (deprecated, removed in 2.0)
-  if (!customElements.get('hab-feed')) {
-    /** @deprecated use <wick-feed> */
-    class HabFeed extends WickFeed {}
-    customElements.define('hab-feed', HabFeed);
-  }
 }
 
 export default WickFeed;

package/types/core.d.ts

@@ -199,6 +199,9 @@ export declare const DAY: number;
  * @returns {number} milliseconds
  */
 export declare const toMs: (t: number | Date) => number;
+/** Warn once per distinct message (used by the 2.0 moved-method stubs in
+ *  wick-chart.js — deleted with them in 3.0). */
+export declare function warnDeprecatedAlias(message: any): void;
 /**
  * Milliseconds east of UTC in `zone` at the instant `at`.
  *   'utc'            → 0
@@ -477,20 +480,6 @@ export declare function detectAnnotations(bars: Bar[], i0: number, i1: number, r
     i: number;
     note: string;
 }>;
-/**
- * Map a price to a sonification frequency over the visible scale.
- * Logarithmic scales map through log-space; result clamped to [lo, hi] Hz.
- * @param {number} price
- * @param {{min: number, max: number, useLog?: boolean}} scale
- * @param {number} [freqLo=180]
- * @param {number} [freqHi=880]
- * @returns {number} frequency in Hz
- */
-export declare function priceToFreq(price: number, scale: {
-    min: number;
-    max: number;
-    useLog?: boolean;
-}, freqLo?: number, freqHi?: number): number;
 /**
  * Volume profile over a visible bar range: volume distributed into price
  * rows, with POC and the value area (greedy expansion around the POC).
@@ -826,7 +815,7 @@ export declare function evalScript(compiled: {
 /**
  * Build an indicator definition from a WickScript expression — used inline by
  * `indicators="expr:{…}"` / `pexpr:{…}"`, or register it under a name:
- * `HabChart.registerIndicator('myspread', scriptIndicator('close - ema(close,21)'))`.
+ * `WickChart.registerIndicator('myspread', scriptIndicator('close - ema(close,21)'))`.
  * @param {string} src
  * @param {{pane?: boolean}} [opts]
  * @returns {IndicatorDef}
@@ -987,24 +976,6 @@ export declare function normalizeOverlays(list: any): object[];
  * @returns {string} a concrete CSS color
  */
 export declare function resolveOverlayColor(raw: any, pal: object): string;
-/**
- * σ-cone projection from realized per-bar volatility: price bands widening
- * with √h (GBM-style, exp(±z·σ·√h)) over `horizon` future bars.
- * @param {number} lastClose anchor price (bar 0)
- * @param {number} volPerBar per-bar stddev of log returns (from calcRealizedVol)
- * @param {number} horizon future bars (clamped 1–500, default 48)
- * @param {number[]} [levels] σ multipliers, e.g. [1, 2] (each clamped to 0–5)
- * @returns {{horizon: number, levels: number[], bands: Record<string, {up: number[], down: number[]}>}}
- *          bands[z].up/.down are arrays indexed by h = 0…horizon ([0] === lastClose)
- */
-export declare function calcVolCone(lastClose: number, volPerBar: number, horizon: number, levels?: number[]): {
-    horizon: number;
-    levels: number[];
-    bands: Record<string, {
-        up: number[];
-        down: number[];
-    }>;
-};
 /**
  * Validate a scenario spec: a ghost path of future prices (bars or API data)
  * plus optional cone settings. Invalid entries are dropped, never thrown.
@@ -1061,34 +1032,6 @@ export declare function normalizeRiskPlan(spec: any): null | {
     maxK: number;
     label: string;
 };
-/**
- * Turn a bar window into an ordered story: the annotation events (pivot
- * highs/lows, volume spikes, gaps, RSI divergences) plus derived **legs** —
- * the move between consecutive opposite pivots ("+12.4% over 38 bars").
- * The timeline drives the bar-walk player and any caption UI.
- *
- * @param {Bar[]} bars full dataset
- * @param {number} i0 first index of the window
- * @param {number} i1 last index of the window
- * @param {{pivot?: number, volMult?: number, gapMult?: number, rsiPeriod?: number}} [opts]
- *        pivot window defaults to 8 (denser than the annotations overlay's 20)
- * @returns {{i: number, time: number, type: string, side: string, note: string,
- *            legPct?: number, legBars?: number}[]} sorted by index, capped at 60
- */
-export declare function narrateWindow(bars: Bar[], i0: number, i1: number, opts?: {
-    pivot?: number;
-    volMult?: number;
-    gapMult?: number;
-    rsiPeriod?: number;
-}): {
-    i: number;
-    time: number;
-    type: string;
-    side: string;
-    note: string;
-    legPct?: number;
-    legBars?: number;
-}[];
 /**
  * Stats for a brushed bar range: net move (open of the first bar → close
  * of the last), extremes, and summed volume. Powers the brush-selection
@@ -1120,72 +1063,6 @@ export declare function brushStats(bars: Bar[], i0: number, i1: number): null |
     low: number;
     volume: number;
 };
-/** Smoothest cheap easing for viewport pans: slow in, slow out. */
-export declare function easeInOutCubic(t: any): number;
-/**
- * Validate one story scene. Every field is optional except that a scene
- * must be an object; omitted fields simply don't change that aspect of
- * the chart when played. `scenario`/`riskPlan` use a 'clear' sentinel for
- * explicit "remove it" (null input means clear too when the KEY is present).
- *
- *   { title: 'The breakout', note: 'What happened…',
- *     range: { from, to },          // times (s or ms) — the camera pans there
- *     indicators: 'sma:20 rsi:14',  // optional indicator string
- *     type: 'candles',              // optional series type
- *     overlays: [...],              // optional zones/levels (normalizeOverlays)
- *     scenario: {...} | null,       // set / clear a scenario
- *     riskPlan: {...} | null,       // set / clear a risk plan
- *     dwell: 2200 }                 // ms to hold after the pan (500–30000)
- *
- * @returns {object|null} normalized scene, or null for non-objects
- */
-export declare function normalizeScene(scene: any): object | null;
-/**
- * Validate a whole story: normalize each scene, drop junk, cap at 20.
- * @returns {object[]} possibly empty
- */
-export declare function sceneList(story: any): object[];
-/**
- * Tracks other charts viewing the same room: last-sighting timestamps per
- * peer plus the viewport each one is looking at. Pure bookkeeping — the
- * transport (BroadcastChannel, WebSocket, …) lives in the component/app.
- *
- * Peers expire `ttl` ms after their last sighting, so a closed tab fades
- * out of the room without an explicit goodbye.
- */
-export declare class PresenceTracker {
-    ttl: number;
-    /** @type {Map<string, {id: string, name: string|null, range: {from:number,to:number}|null, at: number}>} */
-    peers: Map<string, {
-        id: string;
-        name: string | null;
-        range: {
-            from: number;
-            to: number;
-        } | null;
-        at: number;
-    }>;
-    /** @param {number} [ttl=12000] ms a peer survives without a sighting */
-    constructor(ttl?: number);
-    /**
-     * Record a sighting. `patch.range` ({from,to} times) is validated and
-     * normalized; a sighting without a range keeps the previous one.
-     * @returns {boolean} true when this sighting is a join (new peer)
-     */
-    track(id: any, patch?: {}, now?: number): boolean;
-    /** @returns {object|null} the removed peer entry, or null when unknown */
-    drop(id: any): object | null;
-    /** Expire peers not seen within the ttl.
-     *  @returns {object[]} the peer entries that left */
-    sweep(now?: number): object[];
-    /** @returns {{id: string, name: string|null, range: object|null, at: number}[]} copies, oldest sighting first */
-    list(): {
-        id: string;
-        name: string | null;
-        range: object | null;
-        at: number;
-    }[];
-}
 export declare const tfLabelOf: (dtMs: any) => string;
 /**
  * Compact, LLM-friendly summary of a bar window: structured fields plus a
@@ -1215,110 +1092,3 @@ export declare function encodeStateQuery(state: ChartState | null): string;
  * @returns {ChartState}
  */
 export declare function decodeStateQuery(str: string): ChartState;
-/**
- * Tool manifest for LLM/agent control of a chart. Tools map 1:1 onto the
- * public element API; every op through applyChartOps is validated before it
- * touches the chart (LLM output is untrusted input).
- */
-export declare const AI_TOOLS: ({
-    tool: string;
-    description: string;
-    args: {
-        indicators?: undefined;
-        overlays?: undefined;
-        from?: undefined;
-        to?: undefined;
-        type?: undefined;
-        enabled?: undefined;
-        low?: undefined;
-        high?: undefined;
-    };
-} | {
-    tool: string;
-    description: string;
-    args: {
-        indicators: string;
-        overlays?: undefined;
-        from?: undefined;
-        to?: undefined;
-        type?: undefined;
-        enabled?: undefined;
-        low?: undefined;
-        high?: undefined;
-    };
-} | {
-    tool: string;
-    description: string;
-    args: {
-        indicators?: undefined;
-        overlays: string;
-        from?: undefined;
-        to?: undefined;
-        type?: undefined;
-        enabled?: undefined;
-        low?: undefined;
-        high?: undefined;
-    };
-} | {
-    tool: string;
-    description: string;
-    args: {
-        indicators?: undefined;
-        overlays?: undefined;
-        from: string;
-        to: string;
-        type?: undefined;
-        enabled?: undefined;
-        low?: undefined;
-        high?: undefined;
-    };
-} | {
-    tool: string;
-    description: string;
-    args: {
-        indicators?: undefined;
-        overlays?: undefined;
-        from?: undefined;
-        to?: undefined;
-        type: string;
-        enabled?: undefined;
-        low?: undefined;
-        high?: undefined;
-    };
-} | {
-    tool: string;
-    description: string;
-    args: {
-        indicators?: undefined;
-        overlays?: undefined;
-        from?: undefined;
-        to?: undefined;
-        type?: undefined;
-        enabled: string;
-        low: string;
-        high: string;
-    };
-})[];
-/**
- * Compact system prompt for agent control: paste into any LLM alongside the
- * tool manifest. The model answers with a JSON array of {tool, args} ops.
- * @returns {string}
- */
-export declare function aiPromptText(): string;
-/**
- * Validate + apply a list of {tool, args} ops (typically LLM output) to a
- * chart-like target. Ops are whitelisted and their args validated — an op
- * never throws; it returns {ok: false, error} instead so the agent can
- * self-correct. Target contract: getDataWindow(), setAttribute(k, v),
- * setOverlays(list), clearOverlays(), addAlert(a), setVisibleRange(r),
- * fit(), and (static) _registry() for indicator name checks.
- * @param {object} target chart element (or test double)
- * @param {any} ops
- * @returns {Array<{ok: boolean, tool?: string, result?: any, error?: string}>}
- */
-export declare function applyChartOps(target: object, ops: any): Array<{
-    ok: boolean;
-    tool?: string;
-    result?: any;
-    error?: string;
-}>;

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: {
@@ -103,24 +98,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 +113,6 @@ declare class WickChart extends HTMLElementBase {
         done: boolean;
     };
     _measuring: boolean;
-    _walkTimer: number;
-    _storyToken: number;
-    _story: object[];
     _brush: boolean;
     _brushSel: {
         i0: number;
@@ -212,29 +193,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 +491,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 +572,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 +612,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. */
@@ -980,84 +853,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 +869,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;