pinets 0.9.17 → 0.9.19

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

@@ -1,5 +1,9 @@
 /**
- * Average per-trade loss (as a positive percent) across losing closed trades.
- * NaN when no losers yet. Matches Pine's strategy.avg_losing_trade_percent.
+ * Average per-trade loss (as a SIGNED negative percent) across losing
+ * closed trades. NaN when no losers yet.
+ *
+ * Note: `strategy.avg_losing_trade` (the dollar version) is reported as
+ * a POSITIVE magnitude by Pine convention, but `_percent` is signed —
+ * negative values, since they represent losses.
  */
 export declare function avg_losing_trade_percent(context: any): () => number;

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

@@ -1,9 +1,15 @@
 /**
  * Convert a value from the symbol's currency to the account currency.
  *
- * For the common same-currency case (e.g. BTCUSDC's quote currency USDC ≈ USD),
- * this is an identity. Genuine cross-currency conversion would require an FX
- * rate source which we don't model; returns the input unchanged in that case
- * with a console warning on first call.
+ * Pine semantics:
+ *   - same currency string → return the value unchanged (identity)
+ *   - different currency strings → return `na` (NaN), since no FX
+ *     rate is available. String equality is used, not economic
+ *     equivalence — so nominally pegged pairs like USDC vs USD still
+ *     return NaN when their currency strings differ.
+ *
+ * When `syminfo.currency` is undefined we fall back to identity rather
+ * than NaN, so synthetic / array-fed datasets without a syminfo block
+ * don't get poisoned.
  */
 export declare function convert_to_account(context: any): (value: number) => number;

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

@@ -1,5 +1,8 @@
 /**
  * Inverse of convert_to_account: from account currency → symbol currency.
- * Same identity passthrough for matching-currency case.
+ *
+ * Mirrors convert_to_account's TV-matching behavior: identity passthrough
+ * when account and symbol currencies are the same string, NaN when they
+ * differ. See convert_to_account.ts for the full rationale.
  */
 export declare function convert_to_symbol(context: any): (value: number) => number;

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

@@ -2,12 +2,22 @@
  * Price at which the current leveraged position would be force-liquidated.
  * Returns NaN when flat or when the relevant margin% is 100 (no leverage).
  *
- * Formula (simplified):
- *   long  → entry_avg_price * (1 - margin_long / 100)
- *   short → entry_avg_price * (1 + margin_short / 100)
+ * Official TV formula, documented at
+ * https://www.tradingview.com/support/solutions/43000717375/ :
  *
- * This is the simple peak-loss-tolerable price; real broker liquidation
- * depends on maintenance margin schedules which we don't model.
- * Matches Pine's strategy.margin_liquidation_price in the common case.
+ *   MarginLiquidationPriceRaw =
+ *       ((InitialCapital + NetProfit) / (PointValue * AbsPositionSize)
+ *        − Direction * EntryPrice)
+ *     / (MarginPercent / 100 − Direction)
+ *
+ * Where:
+ *   InitialCapital + NetProfit = realized account equity (initial cash
+ *                                 plus closed-trade P&L; excludes openprofit)
+ *   PointValue                 = syminfo.pointvalue (1 for crypto, varies
+ *                                 for futures contracts)
+ *   AbsPositionSize            = |strategy.position_size|
+ *   Direction                  = +1 for long, −1 for short
+ *   EntryPrice                 = strategy.position_avg_price
+ *   MarginPercent              = margin_long for longs, margin_short for shorts
  */
 export declare function margin_liquidation_price(context: any): () => number;

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

@@ -1,5 +1,14 @@
 /**
- * Maximum drawdown as a percent of the equity high-water mark.
- * Matches Pine's strategy.max_drawdown_percent.
+ * Maximum drawdown percent. Pine's semantic is the RUNNING MAX of
+ * `(latched_drawdown / equity_at_that_latch) × 100` across all latch
+ * events over the strategy's lifetime — NOT a derived
+ * `(current_max_drawdown / current_equity_at_peak) × 100`. The two
+ * interpretations diverge when a later latch produces a larger absolute
+ * drawdown but a smaller percentage (because equity grew faster than
+ * the drawdown), in which case the earlier latch's higher ratio is the
+ * reported value.
+ *
+ * The running max is maintained in `updateEquityPeaks` (utils.ts) on
+ * every latch event; this getter is a pure read.
  */
-export declare function max_drawdown_percent(context: any): () => number;
+export declare function max_drawdown_percent(context: any): () => any;

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

