wickchart 1.6.0 → 2.0.0

package/types/report.d.ts

@@ -0,0 +1,114 @@
+/** Decimals worth showing for a price of this magnitude. */
+export declare function decimalsFor(price: any): 2 | 3 | 6;
+/** 1234 → '1.2k', 1234567 → '1.23M', 12 → '12'. */
+export declare function compact(v: any): string;
+export declare function pct(v: any, digits?: number): string;
+/** Greatest index whose time is <= t (binary search; bars are ascending). */
+export declare function indexForTime(bars: any, t: any): number;
+/** Resolve the report colors: theme palettes, overridden by the chart's own
+ *  --wick-* variables when readable (browser) and theme is 'auto'. */
+export declare function reportColors(chart: any, theme?: string): {
+    bg: string;
+    panel: string;
+    text: string;
+    muted: string;
+    up: string;
+    down: string;
+    accent: string;
+} | {
+    bg: string;
+    panel: string;
+    text: string;
+    muted: string;
+    up: string;
+    down: string;
+    accent: string;
+};
+/** Relative luminance of a #hex / rgb() string (0..1, best effort). */
+export declare function luminance(color: any): number;
+/**
+ * Build the whole report as data: sizes, bands, stat rows, colors, labels.
+ * @param {object} chart a <wick-chart> (public API only: data,
+ *   getVisibleRange, exportPNG, clientWidth/Height, getAttribute)
+ * @param {{title?: string, source?: string, brand?: string, theme?: string,
+ *   scale?: number, precision?: number}} [opts]
+ */
+export declare function reportModel(chart: object, opts?: {
+    title?: string;
+    source?: string;
+    brand?: string;
+    theme?: string;
+    scale?: number;
+    precision?: number;
+}): {
+    scale: number;
+    width: number;
+    height: number;
+    bands: {
+        header: number;
+        stats: number;
+        footer: number;
+        chart: number;
+    };
+    grid: {
+        cols: number;
+    };
+    title: any;
+    brand: string;
+    source: string;
+    range: {
+        from: any;
+        to: any;
+    };
+    last: any;
+    precision: number;
+    rows: ({
+        label: string;
+        value: string;
+        color: string;
+    } | {
+        color?: undefined;
+        label: string;
+        value: string;
+    })[];
+    generatedAt: number;
+    colors: {
+        bg: string;
+        panel: string;
+        text: string;
+        muted: string;
+        up: string;
+        down: string;
+        accent: string;
+    } | {
+        bg: string;
+        panel: string;
+        text: string;
+        muted: string;
+        up: string;
+        down: string;
+        accent: string;
+    };
+    stats: {
+        n: number;
+        changePct: number;
+        min: number;
+        max: number;
+        maxDDPct: number;
+        annVolPct: number;
+        up: number;
+        dn: number;
+        avgVolume: number;
+    };
+};
+/**
+ * Compose the branded report and return it as a PNG data URL (default), a
+ * Blob, or the canvas itself.
+ * @returns {Promise<string|Blob|HTMLCanvasElement>}
+ */
+export declare function exportReport(chart: any, opts?: {}): Promise<string | Blob | HTMLCanvasElement>;
+/**
+ * Compose and trigger a download (browser only).
+ * @returns {Promise<void>}
+ */
+export declare function downloadReport(chart: any, filename?: string, opts?: {}): Promise<void>;

package/types/wick-chart.d.ts

@@ -1,4 +1,3 @@
-import { PresenceTracker } from './core.js';
 declare const HTMLElementBase: {
     new (): {};
 };
