oakscriptjs 0.9.5 → 0.10.0

package/src/runtime/series.ts

@@ -174,6 +174,17 @@ export class BarData {
  * const materialized = complex.materialize(); // Breaks closure chain
  * ```
  */
+/** Largest history reference of a script series (PineScript max_bars_back limit). */
+export const MAX_BARS_BACK = 5000;
+
+/** PineScript's runtime error RE10008 text. */
+export function historyError(bar: number, barsBack: number): string {
+  return (
+    `Error on bar ${bar}: The script attempts to reference historical data that is too far from the current bar ` +
+    `(${barsBack} bars back). The history-referencing length for the expression must be a value between 0 and ${MAX_BARS_BACK}.`
+  );
+}
+
 export class Series {
   private extractor: SeriesExtractor;
   private dataSource: BarData;
@@ -186,6 +197,12 @@ export class Series {
    * @param data - Bar data (Bar[] or BarData)
    * @param extractor - Function to extract/compute value for each bar
    */
+  /**
+   * True for PineScript's built-in price variables (open, high, low, close, volume, hl2...): their history covers
+   * every bar, so references further than 5000 bars back are allowed (measured: close[bar_index] runs).
+   */
+  fullHistory = false;
+
   constructor(data: Bar[] | BarData, extractor: SeriesExtractor) {
     // Support both Bar[] and BarData for backward compatibility
     this.dataSource = data instanceof BarData ? data : new BarData(data);
@@ -219,7 +236,9 @@ export class Series {
    * @returns Series with extracted field values
    */
   static fromBars(bars: Bar[] | BarData, field: 'open' | 'high' | 'low' | 'close' | 'volume'): Series {
-    return new Series(bars, (bar) => bar[field] ?? NaN);
+    const series = new Series(bars, (bar) => bar[field] ?? NaN);
+    series.fullHistory = true;
+    return series;
   }
 
   /**
@@ -516,6 +535,8 @@ export class Series {
    */
   offset(offset: number): Series {
     if (offset < 0) throw new RangeError(`Series.offset(${offset}): the offset cannot be negative (it would read a future bar).`);
+    // PineScript runtime error RE10008: a script series keeps at most 5000 bars of history
+    if (offset > MAX_BARS_BACK && !this.fullHistory) throw new Error(historyError(0, Math.floor(offset)));
     return new Series(this.dataSource, (_bar, i, data) => {
       const targetIndex = i - offset;
       if (targetIndex < 0 || targetIndex >= data.length) {

package/src/runtime/types.ts

@@ -138,6 +138,29 @@ export interface ArrowConfig {
     forceOverlay?: boolean;
 }
 
+/**
+ * Configuration of a PineScript `plotcandle()` (kind 'candle') or `plotbar()` (kind 'bar') declaration. The candles
+ * are in `result.plotCandles[id]`, the bars in `result.plotBars[id]`.
+ */
+export interface CandleConfig {
+    /** Unique identifier (key of the data in the result) */
+    id: string;
+    /** 'candle' for plotcandle, 'bar' for plotbar */
+    kind: 'candle' | 'bar';
+    /** Display title */
+    title?: string;
+    /** Static body colour (plotcandle) or bar colour (plotbar) */
+    color?: string;
+    /** Static wick colour (plotcandle only) */
+    wickColor?: string;
+    /** Static border colour (plotcandle only) */
+    borderColor?: string;
+    /** Display mode */
+    display?: 'all' | 'none' | 'data_window' | 'status_line' | 'pane';
+    /** Drawn on the main chart pane even when the script is not an overlay (PineScript `force_overlay`); default false */
+    forceOverlay?: boolean;
+}
+
 /**
  * Configuration for horizontal line outputs in generated indicators
  * Matches PineScript hline() function parameters

package/src/script/index.ts

@@ -37,25 +37,42 @@ import type { Bar } from '../types/index.js';
 import type {
   ArrowData,
   BarColorData,
+  BgColorData,
+  BoxData,
   FillData,
   FillGradient,
   IndicatorResult,
+  LabelData,
+  LabelStyle,
+  LineDrawingData,
+  LinefillData,
   MarkerData,
   MarkerLocation,
+  MarkerPosition,
+  MarkerShape,
   MarkerSize,
+  PineSize,
+  PlotBarData,
+  PlotCandleData,
+  PolylineData,
   ShapeStyle,
+  TableCellData,
+  TableData,
+  TableMergeData,
+  TablePosition,
   TimeValue,
 } from '../types/metadata.js';
 import type {
   ArrowConfig,
   BarColorConfig,
+  CandleConfig,
   FillConfig,
   HLineConfig,
   InputConfig,
   PlotConfig,
   ShapeConfig,
 } from '../runtime/types.js';
-import { BarData, Series } from '../runtime/series.js';
+import { BarData, Series, MAX_BARS_BACK, historyError } from '../runtime/series.js';
 import * as taSeries from '../ta-series.js';
 import * as colorCore from '../color/index.js';
 import { inputColorDefault } from '../color/parse.js';
@@ -65,10 +82,12 @@ import * as labelCore from '../label/index.js';
 import * as boxCore from '../box/index.js';
 import * as linefillCore from '../linefill/index.js';
 import * as polylineCore from '../polyline/index.js';
+import * as tableCore from '../table/index.js';
 import * as chartPointCore from '../chartpoint/index.js';
 import * as textCore from '../text/index.js';
 import * as mathCore from '../math/index.js';
 import { resetDrawings, setDrawingLimits } from '../drawing/registry.js';
+import { drawingOutputs } from '../drawing/output.js';
 import * as timeframeCore from '../timeframe/index.js';
 import * as timeCore from '../time/index.js';
 import * as strCore from '../str/index.js';
@@ -76,6 +95,7 @@ import { formatMessage } from '../str/messageformat.js';
 import { TradingCalendar, type SessionSpec } from '../session/calendar.js';
 import { SessionBars, sessionFlags, type SessionFlags } from '../session/bars.js';
 import { afterCompletion, heikinAshi, mapToChart, periodsOf, resample } from '../security/resample.js';
+import { position } from '../types/index.js';
 import type { ChartPoint } from '../types/index.js';
 import {
   STRATEGY_CONSTANTS,
@@ -98,6 +118,7 @@ import {
   type StrategyTrade,
   type StrategyVariable,
 } from '../strategy/index.js';
+import { parsePineSession } from '../time/session.js';
 
 /** Everything one run of a script produced. */
 export interface ScriptRunResult {
@@ -109,11 +130,17 @@ export interface ScriptRunResult {
   shapeConfig: ShapeConfig[];
   arrowConfig: ArrowConfig[];
   barColorConfig: BarColorConfig[];
+  /** plotcandle() / plotbar() declarations */
+  candleConfig: CandleConfig[];
   defaultInputs: Record<string, unknown>;
   alertConfig: AlertConditionConfig[];
   /** Strategy properties (declared values, else the PineScript defaults) when the script declares strategy(). */
   strategyConfig?: StrategyProperties;
-  /** The renderable output (plots keyed by plotConfig ids, plot-pair fills). */
+  /**
+   * The renderable output: plots keyed by plotConfig ids, plot-pair fills, markers, arrows, background and bar
+   * colours, candles and bars, and the drawings (labels, lines, boxes, linefills, polylines, tables) alive after the
+   * last bar.
+   */
   result: IndicatorResult & { alerts?: AlertState[] };
 }
 
@@ -158,8 +185,11 @@ interface Collector {
   arrowConfig: ArrowConfig[];
   arrows: ArrowData[];
   barColorConfig: BarColorConfig[];
-  bgcolors: BarColorData[];
-  barcolors: BarColorData[];
+  bgColors: BgColorData[];
+  barColors: BarColorData[];
+  candleConfig: CandleConfig[];
+  plotCandles: Record<string, PlotCandleData[]>;
+  plotBars: Record<string, PlotBarData[]>;
   alertConfig: AlertConditionConfig[];
   alerts: AlertState[];
   strategy?: StrategyRun;
@@ -209,8 +239,11 @@ function freshCollector(inputValues: Record<string, unknown>): Collector {
     arrowConfig: [],
     arrows: [],
     barColorConfig: [],
-    bgcolors: [],
-    barcolors: [],
+    bgColors: [],
+    barColors: [],
+    candleConfig: [],
+    plotCandles: {},
+    plotBars: {},
     alertConfig: [],
     alerts: [],
   };
@@ -264,6 +297,7 @@ export function executeScript(
   scriptOptions = options;
   ctx = freshCollector(inputs);
   resetDrawings();
+  mathCore.resetRandom();
   try {
     body();
     const c = ctx;
@@ -282,6 +316,7 @@ export function executeScript(
       shapeConfig: c.shapeConfig,
       arrowConfig: c.arrowConfig,
       barColorConfig: c.barColorConfig,
+      candleConfig: c.candleConfig,
       defaultInputs: c.defaultInputs,
       alertConfig: c.alertConfig,
       strategyConfig: c.strategy?.properties,
@@ -291,8 +326,11 @@ export function executeScript(
         fills: c.fills.length ? c.fills : undefined,
         markers: c.markers.length ? c.markers : undefined,
         arrows: c.arrows.length ? c.arrows : undefined,
-        bgcolors: c.bgcolors.length ? c.bgcolors : undefined,
-        barcolors: c.barcolors.length ? c.barcolors : undefined,
+        bgColors: c.bgColors.length ? c.bgColors : undefined,
+        barColors: c.barColors.length ? c.barColors : undefined,
+        plotCandles: Object.keys(c.plotCandles).length ? c.plotCandles : undefined,
+        plotBars: Object.keys(c.plotBars).length ? c.plotBars : undefined,
+        ...drawingOutputs(ctxBars.bars, chartCtx.timeUnit),
         alerts: c.alerts.length ? c.alerts : undefined,
       },
     };
@@ -449,6 +487,8 @@ export const hl2 = new Series(ctxBars, (b) => (b.high + b.low) / 2);
 export const hlc3 = new Series(ctxBars, (b) => (b.high + b.low + b.close) / 3);
 export const ohlc4 = new Series(ctxBars, (b) => (b.open + b.high + b.low + b.close) / 4);
 export const hlcc4 = new Series(ctxBars, (b) => (b.high + b.low + b.close + b.close) / 4);
+// built-in price variables keep the whole history (no 5000-bar limit)
+for (const s of [hl2, hlc3, ohlc4, hlcc4]) s.fullHistory = true;
 
 const SOURCES: Record<string, Series> = { open, high, low, close, volume, hl2, hlc3, ohlc4, hlcc4 };
 
@@ -775,8 +815,46 @@ export interface PlotCharOptions extends Omit<PlotShapeOptions, 'style'> {
   char?: string;
 }
 
+/** PineScript shape.* style -> marker shape. */
+const MARKER_SHAPES: Record<ShapeStyle, MarkerShape> = {
+  xcross: 'xcross',
+  cross: 'cross',
+  triangleup: 'triangleUp',
+  triangledown: 'triangleDown',
+  flag: 'flag',
+  circle: 'circle',
+  arrowup: 'arrowUp',
+  arrowdown: 'arrowDown',
+  labelup: 'labelUp',
+  labeldown: 'labelDown',
+  square: 'square',
+  diamond: 'diamond',
+};
+
+/**
+ * Marker position of a PineScript location. With location.absolute the shape sits on the price: a label pointing
+ * down above it, a label pointing up below it, the other shapes (and the characters) centred on it.
+ */
+function markerPosition(location: MarkerLocation, shape: ShapeStyle | undefined): MarkerPosition {
+  switch (location) {
+    case 'abovebar':
+      return 'aboveBar';
+    case 'belowbar':
+      return 'belowBar';
+    case 'top':
+      return 'top';
+    case 'bottom':
+      return 'bottom';
+    case 'absolute':
+      return shape === 'labeldown' ? 'atPriceTop' : shape === 'labelup' ? 'atPriceBottom' : 'atPriceMiddle';
+  }
+}
+
+/** Default colour of plotshape / plotchar markers. */
+const MARKER_COLOR = '#2962FF';
+
 /** Shared emitter for plotshape()/plotchar(). Emits one marker per bar where
- *  the condition is truthy (not na, not 0). */
+ *  the condition is truthy (not na, not 0). A plotchar marker has the shape 'circle' and its character in `char`. */
 function emitMarkers(
   kind: 'shape' | 'char',
   condition: Series,
@@ -802,6 +880,19 @@ function emitMarkers(
     offset: options.offset,
     forceOverlay: options.force_overlay,
   });
+  const shapeStyle = kind === 'shape' ? (style as ShapeStyle) : undefined;
+  const template: Omit<MarkerData, 'time'> = {
+    position: markerPosition(location, shapeStyle),
+    shape: shapeStyle ? MARKER_SHAPES[shapeStyle] : 'circle',
+    color: options.color ?? MARKER_COLOR,
+    id,
+  };
+  if (char !== undefined) template.char = char;
+  if (options.text !== undefined) template.text = options.text;
+  if (options.textcolor !== undefined) template.textColor = options.textcolor;
+  if (options.size !== undefined) template.size = options.size;
+  if (options.tooltip !== undefined) template.tooltip = options.tooltip;
+  if (options.force_overlay) template.forceOverlay = true;
   const values = condition.toArray();
   const b = bars();
   const off = options.offset ?? 0;
@@ -810,19 +901,8 @@ function emitMarkers(
     if (v === undefined || Number.isNaN(v) || v === 0) continue;
     const j = i + off;
     if (j < 0 || j >= b.length) continue;
-    c.markers.push({
-      time: b[j]!.time,
-      id,
-      location,
-      style,
-      char,
-      color: options.color,
-      text: options.text,
-      textcolor: options.textcolor,
-      size: options.size,
-      tooltip: options.tooltip,
-      price: location === 'absolute' ? v : undefined,
-    });
+    const time = b[j]!.time;
+    c.markers.push(location === 'absolute' ? { time, ...template, price: v } : { time, ...template });
   }
 }
 
@@ -902,13 +982,14 @@ function emitBarColors(
   c.barColorConfig.push({ id, kind, title: options.title, offset: options.offset, forceOverlay: options.force_overlay });
   const b = bars();
   const off = options.offset ?? 0;
-  const target = kind === 'bgcolor' ? c.bgcolors : c.barcolors;
+  const target: BgColorData[] = kind === 'bgcolor' ? c.bgColors : c.barColors;
+  const forceOverlay = kind === 'bgcolor' && options.force_overlay === true;
   for (let i = 0; i < b.length; i++) {
     const col = typeof colors === 'string' ? colors : colors[i];
     if (!col) continue;
     const j = i + off;
     if (j < 0 || j >= b.length) continue;
-    target.push({ time: b[j]!.time, color: col });
+    target.push(forceOverlay ? { time: b[j]!.time, color: col, forceOverlay } : { time: b[j]!.time, color: col });
   }
 }
 
@@ -931,6 +1012,129 @@ export function barcolor(
   emitBarColors('barcolor', colors, options);
 }
 
+/** A colour argument of plotcandle() / plotbar(): a colour, or per-bar colours (null / undefined entries are na). */
+export type ScriptCandleColor = string | Array<string | null | undefined>;
+
+export interface PlotCandleOptions {
+  /** Body colour: a colour or a per-bar array (color.when); an na entry gives a transparent body */
+  color?: ScriptCandleColor;
+  /** Wick colour: a colour or a per-bar array */
+  wickcolor?: ScriptCandleColor;
+  /** Border colour: a colour or a per-bar array */
+  bordercolor?: ScriptCandleColor;
+  display?: CandleConfig['display'];
+  /** Draw on the main chart pane even when the script is not an overlay (PineScript `force_overlay`); default false. */
+  force_overlay?: boolean;
+}
+
+export interface PlotBarOptions {
+  /** Bar colour: a colour or a per-bar array (color.when); an na entry gives a transparent bar */
+  color?: ScriptCandleColor;
+  display?: CandleConfig['display'];
+  /** Draw on the main chart pane even when the script is not an overlay (PineScript `force_overlay`); default false. */
+  force_overlay?: boolean;
+}
+
+/** Colour of bar i: undefined when the argument is not given, 'transparent' for an na entry. */
+function candleColor(col: ScriptCandleColor | undefined, i: number): string | undefined {
+  if (col === undefined) return undefined;
+  if (typeof col === 'string') return col;
+  return col[i] ?? 'transparent';
+}
+
+interface OhlcRow {
+  i: number;
+  open: number;
+  high: number;
+  low: number;
+  close: number;
+}
+
+/** The bars where open, high, low and close are all not na (PineScript draws no candle / bar otherwise). */
+function ohlcRows(o: Series, h: Series, l: Series, cl: Series): OhlcRow[] {
+  const [ov, hv, lv, cv] = [o.toArray(), h.toArray(), l.toArray(), cl.toArray()];
+  const rows: OhlcRow[] = [];
+  for (let i = 0; i < bars().length; i++) {
+    const [open, high, low, close] = [ov[i]!, hv[i]!, lv[i]!, cv[i]!];
+    if (Number.isFinite(open) && Number.isFinite(high) && Number.isFinite(low) && Number.isFinite(close)) {
+      rows.push({ i, open, high, low, close });
+    }
+  }
+  return rows;
+}
+
+const staticColor = (col: ScriptCandleColor | undefined): string | undefined => (typeof col === 'string' ? col : undefined);
+
+/**
+ * PineScript `plotcandle(open, high, low, close, title?, { color, wickcolor, bordercolor, display, force_overlay })`:
+ * candles in `result.plotCandles[id]`, the declaration in `candleConfig`. A bar with an na value has no candle.
+ */
+export function plotcandle(
+  open: Series,
+  high: Series,
+  low: Series,
+  close: Series,
+  title?: string,
+  options: PlotCandleOptions = {}
+): void {
+  const c = collector();
+  const id = `plotcandle${c.candleConfig.filter((x) => x.kind === 'candle').length}`;
+  c.candleConfig.push({
+    id,
+    kind: 'candle',
+    title,
+    color: staticColor(options.color),
+    wickColor: staticColor(options.wickcolor),
+    borderColor: staticColor(options.bordercolor),
+    display: options.display,
+    forceOverlay: options.force_overlay,
+  });
+  const b = bars();
+  c.plotCandles[id] = ohlcRows(open, high, low, close).map(({ i, ...ohlc }) => {
+    const candle: PlotCandleData = { time: b[i]!.time, ...ohlc };
+    const color = candleColor(options.color, i);
+    const wickColor = candleColor(options.wickcolor, i);
+    const borderColor = candleColor(options.bordercolor, i);
+    if (color !== undefined) candle.color = color;
+    if (wickColor !== undefined) candle.wickColor = wickColor;
+    if (borderColor !== undefined) candle.borderColor = borderColor;
+    if (options.force_overlay) candle.forceOverlay = true;
+    return candle;
+  });
+}
+
+/**
+ * PineScript `plotbar(open, high, low, close, title?, { color, display, force_overlay })`: OHLC bars in
+ * `result.plotBars[id]`, the declaration in `candleConfig`. A bar with an na value is not drawn.
+ */
+export function plotbar(
+  open: Series,
+  high: Series,
+  low: Series,
+  close: Series,
+  title?: string,
+  options: PlotBarOptions = {}
+): void {
+  const c = collector();
+  const id = `plotbar${c.candleConfig.filter((x) => x.kind === 'bar').length}`;
+  c.candleConfig.push({
+    id,
+    kind: 'bar',
+    title,
+    color: staticColor(options.color),
+    display: options.display,
+    forceOverlay: options.force_overlay,
+  });
+  const b = bars();
+  c.plotBars[id] = ohlcRows(open, high, low, close).map(({ i, ...ohlc }) => {
+    const bar: PlotBarData = { time: b[i]!.time, ...ohlc };
+    const color = candleColor(options.color, i);
+    if (color !== undefined) bar.color = color;
+    if (options.force_overlay) bar.forceOverlay = true;
+    return bar;
+  });
+}
+
 // ── Per-bar execution (eachBar) ──────────────────────────────────────────────
 
 /**
@@ -975,11 +1179,30 @@ export interface BarContext {
  * });
  * ```
  */
+/** Initial history buffer of a script series and its growth factor (measured, issue #149). */
+const HISTORY_START = 242;
+const HISTORY_GROWTH = 1.618034;
+
+/**
+ * History buffer of one script series in eachBar(), as PineScript grows it (measured on PineScript, issue #149):
+ * the buffer starts with 242 bars; when the largest reference of a bar goes past it, a jump (the reference grew by
+ * more than 1 since the previous bar) sets the buffer to the reference, and a step of 1 grows it to
+ * round(size * 1.618034); a buffer above 5000 stops the script on the next bar (RE10008), with that size as
+ * "bars back". A reference above 5000 stops it at once.
+ */
+interface HistoryBuffer {
+  size: number;
+  previous: number;
+  barMax: number;
+}
+
 export function eachBar(fn: (c: BarContext) => number | boolean | void): Series {
   collector(); // same lifecycle guard (and error message) as the declaration calls
   const b = bars();
   const out: number[] = new Array(b.length).fill(NaN);
   const cache = new Map<Series, number[]>();
+  const buffers = new Map<Series, HistoryBuffer>();
+  let pendingError: { bar: number; barsBack: number } | null = null;
   let idx = 0;
   const ctx: BarContext = {
     get i() {
@@ -1006,6 +1229,13 @@ export function eachBar(fn: (c: BarContext) => number | boolean | void): Series
     },
     get(src: Series, offset: number = 0): number {
       if (offset < 0) throw new RangeError(`c.get(): the offset cannot be negative (${offset} would read a future bar).`);
+      if (!src.fullHistory && offset > 0) {
+        const k = Math.floor(offset);
+        if (k > MAX_BARS_BACK) throw new Error(historyError(idx, k));
+        let buffer = buffers.get(src);
+        if (!buffer) buffers.set(src, (buffer = { size: HISTORY_START, previous: 0, barMax: 0 }));
+        if (k > buffer.barMax) buffer.barMax = k;
+      }
       let vals = cache.get(src);
       if (!vals) {
         vals = src.toArray();
@@ -1021,9 +1251,21 @@ export function eachBar(fn: (c: BarContext) => number | boolean | void): Series
   };
   try {
     for (idx = 0; idx < b.length; idx++) {
+      if (pendingError && pendingError.bar === idx) throw new Error(historyError(idx, pendingError.barsBack));
       currentBar = idx;
       const r = fn(ctx);
       out[idx] = typeof r === 'number' ? r : typeof r === 'boolean' ? (r ? 1 : 0) : NaN;
+      // grow the history buffers from the largest reference of this bar
+      for (const buffer of buffers.values()) {
+        const k = buffer.barMax;
+        if (k > buffer.size) {
+          const next = k - buffer.previous > 1 ? k : Math.round(buffer.size * HISTORY_GROWTH);
+          if (next > MAX_BARS_BACK && !pendingError) pendingError = { bar: idx + 1, barsBack: next };
+          buffer.size = next;
+        }
+        buffer.previous = k;
+        buffer.barMax = 0;
+      }
     }
   } finally {
     currentBar = -1;
@@ -1467,6 +1709,9 @@ export function inSession(time: number, session: string, timezone?: string): boo
 /** PineScript `str.*`; `format_time` and the dates of `format` use the exchange time zone by default. */
 export const str = {
   ...strCore,
+  // format.mintick rounds to the chart symbol's tick (syminfo.mintick)
+  tostring: ((value: unknown, format?: string, mintick?: number) =>
+    strCore.tostring(value as never, format, format === 'mintick' ? (mintick ?? syminfo.mintick) : mintick)) as typeof strCore.tostring,
   format_time(time: number, format: string = "yyyy-MM-dd'T'HH:mm:ssZ", timezone?: string): string {
     return strCore.format_time(time, format, timezone ?? exchangeTimezone());
   },
@@ -1514,6 +1759,13 @@ function calendarFor(session?: string, timezone?: string): { bars: SessionBars;
   const { bars } = sessionBars();
   if (!session && !timezone) return { bars, test: false };
   const tz = timezone ?? exchangeTimezone();
+  // a session string that is empty or does not start with a digit is the symbol session: "regular" the regular
+  // hours, "extended" and any other name the loaded hours (PineScript)
+  if (session !== undefined && parsePineSession(session) === null) {
+    const name = session.trim();
+    const symbol = name === 'regular' && chartCtx.regularSession ? chartCtx.regularSession : chartCtx.session!;
+    return { bars: new SessionBars(new TradingCalendar(tz, { session: toSpec(symbol).session }, 'symbol'), bars.chart.period), test: true };
+  }
   const spec = session ? { session } : { session: toSpec(chartCtx.session!).session };
   return { bars: new SessionBars(new TradingCalendar(tz, spec, session ? 'pine' : 'symbol'), bars.chart.period), test: true };
 }
@@ -1779,7 +2031,20 @@ export const polyline = {
   },
 };
 
-/** PineScript `text.format_*` constants. */
+/**
+ * PineScript `table.*`; `table.all` lists the live tables in creation order. The live tables go to `result.tables`.
+ */
+export const table = {
+  ...tableCore,
+  get all() {
+    return tableCore.all();
+  },
+};
+
+/** PineScript `position.*` constants (table positions). */
+export { position };
+
+/** PineScript `text.format_*`, `text.align_*` and `text.wrap_*` constants. */
 export const text = { ...textCore };
 
 /**
@@ -1861,10 +2126,27 @@ export type {
   ShapeConfig,
   ArrowConfig,
   BarColorConfig,
+  CandleConfig,
   MarkerData,
+  MarkerPosition,
+  MarkerShape,
   ArrowData,
   BarColorData,
+  BgColorData,
+  PlotCandleData,
+  PlotBarData,
+  LabelData,
+  LabelStyle,
+  LineDrawingData,
+  BoxData,
+  LinefillData,
+  PolylineData,
+  TableData,
+  TableCellData,
+  TableMergeData,
+  TablePosition,
   MarkerLocation,
   MarkerSize,
+  PineSize,
   ShapeStyle,
 };

package/src/session/calendar.ts

@@ -16,6 +16,7 @@
  */
 
 import { zonedFields, zonedToUnix } from '../time/timezone.js';
+import { parsePineSession } from '../time/session.js';
 
 /** Session information of a symbol (hours, corrections, holidays). */
 export interface SessionSpec {
@@ -44,6 +45,8 @@ interface Version {
   periods: Period[];
   /** Index 1 (Sunday) to 7 (Saturday) */
   days: boolean[];
+  /** PineScript session strings: the periods of each weekday (index 1 to 7), from the "|" sections */
+  byDay?: Period[][];
 }
 
 export const toDateNum = (y: number, m: number, d: number): DateNum => y * 10000 + m * 100 + d;
@@ -82,10 +85,26 @@ function parsePeriods(text: string, spec: string): Period[] {
   });
 }
 
+/** A PineScript session string as periods per weekday (rules in time/session.ts). */
+function pineVersion(text: string, from: DateNum): Version {
+  const ranges = parsePineSession(text);
+  if (ranges === null) throw new SyntaxError(`Session "${text}" is the symbol session`);
+  const byDay: Period[][] = Array.from({ length: 8 }, () => []);
+  for (const { start, end, days } of ranges) {
+    const period: Period =
+      start === 0 && end === 0
+        ? { start: 0, end: 1440, startOffset: 0, endOffset: 0 }
+        : { start, end, startOffset: end <= start ? 1 : 0, endOffset: 0 };
+    for (const d of days) byDay[d]!.push(period);
+  }
+  return { from, periods: [], days: byDay.map((p) => p.length > 0), byDay };
+}
+
 function parseVersion(text: string, from: DateNum, spec: string, rule: 'symbol' | 'pine'): Version {
+  if (rule === 'pine') return pineVersion(text, from);
   const [periodText = '', dayText] = text.trim().split(':');
   const periods = parsePeriods(periodText, spec);
-  const allDays = periodText.trim() === '24x7' || (rule === 'pine' && periods.length === 1);
+  const allDays = periodText.trim() === '24x7';
   const digits = dayText ?? (allDays ? '1234567' : '23456');
   if (!/^[1-7]+$/.test(digits)) throw new SyntaxError(`Invalid session days in "${spec}"`);
   const days = new Array<boolean>(8).fill(false);
@@ -137,7 +156,8 @@ export class TradingCalendar {
       periods = correction ?? [];
     } else if (!this.holidays.has(date)) {
       const version = [...this.versions].reverse().find((v) => v.from <= date)!;
-      if (version.days[weekdayOf(date)]) periods = version.periods;
+      if (version.byDay) periods = version.byDay[weekdayOf(date)]!;
+      else if (version.days[weekdayOf(date)]) periods = version.periods;
     }
     const y = Math.floor(date / 10000);
     const m = Math.floor(date / 100) % 100;