@hoox-sh/pynets 0.4.0 → 0.5.0

package/src/runtime/compile/emit_call.ts

@@ -46,6 +46,8 @@ const NS = new Set([
   "syminfo",
   "timenow",
   "chart",
+  "footprint",
+  "volume_row",
 ]);
 
 /** TaEngine methods we emit. Unknown `ta.*` → `null`. */
@@ -453,6 +455,8 @@ export function emitCall(ctx: EmitCtx, node: Call, visit: VisitFn): string {
 
   const req = emitRequest(ctx, name, args);
   if (req != null) return req;
+  const fp = emitFootprint(name, args);
+  if (fp != null) return fp;
 
   return "null";
 }
@@ -1018,7 +1022,6 @@ const SECURITY_FUNCS = new Set([
   "security_lower_tf",
   "request_security",
   "request_security_lower_tf",
-  "request_seed",
 ]);
 
 const SIMPLE_CHART_EXPR = new Set([
@@ -1064,10 +1067,60 @@ function emitRequest(ctx: EmitCtx, name: string, args: CallArgs): string | null
   if (name === "request_currency_rate" || name === "currency_rate") {
     return `__h.currencyRate(${pick(args, 0, ["from", "from_currency"], "null")}, ${pick(args, 1, ["to", "to_currency"], "null")})`;
   }
+  if (name === "request_seed") {
+    return `__h.requestSeed(${pick(args, 0, ["seed"], "0")})`;
+  }
+  if (name === "request_footprint") {
+    return `__h.requestFootprint(${pick(args, 0, ["num_ticks"], "100")}, ${pick(args, 1, ["va_percentage"], "70")})`;
+  }
   if (name.startsWith("request_")) return "null";
   return null;
 }
 
+/** Python `request.footprint` mock + `footprint.*` / `volume_row.*` accessors. */
+function emitFootprint(name: string, args: CallArgs): string | null {
+  const fp = pick(args, 0, ["id", "footprint"], "null");
+  const vr = pick(args, 0, ["id", "volume_row"], "null");
+  switch (name) {
+    case "footprint_buy_volume":
+      return `__h.footprint.buy_volume(${fp})`;
+    case "footprint_sell_volume":
+      return `__h.footprint.sell_volume(${fp})`;
+    case "footprint_delta":
+      return `__h.footprint.delta(${fp})`;
+    case "footprint_total_volume":
+      return `__h.footprint.total_volume(${fp})`;
+    case "footprint_vah":
+      return `__h.footprint.vah(${fp})`;
+    case "footprint_val":
+      return `__h.footprint.val(${fp})`;
+    case "footprint_poc":
+      return `__h.footprint.poc(${fp})`;
+    case "footprint_rows":
+      return `__h.footprint.rows(${fp})`;
+    case "footprint_get_row_by_price":
+      return `__h.footprint.get_row_by_price(${fp}, ${pick(args, 1, ["price"], "null")})`;
+    case "volume_row_up_price":
+      return `__h.footprint.volume_row.up_price(${vr})`;
+    case "volume_row_down_price":
+      return `__h.footprint.volume_row.down_price(${vr})`;
+    case "volume_row_buy_volume":
+      return `__h.footprint.volume_row.buy_volume(${vr})`;
+    case "volume_row_sell_volume":
+      return `__h.footprint.volume_row.sell_volume(${vr})`;
+    case "volume_row_delta":
+      return `__h.footprint.volume_row.delta(${vr})`;
+    case "volume_row_total_volume":
+      return `__h.footprint.volume_row.total_volume(${vr})`;
+    case "volume_row_has_buy_imbalance":
+      return `__h.footprint.volume_row.has_buy_imbalance(${vr})`;
+    case "volume_row_has_sell_imbalance":
+      return `__h.footprint.volume_row.has_sell_imbalance(${vr})`;
+    default:
+      return null;
+  }
+}
+
 function isSimpleSecurityExpr(expr: string): boolean {
   const e = expr.trim();
   if (!e) return false;

package/src/runtime/compile/runtime.ts

@@ -56,7 +56,28 @@ import {
   strUpper,
 } from "../str.ts";
 import { LogBook, formatLogParts } from "../log.ts";
-import { resolveCurrencyRate } from "../request.ts";
+import { PineArray } from "../array.ts";
+import {
+  createFootprint,
+  footprintBuyVolume,
+  footprintDelta,
+  footprintGetRowByPrice,
+  footprintPoc,
+  footprintRows,
+  footprintSellVolume,
+  footprintTotalVolume,
+  footprintVah,
+  footprintVal,
+  volumeRowBuyVolume,
+  volumeRowDelta,
+  volumeRowDownPrice,
+  volumeRowHasBuyImbalance,
+  volumeRowHasSellImbalance,
+  volumeRowSellVolume,
+  volumeRowTotalVolume,
+  volumeRowUpPrice,
+} from "../footprint.ts";
+import { resolveCurrencyRate, resolveSeed } from "../request.ts";
 import { TaEngine } from "../ta.ts";
 import { utcPartsFromMs, timestamp, weekOfYear, timeTradingDay, type UtcParts } from "../time.ts";
 import { TickerId } from "../ticker.ts";
@@ -227,12 +248,41 @@ export function createCompileHelpers(opts?: CompileHelperOpts) {
     udtSet,
     udtRegister,
     currencyRate: resolveCurrencyRate,
+    requestSeed: resolveSeed,
+    requestFootprint: createFootprint,
+    footprint: {
+      buy_volume: footprintBuyVolume,
+      sell_volume: footprintSellVolume,
+      delta: footprintDelta,
+      total_volume: footprintTotalVolume,
+      vah: footprintVah,
+      val: footprintVal,
+      poc: footprintPoc,
+      rows: compileFootprintRows,
+      get_row_by_price: footprintGetRowByPrice,
+      volume_row: {
+        up_price: volumeRowUpPrice,
+        down_price: volumeRowDownPrice,
+        buy_volume: volumeRowBuyVolume,
+        sell_volume: volumeRowSellVolume,
+        delta: volumeRowDelta,
+        total_volume: volumeRowTotalVolume,
+        has_buy_imbalance: volumeRowHasBuyImbalance,
+        has_sell_imbalance: volumeRowHasSellImbalance,
+      },
+    },
     runtimeError(msg: unknown): never {
       throw new Error(String(msg));
     },
   };
 }
 
+function compileFootprintRows(fp: unknown): PineArray {
+  const arr = new PineArray();
+  for (const row of footprintRows(fp)) arr.push(row);
+  return arr;
+}
+
 /** Pine `color.new(color, transp)` — first arg is a color, not r,g,b. */
 function compileColorNew(color: unknown, transp?: unknown) {
   const parsed = asColor(color);

package/src/runtime/footprint.ts

@@ -0,0 +1,272 @@
+/**
+ * Copyright (C) 2024-2026 jango_blockchained
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * Pine v6 `request.footprint` mock + `footprint.*` / `volume_row.*` accessors.
+ * Python `VolumeRow` / `Footprint` / `_handle_request_footprint` (request.py).
+ * Seeded mocks use CPython `random.Random` MT19937 so `request.seed` matches.
+ */
+
+/** Volume row in a footprint (single price level). */
+export class VolumeRow {
+  constructor(
+    public up_price = 0,
+    public down_price = 0,
+    public buy_volume = 0,
+    public sell_volume = 0,
+    public delta = 0,
+    public is_imbalance = false,
+    public is_poc = false,
+    public is_vah = false,
+    public is_val = false,
+  ) {}
+}
+
+/** Footprint object: volume profile for one bar. */
+export class Footprint {
+  constructor(
+    public num_ticks = 100,
+    public va_percentage = 70,
+    public buy_volume = 0,
+    public sell_volume = 0,
+    public delta = 0,
+    public total_volume = 0,
+    public vah_row: VolumeRow | null = null,
+    public val_row: VolumeRow | null = null,
+    public poc_row: VolumeRow | null = null,
+    public rows: VolumeRow[] = [],
+  ) {}
+}
+
+const N = 624;
+const M = 397;
+const MATRIX_A = 0x9908b0df;
+const UPPER_MASK = 0x80000000;
+const LOWER_MASK = 0x7fffffff;
+
+/** CPython 3 `random.Random` (MT19937) for integer `random.seed`. */
+class PyRandom {
+  private readonly mt = new Uint32Array(N);
+  private index = N + 1;
+
+  seed(a: number): void {
+    const n = Math.trunc(a);
+    const abs = n < 0 ? -n : n;
+    const key: number[] = [];
+    if (abs === 0) key.push(0);
+    else {
+      let x = abs;
+      while (x > 0) {
+        key.push(x >>> 0);
+        x = Math.floor(x / 0x100000000);
+      }
+    }
+    this.initByArray(key);
+  }
+
+  random(): number {
+    const a = this.genrand() >>> 5;
+    const b = this.genrand() >>> 6;
+    return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
+  }
+
+  private initGenrand(s: number): void {
+    const mt = this.mt;
+    mt[0] = s >>> 0;
+    for (let mti = 1; mti < N; mti++) {
+      mt[mti] = (Math.imul(1812433253, mt[mti - 1]! ^ (mt[mti - 1]! >>> 30)) + mti) >>> 0;
+    }
+    this.index = N;
+  }
+
+  private initByArray(initKey: number[]): void {
+    const mt = this.mt;
+    this.initGenrand(19650218);
+    let i = 1;
+    let j = 0;
+    const keyLength = initKey.length;
+    let k = N > keyLength ? N : keyLength;
+    for (; k > 0; k--) {
+      mt[i] =
+        ((mt[i]! ^ Math.imul(mt[i - 1]! ^ (mt[i - 1]! >>> 30), 1664525)) + initKey[j]! + j) >>> 0;
+      i++;
+      j++;
+      if (i >= N) {
+        mt[0] = mt[N - 1]!;
+        i = 1;
+      }
+      if (j >= keyLength) j = 0;
+    }
+    for (k = N - 1; k > 0; k--) {
+      mt[i] = ((mt[i]! ^ Math.imul(mt[i - 1]! ^ (mt[i - 1]! >>> 30), 1566083941)) - i) >>> 0;
+      i++;
+      if (i >= N) {
+        mt[0] = mt[N - 1]!;
+        i = 1;
+      }
+    }
+    mt[0] = 0x80000000;
+    this.index = N;
+  }
+
+  private genrand(): number {
+    const mt = this.mt;
+    if (this.index >= N) {
+      for (let kk = 0; kk < N - M; kk++) {
+        const y = (mt[kk]! & UPPER_MASK) | (mt[kk + 1]! & LOWER_MASK);
+        mt[kk] = (mt[kk + M]! ^ (y >>> 1) ^ (y & 1 ? MATRIX_A : 0)) >>> 0;
+      }
+      for (let kk = N - M; kk < N - 1; kk++) {
+        const y = (mt[kk]! & UPPER_MASK) | (mt[kk + 1]! & LOWER_MASK);
+        mt[kk] = (mt[kk + (M - N)]! ^ (y >>> 1) ^ (y & 1 ? MATRIX_A : 0)) >>> 0;
+      }
+      const y = (mt[N - 1]! & UPPER_MASK) | (mt[0]! & LOWER_MASK);
+      mt[N - 1] = (mt[M - 1]! ^ (y >>> 1) ^ (y & 1 ? MATRIX_A : 0)) >>> 0;
+      this.index = 0;
+    }
+    let y = mt[this.index++]!;
+    y ^= y >>> 11;
+    y ^= (y << 7) & 0x9d2c5680;
+    y ^= (y << 15) & 0xefc60000;
+    y ^= y >>> 18;
+    return y >>> 0;
+  }
+}
+
+let pyRng: PyRandom | null = null;
+
+/** `request.seed` — CPython `random.seed(seed_int)`. */
+export function seedFootprintRng(seed: number): void {
+  pyRng = new PyRandom();
+  pyRng.seed(seed);
+}
+
+function nextRandom(): number {
+  return pyRng != null ? pyRng.random() : Math.random();
+}
+
+function asCount(value: unknown, fallback: number): number {
+  if (typeof value === "number" && Number.isFinite(value)) return Math.trunc(value);
+  return fallback;
+}
+
+function rowAt(rows: VolumeRow[], idx: number): VolumeRow | null {
+  return idx >= 0 && idx < rows.length ? rows[idx]! : null;
+}
+
+/**
+ * `request.footprint(num_ticks, va_percentage)` mock.
+ * Missing ticks / VA % use Python defaults 100 / 70. No data_feed → vol_scale 1.
+ */
+export function createFootprint(numTicks: unknown = 100, vaPercentage: unknown = 70): Footprint {
+  const n = asCount(numTicks, 100);
+  const va = asCount(vaPercentage, 70);
+  const rows: VolumeRow[] = [];
+  const basePrice = 100.0;
+  const tickSize = 0.01;
+  for (let i = 0; i < n; i++) {
+    const priceLevel = basePrice + i * tickSize;
+    rows.push(
+      new VolumeRow(
+        priceLevel + tickSize,
+        priceLevel,
+        1000.0 + nextRandom() * 500,
+        900.0 + nextRandom() * 500,
+        100.0 + (nextRandom() * 200 - 100),
+        nextRandom() < 0.1,
+        i === Math.floor(n / 2),
+        i === Math.trunc(n * 0.7),
+        i === Math.trunc(n * 0.3),
+      ),
+    );
+  }
+  const totalBuy = rows.reduce((s, r) => s + r.buy_volume, 0);
+  const totalSell = rows.reduce((s, r) => s + r.sell_volume, 0);
+  return new Footprint(
+    n,
+    va,
+    totalBuy,
+    totalSell,
+    totalBuy - totalSell,
+    totalBuy + totalSell,
+    rowAt(rows, Math.trunc(n * 0.7)),
+    rowAt(rows, Math.trunc(n * 0.3)),
+    rowAt(rows, Math.floor(n / 2)),
+    rows,
+  );
+}
+
+export function footprintBuyVolume(fp: unknown): number {
+  return fp instanceof Footprint ? fp.buy_volume : 0;
+}
+
+export function footprintSellVolume(fp: unknown): number {
+  return fp instanceof Footprint ? fp.sell_volume : 0;
+}
+
+export function footprintDelta(fp: unknown): number {
+  return fp instanceof Footprint ? fp.delta : 0;
+}
+
+export function footprintTotalVolume(fp: unknown): number {
+  return fp instanceof Footprint ? fp.total_volume : 0;
+}
+
+export function footprintVah(fp: unknown): VolumeRow | null {
+  return fp instanceof Footprint ? fp.vah_row : null;
+}
+
+export function footprintVal(fp: unknown): VolumeRow | null {
+  return fp instanceof Footprint ? fp.val_row : null;
+}
+
+export function footprintPoc(fp: unknown): VolumeRow | null {
+  return fp instanceof Footprint ? fp.poc_row : null;
+}
+
+export function footprintRows(fp: unknown): VolumeRow[] {
+  return fp instanceof Footprint ? fp.rows.slice() : [];
+}
+
+export function footprintGetRowByPrice(fp: unknown, price: unknown): VolumeRow | null {
+  if (!(fp instanceof Footprint) || price == null) return null;
+  if (typeof price !== "number" || !Number.isFinite(price)) return null;
+  for (const row of fp.rows) {
+    const lo = Math.min(row.down_price, row.up_price);
+    const hi = Math.max(row.down_price, row.up_price);
+    if (lo <= price && price <= hi) return row;
+  }
+  return null;
+}
+
+export function volumeRowUpPrice(vr: unknown): number {
+  return vr instanceof VolumeRow ? vr.up_price : 0;
+}
+
+export function volumeRowDownPrice(vr: unknown): number {
+  return vr instanceof VolumeRow ? vr.down_price : 0;
+}
+
+export function volumeRowBuyVolume(vr: unknown): number {
+  return vr instanceof VolumeRow ? vr.buy_volume : 0;
+}
+
+export function volumeRowSellVolume(vr: unknown): number {
+  return vr instanceof VolumeRow ? vr.sell_volume : 0;
+}
+
+export function volumeRowDelta(vr: unknown): number {
+  return vr instanceof VolumeRow ? vr.delta : 0;
+}
+
+export function volumeRowTotalVolume(vr: unknown): number {
+  return vr instanceof VolumeRow ? vr.buy_volume + vr.sell_volume : 0;
+}
+
+export function volumeRowHasBuyImbalance(vr: unknown): boolean {
+  return vr instanceof VolumeRow ? Boolean(vr.is_imbalance && vr.buy_volume > vr.sell_volume) : false;
+}
+
+export function volumeRowHasSellImbalance(vr: unknown): boolean {
+  return vr instanceof VolumeRow ? Boolean(vr.is_imbalance && vr.sell_volume > vr.buy_volume) : false;
+}

package/src/runtime/interpret.ts

@@ -123,6 +123,27 @@ import {
   type StubKwargs,
 } from "./library.ts";
 import { isRequestBuiltin, resolveRequest, resolveSecurity } from "./request.ts";
+import {
+  Footprint,
+  footprintBuyVolume,
+  footprintDelta,
+  footprintGetRowByPrice,
+  footprintPoc,
+  footprintRows,
+  footprintSellVolume,
+  footprintTotalVolume,
+  footprintVah,
+  footprintVal,
+  volumeRowBuyVolume,
+  volumeRowDelta,
+  volumeRowDownPrice,
+  volumeRowHasBuyImbalance,
+  volumeRowHasSellImbalance,
+  volumeRowSellVolume,
+  volumeRowTotalVolume,
+  volumeRowUpPrice,
+  type VolumeRow,
+} from "./footprint.ts";
 import { NA, PineSeries, type Cell } from "./series.ts";
 import {
   strContains,
@@ -254,6 +275,8 @@ type Value =
   | PineMap
   | PineMatrix
   | TickerId
+  | Footprint
+  | VolumeRow
   | UdtType
   | UdtInstance
   | LibraryModule
@@ -337,7 +360,7 @@ interface Env {
   onceFired: WeakSet<object>;
   /** Python `_max_bars_back_decls` — recorded only; evaluation is unbounded. */
   maxBarsBackDecls: Array<{ var: Value; num: Value }>;
-  /** Python `_alert_fire_bars` keys for `alertcondition` once_per_bar. */
+  /** Python `_alert_fire_bars` keys for `alert` / `alertcondition` freq gating. */
   alertFireBars: Map<string, number>;
 }
 
@@ -1510,6 +1533,22 @@ export const MATH_CONSTANTS: Record<string, Value> = {
   "plot.linestyle_solid": "linestyle_solid",
   "plot.linestyle_dashed": "linestyle_dashed",
   "plot.linestyle_dotted": "linestyle_dotted",
+  // Python plotting.py PlotStyle tokens — longer than hline's "solid".
+  "plot.style_line": "style_line",
+  "plot.style_linebr": "style_linebr",
+  "plot.style_stepline": "style_stepline",
+  "plot.style_steplinebr": "style_steplinebr",
+  "plot.style_stepline_diamond": "style_stepline_diamond",
+  "plot.style_histogram": "style_histogram",
+  "plot.style_columns": "style_columns",
+  "plot.style_cross": "style_cross",
+  "plot.style_area": "style_area",
+  "plot.style_areabr": "style_areabr",
+  "plot.style_circles": "style_circles",
+  // Python alerts.py `_alerts_builtin_map`.
+  "alert.freq_once_per_bar": "once_per_bar",
+  "alert.freq_once_per_bar_close": "once_per_bar_close",
+  "alert.freq_all": "all",
   "dayofweek.sunday": 1,
   "dayofweek.monday": 2,
   "dayofweek.tuesday": 3,
@@ -1889,6 +1928,8 @@ function evalCall(node: Call, env: Env): Value {
   ) {
     return evalRequestCall(fname!, node, env);
   }
+  const fpCall = evalFootprintCall(fname, node, env);
+  if (fpCall !== undefined) return fpCall;
   const arrVal = evalArrayCall(fname, node, env);
   if (arrVal !== undefined) return arrVal;
   const colorVal = evalColorCall(fname, node, env);
@@ -2577,14 +2618,66 @@ function packDrawings(book: DrawingBook): DrawingEvent[] | undefined {
   return book.items.length === 0 ? undefined : book.items;
 }
 
-/** Python `_emit_alert(..., source="alertcondition", freq=once_per_bar)`. */
-function fireAlertCondition(env: Env, title: string, message: string): void {
-  const key = `alertcondition|${title}|${message}|once_per_bar`;
-  if (env.alertFireBars.get(key) === env.barIndex) return;
+const FREQ_ONCE_PER_BAR = "once_per_bar";
+const FREQ_ONCE_PER_BAR_CLOSE = "once_per_bar_close";
+const FREQ_ALL = "all";
+
+const ALERT_FREQ_ALIASES: Record<string, string> = {
+  once_per_bar: FREQ_ONCE_PER_BAR,
+  freq_once_per_bar: FREQ_ONCE_PER_BAR,
+  "alert.freq_once_per_bar": FREQ_ONCE_PER_BAR,
+  once_per_bar_close: FREQ_ONCE_PER_BAR_CLOSE,
+  freq_once_per_bar_close: FREQ_ONCE_PER_BAR_CLOSE,
+  "alert.freq_once_per_bar_close": FREQ_ONCE_PER_BAR_CLOSE,
+  all: FREQ_ALL,
+  freq_all: FREQ_ALL,
+  "alert.freq_all": FREQ_ALL,
+};
+
+/** Python `normalize_alert_freq`. Unknown non-empty tokens are kept (still once-per-bar gated). */
+function normalizeAlertFreq(freq: unknown): string {
+  if (freq == null) return FREQ_ONCE_PER_BAR;
+  if (typeof freq === "number" && !Number.isFinite(freq)) return FREQ_ONCE_PER_BAR;
+  const s = String(freq).trim().toLowerCase().replace(/ /g, "_");
+  return ALERT_FREQ_ALIASES[s] ?? (s ? s : FREQ_ONCE_PER_BAR);
+}
+
+/** Python `_bar_is_confirmed`. This host sets `barstate.isconfirmed` to 1 on every bar. */
+function barIsConfirmed(_env: Env): boolean {
+  return true;
+}
+
+/** Python `_should_fire_alert`. */
+function shouldFireAlert(env: Env, source: string, title: string, message: string, freq: string): boolean {
+  const freqN = normalizeAlertFreq(freq);
+  if (freqN === FREQ_ALL) return true;
+  if (freqN === FREQ_ONCE_PER_BAR_CLOSE && !barIsConfirmed(env)) return false;
+  const key = `${source}|${title}|${message}|${freqN}`;
+  if (env.alertFireBars.get(key) === env.barIndex) return false;
   env.alertFireBars.set(key, env.barIndex);
+  return true;
+}
+
+/** Python `_emit_alert`. Records on the drawing book (no separate alerts array). */
+function emitAlert(
+  env: Env,
+  message: string,
+  freq: unknown,
+  opts?: { title?: string; source?: string },
+): void {
+  const source = opts?.source ?? "alert";
+  const title = opts?.title ?? "";
+  const freqN = normalizeAlertFreq(freq);
+  if (!shouldFireAlert(env, source, title, message, freqN)) return;
   env.drawings.alert(env.barIndex, message);
   const ev = env.drawings.items[env.drawings.items.length - 1];
-  if (ev != null) ev.extra = { source: "alertcondition", title, freq: "once_per_bar" };
+  if (ev == null) return;
+  ev.extra = title ? { source, title, freq: freqN } : { source, freq: freqN };
+}
+
+/** Python `_emit_alert(..., source="alertcondition", freq=once_per_bar)`. */
+function fireAlertCondition(env: Env, title: string, message: string): void {
+  emitAlert(env, message, FREQ_ONCE_PER_BAR, { title, source: "alertcondition" });
 }
 
 function inputTitle(node: Call): string | null {
@@ -2895,7 +2988,7 @@ function evalRequestSecurity(node: Call, env: Env): Cell {
   );
 }
 
-function evalRequestCall(fname: string, node: Call, env: Env): Cell {
+function evalRequestCall(fname: string, node: Call, env: Env): Value {
   if (
     fname === "request.security" ||
     fname === "request.security_lower_tf" ||
@@ -2916,10 +3009,75 @@ function evalRequestCall(fname: string, node: Call, env: Env): Cell {
     const v = resolveRequest(fname, host, { seed });
     return typeof v === "number" || v === null ? v : NA;
   }
+  if (fname === "request.footprint") {
+    const numTicks = unwrap(evalExpr(callArg(node.args, 0, ["num_ticks"]), env));
+    const va = unwrap(evalExpr(callArg(node.args, 1, ["va_percentage"]), env));
+    const v = resolveRequest(fname, host, {
+      num_ticks: numTicks ?? 100,
+      va_percentage: va ?? 70,
+    });
+    return v instanceof Footprint ? v : NA;
+  }
   const v = resolveRequest(fname, host, {});
   return typeof v === "number" || v === null ? v : NA;
 }
 
+function evalFootprintCall(fname: string | null, node: Call, env: Env): Value | undefined {
+  if (fname == null) return undefined;
+  if (fname.startsWith("footprint.")) {
+    const fp = evalExpr(callArg(node.args, 0, ["id", "footprint"]), env);
+    switch (fname) {
+      case "footprint.buy_volume":
+        return footprintBuyVolume(fp);
+      case "footprint.sell_volume":
+        return footprintSellVolume(fp);
+      case "footprint.delta":
+        return footprintDelta(fp);
+      case "footprint.total_volume":
+        return footprintTotalVolume(fp);
+      case "footprint.vah":
+        return footprintVah(fp);
+      case "footprint.val":
+        return footprintVal(fp);
+      case "footprint.poc":
+        return footprintPoc(fp);
+      case "footprint.rows": {
+        const arr = new PineArray();
+        for (const row of footprintRows(fp)) arr.push(row);
+        return arr;
+      }
+      case "footprint.get_row_by_price":
+        return footprintGetRowByPrice(fp, unwrap(evalExpr(callArg(node.args, 1, ["price"]), env)));
+      default:
+        return undefined;
+    }
+  }
+  if (fname.startsWith("volume_row.")) {
+    const vr = evalExpr(callArg(node.args, 0, ["id", "volume_row"]), env);
+    switch (fname) {
+      case "volume_row.up_price":
+        return volumeRowUpPrice(vr);
+      case "volume_row.down_price":
+        return volumeRowDownPrice(vr);
+      case "volume_row.buy_volume":
+        return volumeRowBuyVolume(vr);
+      case "volume_row.sell_volume":
+        return volumeRowSellVolume(vr);
+      case "volume_row.delta":
+        return volumeRowDelta(vr);
+      case "volume_row.total_volume":
+        return volumeRowTotalVolume(vr);
+      case "volume_row.has_buy_imbalance":
+        return volumeRowHasBuyImbalance(vr);
+      case "volume_row.has_sell_imbalance":
+        return volumeRowHasSellImbalance(vr);
+      default:
+        return undefined;
+    }
+  }
+  return undefined;
+}
+
 function evalMathCall(fname: string | null, node: Call, env: Env): Cell | undefined {
   if (fname === "math.abs" || fname === "abs") {
     return mathAbs(cellArg(node, env, 0, ["number", "x"]));
@@ -4978,8 +5136,16 @@ function evalDrawingCall(fname: string | null, node: Call, env: Env): Value | un
     return book.boxNew(env.barIndex, extra);
   }
   if (fname === "alert") {
+    // Python `_builtin_alert`: zero-arg `alert()` is a soft no-op.
+    if (asArgs(node.args).length === 0) return NA;
     const msg = evalAlertMessage(callArg(node.args, 0, ["message"]), env);
-    book.alert(env.barIndex, msg);
+    const freqExpr = callArg(node.args, 1, ["freq"]);
+    let freq: unknown = null;
+    if (freqExpr != null) {
+      const v = evalExpr(freqExpr, env);
+      freq = typeof v === "string" ? v : unwrap(v);
+    }
+    emitAlert(env, msg, freq, { source: "alert" });
     return NA;
   }
   if (fname === "table.new") {