@mathieuc/tradingview 4.0.0-beta.0 → 4.0.0-beta.1

package/README.md

@@ -25,7 +25,7 @@ console.log(candles.at(-1)); // { time, open, high, low, close, volume }
 
 Prefer to start without code? The setup paths below work too.
 
-> **Version 4 is a breaking rewrite** in TypeScript, with a new API and no compatibility layer. Coming from v3? Read the [migration guide](docs/migration-v4.md). Every v3 feature is still available: see the [coverage matrix](docs/v4-coverage.md) and [reliability evidence](docs/v4-reliability.md). npm versions 3.x keep the previous `Client` API; check the [npm page](https://www.npmjs.com/package/@mathieuc/tradingview) for the version you install.
+> **Version 4 is a breaking rewrite** in TypeScript, with a new API and no compatibility layer. Coming from v3? Read the [migration guide](docs/migration-v4.md). Every v3 feature is still available: see the [coverage matrix](docs/v4-coverage.md). npm versions 3.x keep the previous `Client` API; check the [npm page](https://www.npmjs.com/package/@mathieuc/tradingview) for the version you install.
 
 ## Get started
 

package/dist/chart/index.d.ts

@@ -4,8 +4,8 @@ export { Study } from './study.js';
 export type { StudyChange, StudyEvents, StudyValue } from './study.js';
 export { applyGraphicsCommands, parseGraphics, } from './graphics.js';
 export type { BoxStyleValue, ExtendValue, GraphicBox, GraphicHorizHist, GraphicHorizLine, GraphicLabel, GraphicLine, GraphicPoint, GraphicPolygon, GraphicTable, GraphicsData, HAlignValue, LabelStyleValue, LineStyleValue, RawGraphics, SizeValue, TableCell, TablePositionValue, TextWrapValue, VAlignValue, YLocValue, } from './graphics.js';
-export { mergeStrategyReport, parseTrades } from './strategy.js';
-export type { FromTo, PerformanceReport, RelAbsValue, StrategyReport, StrategyReportChange, TradeReport, } from './strategy.js';
+export { mergeStrategyReport, parseTrades, summarizeStrategyReport } from './strategy.js';
+export type { FromTo, PerformanceReport, RelAbsValue, StrategyReport, StrategyReportChange, StrategySummary, TradeReport, } from './strategy.js';
 export { timeframeSeconds } from './timeframes.js';
 export { CHART_TYPE_STUDIES } from './types.js';
 export type { Adjustment, Candle, ChartType, ChartTypeInputs, MarketSymbol, Subsession, SymbolInfo, Timeframe, Timezone, TradingSession, } from './types.js';

package/dist/chart/index.js

@@ -1,6 +1,6 @@
 export { ChartSession } from './chart-session.js';
 export { Study } from './study.js';
 export { applyGraphicsCommands, parseGraphics, } from './graphics.js';
-export { mergeStrategyReport, parseTrades } from './strategy.js';
+export { mergeStrategyReport, parseTrades, summarizeStrategyReport } from './strategy.js';
 export { timeframeSeconds } from './timeframes.js';
 export { CHART_TYPE_STUDIES } from './types.js';

package/dist/chart/strategy.d.ts

@@ -68,7 +68,7 @@ export interface StrategyReport {
         };
         [key: string]: unknown;
     };
-    /** Trades, most recent first. */
+    /** Trade records, most recent first; may include open positions with an exit valuation. */
     trades: TradeReport[];
     history: {
         buyHold?: number[];
@@ -98,3 +98,16 @@ export type StrategyReportChange = 'report.currency' | 'report.settings' | 'repo
 export declare function parseTrades(trades: any[]): TradeReport[];
 /** Merges a raw report into `target`; returns the changed parts. */
 export declare function mergeStrategyReport(target: StrategyReport, report: any): StrategyReportChange[];
+/** Aggregate counts are authoritative; an exit valuation does not prove closure. */
+export interface StrategySummary {
+    tradeRecordCount: number;
+    closedTradeCount?: number;
+    openTradeCount?: number;
+    closedNetProfit?: number;
+    openPnL?: number;
+    /** Available only when both closed and open PnL are present. */
+    totalPnL?: number;
+    currency?: string;
+}
+/** Summarizes reported aggregates without inferring missing values or trade status. */
+export declare function summarizeStrategyReport(report: StrategyReport): StrategySummary;

package/dist/chart/strategy.js

@@ -1,5 +1,9 @@
+import { TradingViewError } from '../errors.js';
 /** Converts raw trades (oldest first) into readable trades (most recent first). */
 export function parseTrades(trades) {
+    if (!Array.isArray(trades) || trades.some((trade) => !trade || typeof trade !== 'object' || Array.isArray(trade))) {
+        throw new TradingViewError('PARSE_ERROR', 'Strategy trades must be an array of records');
+    }
     return [...trades].reverse().map((t) => ({
         entry: {
             name: t.e?.c,
@@ -20,6 +24,8 @@ export function mergeStrategyReport(target, report) {
     const changes = [];
     if (!report || typeof report !== 'object')
         return changes;
+    // Parse before mutating the target so a malformed trade list cannot leave a partial merge.
+    const trades = report.trades === undefined ? undefined : parseTrades(report.trades);
     if (report.currency) {
         target.currency = report.currency;
         changes.push('report.currency');
@@ -32,20 +38,41 @@ export function mergeStrategyReport(target, report) {
         target.performance = report.performance;
         changes.push('report.perf');
     }
-    if (report.trades) {
-        target.trades = parseTrades(report.trades);
+    if (trades !== undefined) {
+        target.trades = trades;
         changes.push('report.trades');
     }
-    if (report.equity) {
-        target.history = {
-            buyHold: report.buyHold,
-            buyHoldPercent: report.buyHoldPercent,
-            drawDown: report.drawDown,
-            drawDownPercent: report.drawDownPercent,
-            equity: report.equity,
-            equityPercent: report.equityPercent,
-        };
-        changes.push('report.history');
+    const historyKeys = [
+        'buyHold', 'buyHoldPercent', 'drawDown', 'drawDownPercent', 'equity', 'equityPercent',
+    ];
+    let historyChanged = false;
+    for (const key of historyKeys) {
+        if (Array.isArray(report[key])) {
+            target.history[key] = report[key];
+            historyChanged = true;
+        }
     }
+    if (historyChanged)
+        changes.push('report.history');
     return changes;
 }
+/** Summarizes reported aggregates without inferring missing values or trade status. */
+export function summarizeStrategyReport(report) {
+    const finite = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+    const count = (value) => {
+        const n = finite(value);
+        return n !== undefined && Number.isInteger(n) && n >= 0 ? n : undefined;
+    };
+    const closedNetProfit = finite(report.performance.all?.netProfit);
+    const openPnL = finite(report.performance.openPL);
+    return {
+        currency: report.currency,
+        tradeRecordCount: report.trades.length,
+        closedTradeCount: count(report.performance.all?.totalTrades),
+        openTradeCount: count(report.performance.all?.totalOpenTrades),
+        closedNetProfit,
+        openPnL,
+        totalPnL: closedNetProfit !== undefined && openPnL !== undefined
+            ? finite(closedNetProfit + openPnL) : undefined,
+    };
+}

package/dist/chart/study.js

@@ -161,8 +161,16 @@ export class Study extends Emitter {
                     }));
                 }
             }
-            if (parsed?.data?.report)
-                changes.push(...mergeStrategyReport(this.#strategyReport, parsed.data.report));
+            if (parsed?.data?.report) {
+                try {
+                    changes.push(...mergeStrategyReport(this.#strategyReport, parsed.data.report));
+                }
+                catch (error) {
+                    this.emit('error', new TradingViewError('PARSE_ERROR', 'Unable to parse strategy report', {
+                        cause: error,
+                    }));
+                }
+            }
         }
         if (Array.isArray(ns?.indexes))
             this.#graphicIndexes = ns.indexes;

package/dist/data/index.d.ts

@@ -26,3 +26,5 @@ export type { QuoteData, QuoteField } from '../quote/fields.js';
 export type { StudyValue } from '../chart/study.js';
 export type { GraphicsData } from '../chart/graphics.js';
 export type { StrategyReport } from '../chart/strategy.js';
+export { summarizeStrategyReport } from '../chart/strategy.js';
+export type { StrategySummary } from '../chart/strategy.js';

package/dist/data/index.js

@@ -13,3 +13,4 @@ export { DEFAULT_TIMEOUT_MS } from './operation.js';
 // Plain HTTP lookups are already one-shot; they are part of the data API too.
 export { getTechnicalAnalysis, searchIndicators, searchMarkets, } from '../http/index.js';
 export { TradingViewError } from '../errors.js';
+export { summarizeStrategyReport } from '../chart/strategy.js';

package/dist/http/account.js

@@ -109,13 +109,13 @@ export async function getUser(credentials, options = {}) {
     if (!credentials?.session)
         throw new TradingViewError('INVALID_ARGUMENT', 'A session cookie is required');
     const maxRedirects = options.maxRedirects ?? 5;
-    let location = trustedAccountLocation(options.location ?? 'https://www.tradingview.com/chart/');
+    let location = trustedAccountLocation(options.location ?? 'https://www.tradingview.com/');
     for (let redirects = 0;; redirects += 1) {
-        const { status, text, headers } = await request(location, { credentials, redirect: 'manual' }, options);
+        const { text, headers } = await request(location, { credentials, redirect: 'manual' }, options);
         if (text.includes('auth_token'))
             return parseUserPage(text, credentials);
         const next = headers.get('location');
-        const resolved = status >= 300 && status < 400 && next ? new URL(next, location).toString() : undefined;
+        const resolved = next ? new URL(next, location).toString() : undefined;
         if (!resolved || resolved === location) {
             throw new TradingViewError('AUTH_ERROR', 'Wrong or expired sessionid/signature');
         }

package/docs/data-api.md

@@ -152,6 +152,62 @@ Without an account, TradingView refuses Pine studies ("maximum number of studies
 
 `watchIndicator(query, { onData, onError })` streams the same result on every study update; `watcher.latest` holds the last one.
 
+### Strategy totals and open positions
+
+```ts
+import { summarizeStrategyReport } from '@mathieuc/tradingview/data';
+
+const summary = summarizeStrategyReport(result.strategyReport);
+// tradeRecordCount, closedTradeCount, openTradeCount,
+// closedNetProfit, openPnL, totalPnL, currency
+```
+
+Trade records can include open positions with a current exit valuation. An `exit`
+object does **not** establish that a trade is closed. The summary uses reported
+`performance.all.totalTrades` and `totalOpenTrades`, never the record count, for
+closed/open counts. It does not assign a closed/open status to individual records.
+Counts may differ from the available records in a partial report.
+
+`totalPnL` is closed net profit plus open PnL, in the report currency. Missing or
+non-finite values remain `undefined`; a missing open PnL is not assumed to be zero.
+Raw percentage/fraction fields are not rescaled. History series, including buy &
+hold, are retained independently even when no equity series is provided. Updates
+replace supplied arrays and retain omitted series; an empty array clears a series.
+
+Malformed trade lists (a non-array or non-object records) raise `PARSE_ERROR`
+before any part of that report is applied. Studies emit this error for both plain
+and compressed reports. Omitted trade lists retain previous records; `[]` clears them.
+This is structural validation, not full validation of every trade field.
+
+These offline checks validate report decoding and normalization, not fresh-client
+access, Replay playback, export entitlement or Deep Backtesting availability.
+
+In a Basic-account UI check on October 3, 2026, both strategy trade CSV export and
+strategy report XLSX export opened an upgrade prompt recommending Essential.
+No successful export was verified. These are TradingView UI entitlements, not
+library export methods or a guarantee about other accounts. Deep Backtesting is
+separate and was blocked by a Premium upgrade prompt in that session.
+
+### Complete strategy report example
+
+See [strategy-report.js](../examples/strategy-report.js) for a bounded, executable
+public-strategy → trade-records → PnL-summary workflow. Run it from a repository
+checkout after building:
+
+```bash
+node --env-file=.env examples/strategy-report.js
+```
+
+It uses the account cookies from `.env`, runs a public Supertrend strategy and
+closes its connection automatically. It places no orders. Trade records are
+most recent first and can include open positions with current exit valuations;
+use the reported aggregate counts rather than inferring closure from an exit.
+Missing summary fields remain `undefined`, not zero. `count` selects returned
+candles, not a guaranteed exact strategy backtest window. Basic was sufficient
+for the tested symbol/timeframe; UI exports and Deep Backtesting have separate
+subscription requirements.
+
+
 ## Search and technical analysis
 
 ```ts

package/docs/release-4.0.0-beta.1.md

@@ -0,0 +1,39 @@
+# 4.0.0-beta.1 release candidate
+
+Status: prepared for review; not published by this change.
+Target npm dist-tag: **beta**. Keep **latest** on 3.5.2.
+
+## Changes since beta.0
+
+- Preserve buy-and-hold history even when a report has no equity history (#331).
+- Export `summarizeStrategyReport`: separate record counts, closed/open trade
+  counts, closed net profit, open PnL and total PnL; retain unknown fields as
+  undefined (#331).
+- Reject structurally malformed trade lists before modifying a report; report
+  parse errors consistently for plain and compressed envelopes (#332).
+- Add a runnable public-strategy/report/PnL example, with bounded execution,
+  credential checks and explicit failure status.
+- Document Basic Replay playback evidence and separate paid UI export and
+  Deep Backtesting limits from library report access.
+
+## Validation
+
+- Deterministic Node/Bun suites, typecheck, lint, build and packed-consumer smoke
+  checks are required before publication.
+- Basic live probe: daily BINANCE:BTCEUR Replay load, three step acknowledgments,
+  automatic bar advancement, start and stop acknowledgments.
+- Strategy example executed against Basic; report aggregates and history returned.
+- Private compressed strategy capture validated in the preceding fixes.
+- No claim of universal Replay entitlement, UI export success or Deep Backtesting.
+
+## Publication gate
+
+Publication requires the maintainer's explicit go-ahead. After approval, use the
+reviewed commit with a clean checkout, rerun package checks, and publish the
+inspected tarball using `npm publish <tarball> --tag beta`. Verify the resulting
+version and dist-tags. Do not use the default `latest` tag. No tag, GitHub release,
+or npm publication is created by preparing this candidate.
+
+For v3 migration and breaking changes inherited from beta.0, see
+[migration-v4.md](migration-v4.md). This candidate adds no new intended breaking
+change relative to beta.0.

package/docs/v4-coverage.md

@@ -1,13 +1,13 @@
 # v4 coverage matrix
 
-[Migration guide](migration-v4.md) · [Data API](data-api.md) · [Low-level API](low-level-api.md) · [Reliability evidence](v4-reliability.md)
+[Migration guide](migration-v4.md) · [Data API](data-api.md) · [Low-level API](low-level-api.md)
 
 This matrix lists every capability of v3 (`main.js`, `src/`, examples, tests) and of the `agent.ts` preview, with its v4 replacement and the evidence that it works.
 
 **Evidence columns**
 
-- **Unit**: deterministic test in `tests/unit/` (`npm test` with Vitest on Node, `npm run test:bun` with Bun's runner; 109 tests, both green). Websocket tests use a scripted fake server (`tests/helpers/fake-server.ts`) or packets captured from TradingView (`tests/fixtures/live-session.json`); HTTP tests use a mocked `fetch`.
-- **Live**: result of `npm run test:live` (`tests/live/`) and examples against TradingView on **2 October 2026**: 17 anonymous tests locally (including connection recovery) and 22 tests (including five authenticated) in the [manual GitHub Actions run](https://github.com/Mathieu2301/TradingView-API/actions/runs/37078178729):
+- **Unit**: deterministic test in `tests/unit/` (`npm test` with Vitest on Node, `npm run test:bun` with Bun's runner; 115 tests, both green). Websocket tests use a scripted fake server (`tests/helpers/fake-server.ts`) or packets captured from TradingView (`tests/fixtures/live-session.json`); HTTP tests use a mocked `fetch`.
+- **Live**: result of `npm run test:live` (`tests/live/`) and examples against TradingView on **2 October 2026**: 16 anonymous tests locally and 21 tests (including five authenticated) in the [manual GitHub Actions run](https://github.com/Mathieu2301/TradingView-API/actions/runs/37075296707):
   - ✅ verified live anonymously;
   - 🔒 path or variant not exercised live (often requires a specific account asset); deterministic tests only;
   - ➖ not applicable (no network involved).
@@ -31,7 +31,7 @@ Test names are abbreviated as `file › test`.
 | --- | --- | --- | --- |
 | `protocol.parseWSPacket` (frame split, heartbeat as number, invalid JSON warning) | `protocol.decodeFrames` (length-based, UTF-16 lengths, typed frames, lenient fallback, invalid frames reported) | `protocol › decodes several frames...`, `keeps payloads containing frame markers intact`, `reports invalid JSON...`, `falls back to splitting malformed input`, `decodes every message of a captured live session` | ✅ (fixture captured live; UTF-16 lengths checked on Japanese/Korean descriptions) |
 | `protocol.formatWSPacket` | `protocol.encodeFrame`, `encodePacket`, `encodeHeartbeat` | `protocol › encodes packets with UTF-16 lengths` | ✅ |
-| `protocol.parseCompressed` (ZIP via jszip, base64 normalisation, zlib/raw/gzip fallbacks) | `protocol.decodeCompressed` (built-in ZIP reader: stored, deflated, data descriptors, empty entry names; zlib, raw deflate, gzip, plain JSON) and `normaliseBase64`, `readFirstZipEntry` | `protocol › compressed payloads › *` (ZIP fixtures generated independently with Python `zipfile`) | 🔒 live compressed strategy payload not captured; plain report verified |
+| `protocol.parseCompressed` (ZIP via jszip, base64 normalisation, zlib/raw/gzip fallbacks) | `protocol.decodeCompressed` (built-in ZIP reader: stored, deflated, data descriptors, empty entry names; zlib, raw deflate, gzip, plain JSON) and `normaliseBase64`, `readFirstZipEntry` | `protocol › compressed payloads › *` (ZIP fixtures generated independently with Python `zipfile`) | ✅ private compressed browser capture replayed through compiled parser (3 October 2026); plain report verified |
 | `utils.genSessionID` | `protocol.createSessionId` (crypto-random) | `protocol › ids` | ➖ |
 | `utils.genAuthCookies` | Internal cookie builder used by every HTTP call | `http › * with credentials` (cookie headers asserted) | ➖ |
 | Websocket URL `wss://<server>.tradingview.com/socket.io/websocket?from=chart&type=chart`, Origin and browser headers | Same, in `TradingViewClient`; transport is pluggable (`transport` option, default `ws`) | `client › connects with browser-like headers...` | ✅ Node and Bun (Bun needed the Origin header fix) |
@@ -89,7 +89,7 @@ Test names are abbreviated as `file › test`.
 | v3 capability | v4 | Unit evidence | Live |
 | --- | --- | --- | --- |
 | `setMarket(symbol, { replay })` (replay session, add series, reset) | Same option | `chart › runs replay mode...` | ✅ |
-| `replayStep(n)`, `replayStart(interval)`, `replayStop()` resolved by `replay_ok` | Same; reject with `INVALID_STATE` outside replay and on delete | `chart › runs replay mode...`, `rejects pending replay requests...` | ✅ step (`sessions › replays history step by step`); ➖ start/stop live |
+| `replayStep(n)`, `replayStart(interval)`, `replayStop()` resolved by `replay_ok` | Same; reject with `INVALID_STATE` outside replay and on delete | `chart › runs replay mode...`, `rejects pending replay requests...` | ✅ step (`sessions › replays history step by step`); ✅ start/stop acknowledgments and advancing bars on Basic (3 October 2026) |
 | `onReplayLoaded`, `onReplayPoint`, `onReplayResolution`, `onReplayEnd` | `replayLoaded`, `replayPoint`, `replayResolution`, `replayEnd` events | `chart › runs replay mode...` | ✅ |
 | Replay `critical_error` | `CRITICAL_ERROR` on the chart; pending replay requests rejected | (code path shared with chart errors) | ➖ |
 
@@ -102,7 +102,7 @@ Test names are abbreviated as `file › test`.
 | `study.periods` with plot names, `plot_N` fallback for unnamed/duplicate plots | `study.values` (oldest first) | `study › creates a Pine study, names plots...`, `chart › parses a captured live chart session` | ✅ (built-in volume rows) |
 | `study.graphic` (labels, lines, boxes, tables + cells, polygons, horizLines, horizHists, raw) and `graphicsCmds` erase/create | `study.graphics` (`cells` array, `raw` object) | `study › reads graphics commands...`, `applies erase commands` | ✅ horizontal histograms (volume profile); 🔒 Pine drawings |
 | Bars-back translation of graphic X indexes | Same | `study › reads graphics commands...` | ✅ |
-| `study.strategyReport` (plain `data.report` and compressed `dataCompressed`; trades, performance, history, currency, settings) | Same | `study › decodes plain and compressed strategy reports`, `reports undecodable strategy reports as PARSE_ERROR` | ✅ Supertrend strategy report with account; compressed variant unit-tested |
+| `study.strategyReport` (plain `data.report` and compressed `dataCompressed`; trades, performance, history, currency, settings) | Same | `study › decodes plain and compressed strategy reports`, `reports undecodable strategy reports as PARSE_ERROR` | ✅ Supertrend strategy report with account; compressed variant also validated using a private browser capture |
 | `study.setIndicator()` (`modify_study`) | Same | `study › modifies and removes a study` | 🔒 |
 | `study.remove()` | Same (idempotent) | same | ✅ |
 | `onReady`, `onUpdate`, `onError`, `study_error` | `ready`, `loading`, `update`, `error` (`STUDY_ERROR`, message formatted with server context) | `study › formats study errors with their context` | ✅ (anonymous Pine refusal reported as `STUDY_ERROR`) |
@@ -189,4 +189,25 @@ These v3 behaviours were changed on purpose; none removes a capability.
 
 ## Not verified live for this release
 
-The 22-test manual live workflow verified authenticated connection, account lookup, a public Pine RSI, a Supertrend strategy report, the private-indicators listing endpoint, and recent historical `to` with an account. It did **not** verify password login, actual private/invite-only scripts, compressed strategy reports against a live response, older history beyond server limits, second-based/custom timeframes, the `prodata` server, owned layouts/drawings, or Pine permission changes. Those paths have deterministic tests but need the corresponding account assets to verify live. Run `SESSION=... SIGNATURE=... npm run test:live` to repeat the authenticated subset.
+The 21-test manual live workflow verified authenticated connection, account lookup, a public Pine RSI, a Supertrend strategy report, the private-indicators listing endpoint, and recent historical `to` with an account. It did **not** verify password login, actual private/invite-only scripts, older history beyond server limits, second-based/custom timeframes, the `prodata` server, owned layouts/drawings, or Pine permission changes. Those paths have deterministic tests but need the corresponding account assets to verify live. Run `SESSION=... SIGNATURE=... npm run test:live` to repeat the authenticated subset.
+
+## Basic account follow-up — 3 October 2026
+
+A fresh authenticated library client loaded `BINANCE:BTCEUR` daily Replay at a
+reference 30 days before the probe. Loading returned five bars; three step
+requests were acknowledged; automatic playback produced advancing bar timestamps;
+start and stop were both acknowledged. The client was closed after the bounded
+probe. This verifies the library protocol for that symbol/timeframe/reference,
+not intraday Replay, every exchange, unlimited history, or simulated order entry.
+The existing browser chart and its settings were not changed.
+
+`examples/strategy-report.js` was executed with the same Basic account against
+the public Supertrend strategy on `BINANCE:BTCEUR`, timeframe `60`, count `300`.
+It returned trade records, closed/open aggregate counts and PnL, and buy-and-hold
+history. No private payloads or credentials are included in this repository.
+The strategy may compute over more history than the requested candle count;
+`count` is not an exact backtest-window guarantee.
+
+UI CSV and XLSX exports remain plan-blocked (Essential offered), and Deep
+Backtesting remains plan-blocked (Premium offered). The library report example
+is not an implementation of those UI exports and does not enable Deep Backtesting.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mathieuc/tradingview",
-  "version": "4.0.0-beta.0",
+  "version": "4.0.0-beta.1",
   "description": "TradingView market data for JavaScript and TypeScript: candles, quotes, indicators and strategies, with a simple data API and full low-level access.",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,9 +34,7 @@
     "test:live": "vitest run --config vitest.live.config.ts",
     "smoke": "node scripts/smoke.mjs",
     "check": "npm run typecheck && npm run lint && npm test && npm run build && npm run smoke",
-    "prepack": "npm run build",
-    "probe:endurance": "npm run build && node scripts/endurance.mjs",
-    "probe:parity": "npm run build && node scripts/parity.mjs"
+    "prepack": "npm run build"
   },
   "repository": {
     "type": "git",

package/docs/v4-reliability.md

@@ -1,33 +0,0 @@
-# V4 reliability evidence
-
-This page tracks reproducible release checks beyond the [capability matrix](v4-coverage.md). It is evidence for a beta, not a claim that every TradingView account feature works.
-
-## V3/V4 candle parity
-
-On 2 October 2026, the published `@mathieuc/tradingview@3.5.2` and V4 `main` (`95b6d0f`) loaded the same `BINANCE:BTCEUR` market. For each of `D` and `60`, the probe compared 19 closed candles out of 20 requested. All 38 matched on timestamp and OHLC. Volumes matched after applying V3's two-decimal rounding; V4 intentionally preserves the server precision. The still-open candle was excluded because it can change between sequential requests.
-
-Repeat without adding V3 to V4's dependencies:
-
-```sh
-npm ci
-npm install --prefix /tmp/tradingview-v3-baseline --no-save --no-package-lock @mathieuc/tradingview@3.5.2
-TV_V3_ENTRY=/tmp/tradingview-v3-baseline/node_modules/@mathieuc/tradingview/main.js npm run probe:parity
-```
-
-`probe:parity` exits nonzero on a mismatched closed candle. It needs live network access and is not part of deterministic CI.
-
-## Live connection lifecycle
-
-`tests/live/recovery.test.ts` starts candle and quote watchers on one client, closes the connection while both are active, verifies both stop and report `DISCONNECTED`, then fetches candles with a new client. This is a controlled socket close, not proof of recovery from every network failure. The library does not reconnect a closed `TradingViewClient` automatically; consumers create a new client.
-
-`npm run probe:endurance -- --minutes=120 --cycle-seconds=600` streams one-minute BTCUSDT candles and quotes for two hours, rotates the connection every ten minutes, and emits JSON lines with startup counts, updates, heartbeats and errors. It exits nonzero on a startup failure, an early watcher close or missing data. It never reads or logs account credentials. A one-minute smoke run on 2 October 2026 completed three cycles with 16 candle updates, 18 quote updates, five heartbeats and zero errors. The two-hour result should only be recorded after the run ends. The probe also accepts `--symbol`, `--timeframe` and `--chart-type` for issue-specific checks. For example, issue #236 can be investigated with `--symbol=OANDA:EURUSD --chart-type=HeikinAshi`, though a closed forex market cannot prove that quote updates remain live.
-
-## Account redirect regression
-
-V4 now starts the account lookup at `/chart/` and follows `Location` only on HTTP 3xx responses. A deterministic test covers HTTP 200 with a misleading `Location` header. This ports the relevant guard from legacy PR #322; it does not claim to solve CAPTCHA/WAF challenges. The authenticated manual CI run passed all 22 live tests after this change.
-
-## Remaining beta limitations
-
-- The 17 anonymous live tests and five authenticated tests from the [coverage matrix](v4-coverage.md) exercise short-lived calls. The authenticated subset requires `SESSION` and `SIGNATURE`; all five tests passed in the manual GitHub Actions run on 2 October 2026.
-- `prodata`, private/invite-only scripts, owned layouts and drawings, Pine permission changes, password login and a live compressed strategy report still require suitable account assets. Deterministic tests cover their known packet shapes but are not live proof.
-- The scheduled/manual live CI job is currently non-blocking. A red live run must be reviewed before a stable V4 release.