@tony01/astroneum 0.4.1-beta.2

package/dist/de-DE-4PR3NRQ7.js

@@ -0,0 +1,2 @@
+'use client';
+var i="Indikator",a="Haupt-Indikator",r="Sub-Indikator",t="Einstellungen",l="Zeitzone",o="Screenshot",s="Vollbild",c="Beenden",_="Speichern",h="Best\xE4tigen",g="Abbrechen",d="MA(Gleitender Durchschnitt)",m="EMA(Exponentieller gleitender Durchschnitt)",u="SMA",b="BOLL(Bollinger B\xE4nder)",k="BBI(Bulle und B\xE4r Index)",p="SAR(Stopp und Umkehr)",C="VOL(Volumen)",S="MACD(Gleitender Durchschnitt Konvergenz/Divergenz)",T="KDJ",f="RSI(Relativer St\xE4rke-Index)",w="BIAS(Abweichungsrate)",z="BRAR(Bullen- und B\xE4ren-Stimmung)",B="CCI(Commodity Channel Index)",y="DMI(Richtungsbewegungsindex)",U="CR(Energie-Index)",A="PSY(Psychologische Linie)",v="DMA(Differenz gleitender Durchschnitt)",P="TRIX(Dreifach gegl\xE4tteter gleitender Durchschnitt)",L="OBV(On-Balance-Volumen)",D="VR(Volatilit\xE4ts-Volumen-Verh\xE4ltnis)",x="WR(Williams %R)",I="MTM(Momentum-Index)",V="EMV(Bewegungsleichtigkeit)",M="ROC(Preis\xE4nderungsrate)",R="PVT(Preis-Volumen-Trend)",F="AO(Awesome Oszillator)",K="UTC",O="(UTC-10) Honolulu",H="(UTC-8) Juneau",E="(UTC-7) Los Angeles",W="(UTC-5) Chicago",G="(UTC-4) Toronto",j="(UTC-3) S\xE3o Paulo",J="(UTC+1) London",N="(UTC+2) Berlin",X="(UTC+3) Bahrain",Z="(UTC+4) Dubai",Y="(UTC+5) Aschgabat",q="(UTC+6) Almaty",Q="(UTC+7) Bangkok",$="(UTC+8) Shanghai",ee="(UTC+9) Tokio",ne="(UTC+10) Sydney",ie="(UTC+12) Norfolk",ae="Horizontale Linie",re="Horizontaler Strahl",te="Horizontales Segment",le="Vertikale Linie",oe="Vertikaler Strahl",se="Vertikales Segment",ce="Trendlinie",_e="Strahl",he="Segment",ge="Pfeil",de="Preislinie",me="Preiskanalline",ue="Parallele Linie",be="Fibonacci-Linie",ke="Fibonacci-Segment",pe="Fibonacci-Kreis",Ce="Fibonacci-Spirale",Se="Fibonacci-Sektor",Te="Fibonacci-Extension",fe="Gann-Box",we="Gann-F\xE4cher",ze="Andrews-Pitchfork",Be="Rechteck",ye="Parallelogramm",Ue="Kreis",Ae="Dreieck",ve="Drei Wellen",Pe="F\xFCnf Wellen",Le="Acht Wellen",De="Beliebige Wellen",xe="ABCD-Muster",Ie="XABCD-Muster",Ve="Schwacher Magnet",Me="Starker Magnet",Re="Symbol suchen",Fe="Symbol-Code",Ke="Parameter 1",Oe="Parameter 2",He="Parameter 3",Ee="Parameter 4",We="Parameter 5",Ge="Linie 1",je="Linie 2",Je="Linie 3",Ne="Linie 4",Xe="Linie 5",Ze="Zeitraum",Ye="Standardabweichung",qe="Kerzentyp",Qe="Kerze ausgef\xFCllt",$e="Kerze Umriss",en="Aufw\xE4rtskerze Umriss",nn="Abw\xE4rtskerze Umriss",an="OHLC",rn="Fl\xE4che",tn="Letzten Preis anzeigen",ln="H\xF6chstpreis anzeigen",on="Tiefstkurs anzeigen",sn="Letzten Indikatorwert anzeigen",cn="Preisachsentyp",_n="Normal",hn="Prozent",gn="Logarithmisch",dn="Koordinaten umkehren",mn="Gitter anzeigen",un="Standard wiederherstellen",bn={indicator:i,main_indicator:a,sub_indicator:r,setting:t,timezone:l,screenshot:o,full_screen:s,exit_full_screen:c,save:_,confirm:h,cancel:g,ma:d,ema:m,sma:u,boll:b,bbi:k,sar:p,vol:C,macd:S,kdj:T,rsi:f,bias:w,brar:z,cci:B,dmi:y,cr:U,psy:A,dma:v,trix:P,obv:L,vr:D,wr:x,mtm:I,emv:V,roc:M,pvt:R,ao:F,utc:K,honolulu:O,juneau:H,los_angeles:E,chicago:W,toronto:G,sao_paulo:j,london:J,berlin:N,bahrain:X,dubai:Z,ashkhabad:Y,almaty:q,bangkok:Q,shanghai:$,tokyo:ee,sydney:ne,norfolk:ie,horizontal_straight_line:ae,horizontal_ray_line:re,horizontal_segment:te,vertical_straight_line:le,vertical_ray_line:oe,vertical_segment:se,straight_line:ce,ray_line:_e,segment:he,arrow:ge,price_line:de,price_channel_line:me,parallel_straight_line:ue,fibonacci_line:be,fibonacci_segment:ke,fibonacci_circle:pe,fibonacci_spiral:Ce,fibonacci_speed_resistance_fan:Se,fibonacci_extension:Te,gann_box:fe,gann_fan:we,pitchfork:ze,rect:Be,parallelogram:ye,circle:Ue,triangle:Ae,three_waves:ve,five_waves:Pe,eight_waves:Le,any_waves:De,abcd:xe,xabcd:Ie,weak_magnet:Ve,strong_magnet:Me,symbol_search:Re,symbol_code:Fe,params_1:Ke,params_2:Oe,params_3:He,params_4:Ee,params_5:We,line_1:Ge,line_2:je,line_3:Je,line_4:Ne,line_5:Xe,period:Ze,standard_deviation:Ye,candle_type:qe,candle_solid:Qe,candle_stroke:$e,candle_up_stroke:en,candle_down_stroke:nn,ohlc:an,area:rn,last_price_show:tn,high_price_show:ln,low_price_show:on,indicator_last_value_show:sn,price_axis_type:cn,normal:_n,percentage:hn,log:gn,reverse_coordinate:dn,grid_show:mn,restore_default:un};export{xe as abcd,q as almaty,De as any_waves,F as ao,rn as area,ge as arrow,Y as ashkhabad,X as bahrain,Q as bangkok,k as bbi,N as berlin,w as bias,b as boll,z as brar,g as cancel,nn as candle_down_stroke,Qe as candle_solid,$e as candle_stroke,qe as candle_type,en as candle_up_stroke,B as cci,W as chicago,Ue as circle,h as confirm,U as cr,bn as default,v as dma,y as dmi,Z as dubai,Le as eight_waves,m as ema,V as emv,c as exit_full_screen,pe as fibonacci_circle,Te as fibonacci_extension,be as fibonacci_line,ke as fibonacci_segment,Se as fibonacci_speed_resistance_fan,Ce as fibonacci_spiral,Pe as five_waves,s as full_screen,fe as gann_box,we as gann_fan,mn as grid_show,ln as high_price_show,O as honolulu,re as horizontal_ray_line,te as horizontal_segment,ae as horizontal_straight_line,i as indicator,sn as indicator_last_value_show,H as juneau,T as kdj,tn as last_price_show,Ge as line_1,je as line_2,Je as line_3,Ne as line_4,Xe as line_5,gn as log,J as london,E as los_angeles,on as low_price_show,d as ma,S as macd,a as main_indicator,I as mtm,ie as norfolk,_n as normal,L as obv,an as ohlc,ue as parallel_straight_line,ye as parallelogram,Ke as params_1,Oe as params_2,He as params_3,Ee as params_4,We as params_5,hn as percentage,Ze as period,ze as pitchfork,cn as price_axis_type,me as price_channel_line,de as price_line,A as psy,R as pvt,_e as ray_line,Be as rect,un as restore_default,dn as reverse_coordinate,M as roc,f as rsi,j as sao_paulo,p as sar,_ as save,o as screenshot,he as segment,t as setting,$ as shanghai,u as sma,Ye as standard_deviation,ce as straight_line,Me as strong_magnet,r as sub_indicator,ne as sydney,Fe as symbol_code,Re as symbol_search,ve as three_waves,l as timezone,ee as tokyo,G as toronto,Ae as triangle,P as trix,K as utc,oe as vertical_ray_line,se as vertical_segment,le as vertical_straight_line,C as vol,D as vr,Ve as weak_magnet,x as wr,Ie as xabcd};

