tradelab 0.4.0 → 1.0.0

package/src/live/storage/jsonFileStorage.js

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { StorageProvider } from "./interface.js";
+
+function sanitizeNamespace(namespace) {
+  return String(namespace || "default").replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+async function ensureDir(dirPath) {
+  await fsp.mkdir(dirPath, { recursive: true });
+}
+
+async function readJsonFile(filePath) {
+  try {
+    const raw = await fsp.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error && error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+async function writeJsonAtomic(filePath, payload) {
+  const tmpPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random()
+    .toString(16)
+    .slice(2)}.tmp`;
+  await fsp.writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf8");
+  await fsp.rename(tmpPath, filePath);
+}
+
+async function appendJsonLine(filePath, payload) {
+  await ensureDir(path.dirname(filePath));
+  await fsp.appendFile(filePath, `${JSON.stringify(payload)}\n`, "utf8");
+}
+
+async function readJsonLines(filePath) {
+  try {
+    const raw = await fsp.readFile(filePath, "utf8");
+    return raw
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch (error) {
+    if (error && error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+
+/**
+ * Zero-dependency JSON state storage.
+ */
+export class JsonFileStorage extends StorageProvider {
+  constructor({ baseDir = path.resolve(process.cwd(), "output/live-state") } = {}) {
+    super();
+    this.baseDir = baseDir;
+  }
+
+  namespaceDir(namespace) {
+    return path.join(this.baseDir, sanitizeNamespace(namespace));
+  }
+
+  statePath(namespace) {
+    return path.join(this.namespaceDir(namespace), "state.json");
+  }
+
+  tradesPath(namespace) {
+    return path.join(this.namespaceDir(namespace), "trades.jsonl");
+  }
+
+  equityPath(namespace) {
+    return path.join(this.namespaceDir(namespace), "equity.jsonl");
+  }
+
+  async load(namespace) {
+    return readJsonFile(this.statePath(namespace));
+  }
+
+  async save(namespace, state) {
+    const dir = this.namespaceDir(namespace);
+    await ensureDir(dir);
+    await writeJsonAtomic(this.statePath(namespace), state);
+  }
+
+  async appendTrade(namespace, trade) {
+    await appendJsonLine(this.tradesPath(namespace), trade);
+  }
+
+  async appendEquityPoint(namespace, point) {
+    await appendJsonLine(this.equityPath(namespace), point);
+  }
+
+  async loadTrades(namespace) {
+    return readJsonLines(this.tradesPath(namespace));
+  }
+
+  async loadEquityCurve(namespace) {
+    return readJsonLines(this.equityPath(namespace));
+  }
+
+  async clear(namespace) {
+    const dir = this.namespaceDir(namespace);
+    if (!fs.existsSync(dir)) return;
+    await fsp.rm(dir, { recursive: true, force: true });
+  }
+}
+
+export function createJsonFileStorage(options) {
+  return new JsonFileStorage(options);
+}

package/src/metrics/buildMetrics.js

@@ -16,11 +16,7 @@ function sortino(values) {
   const losses = values.filter((value) => value < 0);
   const downsideDeviation = stddev(losses.length ? losses : [0]);
   const avg = mean(values);
-  return downsideDeviation === 0
-    ? avg > 0
-      ? Infinity
-      : 0
-    : avg / downsideDeviation;
+  return downsideDeviation === 0 ? (avg > 0 ? Infinity : 0) : avg / downsideDeviation;
 }
 
 function dayKeyUTC(timeMs) {
@@ -36,10 +32,7 @@ function tradeRMultiple(trade) {
   const initialRisk = trade._initRisk || 0;
   if (initialRisk <= 0) return 0;
   const entry = trade.entryFill ?? trade.entry;
-  const perUnit =
-    trade.side === "long"
-      ? trade.exit.price - entry
-      : entry - trade.exit.price;
+  const perUnit = trade.side === "long" ? trade.exit.price - entry : entry - trade.exit.price;
   return perUnit / initialRisk;
 }
 
@@ -127,6 +120,15 @@ function percentile(values, percentileRank) {
   return sorted[index];
 }
 
+const PROFIT_FACTOR_CAP = 1_000_000;
+
+function finiteProfitFactor(grossProfit, grossLoss) {
+  if (grossLoss === 0) {
+    return grossProfit > 0 ? PROFIT_FACTOR_CAP : 0;
+  }
+  return grossProfit / grossLoss;
+}
+
 /**
  * Build aggregate backtest metrics for completed positions and realized trade legs.
  *
@@ -134,32 +136,89 @@ function percentile(values, percentileRank) {
  * `profitFactor`, `winRate`, `expectancy`, `maxDrawdown`, `sharpe`, `avgHold`,
  * and `sideBreakdown`, while preserving the more specific legacy fields.
  */
-export function buildMetrics({
-  closed,
-  equityStart,
-  equityFinal,
-  candles,
-  estBarMs,
-  eqSeries,
-}) {
-  const completedTrades = closed.filter((trade) => trade.exit.reason !== "SCALE");
-  const winningTrades = completedTrades.filter((trade) => trade.exit.pnl > 0);
-  const losingTrades = completedTrades.filter((trade) => trade.exit.pnl < 0);
-
-  const tradeRs = completedTrades.map(tradeRMultiple);
-  const totalR = sum(tradeRs);
-  const avgR = mean(tradeRs);
+export function buildMetrics({ closed, equityStart, equityFinal, candles, estBarMs, eqSeries }) {
+  const legs = [...closed].sort((left, right) => left.exit.time - right.exit.time);
+  const completedTrades = [];
+  const tradeRs = [];
+  const tradePnls = [];
+  const tradeReturns = [];
+  const holdDurationsMinutes = [];
+  const labels = [];
+  const longRs = [];
+  const shortRs = [];
+  let totalR = 0;
+  let realizedPnL = 0;
+  let winningTradeCount = 0;
+  let grossProfitPositions = 0;
+  let grossLossPositions = 0;
+  let grossProfitLegs = 0;
+  let grossLossLegs = 0;
+  let winningLegCount = 0;
+  let openBars = 0;
+  let longTradesCount = 0;
+  let longTradeWins = 0;
+  let longPnLSum = 0;
+  let shortTradesCount = 0;
+  let shortTradeWins = 0;
+  let shortPnLSum = 0;
 
-  const labels = completedTrades.map((trade) =>
-    trade.exit.pnl > 0 ? "win" : trade.exit.pnl < 0 ? "loss" : "flat"
-  );
-  const { maxWin, maxLoss } = streaks(labels);
+  let peakEquity = equityStart;
+  let currentEquity = equityStart;
+  let maxDrawdown = 0;
+
+  for (const trade of legs) {
+    const pnl = trade.exit.pnl;
+    realizedPnL += pnl;
+
+    if (pnl > 0) {
+      grossProfitLegs += pnl;
+      winningLegCount += 1;
+    } else if (pnl < 0) {
+      grossLossLegs += Math.abs(pnl);
+    }
+
+    currentEquity += pnl;
+    if (currentEquity > peakEquity) peakEquity = currentEquity;
+    const drawdown = (peakEquity - currentEquity) / Math.max(1e-12, peakEquity);
+    if (drawdown > maxDrawdown) maxDrawdown = drawdown;
+
+    if (trade.exit.reason === "SCALE") continue;
+
+    completedTrades.push(trade);
+    tradePnls.push(pnl);
+    tradeReturns.push(pnl / Math.max(1e-12, equityStart));
+    const tradeR = tradeRMultiple(trade);
+    tradeRs.push(tradeR);
+    totalR += tradeR;
+    labels.push(pnl > 0 ? "win" : pnl < 0 ? "loss" : "flat");
+
+    const holdMinutes = (trade.exit.time - trade.openTime) / (1000 * 60);
+    holdDurationsMinutes.push(holdMinutes);
+    openBars += Math.max(1, Math.round((trade.exit.time - trade.openTime) / estBarMs));
+
+    if (pnl > 0) {
+      winningTradeCount += 1;
+      grossProfitPositions += pnl;
+    } else if (pnl < 0) {
+      grossLossPositions += Math.abs(pnl);
+    }
+
+    if (trade.side === "long") {
+      longTradesCount += 1;
+      longPnLSum += pnl;
+      longRs.push(tradeR);
+      if (pnl > 0) longTradeWins += 1;
+    } else if (trade.side === "short") {
+      shortTradesCount += 1;
+      shortPnLSum += pnl;
+      shortRs.push(tradeR);
+      if (pnl > 0) shortTradeWins += 1;
+    }
+  }
 
-  const tradePnls = completedTrades.map((trade) => trade.exit.pnl);
+  const avgR = mean(tradeRs);
+  const { maxWin, maxLoss } = streaks(labels);
   const expectancy = mean(tradePnls);
-  const tradeReturns = completedTrades.map(
-    (trade) => trade.exit.pnl / Math.max(1e-12, equityStart)
-  );
   const tradeReturnStd = stddev(tradeReturns);
   const sharpePerTrade =
     tradeReturnStd === 0
@@ -169,60 +228,17 @@ export function buildMetrics({
       : mean(tradeReturns) / tradeReturnStd;
   const sortinoPerTrade = sortino(tradeReturns);
 
-  const grossProfitPositions = sum(winningTrades.map((trade) => trade.exit.pnl));
-  const grossLossPositions = Math.abs(
-    sum(losingTrades.map((trade) => trade.exit.pnl))
-  );
-  const profitFactorPositions =
-    grossLossPositions === 0
-      ? grossProfitPositions > 0
-        ? Infinity
-        : 0
-      : grossProfitPositions / grossLossPositions;
-
-  const legs = [...closed].sort((left, right) => left.exit.time - right.exit.time);
-  const winningLegs = legs.filter((trade) => trade.exit.pnl > 0);
-  const losingLegs = legs.filter((trade) => trade.exit.pnl < 0);
-  const grossProfitLegs = sum(winningLegs.map((trade) => trade.exit.pnl));
-  const grossLossLegs = Math.abs(sum(losingLegs.map((trade) => trade.exit.pnl)));
-  const profitFactorLegs =
-    grossLossLegs === 0
-      ? grossProfitLegs > 0
-        ? Infinity
-        : 0
-      : grossProfitLegs / grossLossLegs;
-
-  let peakEquity = equityStart;
-  let currentEquity = equityStart;
-  let maxDrawdown = 0;
-
-  for (const leg of legs) {
-    currentEquity += leg.exit.pnl;
-    if (currentEquity > peakEquity) peakEquity = currentEquity;
-    const drawdown = (peakEquity - currentEquity) / Math.max(1e-12, peakEquity);
-    if (drawdown > maxDrawdown) maxDrawdown = drawdown;
-  }
-
-  const realizedPnL = sum(closed.map((trade) => trade.exit.pnl));
+  const profitFactorPositions = finiteProfitFactor(grossProfitPositions, grossLossPositions);
+  const profitFactorLegs = finiteProfitFactor(grossProfitLegs, grossLossLegs);
   const returnPct = (equityFinal - equityStart) / Math.max(1e-12, equityStart);
   const calmar = maxDrawdown === 0 ? (returnPct > 0 ? Infinity : 0) : returnPct / maxDrawdown;
 
   const totalBars = Math.max(1, candles.length);
-  const openBars = completedTrades.reduce((total, trade) => {
-    const barsHeld = Math.max(1, Math.round((trade.exit.time - trade.openTime) / estBarMs));
-    return total + barsHeld;
-  }, 0);
   const exposurePct = openBars / totalBars;
-
-  const holdDurationsMinutes = completedTrades.map(
-    (trade) => (trade.exit.time - trade.openTime) / (1000 * 60)
-  );
   const avgHoldMin = mean(holdDurationsMinutes);
 
   const equitySeries =
-    eqSeries && eqSeries.length
-      ? eqSeries
-      : buildEquitySeriesFromLegs({ legs, equityStart });
+    eqSeries && eqSeries.length ? eqSeries : buildEquitySeriesFromLegs({ legs, equityStart });
   const dailyReturnsSeries = dailyReturns(equitySeries);
   const dailyStd = stddev(dailyReturnsSeries);
   const sharpeDaily =
@@ -236,13 +252,6 @@ export function buildMetrics({
     ? dailyReturnsSeries.filter((value) => value > 0).length / dailyReturnsSeries.length
     : 0;
 
-  const longTrades = completedTrades.filter((trade) => trade.side === "long");
-  const shortTrades = completedTrades.filter((trade) => trade.side === "short");
-  const longRs = longTrades.map(tradeRMultiple);
-  const shortRs = shortTrades.map(tradeRMultiple);
-  const longPnls = longTrades.map((trade) => trade.exit.pnl);
-  const shortPnls = shortTrades.map((trade) => trade.exit.pnl);
-
   const rDistribution = {
     p10: percentile(tradeRs, 0.1),
     p25: percentile(tradeRs, 0.25),
@@ -261,26 +270,22 @@ export function buildMetrics({
 
   const sideBreakdown = {
     long: {
-      trades: longTrades.length,
-      winRate: longTrades.length
-        ? longTrades.filter((trade) => trade.exit.pnl > 0).length / longTrades.length
-        : 0,
-      avgPnL: mean(longPnls),
+      trades: longTradesCount,
+      winRate: longTradesCount ? longTradeWins / longTradesCount : 0,
+      avgPnL: longTradesCount ? longPnLSum / longTradesCount : 0,
       avgR: mean(longRs),
     },
     short: {
-      trades: shortTrades.length,
-      winRate: shortTrades.length
-        ? shortTrades.filter((trade) => trade.exit.pnl > 0).length / shortTrades.length
-        : 0,
-      avgPnL: mean(shortPnls),
+      trades: shortTradesCount,
+      winRate: shortTradesCount ? shortTradeWins / shortTradesCount : 0,
+      avgPnL: shortTradesCount ? shortPnLSum / shortTradesCount : 0,
       avgR: mean(shortRs),
     },
   };
 
   return {
     trades: completedTrades.length,
-    winRate: completedTrades.length ? winningTrades.length / completedTrades.length : 0,
+    winRate: completedTrades.length ? winningTradeCount / completedTrades.length : 0,
     profitFactor: profitFactorPositions,
     expectancy,
     totalR,
@@ -302,10 +307,8 @@ export function buildMetrics({
     startEquity: equityStart,
     profitFactor_pos: profitFactorPositions,
     profitFactor_leg: profitFactorLegs,
-    winRate_pos: completedTrades.length
-      ? winningTrades.length / completedTrades.length
-      : 0,
-    winRate_leg: legs.length ? winningLegs.length / legs.length : 0,
+    winRate_pos: completedTrades.length ? winningTradeCount / completedTrades.length : 0,
+    winRate_leg: legs.length ? winningLegCount / legs.length : 0,
     sharpeDaily,
     sortinoDaily,
     sideBreakdown,

package/src/reporting/exportBacktestArtifacts.js

@@ -24,10 +24,7 @@ export function exportBacktestArtifacts({
     metrics: null,
   };
 
-  const csvTrades =
-    csvSource === "trades"
-      ? result.trades
-      : result.positions ?? result.trades;
+  const csvTrades = csvSource === "trades" ? result.trades : (result.positions ?? result.trades);
 
   if (exportCsv) {
     outputs.csv = exportTradesCsv(csvTrades, {

package/src/reporting/exportTradesCsv.js

@@ -9,10 +9,7 @@ function tradeRMultiple(trade) {
   const initialRisk = trade._initRisk || 0;
   if (initialRisk <= 0) return 0;
   const entry = trade.entryFill ?? trade.entry;
-  const perUnit =
-    trade.side === "long"
-      ? trade.exit.price - entry
-      : entry - trade.exit.price;
+  const perUnit = trade.side === "long" ? trade.exit.price - entry : entry - trade.exit.price;
   return perUnit / initialRisk;
 }
 
@@ -58,9 +55,7 @@ export function exportTradesCsv(
         (trade.maeR ?? 0).toFixed(3),
         trade.adds ?? 0,
         trade.entryATR !== undefined ? Number(trade.entryATR).toFixed(6) : "",
-        trade.exit.exitATR !== undefined
-          ? Number(trade.exit.exitATR).toFixed(6)
-          : "",
+        trade.exit.exitATR !== undefined ? Number(trade.exit.exitATR).toFixed(6) : "",
       ].join(",")
     ),
   ].join("\n");

package/src/reporting/renderHtmlReport.js

@@ -19,7 +19,8 @@ function candidateRoots() {
 }
 
 function readTemplate(relativePath) {
-  for (const root of candidateRoots()) {
+  const roots = candidateRoots();
+  for (const root of roots) {
     const absolutePath = path.join(root, relativePath);
     if (!fs.existsSync(absolutePath)) continue;
 
@@ -29,7 +30,9 @@ function readTemplate(relativePath) {
     return templateCache.get(absolutePath);
   }
 
-  throw new Error(`Could not locate template asset: ${relativePath}`);
+  throw new Error(
+    `Could not locate template asset: ${relativePath} (searched ${roots.length} roots starting from ${roots[0]})`
+  );
 }
 
 function fmt(value, digits = 2) {
@@ -135,9 +138,7 @@ function renderPositionRows(positions) {
           <td>${escapeHtml(fmt(exit.price, 4))}</td>
           <td>${escapeHtml(exit.reason ?? "—")}</td>
           <td>${escapeHtml(fmt(exit.pnl, 2))}</td>
-          <td>${escapeHtml(fmt(trade.mfeR ?? 0, 2))} / ${escapeHtml(
-            fmt(trade.maeR ?? 0, 2)
-          )}</td>
+          <td>${escapeHtml(fmt(trade.mfeR ?? 0, 2))} / ${escapeHtml(fmt(trade.maeR ?? 0, 2))}</td>
         </tr>
       `;
     })
@@ -259,10 +260,7 @@ export function renderHtmlReport({
     ["R p50 / p90", `${fmt(metrics.rDist?.p50 ?? 0, 2)} / ${fmt(metrics.rDist?.p90 ?? 0, 2)}`],
     [
       "Hold p50 / p90",
-      `${fmt(metrics.holdDistMin?.p50 ?? 0, 1)} / ${fmt(
-        metrics.holdDistMin?.p90 ?? 0,
-        1
-      )} min`,
+      `${fmt(metrics.holdDistMin?.p50 ?? 0, 1)} / ${fmt(metrics.holdDistMin?.p90 ?? 0, 1)} min`,
     ],
   ]);
 
@@ -306,10 +304,7 @@ export function exportHtmlReport({
   const safeSymbol = String(symbol).replace(/[^a-zA-Z0-9_.-]+/g, "_");
   const safeInterval = String(interval).replace(/[^a-zA-Z0-9_.-]+/g, "_");
   const safeRange = String(range).replace(/[^a-zA-Z0-9_.-]+/g, "_");
-  const outputPath = path.join(
-    outDir,
-    `report-${safeSymbol}-${safeInterval}-${safeRange}.html`
-  );
+  const outputPath = path.join(outDir, `report-${safeSymbol}-${safeInterval}-${safeRange}.html`);
 
   const html = renderHtmlReport({
     symbol,

package/src/utils/indicators.js

@@ -126,8 +126,7 @@ export function atr(bars, period = 14) {
       continue;
     }
 
-    previousAtr =
-      (previousAtr * (period - 1) + trueRanges[index]) / period;
+    previousAtr = (previousAtr * (period - 1) + trueRanges[index]) / period;
     output[index] = previousAtr;
   }
 

package/src/utils/positionSizing.js

@@ -2,6 +2,16 @@ function roundStep(value, step) {
   return Math.floor(value / step) * step;
 }
 
+let warnedNonPositiveEquity = false;
+
+function warnNonPositiveEquity(equity) {
+  if (warnedNonPositiveEquity) return;
+  warnedNonPositiveEquity = true;
+  console.warn(
+    `[tradelab] calculatePositionSize() received non-positive equity (${equity}); returning size 0`
+  );
+}
+
 export function calculatePositionSize({
   equity,
   entry,
@@ -11,14 +21,18 @@ export function calculatePositionSize({
   minQty = 0.001,
   maxLeverage = 2,
 }) {
+  if (!Number.isFinite(equity) || equity <= 0) {
+    warnNonPositiveEquity(equity);
+    return 0;
+  }
+
   const riskPerUnit = Math.abs(entry - stop);
   if (!Number.isFinite(riskPerUnit) || riskPerUnit <= 0) return 0;
 
   const maxRiskDollars = Math.max(0, equity * riskFraction);
   let quantity = maxRiskDollars / riskPerUnit;
 
-  const leverageCapQty =
-    (equity * maxLeverage) / Math.max(1e-12, Math.abs(entry));
+  const leverageCapQty = (equity * maxLeverage) / Math.max(1e-12, Math.abs(entry));
   quantity = Math.min(quantity, leverageCapQty);
   quantity = roundStep(quantity, qtyStep);
 

package/src/utils/time.js

@@ -8,20 +8,14 @@ function usDstBoundsUTC(year) {
     marchCursor = new Date(marchCursor.getTime() + 24 * 60 * 60 * 1000);
   }
 
-  const dstStart = new Date(
-    Date.UTC(year, 2, marchCursor.getUTCDate(), 7, 0, 0)
-  );
+  const dstStart = new Date(Date.UTC(year, 2, marchCursor.getUTCDate(), 7, 0, 0));
 
   let novemberCursor = new Date(Date.UTC(year, 10, 1, 6, 0, 0));
   while (novemberCursor.getUTCDay() !== 0) {
-    novemberCursor = new Date(
-      novemberCursor.getTime() + 24 * 60 * 60 * 1000
-    );
+    novemberCursor = new Date(novemberCursor.getTime() + 24 * 60 * 60 * 1000);
   }
 
-  const dstEnd = new Date(
-    Date.UTC(year, 10, novemberCursor.getUTCDate(), 6, 0, 0)
-  );
+  const dstEnd = new Date(Date.UTC(year, 10, novemberCursor.getUTCDate(), 6, 0, 0));
 
   return { dstStart, dstEnd };
 }
@@ -58,9 +52,7 @@ export function isSession(timeMs, session = "NYSE") {
   if (session === "FUT") {
     const maintenanceStart = 17 * 60;
     const maintenanceEnd = 18 * 60;
-    return !(
-      minutes >= maintenanceStart && minutes < maintenanceEnd
-    );
+    return !(minutes >= maintenanceStart && minutes < maintenanceEnd);
   }
 
   const open = 9 * 60 + 30;

package/templates/report.html

@@ -4,7 +4,9 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>{{TITLE}} backtest</title>
-    <style>{{CSS}}</style>
+    <style>
+      {{CSS}}
+    </style>
   </head>
   <body>
     <main class="report-shell">
@@ -17,9 +19,7 @@
         <div class="hero-pill">{{HERO_PILL}}</div>
       </header>
 
-      <section class="metric-grid">
-        {{METRIC_CARDS}}
-      </section>
+      <section class="metric-grid">{{METRIC_CARDS}}</section>
 
       <section class="panel-grid">
         <article class="panel panel--wide">
@@ -36,7 +36,9 @@
             <p>Headline stats for completed positions.</p>
           </div>
           <table class="data-table">
-            <tbody>{{SUMMARY_ROWS}}</tbody>
+            <tbody>
+              {{SUMMARY_ROWS}}
+            </tbody>
           </table>
         </article>
 
@@ -70,7 +72,9 @@
             <p>Long/short split and distribution snapshots.</p>
           </div>
           <table class="data-table">
-            <tbody>{{BREAKDOWN_ROWS}}</tbody>
+            <tbody>
+              {{BREAKDOWN_ROWS}}
+            </tbody>
           </table>
         </article>
 
@@ -92,15 +96,25 @@
                   <th>MFE / MAE</th>
                 </tr>
               </thead>
-              <tbody>{{POSITION_ROWS}}</tbody>
+              <tbody>
+                {{POSITION_ROWS}}
+              </tbody>
             </table>
           </div>
         </article>
       </section>
     </main>
 
-    <script id="report-data" type="application/json">{{REPORT_DATA_JSON}}</script>
+    <script id="report-data" type="application/json">
+      {{REPORT_DATA_JSON}}
+    </script>
     <script src="{{PLOTLY_CDN_URL}}"></script>
-    <script>{{REPORT_JS}}</script>
+    <script>
+      {
+        {
+          REPORT_JS;
+        }
+      }
+    </script>
   </body>
 </html>