pinets 0.9.21 → 0.9.23

package/dist/types/Indicator/Indicator.class.d.ts

@@ -59,16 +59,17 @@ export declare class Indicator {
     /** True iff the script references any built-in in `VIEWPORT_DEPENDENT_BUILTINS`. */
     usesVisibleRange(): boolean;
     /**
-     * Title-keyed input map used by the runtime (read by
+     * Input override map used by the runtime (read by
      * `input.utils.resolveInput`). Composed at call time so live mutations
      * to `.input` between `pine.run()` calls are picked up automatically.
      *
-     * Precedence:
-     *   1. Legacy constructor `inputs`            (back-compat)
-     *   2. Explicit writes to `.input[...]`       (new API; takes priority)
+     * Keys are mixed by design and resolved in this precedence by the runtime:
+     *   1. Legacy constructor `inputs` map        — TITLE-keyed (back-compat)
+     *   2. Explicit `.input[...]` writes          — VARID-keyed (canonical);
+     *      resolveInput checks varId before title, so these take priority.
      *
-     * Defaults are NOT included — the runtime falls back to `defval` when a
-     * title is absent.
+     * Defaults are NOT included — the runtime falls back to `defval` when no
+     * override key matches.
      */
     getRuntimeInputs(): Record<string, unknown>;
     /**

package/dist/types/Indicator/inputProxy.d.ts

@@ -1,14 +1,18 @@
 import type { IPineInput } from './types';
 /**
  * Build the live `.input` view exposed on an `Indicator` instance.
- * Title-keyed; entries without an explicit `title=` on the Pine source are
- * excluded (Pine's runtime keys overrides by title, so a title-less input is
- * not overridable).
+ *
+ * Keyed by **varId** (the assigned variable name) as the canonical, primary
+ * override key, with the input's **title** registered as a secondary alias.
+ * This makes every input overridable by a stable, unique handle — robust to
+ * empty or duplicated titles — while `.input['Title']` keeps working for the
+ * common case (unique, non-empty titles). When two inputs share a title, the
+ * title aliases the first; the second is reachable only by its varId.
  *
  * Backing machinery lives in `keyedProxy.ts` and is shared with `.prop`.
  */
-export declare function buildInputProxy(metas: IPineInput[], onSet?: (title: string) => void): {
+export declare function buildInputProxy(metas: IPineInput[], onSet?: (key: string) => void): {
     proxy: Record<string, unknown>;
     values: Record<string, unknown>;
-    metaByTitle: Map<string, IPineInput>;
+    metaByKey: Map<string, IPineInput>;
 };

package/dist/types/Indicator/keyedProxy.d.ts

@@ -20,6 +20,14 @@ export interface KeyedSchemaEntry {
     options?: unknown[];
     minval?: number;
     maxval?: number;
+    /**
+     * Secondary keys that also resolve to this entry (e.g. an input's title
+     * aliasing its varId). The canonical `key` always takes priority; an alias
+     * is registered only if not already claimed by a canonical key or an
+     * earlier entry. Values/overrides are stored under the canonical key, so
+     * reading or writing via an alias hits the same slot.
+     */
+    aliases?: string[];
 }
 export interface BuildKeyedProxyResult {
     proxy: Record<string, unknown>;

package/dist/types/Indicator/types.d.ts

@@ -29,6 +29,7 @@ export type PineInputDisplay = 'none' | 'data_window' | 'status_line' | 'all';
 export interface IPineInput {
     type: PineInputType;
     defval: unknown;
+    varId?: string;
     title?: string;
     tooltip?: string;
     group?: string;

package/dist/types/namespaces/color/PineColor.d.ts

@@ -1,3 +1,26 @@
+/**
+ * Resolve any static color value to its `[r, g, b, a]` components (a in
+ * 0..1). Accepts:
+ *   - `#RRGGBB` / `#RRGGBBAA` hex
+ *   - `rgb(r,g,b)` / `rgba(r,g,b,a)` strings
+ *   - a named constant, with or without the namespace: `color.red` / `red`
+ * Returns null for anything it can't parse as a color.
+ */
+export declare function resolveColorToRgba(value: unknown): [number, number, number, number] | null;
+/**
+ * Format `[r, g, b, a]` (a in 0..1) as a canonical 8-digit RGBA hex string
+ * `#RRGGBBAA` (uppercase, alpha byte ALWAYS present — `FF` = fully opaque).
+ */
+export declare function rgbaToHex8(r: number, g: number, b: number, a: number): string;
+/**
+ * Normalize any color value to a canonical 8-digit RGBA hex string
+ * `#RRGGBBAA` (see {@link rgbaToHex8}). Accepts every shape a color input
+ * can carry (hex, rgb()/rgba(), named constant). Values it can't parse as
+ * a color are returned unchanged, so non-color data passes through
+ * untouched. Used by `Indicator.getInputsMeta()` to present color-input
+ * defaults in a single canonical form.
+ */
+export declare function normalizeColorToRgbaHex(value: unknown): unknown;
 /**
  * PineColor implements the Pine Script `color` namespace.
  *

package/dist/types/namespaces/input/types.d.ts

@@ -11,4 +11,11 @@ export type InputOptions = {
     confirm?: boolean;
     display?: string;
     active?: boolean;
+    /**
+     * Transpiler-injected handle: the variable the input is assigned to
+     * (`len = input.int(…)` → "len"). Popped from the call args by
+     * parseInputOptions and used as the PRIMARY override key by resolveInput
+     * (title is the secondary fallback). Absent for non-transpiled JS calls.
+     */
+    __varId?: string;
 };

package/dist/types/namespaces/strategy/types.d.ts

@@ -68,6 +68,14 @@ export interface Trade {
     max_drawdown?: number;
     max_runup?: number;
     status: 'open' | 'closed';
+    /**
+     * PHYSICAL entry price of this lot, immutable — used to compute
+     * per-lot exit-bracket levels (strategy.exit profit/loss ticks).
+     * Distinct from `entry_price`, which is the LEDGER value and can be
+     * swapped by FIFO entry/exit pairing when a newer lot's bracket fills
+     * before an older lot's (TV ledger convention).
+     */
+    _bracket_entry?: number;
 }
 /**
  * A pending or filled order tracked internally by the engine.
@@ -115,6 +123,7 @@ export interface Order {
     _attachedAtReversal?: boolean;
     _isPersistent?: boolean;
     _callsiteId?: string;
+    _intended_trade_ids?: string[];
 }
 /**
  * Strategy state stored on the Context after a backtest run.
@@ -152,6 +161,10 @@ export interface StrategyState {
     equity_at_drawdown_peak: number;
     max_drawdown_percent_value: number;
     max_runup_percent_value: number;
+    sharpe_ratio: number;
+    sortino_ratio: number;
+    _monthly_equity?: number[];
+    _last_month_key?: number;
     wintrades: number;
     losstrades: number;
     eventrades: number;

package/dist/types/namespaces/strategy/utils.d.ts

@@ -136,7 +136,7 @@ export declare function closePartialPosition(context: any, qtyToClose: number, e
  * Wraps `closePartialPosition` by temporarily reorganizing `opentrades` so
  * the matching trades sit at the head of the FIFO queue.
  */
-export declare function closeMatching(context: any, fromEntry: string | undefined, qtyToClose: number, exitPrice: number, exitTime: number, closeInfo?: CloseInfo): void;
+export declare function closeMatching(context: any, fromEntry: string | undefined, qtyToClose: number, exitPrice: number, exitTime: number, closeInfo?: CloseInfo, specificTradeId?: string): void;
 /**
  * Process exit-category orders each bar (after entry-order fills, before the
  * user script runs). Handles:
@@ -146,18 +146,57 @@ export declare function closeMatching(context: any, fromEntry: string | undefine
  *     triggers evaluated against current bar's high/low. Trailing-stop
  *     peak (trade.trail_peak) is updated each bar even when not triggered.
  */
-export declare function processExitOrders(context: any): void;
+export declare function processExitOrders(context: any, phase?: 'open' | 'intrabar'): void;
+/**
+ * Apply a SECOND margin call scheduled by the phantom re-check (see
+ * processMarginCall). TV books that fill at the PREVIOUS bar's close,
+ * AFTER the script's on-close evaluation — so the script and any order
+ * it queued saw the pre-MC#2 position. PineTS mirrors this by booking
+ * the fill at the very start of the NEXT bar, before entries process:
+ * a reversal queued at the MC bar's close (qty frozen at queue time)
+ * then naturally overshoots by exactly q2, reproducing TV's phantom
+ * opposite-side position (xlsx-confirmed: 2021-10-02 reversal long
+ * 5.263108 = 5 + 0.263108).
+ *
+ * Same-direction (non-reversal) entries queued on the MC bar are
+ * CANCELED — TV's transient post-MC state rejects them (2022-04-19: the
+ * add queued at the 04-18 close never filled; the next add was accepted
+ * a bar later). Opposite-direction reversals are unaffected (E1), and a
+ * close-MC that flattens the position leaves nothing to gate (IC=900k
+ * experiment: next-open entry from flat was admitted).
+ */
+export declare function applyPendingCloseMarginCall(context: any): void;
 /**
- * Margin-call check (TV broker emulator). After all entries and user-defined
- * exits have processed for the bar, check whether the bar's INTRA-BAR
- * adverse movement (low for longs, high for shorts) would have pushed
- * account equity below required maintenance margin. If yes, FORCE LIQUIDATE
- * all open positions at the bar's adverse extreme with exit_id="Margin call".
+ * True when the bar's first intra-bar move is ADVERSE for the current
+ * position (TV broker-emulator path assumption: open closer to high →
+ * open→high→low→close; open closer to low → open→low→high→close).
+ * Used to path-order the margin-call checkpoint against exit fills.
+ */
+export declare function isAdverseFirstBar(context: any): boolean;
+/**
+ * Margin-call check (TV broker emulator) at one of two intra-bar
+ * CHECKPOINTS along the assumed price path:
+ *
+ *   'open'    — right after entries fill at the bar's open: equity and
+ *               required margin evaluated AT THE OPEN, liquidation fills
+ *               at the open price.
+ *   'extreme' — at the bar's adverse extreme (low for longs, high for
+ *               shorts), liquidation fills at the extreme itself — the
+ *               pessimistic broker model (intra-bar tick order unknown).
+ *   'close'   — at the bar's close, after all exits: if the (possibly
+ *               already-trimmed) position still breaches at the closing
+ *               price, another partial liquidation fills at the close.
+ *               Evidence: 2021-10-01 (profit QA) shows TWO same-bar MC
+ *               prices — 4×cover at the high, then a further 0.263108
+ *               at 48,147.38 (the close).
  *
- * The exit price is the bar's adverse extreme itself, NOT the theoretical
- * threshold where equity would exactly equal required margin. This is the
- * pessimistic broker model — the trader is assumed to be liquidated at
- * the worst intra-bar price, since intra-bar tick order is unknown.
+ * TV checks margin along the path, interleaved with exit fills — proven
+ * by the MC-ordering probe (BTCUSDT 1D, 2026-02-05): a 5-lot short
+ * entered at the open was split within one bar into MC 0.00228 at the
+ * OPEN price, MC 0.0888 at the high, then a TP fill of 4.90892 at the
+ * lows. The caller orders the 'extreme' checkpoint BEFORE exit
+ * processing on adverse-first bars and AFTER it on favorable-first bars
+ * (favorable exits free margin before the adverse extreme is reached).
  *
  * Runs for ALL margin percentages including 100%. At 100% margin the
  * trader still needs full notional collateral; adverse price movement
@@ -166,7 +205,7 @@ export declare function processExitOrders(context: any): void;
  * (the "Margin calls" stat in the Strategy Tester is non-zero on 100%
  * margin runs whenever a position's mark-to-market loss exceeds equity).
  */
-export declare function processMarginCall(context: any): void;
+export declare function processMarginCall(context: any, checkpoint?: 'open' | 'extreme' | 'close'): void;
 /**
  * End-of-bar finalize: refresh equity at CLOSE and latch
  * `strategy.max_drawdown` / `strategy.max_runup` using the bar's H/L. Runs
@@ -174,6 +213,29 @@ export declare function processMarginCall(context: any): void;
  * of whether the strategy uses exit orders.
  */
 export declare function finalizeStrategyBar(context: any): void;
+/**
+ * End-of-run finalize: compute the risk-adjusted performance ratios
+ * (Sharpe / Sortino) from the monthly equity curve captured during the
+ * run. Called ONCE after the last bar (see PineTS.class.ts).
+ *
+ * TV broker-emulator formula (confirmed against the Help Center docs and
+ * reverse-engineered to the third decimal across 7 QA datasets,
+ * 2026-06-15):
+ *   - Sample the MARK-TO-MARKET equity at each calendar month's close.
+ *   - Monthly simple returns rᵢ = Eᵢ / Eᵢ₋₁ − 1, anchored at the initial
+ *     capital (the first return runs from initial_capital to month 1).
+ *   - MR = mean(rᵢ);  RFR = risk_free_rate / 100 / 12 (annual % → monthly).
+ *   - Sharpe  = (MR − RFR) / SD,  SD = √(Σ(rᵢ − MR)² / N)   (population).
+ *   - Sortino = (MR − RFR) / DD,  DD = √(Σ min(0, rᵢ − RFR)² / N)
+ *     (downside deviation over ALL N returns, target = RFR — per TV's
+ *     documented DD = sqrt(sum(min(0, Xᵢ − T))² / N)).
+ *   - No annualization.
+ *
+ * Note: the ratios are only as accurate as the bar-by-bar equity path;
+ * they ride on the strategy engine's mark-to-market fidelity. With < 2
+ * monthly returns (very short backtests) they are left at 0.
+ */
+export declare function finalizeStrategyRun(context: any): void;
 /**
  * Initialize strategy state
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.9.21",
+    "version": "0.9.23",
     "description": "Run Pine Script anywhere. PineTS is an open-source transpiler and runtime that brings Pine Script logic to Node.js and the browser with 1:1 syntax compatibility. Reliably write, port, and run indicators or strategies on your own infrastructure.",
     "keywords": [
         "Pine Script",