oakscriptjs 0.10.1 → 0.11.1

package/src/callsite/index.ts

@@ -9,10 +9,11 @@
  * - {@link whenCalled}: vectorized, when the bars of the calls are known in advance.
  * - {@link crossover} / {@link crossunder} / {@link cross} / {@link barssince}: one stateful call site for bar
  *   loops, called only on the bars where the Pine call runs.
- * - {@link lowest} / {@link highest}: `ta.lowest` / `ta.highest` with a series length (a different length on each
- *   call), which PineScript computes with a state kept between calls.
- * - {@link lowestByBar} / {@link highestByBar} / {@link linreg}: `ta.lowest` / `ta.highest` / `ta.linreg` in a
- *   conditional block, whose history is kept by bar (not by call).
+ * - {@link lowestByBar} / {@link highestByBar} / {@link lowestbars} / {@link highestbars} / {@link pivothigh} /
+ *   {@link pivotlow}: `ta.lowest` / `ta.highest` / `ta.lowestbars` / `ta.highestbars` / `ta.pivothigh` /
+ *   `ta.pivotlow` in a conditional block or a loop, also with a length that changes on each call. They keep the
+ *   non-na values of their calls; {@link lowest} / {@link highest} are the same sites called with `(value, length)`.
+ * - {@link linreg}: `ta.linreg` in a conditional block, whose history is kept by bar (not by call).
  * - {@link sum} / {@link sma}: `math.sum` / `ta.sma` in a `for` / `while` loop, called several times on one bar.
  *
  * Since PineScript v6, `and` / `or` are lazy: the right operand runs only when the left operand does not decide
@@ -45,6 +46,7 @@
 import type { Source } from '../types/index.js';
 import { linreg as linregSeries } from '../ta/index.js';
 import { RunningSum, isNa } from '../ta/running-sum.js';