@@ -1,5 +1,17 @@
 /**
- * Maximum equity run-up as a percent of initial capital.
- * Matches Pine's strategy.max_runup_percent.
+ * Maximum equity run-up percent. Mirrors the `max_drawdown_percent`
+ * semantic — TV reports the RUNNING MAX of the per-latch ratio,
+ * `(latched_runup / equity_at_that_latch) × 100`, across all latches
+ * in the strategy's lifetime.
+ *
+ * In most strategies the runup ratio grows monotonically with each
+ * latch, so this matches a derived `(current_max_runup /
+ * current_equity_at_runup_peak) × 100`. But in scenarios where a
+ * later latch produces a larger absolute runup yet a smaller
+ * percentage (because equity grew faster than the runup), TV keeps
+ * the highest ratio ever seen — same as the drawdown semantic.
+ *
+ * The running max is maintained in `updateEquityPeaks` whenever
+ * max_runup is latched to a new peak — see utils.ts.
  */
-export declare function max_runup_percent(context: any): () => number;
+export declare function max_runup_percent(context: any): () => any;

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

@@ -111,6 +111,10 @@ export interface Order {
     immediately?: boolean;
     trail_peak?: number;
     trail_armed?: boolean;
+    _isReversalEntry?: boolean;
+    _attachedAtReversal?: boolean;
+    _isPersistent?: boolean;
+    _callsiteId?: string;
 }
 /**
  * Strategy state stored on the Context after a backtest run.
@@ -144,6 +148,10 @@ export interface StrategyState {
     max_runup: number;
     equity_peak: number;
     equity_trough: number;
+    equity_at_runup_peak: number;
+    equity_at_drawdown_peak: number;
+    max_drawdown_percent_value: number;
+    max_runup_percent_value: number;
     wintrades: number;
     losstrades: number;
     eventrades: number;
@@ -173,4 +181,7 @@ export interface StrategyState {
         max_position_size?: number;
     };
     risk_halted: boolean;
+    _exit_call_history?: Map<string, number>;
+    _exit_fallback_counter?: number;
+    _exit_fallback_last_bar?: number;
 }

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

@@ -3,6 +3,58 @@ import { Order, StrategyState } from './types';
  * Parse strategy() function arguments
  */
 export declare function parseStrategyOptions(args: any[]): any;
+/**
+ * Round a stop/limit price to the symbol's mintick grid, AWAY from the
+ * reference price (typically the current bar's close at order placement).
+ *
+ * Pine's broker emulator places stop/limit orders on the mintick grid
+ * conservatively — a buy stop at 4188.4541 above current 4184 becomes
+ * 4188.46 (ceiling), not 4188.45. This makes the order trigger LATER
+ * (requires more price movement), mirroring real-broker order placement.
+ *
+ * The rule:
+ *   price > referencePrice → ceil to mintick (push price UP)
+ *   price < referencePrice → floor to mintick (push price DOWN)
+ *   price === referencePrice → return as-is
+ *
+ * Covers all four cases naturally:
+ *   - Buy stop above current  → ceil
+ *   - Sell stop below current → floor
+ *   - Buy limit below current → floor
+ *   - Sell limit above current → ceil
+ *   - Long TP above entry / SL below entry → ceil / floor
+ *   - Short TP below entry / SL above entry → floor / ceil
+ *
+ * For mintick === 0 or undefined (defensive), returns the price unchanged.
+ */
+export declare function roundToMintick(price: number, referencePrice: number, mintick: number): number;
+/**
+ * Margin required to hold a position of `qty` contracts at `price`, given
+ * the `marginPct` (% of notional that must be posted as collateral). The
+ * pointValue factor converts price units to account-currency dollars
+ * (1 for crypto, varies for futures).
+ *
+ * Pine docs (strategy() declaration): `margin_long` / `margin_short` is
+ * the percentage of notional held as collateral. 100 = no leverage, 20 =
+ * 5× leverage, etc.
+ */
+export declare function computeRequiredMargin(qty: number, price: number, marginPct: number, pointValue: number): number;
+/**
+ * Account equity computed AS IF the marketprice were `atPrice` — used to
+ * check what equity would be at a hypothetical intra-bar price (e.g. the
+ * bar's adverse extreme for a margin-call check).
+ *
+ *   equity_at_price = initial_capital + netprofit + unrealizedPnL_at_price
+ *
+ * The mark-to-market is computed against EVERY open trade's entry price.
+ */
+export declare function computeEquityAtPrice(context: any, atPrice: number): number;
+/**
+ * Total margin currently held by all open positions, valued at `atPrice`.
+ * Per-position margin uses `margin_long` for longs and `margin_short` for
+ * shorts (Pine semantic — see strategy() declaration).
+ */
+export declare function computeHeldMargin(context: any, atPrice: number): number;
 /**
  * Calculate order quantity based on strategy configuration
  */