package/dist/entries/alerts.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Client-side price / indicator alerts engine — extended.
+ *
+ * Alerts are persisted to localStorage and evaluated on every new bar
+ * or price tick via `AlertManager.check()`.
+ *
+ * Extended fields: expiration, messageTemplate, emailEnabled,
+ * plainTextEnabled, plainTextEmail, toastEnabled, notificationSchedule,
+ * soundTitle, soundDuration.
+ *
+ * Delivery: sound (variable titles), browser notification, toast popup,
+ * webhook (via server-side relay /astroneum/api/alerts/webhook), email
+ * (via API route), plain-text email, schedule gate. Webhook delivery status
+ * is written back onto the alert so the alert log can surface it
+ * (mirrors TradingView's "Webhook status" column).
+ */
+type AlertCondition = 'above' | 'below' | 'crosses_above' | 'crosses_below' | 'crossing';
+type AlertStatus = 'active' | 'triggered' | 'expired' | 'dismissed';
+type AlertFrequency = 'once' | 'every_bar' | 'bar_close';
+type SoundTitle = 'Thin' | 'Classic' | 'Alert' | 'Bell' | 'Chime';
+type SoundDuration = 'once' | 'repeating';
+type WebhookStatus = 'pending' | 'delivered' | 'failed';
+interface NotificationSchedule {
+    preset: '24/7' | 'weekdays' | 'working_hours' | 'custom';
+    days?: number[];
+    from?: string;
+    to?: string;
+}
+interface Alert {
+    id: string;
+    symbol: string;
+    condition: AlertCondition;
+    price: number;
+    note?: string;
+    timeframe?: string;
+    frequency: AlertFrequency;
+    status: AlertStatus;
+    createdAt: string;
+    triggeredAt?: string;
+    soundEnabled: boolean;
+    notificationEnabled: boolean;
+    webhookUrl?: string;
+    webhookStatus?: WebhookStatus;
+    webhookStatusAt?: string;
+    webhookHttpStatus?: number;
+    expiration?: string;
+    messageTemplate?: string;
+    emailEnabled?: boolean;
+    plainTextEnabled?: boolean;
+    plainTextEmail?: string;
+    toastEnabled?: boolean;
+    notificationSchedule?: NotificationSchedule;
+    soundTitle?: SoundTitle;
+    soundDuration?: SoundDuration;
+}
+type AlertCreate = Omit<Alert, 'id' | 'status' | 'createdAt' | 'triggeredAt'> & Partial<Pick<Alert, 'frequency' | 'soundEnabled' | 'notificationEnabled'>>;
+interface AlertCheckInput {
+    symbol: string;
+    price: number;
+    timestamp: number;
+}
+type AlertTriggeredCallback = (alert: Alert, price: number) => void;
+declare class AlertManager {
+    private static _instance;
+    private _alerts;
+    private _lastPrice;
+    private _listeners;
+    private _savePending;
+    private constructor();
+    static getInstance(): AlertManager;
+    add(create: AlertCreate): string;
+    update(id: string, patch: Partial<Omit<Alert, 'id' | 'createdAt'>>): boolean;
+    delete(id: string): boolean;
+    dismiss(id: string): boolean;
+    reactivate(id: string): boolean;
+    clear(symbol?: string): void;
+    getAll(): readonly Alert[];
+    getActive(): Alert[];
+    getForSymbol(symbol: string): Alert[];
+    getActiveForSymbol(symbol: string): Alert[];
+    getHistory(): Alert[];
+    /**
+     * Call on every price tick or bar close.
+     * Checks expiration, evaluates conditions, fires delivery.
+     */
+    check(input: AlertCheckInput): void;
+    private _schedulePersist;
+    private _fire;
+    onTriggered(cb: AlertTriggeredCallback): () => void;
+    requestNotificationPermission(): Promise<NotificationPermission>;
+}
+
+export { type Alert, type AlertCheckInput, type AlertCondition, type AlertCreate, type AlertFrequency, AlertManager, type AlertStatus, type AlertTriggeredCallback, type NotificationSchedule, type SoundDuration, type SoundTitle };

package/dist/entries/alerts.js

@@ -0,0 +1,2 @@
+'use client';
+export{a as AlertManager}from'../chunk-4YOLQ5DC.js';

package/dist/entries/datafeeds/crypto.d.ts

@@ -0,0 +1,65 @@
+import { e as SymbolInfo, d as Period, C as CandleData, D as Datafeed, i as DatafeedSubscribeCallback } from '../../Indicator-BBI3L_lx.js';
+import 'react';
+
+interface CryptoSymbolInfo extends SymbolInfo {
+    exchange: string;
+    venueSymbol?: string;
+    instId?: string;
+    productType?: string;
+}
+declare const STANDARD_CRYPTO_SYMBOLS: readonly SymbolInfo[];
+type DatafeedErrorType = 'history-empty' | 'history-request-failed' | 'unsupported-period' | 'unsupported-symbol' | 'subscription-failed';
+interface DatafeedErrorDetail {
+    exchange?: string;
+    ticker: string;
+    period: string;
+    type: DatafeedErrorType;
+    message: string;
+}
+declare const DATAFEED_ERROR_EVENT = "astroneum:datafeed-error";
+interface ExchangeAdapter {
+    readonly id: string;
+    getHistoryBars(symbol: SymbolInfo, period: Period, from: number, to: number): Promise<CandleData[]>;
+    getWebSocketUrl(symbol: SymbolInfo, period: Period): string;
+    parseMessage(event: MessageEvent, symbol: SymbolInfo, period: Period): CandleData | null;
+    onOpen?(ws: WebSocket, symbol: SymbolInfo, period: Period): void;
+}
+declare const BinanceAdapter: ExchangeAdapter;
+declare const BitgetAdapter: ExchangeAdapter;
+declare const OkxAdapter: ExchangeAdapter;
+interface StandardCryptoDatafeedOptions {
+    /**
+     * Symbols available through searchSymbols.
+     * Defaults to STANDARD_CRYPTO_SYMBOLS.
+     */
+    symbols?: readonly SymbolInfo[];
+    /**
+     * Exchange adapters keyed by adapter.id.
+     * Defaults to built-in Binance, Bitget, and OKX adapters.
+     */
+    adapters?: readonly ExchangeAdapter[];
+    /**
+     * Tick interpolation duration (ms) for smoother live movement.
+     * Set to 0 for raw, non-interpolated tick rendering.
+     * Defaults to 220.
+     */
+    smoothingDuration?: number;
+}
+declare class StandardCryptoDatafeed implements Datafeed {
+    private readonly symbols;
+    private readonly liveFeeds;
+    private readonly supportedExchanges;
+    private readonly noDataFeed;
+    private readonly activeFeedByKey;
+    constructor(options?: StandardCryptoDatafeedOptions);
+    searchSymbols(search?: string): Promise<SymbolInfo[]>;
+    getHistoryData(symbol: SymbolInfo, period: Period, from: number, to: number): Promise<CandleData[]>;
+    subscribe(symbol: SymbolInfo, period: Period, callback: DatafeedSubscribeCallback): void;
+    unsubscribe(symbol: SymbolInfo, period: Period): void;
+    private normalizeSymbol;
+    private resolveFeed;
+    private resolveExchange;
+}
+declare function createStandardCryptoDatafeed(options?: StandardCryptoDatafeedOptions): StandardCryptoDatafeed;
+
+export { BinanceAdapter, BitgetAdapter, type CryptoSymbolInfo, DATAFEED_ERROR_EVENT, type DatafeedErrorDetail, type DatafeedErrorType, type ExchangeAdapter, OkxAdapter, STANDARD_CRYPTO_SYMBOLS, StandardCryptoDatafeed, type StandardCryptoDatafeedOptions, createStandardCryptoDatafeed };

package/dist/entries/datafeeds/crypto.js

@@ -0,0 +1,2 @@
+'use client';
+export{c as BinanceAdapter,d as BitgetAdapter,b as DATAFEED_ERROR_EVENT,e as OkxAdapter,a as STANDARD_CRYPTO_SYMBOLS,f as StandardCryptoDatafeed,g as createStandardCryptoDatafeed}from'../../chunk-I4YQBP2M.js';import'../../chunk-SDXH2WAI.js';

package/dist/entries/datafeeds/polygon.d.ts

@@ -0,0 +1,113 @@
+import { D as Datafeed, e as SymbolInfo, d as Period, C as CandleData, i as DatafeedSubscribeCallback } from '../../Indicator-BBI3L_lx.js';
+import 'react';
+
+declare class DefaultDatafeed implements Datafeed {
+    #private;
+    constructor(apiKey: string);
+    private _prevSymbolMarket?;
+    private _ws?;
+    private _reconnectDelay;
+    private _reconnectTimer?;
+    private _currentSymbol?;
+    private _currentCallback?;
+    private _prevTickTimestamp;
+    private _prevTickOpen;
+    private _prevTickHigh;
+    private _prevTickLow;
+    private _prevTickClose;
+    /** Returns true when the incoming tick carries new information. */
+    private _isDeltaTick;
+    /** Update the rolling reference point for delta comparison. */
+    private _updateDeltaRef;
+    /**
+     * OHLCV-aware coalescer: merges ticks arriving within the same rAF frame
+     * into one financially accurate bar (high=max, low=min, close=last, volume=sum).
+     * Feeds the merged result into the TickAnimator for smooth close interpolation.
+     */
+    private readonly _mergeTick;
+    /**
+     * Smooth price interpolation: animates the last bar's close/high/low values
+     * over 120ms so rapid ticks produce fluid motion instead of jarring jumps.
+     * The interpolated frame is what actually reaches the chart callback.
+     */
+    private readonly _animator;
+    searchSymbols(search?: string): Promise<SymbolInfo[]>;
+    getHistoryData(symbol: SymbolInfo, period: Period, from: number, to: number): Promise<CandleData[]>;
+    /**
+     * Subscribes to real-time trade ticks for the given symbol.
+     * NOTE: Polygon's delayed WebSocket stream delivers raw trades (ev: 'T'),
+     * not pre-aggregated OHLCV bars. Bar aggregation is handled by the engine.
+     * The `_period` parameter is intentionally unused.
+     */
+    subscribe(symbol: SymbolInfo, _period: Period, callback: DatafeedSubscribeCallback): void;
+    private _setupWS;
+    private _scheduleReconnect;
+    private _teardownWS;
+    /**
+     * Tears down the active WebSocket subscription for the given symbol.
+     * The `_period` parameter is intentionally unused (matches interface contract).
+     */
+    unsubscribe(symbol: SymbolInfo, _period: Period): void;
+}
+
+interface WebSocketDatafeedOptions {
+    /**
+     * Duration in milliseconds for TickAnimator smooth interpolation.
+     * Set to 0 to disable smoothing. Default: 140
+     */
+    smoothingDuration?: number;
+    /**
+     * Base reconnect delay in ms (doubles on each failure). Default: 1000
+     */
+    reconnectBaseMs?: number;
+    /**
+     * Maximum reconnect delay in ms. Default: 30000
+     */
+    reconnectMaxMs?: number;
+}
+declare abstract class WebSocketDatafeed implements Datafeed {
+    protected readonly smoothingDuration: number;
+    protected readonly reconnectBaseMs: number;
+    protected readonly reconnectMaxMs: number;
+    private readonly _sockets;
+    private readonly _animators;
+    private readonly _reconnectTimers;
+    private readonly _reconnectDelays;
+    private readonly _manualClose;
+    constructor(options?: WebSocketDatafeedOptions);
+    /** Fetch historical OHLCV bars from your REST API. */
+    abstract getHistoryBars(symbol: SymbolInfo, period: Period, from: number, to: number): Promise<CandleData[]>;
+    /**
+     * Return the WebSocket URL for the given symbol/period.
+     * Called on every (re)connect.
+     */
+    abstract getWebSocketUrl(symbol: SymbolInfo, period: Period): string;
+    /**
+     * Parse a raw WebSocket MessageEvent.
+     * Return a CandleData object to emit a tick, or null to ignore the message.
+     */
+    abstract parseMessage(event: MessageEvent, symbol: SymbolInfo, period: Period): CandleData | null;
+    /** Optionally override to search your symbol catalogue. Default returns []. */
+    searchSymbols(_search?: string): Promise<SymbolInfo[]>;
+    /**
+     * Called immediately after a WebSocket connection opens.
+     * Override to send a subscription frame (e.g., Binance topic subscribe JSON).
+     */
+    protected onOpen(_ws: WebSocket, _symbol: SymbolInfo, _period: Period): void;
+    getHistoryData(symbol: SymbolInfo, period: Period, from: number, to: number): Promise<CandleData[]>;
+    subscribe(symbol: SymbolInfo, period: Period, callback: DatafeedSubscribeCallback): void;
+    unsubscribe(symbol: SymbolInfo, period: Period): void;
+    /**
+     * Convert a Period to a Binance-style interval string ('1m', '5m', '1h', etc.)
+     * Returns null if the multiplier is not a standard Binance interval.
+     */
+    protected toInterval(period: Period): string | null;
+    /** Period duration in milliseconds. */
+    protected periodMs(period: Period): number;
+    private _key;
+    private _connect;
+    private _scheduleReconnect;
+    private _cleanup;
+}
+
+export { DefaultDatafeed, WebSocketDatafeed, type WebSocketDatafeedOptions };

package/dist/entries/datafeeds/polygon.js

@@ -0,0 +1,2 @@
+'use client';
+export{a as DefaultDatafeed}from'../../chunk-2YYGUSVX.js';import'../../chunk-YFPXTHZX.js';export{b as WebSocketDatafeed}from'../../chunk-SDXH2WAI.js';

package/dist/entries/multichart.d.ts

@@ -0,0 +1,96 @@
+import { A as AstroneumOptions, e as SymbolInfo, d as Period, a as AstroneumHandle } from '../Indicator-BBI3L_lx.js';
+import 'react';
+
+/** Number of charts in a multi-chart view. */
+type MultiChartCount = 2 | 4 | 8 | 16;
+/** A slot configuration within the layout. */
+interface MultiChartSlot {
+    symbol: SymbolInfo;
+    period: Period;
+}
+/** Options for creating a MultiChartLayout. */
+interface MultiChartLayoutOptions extends Omit<AstroneumOptions, 'symbol' | 'period'> {
+    /** The DOM element (or id) to render the layout into. */
+    container: string | HTMLElement;
+    /**
+     * Number of charts to display. Determines the grid.
+     * 2  → 1×2 (two columns)
+     * 4  → 2×2
+     * 8  → 2×4
+     * 16 → 4×4
+     */
+    count?: MultiChartCount;
+    /** Initial slot configuration. Defaults to the first symbol/period for all slots. */
+    slots?: MultiChartSlot[];
+    /** Symbol / period used for slots with no explicit configuration. */
+    symbol: SymbolInfo;
+    period: Period;
+    /** Whether to sync crosshair across all charts (default: true). */
+    syncCrosshair?: boolean;
+    /** Whether to sync symbol and period across all charts (default: false). */
+    syncSymbolPeriod?: boolean;
+    /** localStorage key for layout persistence. Pass null to disable. */
+    storageKey?: string | null;
+}
+/**
+ * Manages a grid of Astroneum chart instances inside a single container.
+ *
+ * @example
+ * ```ts
+ * const layout = new MultiChartLayout({
+ *   container: 'chart-root',
+ *   count: 4,
+ *   symbol: { ticker: 'AAPL' },
+ *   period: { multiplier: 1, timespan: 'day', text: 'D' },
+ *   datafeed: myDatafeed,
+ *   storageKey: 'my-layout'
+ * })
+ * ```
+ */
+declare class MultiChartLayout {
+    private _container;
+    private _count;
+    private _charts;
+    private _slots;
+    private _options;
+    private _storageKey;
+    private _syncCrosshair;
+    private _syncSymbolPeriod;
+    private _activeIndex;
+    private _wrapperEl;
+    constructor(options: MultiChartLayoutOptions);
+    private _render;
+    private _setActive;
+    private _destroy;
+    private _persist;
+    /** Change the layout grid (2 | 4 | 8 | 16). Re-renders all charts. */
+    setCount(count: MultiChartCount): void;
+    /** Get the count of charts. */
+    getCount(): MultiChartCount;
+    /** Get the chart instance at a given index. */
+    getChart(index: number): AstroneumHandle | undefined;
+    /** Get all chart instances. */
+    getAllCharts(): AstroneumHandle[];
+    /** Get the index of the currently active (focused) chart. */
+    getActiveIndex(): number;
+    /** Get the currently active chart instance. */
+    getActiveChart(): AstroneumHandle | undefined;
+    /**
+     * Set the symbol for a specific chart slot (or all slots if syncSymbolPeriod is on).
+     */
+    setSymbol(symbol: SymbolInfo, index?: number): void;
+    /**
+     * Set the period for a specific chart slot (or all slots if syncSymbolPeriod is on).
+     */
+    setPeriod(period: Period, index?: number): void;
+    /** Set theme for all charts. */
+    setTheme(theme: string): void;
+    /** Set locale for all charts. */
+    setLocale(locale: string): void;
+    /** Save current layout to localStorage immediately. */
+    saveLayout(): void;
+    /** Destroy all charts and clean up the DOM. */
+    destroy(): void;
+}
+
+export { type MultiChartCount, MultiChartLayout, type MultiChartLayoutOptions, type MultiChartSlot };

package/dist/entries/multichart.js

@@ -0,0 +1,2 @@
+'use client';
+export{m as MultiChartLayout}from'../chunk-OOMZRONH.js';import'../chunk-YFPXTHZX.js';import'../chunk-4YOLQ5DC.js';import'../chunk-YW3STIPY.js';

package/dist/entries/portfolio.d.ts

@@ -0,0 +1,55 @@
+/**
+ * PortfolioTracker — client-side position / P&L tracker.
+ * Persists to localStorage under key 'astroneum-portfolio'.
+ */
+type PositionSide = 'long' | 'short';
+interface Position {
+    id: string;
+    symbol: string;
+    side: PositionSide;
+    quantity: number;
+    entryPrice: number;
+    entryTime: string;
+    exitPrice?: number;
+    exitTime?: string;
+    note?: string;
+}
+interface PnLResult {
+    position: Position;
+    /** Unrealised (open) or realised (closed) gross P&L in price units × quantity */
+    pnl: number;
+    /** P&L as a fraction of entry value, e.g. 0.05 = +5 % */
+    pnlPercent: number;
+}
+type PortfolioChangedCallback = (positions: Position[]) => void;
+declare class PortfolioTracker {
+    private static _instance;
+    private _positions;
+    private _listeners;
+    private constructor();
+    static getInstance(): PortfolioTracker;
+    onChange(cb: PortfolioChangedCallback): () => void;
+    addPosition(params: Omit<Position, 'id' | 'entryTime'> & {
+        entryTime?: string;
+    }): Position;
+    closePosition(id: string, exitPrice: number, exitTime?: string): void;
+    deletePosition(id: string): void;
+    getOpenPositions(symbol?: string): Position[];
+    getClosedPositions(symbol?: string): Position[];
+    getAllPositions(): Position[];
+    /**
+     * Calculate P&L for a single position.
+     * @param id - Position id
+     * @param currentPrice - Current market price (used for open positions)
+     */
+    getPnL(id: string, currentPrice?: number): PnLResult | null;
+    /**
+     * Calculate total P&L across all positions (open or closed).
+     * @param currentPrices - Map of symbol → current price for open positions
+     */
+    getTotalPnL(currentPrices?: Record<string, number>): number;
+    private _persist;
+    private _load;
+}
+
+export { type PnLResult, PortfolioTracker, type Position, type PositionSide };

package/dist/entries/portfolio.js

@@ -0,0 +1,2 @@
+'use client';
+export{a as PortfolioTracker}from'../chunk-2SN3RH42.js';

package/dist/entries/replay.d.ts

@@ -0,0 +1,141 @@
+import { D as Datafeed, e as SymbolInfo, d as Period, C as CandleData, N as Nullable } from '../Indicator-BBI3L_lx.js';
+import 'react';
+
+type BarReplayState = 'idle' | 'playing' | 'paused' | 'finished';
+interface BarReplayOptions {
+    /** The datafeed to load historical bars from. */
+    datafeed: Datafeed;
+    /** Symbol to replay. */
+    symbol: SymbolInfo;
+    /** Period to replay. */
+    period: Period;
+    /**
+     * Timestamp (ms) to start the replay from.
+     * If omitted, uses the earliest bar in the loaded history.
+     */
+    startTime?: number;
+    /**
+     * Timestamp (ms) to end the replay at.
+     * If omitted, replays to the latest available bar.
+     */
+    endTime?: number;
+    /**
+     * Milliseconds between each bar step when playing automatically.
+     * Default: 500ms
+     */
+    intervalMs?: number;
+    /**
+     * Number of initial bars to pre-load before replay begins.
+     * Default: 300
+     */
+    initialBars?: number;
+    /** Called whenever a new bar is emitted during replay. */
+    onBar?: (bar: CandleData, index: number, total: number) => void;
+    /** Called when replay state changes. */
+    onStateChange?: (state: BarReplayState) => void;
+    /** Called when replay finishes (reached endTime or last bar). */
+    onFinish?: () => void;
+}
+/**
+ * Historical bar replay engine for manual strategy testing.
+ *
+ * Important: for realistic backtesting, use `getRevealedBars()` to feed only
+ * bars up to the cursor into the chart. This ensures indicators only see data
+ * available at the replay point — not future bars.
+ *
+ * Usage:
+ * ```ts
+ * const replay = new BarReplay({
+ *   datafeed,
+ *   symbol: { ticker: 'AAPL' },
+ *   period: { multiplier: 1, timespan: 'day', text: 'D' },
+ *   onBar: (bar, idx, total) => {
+ *     // Feed only revealed bars for realistic indicator calculations
+ *     chart.setData(replay.getRevealedBars())
+ *   },
+ *   onStateChange: (s) => console.log('state:', s),
+ * })
+ *
+ * await replay.load()
+ * // Initialize chart with pre-replay context only
+ * chart.setData(replay.getRevealedBars())
+ * replay.play()
+ * ```
+ */
+declare class BarReplay {
+    private _opts;
+    private _bars;
+    private _cursor;
+    private _state;
+    private _timer;
+    constructor(options: BarReplayOptions);
+    private _setState;
+    private _emitCurrent;
+    private _advance;
+    private _stop;
+    /**
+     * Load historical bars from the datafeed.
+     * Must be called before play/step.
+     */
+    load(): Promise<void>;
+    /**
+     * Get the bars that have been "revealed" so far (up to and including cursor).
+     * Use this to initialise the chart with the pre-replay context bars.
+     */
+    getRevealedBars(): CandleData[];
+    /** Get all loaded bars (for reference). */
+    getAllBars(): CandleData[];
+    /** Current replay state. */
+    get state(): BarReplayState;
+    /** Index of the current bar (0-based from start of loaded bars). */
+    get cursor(): number;
+    /** Total number of loaded bars. */
+    get total(): number;
+    /** Current bar or null if no bars loaded. */
+    get currentBar(): Nullable<CandleData>;
+    /** Progress as a value between 0 and 1. */
+    get progress(): number;
+    /**
+     * Start auto-playing the replay at the configured interval.
+     */
+    play(): void;
+    /**
+     * Pause auto-play. Use play() to resume.
+     */
+    pause(): void;
+    /**
+     * Toggle between play and pause.
+     */
+    togglePlayPause(): void;
+    /**
+     * Advance by one bar (manual step). Pauses auto-play if running.
+     */
+    stepForward(): void;
+    /**
+     * Go back one bar. Pauses auto-play if running.
+     */
+    stepBack(): void;
+    /**
+     * Jump to a specific bar index. Pauses auto-play.
+     */
+    seekTo(index: number): void;
+    /**
+     * Seek to a timestamp. Finds the nearest bar at or before the given time.
+     */
+    seekToTime(timestamp: number): void;
+    /**
+     * Change the playback speed.
+     * @param intervalMs Milliseconds between bars (lower = faster)
+     */
+    setSpeed(intervalMs: number): void;
+    /**
+     * Reset replay to the beginning (before initial pre-load position).
+     */
+    reset(): void;
+    /**
+     * Stop and clean up. Call when done with this instance.
+     */
+    destroy(): void;
+}
+
+export { BarReplay, type BarReplayOptions, type BarReplayState };

package/dist/entries/replay.js

@@ -0,0 +1,2 @@
+'use client';
+export{a as BarReplay}from'../chunk-3GJSZFLM.js';

package/dist/entries/script.d.ts

@@ -0,0 +1,68 @@
+import { I as IndicatorTemplate } from '../Indicator-BBI3L_lx.js';
+import 'react';
+
+/**
+ * Client-side JavaScript indicator scripting engine.
+ *
+ * Lets users write Pine-Script–inspired indicator logic in plain JS
+ * and compile it into an IndicatorTemplate that is registered
+ * with the chart engine during compilation.
+ *
+ * Security: scripts run inside a Function scope with a curated API
+ * surface (forbidden identifiers shadowed, Object/Array prototypes frozen).
+ * This is a best-effort sandbox suitable for trusted user scripts only —
+ * constructor-chain escapes (e.g. (0).constructor.constructor) are not
+ * fully blocked. Do NOT run untrusted third-party scripts without a
+ * real isolate (sandboxed iframe or Web Worker).
+ *
+ * Usage:
+ *   const engine = ScriptEngine.getInstance()
+ *   const template = engine.compile(`
+ *     study('My MA', { overlay: true })
+ *     const len = input('Length', 14)
+ *     plot(ta.sma(close, len), { title: 'SMA', color: '#2962ff' })
+ *   `)
+ *   chart.createIndicator(template.name)
+ */
+
+interface StudyOptions {
+    /** Display name shown in tooltip */
+    shortName?: string;
+    /** Whether to overlay on the price pane (default false) */
+    overlay?: boolean;
+    /** Precision of displayed values */
+    precision?: number;
+}
+interface PlotOptions {
+    title?: string;
+    color?: string;
+    lineWidth?: number;
+    visible?: boolean;
+}
+interface InputOptions {
+    type?: 'int' | 'float' | 'bool' | 'string';
+    options?: (number | string)[];
+}
+interface CompiledIndicator extends IndicatorTemplate {
+    /** Original source for editing */
+    _source: string;
+}
+declare class ScriptEngine {
+    private static _instance;
+    private _registry;
+    private constructor();
+    static getInstance(): ScriptEngine;
+    /**
+     * Compile a script string into an IndicatorTemplate.
+     * Throws a descriptive Error if compilation or type validation fails.
+     */
+    compile(source: string, name?: string): CompiledIndicator;
+    /** Get a previously compiled template by name */
+    get(name: string): CompiledIndicator | undefined;
+    /** All registered script names */
+    list(): string[];
+    /** Remove a compiled indicator */
+    remove(name: string): void;
+}
+
+export { type CompiledIndicator, type InputOptions, type PlotOptions, ScriptEngine, type StudyOptions };

package/dist/entries/script.js

@@ -0,0 +1,2 @@
+'use client';
+export{l as ScriptEngine}from'../chunk-YW3STIPY.js';