+import { checkSumLength, checkWindowLength } from '../ta/limits.js';
 import { seededRandom } from '../math/index.js';
 
 /**
@@ -133,58 +135,63 @@ export function cross(): (a: number, b: number) => boolean {
   };
 }
 
-/** One `ta.lowest` / `ta.highest` call site with a series length; rules in {@link lowest}. */
-function extremeSite(isLowest: boolean): (value: number, length: number) => number {
-  const better = isLowest ? (a: number, b: number) => a < b : (a: number, b: number) => a > b;
-  const values: number[] = [];
-  let extreme = NaN;
-  let extremeAt = -1;
-  let prevLength = NaN;
-  const keep = (v: number, at: number) => {
-    extreme = v;
-    extremeAt = at;
-  };
-  const rescan = (i: number, length: number) => {
-    extreme = NaN;
-    for (let b = i; b > i - length && b >= 0; b--) {
-      const v = values[b]!;
-      if (!Number.isNaN(v) && (Number.isNaN(extreme) || !better(extreme, v))) keep(v, b);
+/** The values a ta.highest / ta.lowest / ta.pivothigh call site keeps: the non-na values of its calls, one per bar. */
+class KeptCalls {
+  readonly values: number[] = [];
+  readonly bars: number[] = [];
+
+  /** Keeps a non-na value; a later call on the same bar (a loop) replaces the value of that bar. */
+  add(barIndex: number, value: number): void {
+    if (Number.isNaN(value)) return;
+    const last = this.values.length - 1;
+    if (last >= 0 && this.bars[last] === barIndex) this.values[last] = value;
+    else {
+      this.values.push(value);
+      this.bars.push(barIndex);
     }
-  };
-  return (value, length) => {
-    const i = values.length;
-    values.push(value);
-    if (Number.isNaN(value)) {
-      extreme = NaN;
-      prevLength = length;
-      return NaN;
+  }
+
+  /** Position of the best of the last `count` kept values (the newest one on ties), -1 when there is none. */
+  best(count: number, isLowest: boolean): number {
+    const last = this.values.length - 1;
+    if (last < 0 || !(count >= 1)) return -1;
+    let best = last;
+    for (let k = last - 1; k >= 0 && k > last - count; k--) {
+      if (isLowest ? this.values[k]! < this.values[best]! : this.values[k]! > this.values[best]!) best = k;
     }
-    if (length > prevLength) {
-      const from = Math.max(0, i - length + 1);
-      const to = Math.max(0, i - prevLength + 1);
-      if (values.slice(from, to).some(Number.isNaN)) keep(value, i);
-      else {
-        for (let b = from; b < to; b++) if (Number.isNaN(extreme) || better(values[b]!, extreme)) keep(values[b]!, b);
-        if (Number.isNaN(extreme) || better(value, extreme)) keep(value, i);
-      }
-    } else if (length < prevLength || Number.isNaN(extreme) || i - extremeAt >= length) rescan(i, length);
-    else if (better(value, extreme)) keep(value, i);
-    prevLength = length;
-    return i < length - 1 ? NaN : extreme;
+    return best;
+  }
+}
+
+/** One `ta.lowest` / `ta.highest` / `ta.lowestbars` / `ta.highestbars` call site; rules in {@link lowestByBar}. */
+function extremeByBarSite(
+  isLowest: boolean,
+  offsets: boolean
+): (barIndex: number, value: number, length: number) => number {
+  const kept = new KeptCalls();
+  const name = (isLowest ? 'lowest' : 'highest') + (offsets ? 'bars' : '');
+  return (barIndex, value, length) => {
+    checkWindowLength(name, length, barIndex);
+    kept.add(barIndex, value);
+    const len = Math.trunc(length);
+    if (barIndex < len - 1) return NaN;
+    const best = kept.best(len, isLowest);
+    if (best < 0) return NaN;
+    return offsets ? -(barIndex - kept.bars[best]!) : kept.values[best]!;
   };
 }
 
+/** {@link extremeByBarSite} called with `(value, length, barIndex?)`: without a bar index, every call is a new bar. */
+function extremeSite(isLowest: boolean): (value: number, length: number, barIndex?: number) => number {
+  const site = extremeByBarSite(isLowest, false);
+  let calls = 0;
+  return (value, length, barIndex) => site(barIndex ?? calls++, value, length);
+}
+
 /**
- * One `ta.lowest(source, length)` call site with a series length (a different length on each call), called with
- * `(value, length)`.
- *
- * PineScript rules (measured with a length that changes on each bar):
- * - the extreme is kept with its bar; a new value that passes it replaces it; when the kept extreme is `length`
- *   calls old, the last `length` values are scanned again (na skipped, the oldest wins a tie)
- * - a length smaller than on the previous call: the last `length` values are scanned again
- * - a length larger than on the previous call: the values that enter the window at its old end are compared with the
- *   extreme; when one of them is na, the extreme restarts from the current value (the values in between are not read)
- * - an na value gives na and resets the extreme; na before call `length - 1`
+ * One `ta.lowest(source, length)` call site, called with `(value, length, barIndex?)`: the same site as
+ * {@link lowestByBar} (same rules). Pass the bar index when the call does not run on every bar; without it every
+ * call counts as one bar, which is right for a call on every bar (for example with a length that changes).
  *
  * @example
  * ```typescript
@@ -193,62 +200,34 @@ function extremeSite(isLowest: boolean): (value: number, length: number) => numb
  * const out = closes.map((_, i) => lowPrice(i > 0 ? closes[i - 1]! : NaN, lookback[i]!));
  * ```
  */
-export function lowest(): (value: number, length: number) => number {
+export function lowest(): (value: number, length: number, barIndex?: number) => number {
   return extremeSite(true);
 }
 
 /**
- * One `ta.highest(source, length)` call site with a series length (a different length on each call), called with
- * `(value, length)`. Same rules as {@link lowest}.
+ * One `ta.highest(source, length)` call site, called with `(value, length, barIndex?)`. Same rules as
+ * {@link lowest}.
  */
-export function highest(): (value: number, length: number) => number {
+export function highest(): (value: number, length: number, barIndex?: number) => number {
   return extremeSite(false);
 }
 
-/** One `ta.lowest` / `ta.highest` call site whose history is kept by bar; rules in {@link lowestByBar}. */
-function extremeByBarSite(isLowest: boolean): (barIndex: number, value: number, length: number) => number {
-  const better = isLowest ? (a: number, b: number) => a < b : (a: number, b: number) => a > b;
-  let ring: number[] = [];
-  let extreme = NaN;
-  let extremeAt = -1;
-  return (barIndex, value, length) => {
-    const len = Math.floor(length);
-    if (ring.length !== len + 1) {
-      ring = new Array<number>(len + 1).fill(0);
-      extreme = NaN;
-    }
-    ring[barIndex % (len + 1)] = value;
-    if (Number.isNaN(extreme) || better(value, extreme)) {
-      extreme = value;
-      extremeAt = barIndex;
-    } else if (barIndex - extremeAt >= len) {
-      extreme = NaN;
-      for (let b = barIndex - len + 1; b <= barIndex; b++) {
-        const v = ring[b % (len + 1)]!;
-        if (!Number.isNaN(v) && (Number.isNaN(extreme) || better(v, extreme))) {
-          extreme = v;
-          extremeAt = b;
-        }
-      }
-    }
-    return barIndex < len - 1 ? NaN : extreme;
-  };
-}
-
 /**
- * One `ta.lowest(source, length)` call site in a conditional block whose history is kept by bar (not by call), called
- * with `(barIndex, value, length)` on the bars where the Pine call runs.
+ * One `ta.lowest(source, length)` call site in a conditional block or a loop, called with
+ * `(barIndex, value, length)` on the bars (and loop turns) where the Pine call runs. The length can change from one
+ * call to the next.
  *
- * PineScript rules (measured on a call in a ternary branch, length 6):
- * - the values are kept in a ring of `length + 1` slots indexed by the bar index, filled with 0 at the start and
- *   written only on the bars where the call runs: a bar before the first call counts as 0, and a bar without a call
- *   holds the value of the call `length + 1` bars earlier (0 if there was none)
- * - on a call, the value replaces the kept extreme when there is none or when it is strictly lower; only otherwise,
- *   when the kept extreme is `length` bars old, the last `length` bars are read again from the ring (the oldest bar
- *   wins a tie)
- * - na before bar `length - 1` (by bar, not by call)
+ * PineScript rules (measured in `if` blocks, ternaries, user functions and `for` loops, with constant lengths and
+ * lengths that change, on sources with and without na):
+ * - the call site keeps the non-na values it received, each with its bar; nothing is kept for a bar without a call
+ *   or for an na value
+ * - the result is na while `barIndex < length - 1` (by bar, not by call) and while no value was received
+ * - otherwise it is the lowest of the last `length` kept values, or of all of them when there are fewer: the first
+ *   call after bar `length - 1` gives its own value. A call with an na value also gives this result
+ * - in a loop (several calls on one bar), a bar has one kept value: each call replaces the value of the earlier
+ *   calls of that bar, so a call gives the lowest of its value and the values of the bars before
  *
- * {@link lowest} keeps the history by call instead; both rules were measured, on different scripts.
+ * Called on every bar, it equals `ta.lowest`.
  *
  * @example
  * ```typescript
@@ -258,16 +237,86 @@ function extremeByBarSite(isLowest: boolean): (barIndex: number, value: number,
  * ```
  */
 export function lowestByBar(): (barIndex: number, value: number, length: number) => number {
-  return extremeByBarSite(true);
+  return extremeByBarSite(true, false);
 }
 
 /**
- * One `ta.highest(source, length)` call site in a conditional block whose history is kept by bar, called with
- * `(barIndex, value, length)`. Same rules as {@link lowestByBar} (a value replaces the kept extreme when it is
- * strictly higher).
+ * One `ta.highest(source, length)` call site in a conditional block or a loop, called with
+ * `(barIndex, value, length)`. Same rules as {@link lowestByBar}.
  */
 export function highestByBar(): (barIndex: number, value: number, length: number) => number {
-  return extremeByBarSite(false);
+  return extremeByBarSite(false, false);
+}
+
+/**
+ * One `ta.lowestbars(source, length)` call site in a conditional block or a loop, called with
+ * `(barIndex, value, length)`: the offset (0 or negative) from this bar to the bar of the lowest of the last `length`
+ * kept values, the newest one on equal values. The values are kept as in {@link lowestByBar}; the offset counts
+ * bars, not calls, so it can be below `-(length - 1)`.
+ *
+ * @example
+ * ```typescript
+ * // Pine:  off = cond ? ta.lowestbars(low, 10) : na
+ * const site = callsite.lowestbars();
+ * const off = lows.map((v, i) => (cond[i] ? site(i, v, 10) : NaN));
+ * ```
+ */
+export function lowestbars(): (barIndex: number, value: number, length: number) => number {
+  return extremeByBarSite(true, true);
+}
+
+/**
+ * One `ta.highestbars(source, length)` call site in a conditional block or a loop, called with
+ * `(barIndex, value, length)`. Same rules as {@link lowestbars}.
+ */
+export function highestbars(): (barIndex: number, value: number, length: number) => number {
+  return extremeByBarSite(false, true);
+}
+
+/** One `ta.pivothigh` / `ta.pivotlow` call site; rules in {@link pivothigh}. */
+function pivotSite(isLowest: boolean): (barIndex: number, value: number, leftbars: number, rightbars: number) => number {
+  const kept = new KeptCalls();
+  return (barIndex, value, leftbars, rightbars) => {
+    kept.add(barIndex, value);
+    const left = Math.trunc(leftbars);
+    const right = Math.trunc(rightbars);
+    if (!(barIndex >= left + right)) return NaN;
+    const best = kept.best(left + right + 1, isLowest);
+    return best >= 0 && kept.bars[best] === barIndex - right ? kept.values[best]! : NaN;
+  };
+}
+
+/**
+ * One `ta.pivothigh(source, leftbars, rightbars)` call site in a conditional block, called with
+ * `(barIndex, value, leftbars, rightbars)` on the bars where the Pine call runs. The lengths can change from one call
+ * to the next (the lengths of the current call are used).
+ *
+ * PineScript rules (measured in `if` blocks and ternaries, and on sources with na):
+ * - the call site keeps the non-na values it received, each with its bar
+ * - on a call it takes the last `leftbars + rightbars + 1` kept values (all of them when there are fewer) and finds
+ *   the highest, the newest one on equal values
+ * - there is a pivot only when that value is on the bar `rightbars` BARS back (by bar index, not by call); the
+ *   result is its value, na otherwise and before bar `leftbars + rightbars`
+ *
+ * Called on every bar, it equals `ta.pivothigh`.
+ *
+ * @example
+ * ```typescript
+ * // Pine:  ph = useFilter ? ta.pivothigh(src, 5, 5) : na
+ * const site = callsite.pivothigh();
+ * const ph = src.map((v, i) => (useFilter[i] ? site(i, v, 5, 5) : NaN));
+ * ```
+ */
+export function pivothigh(): (barIndex: number, value: number, leftbars: number, rightbars: number) => number {
+  return pivotSite(false);
+}
+
+/**
+ * One `ta.pivotlow(source, leftbars, rightbars)` call site in a conditional block, called with
+ * `(barIndex, value, leftbars, rightbars)`. Same rules as {@link pivothigh} (the lowest value).
+ */
+export function pivotlow(): (barIndex: number, value: number, leftbars: number, rightbars: number) => number {
+  return pivotSite(true);
 }
 
 /**
@@ -315,6 +364,7 @@ function loopSumSite(
   let pending = false;
   return (barIndex, value, length) => {
     const len = Math.floor(length);
+    checkSumLength(name === 'sum' ? 'math.sum' : `ta.${name}`, len, barIndex);
     if (!(len >= 1)) throw new Error(`callsite.${name}: length must be at least 1 (got ${length})`);
     if (barIndex !== lastBar) {
       if (pending) {

package/src/drawing/registry.ts

@@ -8,6 +8,42 @@
  * - when a creation brings the count above `max_*_count + 5`, the oldest objects are deleted until
  *   `max_*_count` remain (default 50). Copies count as creations. Linefills follow the same rule with
  *   `max_lines_count`; lines deleted by this rule do not delete their linefills
+ * - the object that was just created is never deleted by this rule
+ * - an object that a `var` variable of the drawing type refers to is never deleted by this rule, and it still counts
+ *   (measured for lines, labels and boxes: with 9 held boxes and a maximum of 50, 9 held + 46 others stay; with 8
+ *   held lines and a maximum of 5, the 8 and the newest line stay). The protection starts on the bar after the
+ *   assignment: 12 `var` lines created on the first bar with a maximum of 5 lose the first 6. Only
+ *   the variable itself protects: an object in a `var` array, in a field of a user type or in a variable that got
+ *   another object or `na` later is deleted like any other. JavaScript has no `var` declaration to observe, so the
+ *   script says it: {@link varDrawing} (a variable), or {@link holdDrawing} / {@link releaseDrawing}
+ * - linefills have the limit of `max_lines_count` with another rule for the held ones (measured on one script, two
+ *   long runs): a fill is skipped when a `var` variable holds it or released it less than 5,000 bars ago (the bar
+ *   of {@link setDrawingBar}); when the count is still above the maximum + 5 after that, the oldest fills are
+ *   deleted until the maximum remain, the held ones too
+ * - the script deletes count (`line.delete`, `label.delete`, ...): each kind has a number `P` of deleted objects. A
+ *   delete adds 1; a creation first sets `P` to 0 when it is 5 or more (3 or more for polylines)
+ * - polylines use `P` on every bar: a creation cuts when the count is above `max_polylines_count + 5 + P`, down to
+ *   the maximum + `P`, and the polylines of the cut are added to `P`. A script that deletes and creates one polyline
+ *   per bar therefore sees the cut 0, 1 or 2 bars late
+ * - lines, labels and boxes use `P` on the last bar only, with its value at the start of that bar: there the cut is
+ *   above the maximum + 5 + `P`, down to the maximum + `P` (up to 4 more objects)
+ * - the last bar has rules of its own (measured from the count after each creation, on a closed and on an open last
+ *   bar): a cut deletes the objects of the bars before first, at most those (a line takes its linefills with it);
+ *   once none is left, a cut deletes objects of the last bar as on any bar. With 10 lines and a maximum of 10, 13
+ *   lines on the last bar leave these 13: the cut at the 16th line deletes the 10 old ones only. Lines, labels and
+ *   boxes: equal to PineScript, count after every operation and objects alive at the end, on 72 of 72 runs checked
+ *   after the rule was written (and 218 of 218 end states before)
+ * - polylines on the last bar: the `P` carried from the bar before is counted twice (the first creation adds it once
+ *   more, unless it sets `P` to 0), later creations do not set `P` to 0, and the polylines of the bars before that a
+ *   cut deletes are added to `P`. Once none is
+ *   left, `P` is at least the number of polylines of the bars before deleted on the last bar (by the count or by
+ *   the script) and a cut deletes polylines of the last bar: a script that deletes its 100 polylines and creates 200
+ *   on the last bar keeps them all (#176). Equal to PineScript for the polylines alive at the end on 271 of
+ *   281 probe runs; the count inside the bar can differ when the script deletes polylines of the last bar
+ *
+ * - a bar index (`xloc.bar_index`) more than 10,000 bars before the current bar stops the script (runtime error
+ *   RE10026) in `line.new`, `box.new`, `label.new`, `polyline.new` and the setters of x. The current bar is the one
+ *   of `eachBar` in a script run; a port with its own bar loop gives it with {@link setDrawingBar}
  *
  * The script API (`executeScript`) resets the registry at the start of every run and applies the
  * `max_*_count` values of `indicator()`. Outside a script run the registry is global to the module.
@@ -50,6 +86,169 @@ let limits: Required<DrawingLimits> = {
   polyline: DEFAULT_MAX_COUNT,
 };
 const deleted = new WeakSet<object>();
+/** Objects held by a `var` variable, with the number of variables that hold them. */
+let held = new WeakMap<object, number>();
+/** Bar on which the last `var` variable released an object (linefill rule). */
+let releasedAt = new WeakMap<object, number>();
+/** Bars during which a released linefill is still skipped by the maximum count. */
+const LINEFILL_RELEASE_BARS = 5000;
+/** Bar on which a `var` variable got an object: the maximum count skips it from the next bar on. */
+let heldAt = new WeakMap<object, number>();
+/** Kinds with a maximum count of their own. */
+type CountedKind = 'line' | 'label' | 'box' | 'polyline';
+const COUNTED_KINDS: readonly CountedKind[] = ['line', 'label', 'box', 'polyline'];
+const isCounted = (kind: DrawingKind): kind is CountedKind => (COUNTED_KINDS as readonly DrawingKind[]).includes(kind);
+/** `P` of the module notes: objects deleted by the script (for polylines also by the maximum count). */
+let pending: Record<CountedKind, number> = { line: 0, label: 0, box: 0, polyline: 0 };
+/** A creation sets `P` to 0 from this value on. */
+const PENDING_RESET: Record<CountedKind, number> = { line: 5, label: 5, box: 5, polyline: 3 };
+
+/**
+ * Marks an object as held by a `var` variable (PineScript `var line l = ...` or `l := line.new(...)` on a `var`
+ * variable): the maximum count never deletes it, and it still counts. Returns the object.
+ */
+export function holdDrawing<T extends object>(obj: T): T {
+  if (!held.has(obj)) {
+    if (currentBar === null) heldAt.delete(obj);
+    else heldAt.set(obj, currentBar);
+  }
+  held.set(obj, (held.get(obj) ?? 0) + 1);
+  return obj;
+}
+
+/** The `var` variable no longer refers to the object (it got another object or `na`). */
+export function releaseDrawing(obj: object | null | undefined): void {
+  if (!obj) return;
+  const count = held.get(obj) ?? 0;
+  if (count > 1) held.set(obj, count - 1);
+  else if (held.delete(obj) && currentBar !== null) releasedAt.set(obj, currentBar);
+}
+
+/** Held by a `var` variable since a bar before the current one (or outside a bar loop). */
+function heldBefore(obj: object): boolean {
+  if (!held.has(obj)) return false;
+  const bar = heldAt.get(obj);
+  return bar === undefined || currentBar === null || bar < currentBar;
+}
+
+/** Linefill rule: held, or released less than 5,000 bars ago. */
+function fillProtected(obj: object): boolean {
+  if (held.has(obj)) return true;
+  const bar = releasedAt.get(obj);
+  return bar !== undefined && currentBar !== null && currentBar - bar < LINEFILL_RELEASE_BARS;
+}
+
+/** A `var` variable of a drawing type: see {@link varDrawing}. */
+export interface DrawingVariable<T extends object> {
+  /** The object of the variable; setting it holds the new object and releases the one before */
+  value: T | undefined;
+}
+
+/**
+ * A PineScript `var` variable of a drawing type (`var line l = na`). The object it refers to is not deleted by the
+ * maximum count; assigning another object (or `undefined` for `na`) releases the one before.
+ *
+ * @example
+ * ```typescript
+ * // Pine:  var line level = na
+ * //        level := line.new(bar_index, close, bar_index + 1, close)
+ * const level = varDrawing<Line>();
+ * level.value = line.new(i, close, i + 1, close);
+ * ```
+ */
+export function varDrawing<T extends object>(initial?: T): DrawingVariable<T> {
+  let current: T | undefined = initial ? holdDrawing(initial) : undefined;
+  return {
+    get value() {
+      return current;
+    },
+    set value(next: T | undefined) {
+      if (next === current) return;
+      releaseDrawing(current);
+      current = next ? holdDrawing(next) : undefined;
+    },
+  };
+}
+
+/** Largest distance, in bars, of a bar index before the current bar (PineScript runtime error RE10026 above it). */
+export const MAX_DRAWING_BARS_BACK = 10000;
+/** Largest distance, in bars, of a bar index after the last bar of the data (PineScript runtime error RE10020 above it). */
+export const MAX_DRAWING_BARS_FORWARD = 500;
+let currentBar: number | null = null;
+let lastBarIndex: number | null = null;
+
+/** Kinds whose allowance on the last bar is the `P` they had when the bar started. */
+type AllowanceKind = 'line' | 'label' | 'box';
+const isAllowanceKind = (kind: DrawingKind): kind is AllowanceKind => kind === 'line' || kind === 'label' || kind === 'box';
+
+/** State of the last bar (see the module notes). */
+interface LastBar {
+  bar: number;
+  /** The objects alive when the bar started (the objects of the bars before) */
+  old: Set<object>;
+  /** `P` of lines, labels and boxes when the bar started: their allowance for the whole bar */
+  allowance: Record<AllowanceKind, number>;
+  /** `P` of polylines when the bar started */
+  carried: number;
+  /** A polyline was created on this bar */
+  polyline: boolean;
+  /** Polylines of the bars before deleted on this bar (by the count or by the script) */
+  oldPolylinesGone: number;
+}
+let lastBar: LastBar | null = null;
+
+/**
+ * Tells the drawing functions which bar is being calculated (`bar_index`), so that a bar index more than 10,000
+ * bars back throws as in PineScript; `null` turns the check off. `eachBar` of the script API calls it.
+ *
+ * The bar also dates the objects held by a `var` variable (protected from the next bar on). `last` says that it is
+ * the last bar of the data, which has rules of its own for the maximum count. `lastIndex` is the bar index of the
+ * last bar of the data (PineScript `last_bar_index`): with it, a bar index more than 500 bars after it throws, also
+ * on the bars before the last one (RE10020).
+ */
+export function setDrawingBar(barIndex: number | null, last: boolean = false, lastIndex?: number): void {
+  if (lastBar && !(last && barIndex === lastBar.bar)) lastBar = null;
+  currentBar = barIndex;
+  lastBarIndex = barIndex === null ? null : (lastIndex ?? (last ? barIndex : null));
+  if (barIndex !== null && last && !lastBar) {
+    const start = (kind: AllowanceKind): number => (pending[kind] >= PENDING_RESET[kind] ? 0 : pending[kind]);
+    lastBar = {
+      bar: barIndex,
+      old: new Set<object>([...live.line, ...live.label, ...live.box, ...live.polyline]),
+      allowance: { line: start('line'), label: start('label'), box: start('box') },
+      carried: pending.polyline,
+      polyline: false,
+      oldPolylinesGone: 0,
+    };
+  }
+}
+
+/**
+ * Throws the PineScript runtime error RE10026 when `x` is a bar index more than 10,000 bars before the current bar,
+ * and RE10020 when it is more than 500 bars after the last bar of the data (when {@link setDrawingBar} knows it).
+ * `method` and `variable` are the names of the PineScript message ("line.new", "x1").
+ *
+ * Returns `x`, truncated when it is a bar index: PineScript's x is an int (a box from 5537.94 starts on bar 5537,
+ * #176).
+ */
+export function checkBarIndex(method: string, variable: string, x: number, xloc: string | undefined): number {
+  if ((xloc ?? 'bar_index') !== 'bar_index') return x;
+  x = Math.trunc(x);
+  if (currentBar === null) return x;
+  if (lastBarIndex !== null && x - lastBarIndex > MAX_DRAWING_BARS_FORWARD) {
+    throw new Error(
+      `Error on bar ${currentBar}: Objects positioned using xloc.bar_index cannot be drawn further than ` +
+        `${MAX_DRAWING_BARS_FORWARD} bars into the future.`
+    );
+  }
+  if (currentBar - x > MAX_DRAWING_BARS_BACK) {
+    throw new Error(
+      `Error on bar ${currentBar}: Bar index value of the \`${variable}\` argument (${x}) in \`${method}()\` is too far ` +
+        'from the current bar index. Try using `time` instead.'
+    );
+  }
+  return x;
+}
 
 /** Numeric fields that become NaN when an object is deleted, so that its getters return `na`. */
 const COORDINATES: { [K in DrawingKind]: Array<keyof DrawingTypes[K]> } = {
@@ -69,14 +268,77 @@ function markDeleted<K extends DrawingKind>(kind: K, obj: DrawingTypes[K], expli
   }
 }
 
+/** Objects above the maximum that the rule allows for, besides the 5: `P` of the module notes. */
+function allowance(kind: DrawingKind): number {
+  if (kind === 'polyline') return pending.polyline;
+  return lastBar && isAllowanceKind(kind) ? lastBar.allowance[kind] : 0;
+}
+
+/**
+ * The maximum count after the creation of `obj`: removes the objects to delete from `list` (the oldest first; the new
+ * object and an object held by a `var` variable are skipped and still count) and returns them.
+ */
+function cutOldest<K extends DrawingKind>(
+  kind: K,
+  list: Array<DrawingTypes[K]>,
+  obj: DrawingTypes[K],
+  only?: (old: object) => boolean
+): Array<DrawingTypes[K]> {
+  if (kind === 'table') return []; // tables have no maximum count
+  const max = limits[kind === 'linefill' ? 'line' : (kind as keyof DrawingLimits)] + allowance(kind);
+  if (list.length <= max + SLACK) return [];
+  const kept: Array<DrawingTypes[K]> = [];
+  const cut: Array<DrawingTypes[K]> = [];
+  let excess = list.length - max;
+  for (const old of list) {
+    if (excess > 0 && old !== obj && (!only || only(old)) && !(kind === 'linefill' ? fillProtected(old) : heldBefore(old))) {
+      excess--;
+      cut.push(old);
+    } else kept.push(old);
+  }
+  // linefills: still above the maximum + 5, the oldest go, the held ones too
+  if (kind === 'linefill' && kept.length > max + SLACK) cut.push(...kept.splice(0, kept.length - max));
+  list.length = 0;
+  list.push(...kept);
+  return cut;
+}
+
 /** Records a new object and deletes the oldest objects of its kind when the count is too high. */
 export function register<K extends DrawingKind>(kind: K, obj: DrawingTypes[K]): DrawingTypes[K] {
   const list = live[kind];
+  if (lastBar && isCounted(kind)) return registerLast(lastBar, kind, obj);
+  if (isCounted(kind) && pending[kind] >= PENDING_RESET[kind]) pending[kind] = 0;
   list.push(obj);
-  if (kind === 'table') return obj; // tables have no maximum count
-  const max = limits[kind === 'linefill' ? 'line' : (kind as keyof DrawingLimits)];
-  if (list.length > max + SLACK) {
-    for (const old of list.splice(0, list.length - max)) markDeleted(kind, old, false);
+  const cut = cutOldest(kind, list, obj);
+  if (kind === 'polyline') pending.polyline += cut.length;
+  for (const old of cut) markDeleted(kind, old, false);
+  return obj;
+}
+
+/** An object created on the last bar (see the module notes). */
+function registerLast<K extends DrawingKind>(bar: LastBar, kind: K, obj: DrawingTypes[K]): DrawingTypes[K] {
+  if (kind === 'polyline' && !bar.polyline) {
+    bar.polyline = true;
+    if (pending.polyline >= PENDING_RESET.polyline) pending.polyline = 0;
+    else pending.polyline += bar.carried; // counted twice
+  }
+  const list = live[kind];
+  list.push(obj);
+  const isOld = (old: object): boolean => bar.old.has(old);
+  if (list.some((old) => old !== obj && isOld(old) && !heldBefore(old))) {
+    // the objects of the bars before only; a line takes its linefills with it
+    const cut = cutOldest(kind, list, obj, isOld);
+    if (kind === 'polyline') {
+      pending.polyline += cut.length;
+      bar.oldPolylinesGone += cut.length;
+    }
+    for (const old of cut) markDeleted(kind, old, true);
+  } else {
+    // the polylines of the bars before deleted on this bar count before the cut (#176)
+    if (kind === 'polyline' && pending.polyline < bar.oldPolylinesGone) pending.polyline = bar.oldPolylinesGone;
+    const cut = cutOldest(kind, list, obj);
+    if (kind === 'polyline' && cut.length > 0) pending.polyline = bar.oldPolylinesGone;
+    for (const old of cut) markDeleted(kind, old, false);
   }
   return obj;
 }
@@ -85,7 +347,11 @@ export function register<K extends DrawingKind>(kind: K, obj: DrawingTypes[K]):
 export function remove<K extends DrawingKind>(kind: K, obj: DrawingTypes[K]): void {
   const list = live[kind];
   const index = list.indexOf(obj);
-  if (index !== -1) list.splice(index, 1);
+  if (index !== -1) {
+    list.splice(index, 1);
+    if (isCounted(kind)) pending[kind]++;
+    if (kind === 'polyline' && lastBar?.old.has(obj)) lastBar.oldPolylinesGone++;
+  }
   if (!deleted.has(obj)) markDeleted(kind, obj, true);
 }
 
@@ -102,6 +368,13 @@ export function all<K extends DrawingKind>(kind: K): Array<DrawingTypes[K]> {
 /** Forgets all objects (without deleting them) and sets the maximum counts (default 50). */
 export function resetDrawings(newLimits: DrawingLimits = {}): void {
   for (const kind of Object.keys(live) as DrawingKind[]) live[kind].length = 0;
+  held = new WeakMap();
+  releasedAt = new WeakMap();
+  heldAt = new WeakMap();
+  pending = { line: 0, label: 0, box: 0, polyline: 0 };
+  currentBar = null;
+  lastBarIndex = null;
+  lastBar = null;
   limits = {
     line: newLimits.line ?? DEFAULT_MAX_COUNT,
     label: newLimits.label ?? DEFAULT_MAX_COUNT,