@@ -21,11 +20,7 @@ declare class WickChart extends HTMLElementBase {
     _hover: {
         index: any;
         x: number;
-        y: number;
-    } | {
-        index: number;
-        x: number;
-        y: number;
+        y: any;
     };
     _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;
@@ -164,6 +145,19 @@ declare class WickChart extends HTMLElementBase {
         panes: any[];
         volume: boolean;
     };
+    _workerOn: boolean;
+    _epoch: number;
+    _workerCache: {
+        epoch: number;
+        map: {};
+        pending: {};
+        sent: number;
+    };
+    _sid: number;
+    _onlineSeries: {
+        epoch: number;
+        map: {};
+    };
     _pointers: Map<any, any>;
     _pan: {
         x: number;
@@ -176,6 +170,13 @@ declare class WickChart extends HTMLElementBase {
         idxAtMid: number;
         midX: number;
     };
+    _scrub: boolean;
+    _pressTimer: number;
+    _pressOrigin: {
+        pointerId: any;
+        x: any;
+        y: any;
+    };
     _layers: any[];
     _layerClaim: {
         layer: any;
@@ -187,30 +188,11 @@ declare class WickChart extends HTMLElementBase {
     _positions: any[];
     _alerts: any[];
     _seq: number;
+    _alertEval: string;
+    _lastClosedIdx: number;
+    _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;
@@ -219,8 +201,11 @@ declare class WickChart extends HTMLElementBase {
     _onWheel: (e: any) => void;
     _onDbl: () => void;
     _onKey: (e: any) => void;
+    _onTouchMove: (e: any) => void;
+    _onDprChange: () => void;
     tabIndex: number;
     _ro: any;
+    _dprMq: MediaQueryList;
     _posVersion: any;
     _pendingRange: {
         from: number;
@@ -237,9 +222,18 @@ declare class WickChart extends HTMLElementBase {
         rawHi: number;
     };
     static get observedAttributes(): string[];
+    /**
+     * Shared ChartWorkerPool for the worker compute path (set by importing
+     * 'wickchart/worker'; null — everything sync — until then).
+     * @type {object|null}
+     */
+    static _workerPool: object | null;
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
+    /** (Re)arm the devicePixelRatio watcher for the current ratio. */
+    _watchDpr(): void;
+    _unwatchDpr(): void;
     attributeChangedCallback(name: any, _old: any, val: any): void;
     /** Indicator registry (module scope — shared with the legacy alias tag). */
     static _registry(): Map<string, {
@@ -282,7 +276,7 @@ declare class WickChart extends HTMLElementBase {
             smooth?: undefined;
             period?: undefined;
         };
-        compute: (bars: any) => number[];
+        compute: (bars: any, p: any) => number[];
         color?: undefined;
         guides?: undefined;
         range?: undefined;
@@ -497,7 +491,7 @@ declare class WickChart extends HTMLElementBase {
      */
     /** @param {import('./core.js').IndicatorDef} def */
     static registerIndicator(name: any, def: import('./core.js').IndicatorDef): void;
-    /** The custom element class (also exported implicitly for users). */
+    /** The tag this class registers as. */
     static get elementName(): string;
     get data(): any[];
     /**
@@ -578,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,
@@ -619,99 +612,34 @@ 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;
-    };
+    /** 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. */
     /**
-     * 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>}
+     * Index of the newest bar known to be final: any bar with a newer bar
+     * behind it, plus the front bar when the feed flagged it `closed: true`
+     * (Binance's `k.x`). -1 when nothing has closed yet.
      */
-    applyAI(ops: any): Array<object>;
+    _lastClosedIndex(): number;
+    /** Re-baseline the closed-bar cursor without firing anything. */
+    _syncClosedIdx(): void;
     /**
-     * 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]
+     * Resolve an alert's evaluation mode: an explicit 'close' / 'live' on the
+     * alert wins, otherwise the chart-level `alert-evaluate` default (itself
+     * 'live', so 1.x behaviour is unchanged unless asked for).
+     * @param {string|undefined} v
+     * @returns {'live'|'close'}
      */
-    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. */
+    _evalMode(v: string | undefined): 'live' | 'close';
+    /** Dispatch one alert, retiring it when it was a `once` alert. */
+    _fireAlert(alert: any, detail: any): void;
     _checkAlerts(prevClose: any, bar: any): void;
     /** Cached boolean series for a scripted alert's predicate (per data version). */
     _predicateCache(alert: any): any;
@@ -724,14 +652,18 @@ declare class WickChart extends HTMLElementBase {
     get indicators(): any;
     set indicators(v: any);
     static _MAX_SP: number;
+    /** Hold this long on a touchscreen to open the crosshair (ms). */
+    static _PRESS_MS: number;
+    /** Finger travel that cancels the press and makes it a pan (px). */
+    static _PRESS_SLOP: number;
     /**
      * Lowest allowed px/bar: either 0.35, or whatever fits the entire
      * dataset on screen — so any history can be zoomed out fully.
      */
     _minSpacing(): number;
-    static _timeToMs(t: any): any;
+    static _timeToMs(t: any): number;
     static _normBar(b: any): {
-        time: any;
+        time: number;
         open: any;
         high: any;
         low: any;
@@ -759,6 +691,33 @@ declare class WickChart extends HTMLElementBase {
     _volShadeCache(): any;
     /** Compute (and cache per data version) an indicator entry's series. */
     _indicatorSeries(entry: any): any;
+    /**
+     * After a live stream tick (append or forming-bar replace), patch every
+     * online-capable series by recomputing a bounded tail with the same
+     * batch definition — O(warm-up) instead of a full-history recompute per
+     * indicator per tick. Bases are seeded by the sync or worker path; bulk
+     * loads (epoch changes) reseed automatically.
+     */
+    _onlineTick(): void;
+    /** Recompute the last K bars of one series in place (K = max(400,
+     *  10×period), clamped to the data). False when the series and data
+     *  lengths can't line up — the caller drops the base and reseeds. */
+    _patchSeriesTail(res: any, entry: any, d: any): boolean;
+    /** Remember a fresh series as the base for incremental tick updates
+     *  (online-capable builtins only). */
+    _seedOnline(k: any, entry: any, res: any): void;
+    /** Bar count from which the worker path engages (below it, sync wins). */
+    _workerCols(): {
+        time: Float64Array<ArrayBuffer>;
+        open: Float64Array<ArrayBuffer>;
+        high: Float64Array<ArrayBuffer>;
+        low: Float64Array<ArrayBuffer>;
+        close: Float64Array<ArrayBuffer>;
+        volume: Float64Array<ArrayBuffer>;
+    };
+    /** Kick an off-thread compute for one indicator (idempotent per epoch). */
+    _workerCompute(pool: any, entry: any, k: any): void;
+    _workerArrived(k: any, epoch: any, res: any, entry: any): void;
     /** Resolve a line color: #hex / rgb() / CSS name / palette key ('rsi', 'up', …) / cycle.
      *  Untrusted values (URL/attribute-sourced) are validated — never interpolated raw. */
     _lineColor(entry: any, line: any, pal: any, cycleIdx: any): any;
@@ -782,6 +741,8 @@ declare class WickChart extends HTMLElementBase {
      * the walk to those bars — used at deep zoom where bars are aggregated
      * into pixel columns (keeps this O(screen) instead of O(visible bars)).
      */
+    /** An instant shifted into the chart's display zone, for the formatters. */
+    _zt(t: any): any;
     _timeTicks(i0: any, i1: any, sampleIdx: any): any[];
     _render(): void;
     _pill(x: any, y: any, text: any, bg: any, fg: any, align: string, widthOverride: any): void;
@@ -873,88 +834,30 @@ declare class WickChart extends HTMLElementBase {
         x: number;
         y: number;
     };
+    /**
+     * Put the crosshair on the bar under a point and announce it. Shared by
+     * mouse hover, keyboard walking and the touch scrub gesture.
+     */
+    _hoverAt(pt: any): void;
+    /**
+     * Start the long-press timer for a touch. A touchscreen has no hover, so
+     * without this there is no way to read a bar's values on a phone: a tap
+     * selects, a drag pans, and the legend never leaves the last candle.
+     * Holding still opens the crosshair; moving first cancels and pans.
+     */
+    _armPress(pointerId: any, pt: any): void;
+    _disarmPress(): void;
+    /** Leave scrub mode and put the crosshair away. */
+    _endScrub(): void;
     _pointerDown(e: any): void;
     _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.
@@ -966,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,17 +15,36 @@ 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;
     _binance(gen: any, chart: any, sym: any, tfId: any, limit: any, live: any): Promise<void>;
     _pollBinance(gen: any, chart: any, sym: any, tfId: any): void;
     _degrade(gen: any, chart: any, sym: any, tfId: any, limit: any, live: any, err: any): void;
+    /**
+     * Wrap chart.update for aggregated bars: the chart keys bars by timestamp,
+     * and two groups can close inside the same millisecond, so emitted times
+     * are nudged +1ms to stay strictly increasing (keeps the one-bar-per-
+     * timestamp integrity invariant; display-only, values are untouched).
+     */
+    _aggEmit(gen: any, chart: any): (bar: any) => void;
+    /** Seed + stream one aggregator onto the chart (shared by all sources). */
+    _aggAttach(gen: any, chart: any, res: any, bars: any, limit: any, status: any): {
+        emit: (bar: any) => void;
+        aggregator: any;
+        /** Push one print through; emits the closed bar, then the forming one. */
+        push(t: any): void;
+    };
+    _syntheticTrades(gen: any, chart: any, key: any, agg: any, limit: any, live: any, status?: string): void;
+    _binanceTrades(gen: any, chart: any, sym: any, agg: any, limit: any, live: any): Promise<void>;
+    _pollBinanceTrades(gen: any, chart: any, sym: any, handle: any, fromId: any, agg: any, limit: any, live: any): void;
+    _restTrades(gen: any, chart: any, url: any, agg: any, limit: any, live: any): Promise<void>;
     _rest(gen: any, chart: any, url: any, limit: any, live: any): Promise<void>;
 }
 export default WickFeed;
 export { WickFeed };
+export { parseAggregate, TickBarAggregator, aggregateTrades, normalizeTrades, genSyntheticTrades, makeSynthTradeStream, } from './feeds.js';