@@ -51,14 +103,31 @@ export declare function evaluateCatastrophicRiskHalt(strategy: StrategyState): v
  * @param price     fill price
  * @param time      fill time (ms)
  */
-export declare function openTrade(context: any, entryId: string, direction: number, qty: number, price: number, time: number): void;
+export declare function openTrade(context: any, entryId: string, direction: number, qty: number, price: number, time: number, entryComment?: string, isReversalOpen?: boolean): void;
 /**
  * Close partial or full position.
  *
  * FIFO accounting: closes oldest open trades first. Splits a trade if the
  * close qty is smaller than the trade's remaining qty.
  */
-export declare function closePartialPosition(context: any, qtyToClose: number, exitPrice: number, exitTime: number): void;
+export interface CloseInfo {
+    /** Which exit leg triggered ('profit'/'loss'/'trailing'), null otherwise. */
+    triggerKind?: 'profit' | 'loss' | 'trailing' | null;
+    /** Exit order's id, set onto the closed trade as trade.exit_id. */
+    exitId?: string;
+    /** Resolved exit comment (the matching comment_profit/loss/trailing). */
+    exitComment?: string;
+    /**
+     * True when this close is part of a single REVERSAL order that will
+     * also open a new trade in the opposite direction. Affects
+     * `cash_per_order` commission: TV charges the flat fee ONCE per order
+     * placement, attributed to the new entry — the implicit close leg of
+     * the reversal does NOT incur a second flat charge. Per-leg types
+     * (percent, cash_per_contract) are unaffected by this flag.
+     */
+    isImplicitReversal?: boolean;
+}
+export declare function closePartialPosition(context: any, qtyToClose: number, exitPrice: number, exitTime: number, closeInfo?: CloseInfo): void;
 /**
  * FIFO close of `qtyToClose` contracts from open trades, optionally filtered
  * by `fromEntry` — when set, only trades whose `entry_id === fromEntry` are
@@ -67,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): void;
+export declare function closeMatching(context: any, fromEntry: string | undefined, qtyToClose: number, exitPrice: number, exitTime: number, closeInfo?: CloseInfo): void;
 /**
  * Process exit-category orders each bar (after entry-order fills, before the
  * user script runs). Handles:
@@ -78,6 +147,29 @@ export declare function closeMatching(context: any, fromEntry: string | undefine
  *     peak (trade.trail_peak) is updated each bar even when not triggered.
  */
 export declare function processExitOrders(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".
+ *
+ * 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.
+ *
+ * Skipped entirely when the position's `margin_pct >= 100` (no leverage)
+ * or when there are no open positions.
+ */
+export declare function processMarginCall(context: any): void;
+/**
+ * End-of-bar finalize: refresh equity at CLOSE and latch
+ * `strategy.max_drawdown` / `strategy.max_runup` using the bar's H/L. Runs
+ * UNCONDITIONALLY once per bar (after entry+exit fills are done), regardless
+ * of whether the strategy uses exit orders.
+ */
+export declare function finalizeStrategyBar(context: any): void;
 /**
  * Initialize strategy state
  */

package/dist/types/transpiler/settings.d.ts

@@ -2,6 +2,7 @@ export declare const KNOWN_NAMESPACES: string[];
 export declare const NAMESPACES_LIKE: string[];
 export declare const ASYNC_METHODS: string[];
 export declare const VIEWPORT_DEPENDENT_BUILTINS: string[];
+export declare const CALLSITE_ID_NAMESPACES: string[];
 export declare const FACTORY_METHODS: string[];
 export declare const NAMESPACE_COLLISION_NAMES: Set<string>;
 export declare const JS_RESERVED_WORDS: Set<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.9.17",
+    "version": "0.9.19",
     "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",
@@ -105,7 +105,7 @@
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/QuantForgeOrg/PineTS.git"
+        "url": "git+https://github.com/LuxAlgo/PineTS.git"
     },
-    "homepage": "https://quantforge.org/pinets/"
+    "homepage": "https://luxalgo.com/"
 }