@hoox-sh/pynets 0.1.0 → 0.3.0

package/src/runtime/interpret.ts

@@ -7,7 +7,8 @@
  * arrays, color/str, strategy events + position series, input*, math.*,
  * request.security, UDF FunctionDef, matrix.*, extra TA, drawings/alert,
  * derived prices, calendar, Pine na-compare.
- * Not a port of runtime/host.py — same public envelope, interpret only.
+ * Not a port of runtime/host.py — same public envelope.
+ * Compile is JS emit in ./compile/ (mode compile|auto).
  */
 import { parse } from "../ast/helper.ts";
 import type {
@@ -15,6 +16,7 @@ import type {
   Arg,
   Assign,
   Attribute,
+  AugAssign,
   BoolOp,
   Call,
   Conditional,
@@ -24,6 +26,7 @@ import type {
   TypeDef,
   EnumDef,
   Import,
+  Once,
   Param,
   ReAssign,
   Script,
@@ -58,13 +61,18 @@ import {
 import {
   timeframeFromSeconds,
   timeframeInSeconds,
+  timeframePeriodChanged,
   timeframeIsDaily,
+  timeframeIsDwm,
+  timeframeIsHours,
   timeframeIsIntraday,
+  timeframeIsMinutes,
   timeframeIsMonthly,
+  timeframeIsSeconds,
   timeframeIsWeekly,
   timeframeMultiplier as tfMultiplier,
 } from "./timeframe.ts";
-import { DrawingBook, type DrawingEvent } from "./drawings.ts";
+import { DrawingBook, type DrawingEvent, type DrawingKind } from "./drawings.ts";
 import { LogBook, formatLogParts, runtimeError, type LogRecord } from "./log.ts";
 import { MemoryProvider, type BarProvider } from "./provider.ts";
 import {
@@ -137,10 +145,24 @@ import {
   strTrim,
   strUpper,
 } from "./str.ts";
-import { StrategyBook, type BrokerSettings, type StrategyEvent, type StrategySummary } from "./strategy.ts";
+import {
+  StrategyBook,
+  isStrategyCashAmount,
+  strategyCashAmount,
+  type BrokerSettings,
+  type StrategyCashAmount,
+  type StrategyEvent,
+  type StrategySummary,
+} from "./strategy.ts";
 import { PineMap } from "./map.ts";
 import { PineMatrix } from "./matrix.ts";
-import { TaEngine } from "./ta.ts";
+import { TaEngine, type TaRecord } from "./ta.ts";
+import {
+  CompileError,
+  compileEligible,
+  compileScript,
+} from "./compile/index.ts";
+import type { RuntimeMode } from "./compile/types.ts";
 
 export type { DrawingEvent };
 
@@ -153,15 +175,28 @@ export interface OHLCVBar {
   close?: number;
   volume?: number;
   time?: number;
+  time_close?: number;
 }
 
 export type InputOverrides = Record<string, number | string | boolean>;
 
+/** One library source, same shape as Python `Runtime.run(..., libraries=[{...}])`. */
+export type LibrarySourceSpec = {
+  namespace: string;
+  name: string;
+  version?: number;
+  source: string;
+};
+
 export interface RuntimeOptions {
   inputs?: InputOverrides;
   broker?: BrokerSettings;
   timeframe?: string | null;
-  libraries?: LibraryRegistry;
+  libraries?: LibraryRegistry | LibrarySourceSpec[];
+  /** interpret (default) | compile (JS emit) | auto (compile, fallback interpret). */
+  mode?: RuntimeMode;
+  /** Wall-clock budget in seconds. Interpret only; checked every 32 bars. */
+  timeout_seconds?: number | null;
 }
 
 export interface RuntimeFill {
@@ -180,7 +215,9 @@ export interface RuntimeResult {
   count: number;
   script_name: string | null;
   script_type: string;
-  mode: "interpret";
+  mode: "interpret" | "compile";
+  auto_backend?: "interpret" | "compile";
+  compile_fallback_reason?: string;
   events?: StrategyEvent[];
   fills?: RuntimeFill[];
   drawings?: DrawingEvent[];
@@ -189,6 +226,8 @@ export interface RuntimeResult {
   plot_data?: Record<string, { data: Array<{ value: number | null; time?: number }> }>;
   /** Book-level strategy scalars when the script is a strategy (or any fills ran). */
   strategy?: StrategySummary;
+  /** True when interpret stopped after `timeout_seconds`. */
+  timed_out?: boolean;
   error?: string;
   error_kind?: string;
 }
@@ -196,8 +235,17 @@ export interface RuntimeResult {
 /** Eval-only: Cell, tagged tuple/array, color, or strategy.long/short strings. */
 type TupleVal = { __tuple: true; elts: Value[] };
 type ArrayVal = { __array: true; elts: Value[] };
+type ChartPointVal = {
+  __chartPoint: true;
+  index: number | null;
+  time: number | null;
+  x: number | null;
+  y: number | null;
+  price: number | null;
+};
 type Value =
   | Cell
+  | boolean // Python True/False (e.g. `barmerge.*`); coerces to 1/0 via unwrap/valuesEq
   | TupleVal
   | ArrayVal
   | Color
@@ -211,7 +259,10 @@ type Value =
   | LibraryModule
   | UdfDef
   | EnumType
-  | EnumMember;
+  | EnumMember
+  | TaRecord
+  | ChartPointVal
+  | StrategyCashAmount;
 
 const LOOP_BREAK = Object.freeze({ __loop: "break" as const });
 const LOOP_CONTINUE = Object.freeze({ __loop: "continue" as const });
@@ -283,6 +334,11 @@ interface Env {
   barTimes: number[];
   libraries: LibraryRegistry;
   pendingExports: Map<string, Value>;
+  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. */
+  alertFireBars: Map<string, number>;
 }
 
 export class Runtime {
@@ -290,6 +346,8 @@ export class Runtime {
   readonly broker: BrokerSettings;
   readonly timeframe: string | null;
   readonly libraries: LibraryRegistry;
+  readonly mode: RuntimeMode;
+  readonly timeout_seconds: number | null;
 
   constructor(
     public readonly symbol = "AAPL",
@@ -298,7 +356,9 @@ export class Runtime {
     this.inputs = options?.inputs ?? {};
     this.broker = options?.broker ?? {};
     this.timeframe = options?.timeframe ?? null;
-    this.libraries = options?.libraries ?? new LibraryRegistry();
+    this.libraries = resolveLibraries(options?.libraries);
+    this.mode = options?.mode ?? "interpret";
+    this.timeout_seconds = options?.timeout_seconds ?? null;
   }
 
   /** Store Pine source for `import namespace/name/version`. */
@@ -328,14 +388,24 @@ export class Runtime {
       };
     }
     const extraOpts = extra && !isPlainInputs(extra) ? extra : undefined;
+    const mode = extraOpts?.mode ?? this.mode;
+    const inputs = mergeInputs(this.inputs, extra);
+    const host = {
+      symbol: this.symbol,
+      inputs,
+      broker: extraOpts?.broker ?? this.broker,
+      timeframe: extraOpts?.timeframe ?? this.timeframe,
+      libraries: extraOpts?.libraries != null ? resolveLibraries(extraOpts.libraries) : this.libraries,
+      timeout_seconds: extraOpts?.timeout_seconds ?? this.timeout_seconds,
+    };
+    if (mode === "compile") {
+      return runCompiled(source, ohlcv, host);
+    }
+    if (mode === "auto") {
+      return runAuto(source, tree, ohlcv, host);
+    }
     try {
-      return interpretTree(tree, ohlcv, {
-        symbol: this.symbol,
-        inputs: mergeInputs(this.inputs, extra),
-        broker: extraOpts?.broker ?? this.broker,
-        timeframe: extraOpts?.timeframe ?? this.timeframe,
-        libraries: extraOpts?.libraries ?? this.libraries,
-      });
+      return interpretTree(tree, ohlcv, host);
     } catch (err) {
       return {
         series: {},
@@ -434,6 +504,7 @@ export function interpretTree(
     broker?: BrokerSettings;
     timeframe?: string | null;
     libraries?: LibraryRegistry;
+    timeout_seconds?: number | null;
   },
 ): RuntimeResult {
   const scriptNode = tree.kind === "Script" ? (tree as Script) : null;
@@ -469,12 +540,25 @@ export function interpretTree(
     barTimes: ohlcv.map((b, i) => b.time ?? i * 60_000),
     libraries: host?.libraries ?? new LibraryRegistry(),
     pendingExports: new Map(),
+    onceFired: new WeakSet(),
+    maxBarsBackDecls: [],
+    alertFireBars: new Map(),
   };
 
   const n = ohlcv.length;
   let runError: { error: string; error_kind: string } | undefined;
+  let timedOut = false;
+  let barsDone = n;
+  const timeoutSec = host?.timeout_seconds;
+  const deadline =
+    timeoutSec != null && Number.isFinite(timeoutSec) ? performance.now() + timeoutSec * 1000 : null;
   try {
     for (let i = 0; i < n; i++) {
+      if (deadline != null && (i & 31) === 0 && performance.now() > deadline) {
+        timedOut = true;
+        barsDone = i;
+        break;
+      }
       beginBar(env, ohlcv[i]!, i);
       env.book.processPending(i, {
         open: num(env.ctx.open) ?? undefined,
@@ -526,7 +610,7 @@ export function interpretTree(
     series: plots,
     plots: firstTitle ? (plots[firstTitle] ?? []) : [],
     plot_meta,
-    count: n,
+    count: timedOut ? barsDone : n,
     script_name,
     script_type,
     mode: "interpret",
@@ -539,6 +623,9 @@ export function interpretTree(
       ? { strategy: env.book.summary(num(env.ctx.close) ?? 0) }
       : {}),
     ...(runError ?? {}),
+    ...(timedOut
+      ? { timed_out: true, error: "Script execution timed out", error_kind: "runtime" }
+      : {}),
   };
 }
 
@@ -582,9 +669,24 @@ function beginBar(env: Env, bar: OHLCVBar, i: number): void {
   pushNamedSeries(env, "close", c);
   pushNamedSeries(env, "volume", vol);
   pushNamedSeries(env, "time", t);
+  // Explicit `time_close` wins. Otherwise Python's host: next bar open
+  // (0 counts as missing), and the last bar is this open + 1 day.
+  const explicitClose = bar.time_close;
+  let tClose = t;
+  if (typeof explicitClose === "number" && Number.isFinite(explicitClose)) {
+    tClose = explicitClose;
+  } else if (i + 1 < env.barCount) {
+    const next = env.barTimes[i + 1] ?? 0;
+    tClose = next !== 0 ? next : t;
+  } else {
+    tClose = Math.trunc(t) + 86_400_000;
+  }
+  pushNamedSeries(env, "time_close", tClose);
   env.ctx.bar_index = i;
   env.ctx.last_bar_index = env.barCount - 1;
   env.ctx.last_bar_time = env.lastBarTime;
+  // Python `_builtin_timenow`: host ctx, else dataset last bar time (no wall-clock).
+  env.ctx.timenow = env.lastBarTime;
 
   bindDerived(env, "hl2", (h + l) / 2);
   bindDerived(env, "hlc3", (h + l + c) / 3);
@@ -623,17 +725,23 @@ function bindDerived(env: Env, id: string, value: Cell): void {
   }
 }
 
+function unwrapSpecialize(node: expr): expr {
+  let cur = node;
+  while (cur.kind === "Specialize") cur = cur.value;
+  return cur;
+}
+
 function attrPath(node: expr): string | null {
-  if (node.kind === "Name") return node.id;
-  if (node.kind === "Attribute") {
-    const base = attrPath(node.value);
-    return base ? `${base}.${node.attr}` : node.attr;
+  const n = unwrapSpecialize(node);
+  if (n.kind === "Name") return n.id;
+  if (n.kind === "Attribute") {
+    const base = attrPath(n.value);
+    return base ? `${base}.${n.attr}` : n.attr;
   }
   return null;
 }
 
 function callName(node: Call): string | null {
-  if (node.func.kind === "Name") return node.func.id;
   return attrPath(node.func);
 }
 
@@ -716,6 +824,8 @@ function callArg(
 
 function defaultPlotTitle(fname: string): string {
   if (fname === "hline") return "hline";
+  if (fname === "plotcandle") return "candles";
+  if (fname === "plotbar") return "bars";
   if (fname === "plotshape") return "shape";
   if (fname === "plotchar") return "char";
   if (fname === "plotarrow") return "arrow";
@@ -872,6 +982,61 @@ function evalAssign(stmt: Assign, env: Env): Value {
   return value;
 }
 
+function applyBinOp(kind: string, leftV: Value, rightV: Value): Value {
+  // Python _safe_op: any na operand propagates na, before the string-concat
+  // fast path — otherwise `"a" + na` would stringify to "ana" instead of na.
+  // Checked on the raw values: strings are valid Add operands (unwrap maps
+  // them to NA as non-cells).
+  if (leftV == null || rightV == null) return NA;
+  if (kind === "Add" && (typeof leftV === "string" || typeof rightV === "string")) {
+    return stringifyVal(leftV) + stringifyVal(rightV);
+  }
+  const l = unwrap(leftV);
+  const r = unwrap(rightV);
+  if (l == null || r == null) return NA;
+  switch (kind) {
+    case "Add":
+      return l + r;
+    case "Sub":
+      return l - r;
+    case "Mult":
+      return l * r;
+    case "Div":
+      return r === 0 ? NA : l / r;
+    case "Mod":
+      return r === 0 ? NA : l % r;
+    case "BitAnd":
+      return Math.trunc(l) & Math.trunc(r);
+    case "BitOr":
+      return Math.trunc(l) | Math.trunc(r);
+    case "BitXor":
+      return Math.trunc(l) ^ Math.trunc(r);
+    case "LShift":
+      return Math.trunc(l) << Math.trunc(r);
+    case "RShift":
+      return Math.trunc(l) >> Math.trunc(r);
+  }
+  return NA;
+}
+
+function evalAugAssign(stmt: AugAssign, env: Env): Value {
+  if (stmt.target.kind === "Attribute") {
+    const obj = evalExpr(stmt.target.value, env);
+    const value = evalExpr(stmt.value, env);
+    if (obj instanceof UdtInstance) {
+      obj.set(stmt.target.attr, value);
+      return value;
+    }
+    return NA;
+  }
+  if (stmt.target.kind !== "Name") return NA;
+  const current = ctxGet(env, stmt.target.id);
+  if (current === undefined) return NA;
+  const result = applyBinOp(stmt.op.kind, current, evalExpr(stmt.value, env));
+  bindName(env, stmt.target.id, result);
+  return result;
+}
+
 function evalReAssign(stmt: ReAssign, env: Env): Value {
   if (stmt.target.kind === "Tuple") {
     const packed = evalExpr(stmt.value, env);
@@ -902,6 +1067,21 @@ function applyStrategyDecl(stmt: { kind: string; value?: expr | null }, env: Env
   if (comm != null) settings.commission = comm;
   if (slip != null) settings.slippage = slip;
   if (pyr != null) settings.pyramiding = Math.trunc(pyr);
+  const apm = evalExpr(callArg(stmt.value.args, -1, ["avg_price_model"]), env);
+  if (typeof apm === "string") settings.avg_price_model = apm;
+  const lev = unwrap(evalExpr(callArg(stmt.value.args, -1, ["leverage"]), env));
+  if (lev != null) settings.leverage = lev;
+  const ml = unwrap(evalExpr(callArg(stmt.value.args, -1, ["margin_long"]), env));
+  if (ml != null) settings.margin_long = ml;
+  const ms = unwrap(evalExpr(callArg(stmt.value.args, -1, ["margin_short"]), env));
+  if (ms != null) settings.margin_short = ms;
+  const dqt = evalExpr(callArg(stmt.value.args, -1, ["default_qty_type"]), env);
+  if (typeof dqt === "string") settings.default_qty_type = dqt;
+  else if (isStrategyCashAmount(dqt)) settings.default_qty_type = "cash";
+  const dqv = unwrap(evalExpr(callArg(stmt.value.args, -1, ["default_qty_value"]), env));
+  if (dqv != null) settings.default_qty_value = dqv;
+  const cur = evalExpr(callArg(stmt.value.args, -1, ["currency"]), env);
+  if (typeof cur === "string" && cur !== "") settings.currency = cur;
   if (Object.keys(settings).length) env.book.configure(settings);
   const capital = unwrap(evalExpr(callArg(stmt.value.args, -1, ["initial_capital"]), env));
   if (capital != null && Number.isFinite(capital)) env.book.initialCapital = capital;
@@ -956,9 +1136,12 @@ function execStmt(
   if (stmt.kind === "ReAssign") {
     return evalReAssign(stmt as ReAssign, env);
   }
+  if (stmt.kind === "AugAssign") {
+    return evalAugAssign(stmt as AugAssign, env);
+  }
   if (stmt.kind === "Break") throw LOOP_BREAK;
   if (stmt.kind === "Continue") throw LOOP_CONTINUE;
-  if (stmt.kind === "Switch" || stmt.kind === "While" || stmt.kind === "If") {
+  if (stmt.kind === "Switch" || stmt.kind === "While" || stmt.kind === "If" || stmt.kind === "Once") {
     return evalExpr(stmt as unknown as expr, env);
   }
   if (stmt.kind !== "Expr" || !("value" in stmt) || stmt.value == null) return NA;
@@ -973,12 +1156,18 @@ function execStmt(
       fname === "plotchar" ||
       fname === "plotarrow" ||
       fname === "bgcolor" ||
-      fname === "barcolor"
+      fname === "barcolor" ||
+      fname === "plotcandle" ||
+      fname === "plotbar"
     ) {
       const plotArgs = asArgs(value.args);
+      const ohlc = fname === "plotcandle" || fname === "plotbar";
       const title = resolvePlotTitle(plotArgs, fname);
       const key = uniquifyPlotKey(env, value, title);
-      const seriesExpr = callArg(value.args, 0, ["series", "source"]) ?? plotArgs[0]?.value;
+      // Python primary column is close (arg 3), not open.
+      const seriesExpr = ohlc
+        ? callArg(value.args, 3, ["close"])
+        : (callArg(value.args, 0, ["series", "source"]) ?? plotArgs[0]?.value);
       const cell = unwrap(evalExpr(seriesExpr, env));
       if (!env.plots[key]) {
         env.plots[key] = [];
@@ -1002,7 +1191,10 @@ function evalExpr(node: expr | undefined, env: Env): Value {
   switch (node.kind) {
     case "Name": {
       const v = ctxGet(env, node.id);
-      return v === undefined ? NA : v;
+      if (v !== undefined) return v;
+      // Python `_MATH_CONSTANTS`: omitted 1T quotes stay na.
+      if (node.id === "bid" || node.id === "ask") return NA;
+      return NA;
     }
     case "Constant": {
       const v = node.value;
@@ -1012,29 +1204,8 @@ function evalExpr(node: expr | undefined, env: Env): Value {
       if (v === false) return 0;
       return NA;
     }
-    case "BinOp": {
-      const leftV = evalExpr(node.left, env);
-      const rightV = evalExpr(node.right, env);
-      if (node.op.kind === "Add" && (typeof leftV === "string" || typeof rightV === "string")) {
-        return stringifyVal(leftV) + stringifyVal(rightV);
-      }
-      const l = unwrap(leftV);
-      const r = unwrap(rightV);
-      if (l == null || r == null) return NA;
-      switch (node.op.kind) {
-        case "Add":
-          return l + r;
-        case "Sub":
-          return l - r;
-        case "Mult":
-          return l * r;
-        case "Div":
-          return r === 0 ? NA : l / r;
-        case "Mod":
-          return r === 0 ? NA : l % r;
-      }
-      return NA;
-    }
+    case "BinOp":
+      return applyBinOp(node.op.kind, evalExpr(node.left, env), evalExpr(node.right, env));
     case "UnaryOp": {
       const v = unwrap(evalExpr(node.operand, env));
       if (node.op.kind === "Not") return isTruthy(v) ? 0 : 1;
@@ -1089,8 +1260,23 @@ function evalExpr(node: expr | undefined, env: Env): Value {
       return evalWhile(node, env);
     case "Switch":
       return evalSwitch(node, env);
+    case "Once": {
+      const onceNode = node as Once;
+      if (env.onceFired.has(onceNode)) return NA;
+      const t = onceNode.test == null ? 1 : unwrap(evalExpr(onceNode.test, env));
+      if (!isTruthy(t)) return NA;
+      for (const s of onceNode.body) execStmt(s, env);
+      env.onceFired.add(onceNode);
+      return NA;
+    }
     case "BoolOp":
       return evalBoolOp(node, env);
+    case "Qualify":
+      return evalExpr(node.value, env);
+    case "Specialize":
+      return evalExpr(node.value, env);
+    case "AugAssign":
+      return evalAugAssign(node, env);
   }
 }
 
@@ -1167,16 +1353,27 @@ function evalSwitch(node: Switch, env: Env): Value {
   const subject = subjectPresent ? evalExpr(node.subject!, env) : null;
   for (const c of cases) {
     if (c.pattern == null) return execBlock(c.body, env);
-    if (subjectPresent) {
-      const pat = evalExpr(c.pattern, env);
-      if (valuesEq(pat, subject)) return execBlock(c.body, env);
-    } else if (isTruthy(unwrap(evalExpr(c.pattern, env)))) {
-      return execBlock(c.body, env);
-    }
+    if (switchArmMatches(subjectPresent, subject, c.pattern, env)) return execBlock(c.body, env);
   }
   return NA;
 }
 
+/** Python `_switch_case_matches`: multi-value arms (`1, 2 =>`) match any element. */
+function switchArmMatches(
+  subjectPresent: boolean,
+  subject: Value | null,
+  pattern: expr,
+  env: Env,
+): boolean {
+  const pat = evalExpr(pattern, env);
+  if (isTuple(pat)) {
+    if (!subjectPresent) return pat.elts.some((p) => isTruthy(unwrap(p)));
+    return pat.elts.some((p) => valuesEq(p, subject as Value));
+  }
+  if (subjectPresent) return valuesEq(pat, subject as Value);
+  return isTruthy(unwrap(pat));
+}
+
 function execBlock(body: stmt[] | stmt | null | undefined, env: Env): Value {
   let last: Value = NA;
   for (const s of asStmts(body)) last = execStmt(s, env);
@@ -1231,73 +1428,154 @@ function evalForIn(node: ForIn, env: Env): Value {
   return last;
 }
 
-/** `strategy.long` / `strategy.short` → "long"/"short"; other attrs are na. */
+/**
+ * Python `_MATH_CONSTANTS` static dotted keys (base.py).
+ * `barmerge.*` are Python True/False booleans (ast/evaluator/base.py ~92),
+ * matching compile (emit.ts) — plotting coerces to 1/0 on both backends.
+ * Dynamic series (`timeframe.*` flags, `syminfo.ticker`, `bid`/`ask`) stay in Name blocks.
+ */
+/* Exported for direct unit tests (typeof / parity assertions); not part of the package API. */
+export const MATH_CONSTANTS: Record<string, Value> = {
+  "math.pi": Math.PI,
+  "math.e": Math.E,
+  "math.phi": (1 + Math.sqrt(5)) / 2,
+  "math.rphi": 2 / (1 + Math.sqrt(5)),
+  "format.mintick": "mintick",
+  "format.percent": "percent",
+  "format.volume": "volume",
+  "format.price": "price",
+  "text.formatting.none": "",
+  "text.formatting.bold": "bold",
+  "text.formatting.italic": "italic",
+  "text.formatting.bold_italic": "bold italic",
+  "size.auto": "auto",
+  "size.tiny": 8,
+  "size.small": 10,
+  "size.normal": 12,
+  "size.large": 16,
+  "size.huge": 20,
+  "order.ascending": 1,
+  "order.descending": -1,
+  "barmerge.gaps_on": true,
+  "barmerge.gaps_off": false,
+  "barmerge.lookahead_on": true,
+  "barmerge.lookahead_off": false,
+  "shape.arrowup": "arrowup",
+  "shape.arrowdown": "arrowdown",
+  "shape.circle": "circle",
+  "shape.cross": "cross",
+  "shape.diamond": "diamond",
+  "shape.flag": "flag",
+  "shape.labelup": "labelup",
+  "shape.labeldown": "labeldown",
+  "shape.square": "square",
+  "shape.triangledown": "triangledown",
+  "shape.triangleup": "triangleup",
+  "shape.xcross": "xcross",
+  "location.abovebar": "abovebar",
+  "location.belowbar": "belowbar",
+  "location.top": "top",
+  "location.bottom": "bottom",
+  "location.absolute": "absolute",
+  "xloc.bar_index": "bar_index",
+  "xloc.bar_time": "bar_time",
+  "yloc.price": "price",
+  "yloc.abovebar": "abovebar",
+  "yloc.belowbar": "belowbar",
+  "extend.none": "none",
+  "extend.left": "left",
+  "extend.right": "right",
+  "extend.both": "both",
+  // Pine display.* is a bitfield: none=0 pane=1 data_window=2 price_scale=4
+  // status_line=8 all=15. Integers so `display.pane + display.data_window` works.
+  "display.none": 0,
+  "display.pane": 1,
+  "display.all": 15,
+  "display.data_window": 2,
+  "display.price_scale": 4,
+  "display.status_line": 8,
+  "position.top_left": "top_left",
+  "position.top_center": "top_center",
+  "position.top_right": "top_right",
+  "position.middle_left": "middle_left",
+  "position.middle_center": "middle_center",
+  "position.middle_right": "middle_right",
+  "position.bottom_left": "bottom_left",
+  "position.bottom_center": "bottom_center",
+  "position.bottom_right": "bottom_right",
+  "hline.style_solid": "solid",
+  "hline.style_dashed": "dashed",
+  "hline.style_dotted": "dotted",
+  // Python plotting.py PlotStyle / `_builtin_plot_linestyle_*`.
+  "plot.linestyle_solid": "linestyle_solid",
+  "plot.linestyle_dashed": "linestyle_dashed",
+  "plot.linestyle_dotted": "linestyle_dotted",
+  "dayofweek.sunday": 1,
+  "dayofweek.monday": 2,
+  "dayofweek.tuesday": 3,
+  "dayofweek.wednesday": 4,
+  "dayofweek.thursday": 5,
+  "dayofweek.friday": 6,
+  "dayofweek.saturday": 7,
+  "month.january": 1,
+  "month.february": 2,
+  "month.march": 3,
+  "month.april": 4,
+  "month.may": 5,
+  "month.june": 6,
+  "month.july": 7,
+  "month.august": 8,
+  "month.september": 9,
+  "month.october": 10,
+  "month.november": 11,
+  "month.december": 12,
+};
+
+function mathConstant(node: Attribute): Value | undefined {
+  const path = attrPath(node);
+  if (path == null || !Object.prototype.hasOwnProperty.call(MATH_CONSTANTS, path)) return undefined;
+  return MATH_CONSTANTS[path];
+}
+
+/** `strategy.long` / `strategy.short` → "long"/"short"; dotted `_MATH_CONSTANTS`; other attrs are na. */
 function evalAttribute(node: Attribute, env: Env): Value {
+  const constant = mathConstant(node);
+  if (constant !== undefined) return constant;
+  const strat = evalStrategyAttr(node, env);
+  if (strat !== undefined) return strat;
   if (node.value.kind === "Name") {
-    if (node.value.id === "strategy") {
-      if (node.attr === "long" || node.attr === "short") return node.attr;
-      if (node.attr === "position_size") return env.book.position.qty;
-      if (node.attr === "position_avg_price") return env.book.position.avgPrice;
-      if (node.attr === "netprofit") return env.book.realizedPnl;
-      if (node.attr === "openprofit") {
-        const q = env.book.position.qty;
-        const avg = env.book.position.avgPrice;
-        const mark = num(env.ctx.close);
-        if (q === 0 || avg == null || mark == null) return 0;
-        return q * (mark - avg);
-      }
-      if (node.attr === "equity") return env.book.equity(num(env.ctx.close) ?? 0);
-      if (node.attr === "opentrades") return env.book.opentrades;
-      if (node.attr === "closedtrades") return env.book.closedtrades;
-      if (node.attr === "wintrades") return env.book.wintrades;
-      if (node.attr === "losstrades") return env.book.losstrades;
-      if (node.attr === "eventrades") return env.book.eventrades;
-      if (node.attr === "grossprofit") return env.book.grossprofit;
-      if (node.attr === "grossloss") return env.book.grossloss;
-      if (node.attr === "avg_trade") return env.book.avgTrade();
-      if (node.attr === "avg_winning_trade") return env.book.avgWinningTrade();
-      if (node.attr === "avg_losing_trade") return env.book.avgLosingTrade();
-      if (node.attr === "netprofit_percent") {
-        return env.book.netprofitPercent(num(env.ctx.close) ?? 0);
-      }
-      if (node.attr === "openprofit_percent") {
-        return env.book.openprofitPercent(num(env.ctx.close) ?? 0);
-      }
-      if (node.attr === "grossprofit_percent") return env.book.grossprofitPercent();
-      if (node.attr === "grossloss_percent") return env.book.grosslossPercent();
-      if (node.attr === "avg_trade_percent") return env.book.avgTradePercent();
-      if (node.attr === "avg_winning_trade_percent") return env.book.avgWinningTradePercent();
-      if (node.attr === "avg_losing_trade_percent") return env.book.avgLosingTradePercent();
-      if (node.attr === "max_drawdown") return env.book.maxDrawdown();
-      if (node.attr === "max_drawdown_percent") return env.book.maxDrawdownPercent();
-      if (node.attr === "max_runup") return env.book.maxRunup();
-      if (node.attr === "max_runup_percent") return env.book.maxRunupPercent();
-      if (node.attr === "percent_profitable" || node.attr === "winrate") {
-        return env.book.percentProfitable();
-      }
-      if (node.attr === "profitfactor" || node.attr === "profit_factor") {
-        return env.book.profitFactor();
-      }
-      if (node.attr === "initial_capital") return env.book.initialCapital;
-      if (node.attr === "commission") return 0;
-      if (node.attr === "cash") return "cash";
-      if (node.attr === "fixed") return "fixed";
-      if (node.attr === "percent_of_equity") return "percent_of_equity";
-    }
     if (node.value.id === "syminfo") {
       if (node.attr === "ticker" || node.attr === "tickerid") return env.symbol;
+      if (node.attr === "prefix") return extractPrefix(env.symbol);
       if (node.attr === "timezone") return "Etc/UTC";
       if (node.attr === "currency") return "USD";
       if (node.attr === "mintick") return 0.01;
       if (node.attr === "type") return "stock";
+      if (node.attr === "isin") return "";
+      if (node.attr === "current_contract") return NA;
+      if (node.attr === "main_tickerid") return env.symbol;
     }
     if (node.value.id === "timeframe") {
-      if (node.attr === "period") return env.timeframe ?? "";
-      if (node.attr === "multiplier") return tfMultiplier(env.timeframe);
-      if (node.attr === "isintraday") return timeframeIsIntraday(env.timeframe) ? 1 : 0;
-      if (node.attr === "isdaily") return timeframeIsDaily(env.timeframe) ? 1 : 0;
-      if (node.attr === "isweekly") return timeframeIsWeekly(env.timeframe) ? 1 : 0;
-      if (node.attr === "ismonthly") return timeframeIsMonthly(env.timeframe) ? 1 : 0;
+      // Python SoT: with no configured timeframe the evaluator's static
+      // "Chart timeframe defaults (daily)" table applies (base.py) and
+      // `_chart_period` / `_period_flags` resolve the chart to daily —
+      // period "D", isdaily/isdwm true, everything else false. Normalize
+      // null/empty to "D" so derivation lands on that table; a configured
+      // timeframe keeps the dynamic helpers unchanged.
+      const tf = env.timeframe == null || env.timeframe === "" ? "D" : env.timeframe;
+      if (node.attr === "period") return tf;
+      if (node.attr === "main_period") return tf;
+      if (node.attr === "multiplier") return tfMultiplier(tf);
+      if (node.attr === "isintraday") return timeframeIsIntraday(tf) ? 1 : 0;
+      if (node.attr === "isdaily") return timeframeIsDaily(tf) ? 1 : 0;
+      if (node.attr === "isweekly") return timeframeIsWeekly(tf) ? 1 : 0;
+      if (node.attr === "ismonthly") return timeframeIsMonthly(tf) ? 1 : 0;
+      if (node.attr === "isseconds" || node.attr === "isinseconds") {
+        return timeframeIsSeconds(tf) ? 1 : 0;
+      }
+      if (node.attr === "isminutes") return timeframeIsMinutes(tf) ? 1 : 0;
+      if (node.attr === "ishours") return timeframeIsHours(tf) ? 1 : 0;
+      if (node.attr === "isdwm") return timeframeIsDwm(tf) ? 1 : 0;
     }
     if (node.value.id === "color") {
       const named = colorByName(node.attr);
@@ -1336,6 +1614,14 @@ function evalAttribute(node: Attribute, env: Env): Value {
       const taAttr = evalTaAttr(node.attr, env);
       if (taAttr !== undefined) return taAttr;
     }
+    if (node.value.id === "order") {
+      if (node.attr === "ascending") return 1;
+      if (node.attr === "descending") return -1;
+    }
+    if (node.attr === "all") {
+      const kind = drawingAllKind(node.value.id);
+      if (kind != null) return drawingAllArray(env, kind);
+    }
   }
   const obj = evalExpr(node.value, env);
   if (obj instanceof UdtInstance) {
@@ -1355,6 +1641,33 @@ function evalAttribute(node: Attribute, env: Env): Value {
     if (typeof exp === "function") return NA;
     return exp as Value;
   }
+  if (isTaRecord(obj)) return taRecordField(obj, node.attr);
+  if (isChartPoint(obj)) return chartPointField(obj, node.attr);
+  return NA;
+}
+
+function isTaRecord(value: Value): value is TaRecord {
+  return typeof value === "object" && value !== null && (value as TaRecord).__taRecord === true;
+}
+
+/** Brand-gated field read. Booleans plot as 1/0. Class instances never reach here. */
+function taRecordField(obj: TaRecord, attr: string): Value {
+  if (
+    obj instanceof UdtInstance ||
+    obj instanceof EnumType ||
+    obj instanceof LibraryModule ||
+    obj instanceof PineArray ||
+    obj instanceof PineMap ||
+    obj instanceof PineMatrix
+  ) {
+    return NA;
+  }
+  if (!Object.prototype.hasOwnProperty.call(obj, attr)) return NA;
+  const v = obj[attr];
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (typeof v === "number") return Number.isFinite(v) ? v : NA;
+  if (v === null) return NA;
+  if (typeof v === "string") return v;
   return NA;
 }
 
@@ -1389,7 +1702,7 @@ function evalTaAttr(attr: string, env: Env): Value | undefined {
     const src = h != null && l != null && c != null ? (h + l + c) / 3 : c;
     return (ta.vwap as TaEngine["vwap"]).call(env.ta, site, src, num(env.ctx.volume));
   }
-  if (attr === "pvt" && typeof ta.pvt === "function") {
+  if ((attr === "pvt" || attr === "vpt") && typeof ta.pvt === "function") {
     return (ta.pvt as TaEngine["pvt"]).call(env.ta, site, num(env.ctx.close), num(env.ctx.volume));
   }
   if (attr === "nvi" && typeof ta.nvi === "function") {
@@ -1398,6 +1711,41 @@ function evalTaAttr(attr: string, env: Env): Value | undefined {
   if (attr === "pvi" && typeof ta.pvi === "function") {
     return (ta.pvi as TaEngine["pvi"]).call(env.ta, site, num(env.ctx.close), num(env.ctx.volume));
   }
+  if (attr === "wad" && typeof ta.wad === "function") {
+    return (ta.wad as TaEngine["wad"]).call(
+      env.ta,
+      site,
+      num(env.ctx.high),
+      num(env.ctx.low),
+      num(env.ctx.close),
+      num(env.ctx.volume),
+    );
+  }
+  if (attr === "wvad" && typeof ta.wvad === "function") {
+    return (ta.wvad as TaEngine["wvad"]).call(
+      env.ta,
+      site,
+      num(env.ctx.high),
+      num(env.ctx.low),
+      num(env.ctx.close),
+      num(env.ctx.volume),
+      20,
+    );
+  }
+  if (attr === "cmf" && typeof ta.cmf === "function") {
+    return (ta.cmf as TaEngine["cmf"]).call(
+      env.ta,
+      site,
+      num(env.ctx.high),
+      num(env.ctx.low),
+      num(env.ctx.close),
+      num(env.ctx.volume),
+      20,
+    );
+  }
+  if (attr === "ao") {
+    return env.ta.ao(site, num(env.ctx.high), num(env.ctx.low), 5, 34);
+  }
   return undefined;
 }
 
@@ -1433,6 +1781,9 @@ function isNaVal(value: Value): boolean {
 }
 
 function valuesEq(left: Value, right: Value): boolean {
+  // Python True/False compare as 1/0 (True == 1), e.g. `barmerge.gaps_on == 1`.
+  if (typeof left === "boolean") left = left ? 1 : 0;
+  if (typeof right === "boolean") right = right ? 1 : 0;
   if (isNaVal(left) && isNaVal(right)) return true;
   if (isNaVal(left) || isNaVal(right)) return false;
   if (left instanceof EnumMember) return left.equals(right);
@@ -1470,20 +1821,27 @@ function cmp(left: Value, op: string, right: Value): boolean | null {
 }
 
 function evalCall(node: Call, env: Env): Value {
-  if (node.func.kind === "Attribute") {
-    const obj = evalExpr(node.func.value, env);
+  const callee = unwrapSpecialize(node.func);
+  if (callee.kind === "Attribute") {
+    const obj = evalExpr(callee.value, env);
     if (obj instanceof LibraryModule) {
-      return evalLibraryMemberCall(obj, node.func.attr, node, env);
+      return evalLibraryMemberCall(obj, callee.attr, node, env);
     }
     if (obj instanceof UdtInstance) {
-      const meth = obj.getMethod(node.func.attr);
+      const meth = obj.getMethod(callee.attr);
       if (meth && isUdfDef(meth.body)) return evalUdf(meth.body, node, env, obj);
     }
-    if (obj instanceof UdtType && node.func.attr === "new") {
+    if (obj instanceof UdtType && callee.attr === "new") {
       const overrides: Record<string, unknown> = {};
+      let pos = 0;
       for (const a of asArgs(node.args)) {
         const key = argKeyword(a);
-        if (key) overrides[key] = evalExpr(a.value, env);
+        if (key) {
+          overrides[key] = evalExpr(a.value, env);
+          continue;
+        }
+        const field = obj.fields[pos++];
+        if (field) overrides[field.name] = evalExpr(a.value, env);
       }
       return obj.newInstance(overrides);
     }
@@ -1503,7 +1861,10 @@ function evalCall(node: Call, env: Env): Value {
     return env.ta.rma(site, srcArg(node, env), lenArg(node, env, 1));
   }
   if (fname === "ta.atr" || fname === "atr") {
-    const period = lenArg(node, env, 0);
+    // Python 1-arg period-only form gates the length on _is_period_like
+    // (volatility.py ~54 / basic.py ~420): non-period-like → ignored → same
+    // as the arg being absent (na period 0 → na kernel).
+    const period = periodLikeArg(node, env, 0, ["length"]) ?? 0;
     return env.ta.atr(site, num(env.ctx.high), num(env.ctx.low), num(env.ctx.close), period);
   }
   if (fname === "ta.kc" || fname === "kc") {
@@ -1520,7 +1881,12 @@ function evalCall(node: Call, env: Env): Value {
   const mathVal = evalMathCall(fname, node, env);
   if (mathVal !== undefined) return mathVal;
   if (isInputBuiltin(fname)) return evalInput(node, env, fname!);
-  if (isRequestBuiltin(fname) || fname === "request.security") {
+  if (
+    isRequestBuiltin(fname) ||
+    fname === "request.security" ||
+    fname === "security" ||
+    fname === "security_lower_tf"
+  ) {
     return evalRequestCall(fname!, node, env);
   }
   const arrVal = evalArrayCall(fname, node, env);
@@ -1573,9 +1939,44 @@ function evalCall(node: Call, env: Env): Value {
   }
   const timeVal = evalTimeCall(fname, node, env);
   if (timeVal !== undefined) return timeVal;
+  if (fname === "max_bars_back") {
+    const varExpr = callArg(node.args, 0, ["var"]);
+    const numExpr = callArg(node.args, 1, ["num"]);
+    env.maxBarsBackDecls.push({
+      var: varExpr == null ? NA : evalExpr(varExpr, env),
+      num: numExpr == null ? 0 : evalExpr(numExpr, env),
+    });
+    return NA;
+  }
+  if (fname === "alertcondition") {
+    const condExpr = callArg(node.args, 0, ["condition"]);
+    if (condExpr == null) runtimeError("alertcondition() requires at least a condition argument");
+    const raw = evalExpr(condExpr, env);
+    const condition = isTruthy(unwrap(raw));
+    let title = "Alert";
+    let message = "Alert";
+    const titleExpr = callArg(node.args, 1, ["title"]);
+    const msgExpr = callArg(node.args, 2, ["message"]);
+    if (titleExpr != null) {
+      const t = evalExpr(titleExpr, env);
+      if (t != null) title = typeof t === "string" ? t : unwrap(t) == null ? title : String(unwrap(t));
+    }
+    if (msgExpr != null) {
+      const m = evalExpr(msgExpr, env);
+      if (m != null) message = typeof m === "string" ? m : unwrap(m) == null ? message : String(unwrap(m));
+    }
+    if (condition) fireAlertCondition(env, title, message);
+    return NA;
+  }
+  if (fname === "timeframe.change") return timeframeChange(node, env);
+  if (fname === "syminfo.prefix") return syminfoPrefix(node, env);
   if (fname === "timeframe.in_seconds") {
+    // Python SoT (timeframe.py:189-190): None / "" map to "D" (daily 86400)
+    // before parsing — same default compile applies (runtime.ts
+    // timeframeInSecondsOrDaily). A configured chart timeframe ("5") keeps
+    // its own duration via the env fallback (pinned in interpret_wave6).
     const p = evalAsString(callArg(node.args, 0, ["timeframe", "period"]), env) ?? env.timeframe;
-    return timeframeInSeconds(p);
+    return timeframeInSeconds(p == null || p === "" ? "D" : p);
   }
   if (fname === "timeframe.from_seconds") {
     const s = unwrap(evalExpr(callArg(node.args, 0, ["seconds"]), env));
@@ -1648,11 +2049,16 @@ function evalCall(node: Call, env: Env): Value {
     const id = evalId(callArg(node.args, 0, ["id"]));
     const dir = evalDirection(callArg(node.args, 1, ["direction"]), env);
     const qtyArg = callArg(node.args, 2, ["qty"]);
-    const qtyRaw = qtyArg == null ? 1 : unwrap(evalExpr(qtyArg, env));
-    const qty = qtyRaw == null || !Number.isFinite(qtyRaw) ? Number.NaN : qtyRaw;
+    const mark = num(env.ctx.close);
+    let qty: number;
+    if (qtyArg == null) {
+      qty = env.book.resolveDefaultQty(mark ?? 0);
+    } else {
+      const qtyRaw = unwrap(evalExpr(qtyArg, env));
+      qty = qtyRaw == null || !Number.isFinite(qtyRaw) ? Number.NaN : qtyRaw;
+    }
     const limit = unwrap(evalExpr(callArg(node.args, -1, ["limit"]), env));
     const stop = unwrap(evalExpr(callArg(node.args, -1, ["stop"]), env));
-    const mark = num(env.ctx.close);
     env.book.placeEntry(env.barIndex, id, dir, qty, {
       limit,
       stop,
@@ -1666,13 +2072,40 @@ function evalCall(node: Call, env: Env): Value {
   if (fname === "strategy.close") {
     const id = evalId(callArg(node.args, 0, ["id"]));
     const mark = num(env.ctx.close);
+    const qtyExpr = callArg(node.args, 1, ["qty"]);
+    const qtyRaw = qtyExpr == null ? undefined : unwrap(evalExpr(qtyExpr, env));
     if (env.book.position.qty !== 0 && mark != null) {
-      env.book.fillClose(env.barIndex, id, mark, { time: num(env.ctx.time) ?? undefined });
+      env.book.fillClose(env.barIndex, id, mark, {
+        time: num(env.ctx.time) ?? undefined,
+        qty: qtyRaw ?? undefined,
+      });
     } else env.book.close(env.barIndex, id);
     return NA;
   }
   if (fname === "strategy.exit") {
-    env.book.exit(env.barIndex, evalId(callArg(node.args, 0, ["id"])));
+    const id = evalId(callArg(node.args, 0, ["id"]));
+    const fromStr = evalAsString(callArg(node.args, 1, ["from_entry"]), env);
+    const fromEntry = fromStr != null && fromStr !== "" ? fromStr : null;
+    env.book.placeExit(env.barIndex, id, {
+      from_entry: fromEntry,
+      qty: unwrap(evalExpr(callArg(node.args, 2, ["qty"]), env)),
+      qty_percent: unwrap(evalExpr(callArg(node.args, 3, ["qty_percent"]), env)),
+      profit: unwrap(evalExpr(callArg(node.args, 4, ["profit"]), env)),
+      limit: unwrap(evalExpr(callArg(node.args, 5, ["limit"]), env)),
+      loss: unwrap(evalExpr(callArg(node.args, 6, ["loss"]), env)),
+      stop: unwrap(evalExpr(callArg(node.args, 7, ["stop"]), env)),
+      trail_price: unwrap(evalExpr(callArg(node.args, 8, ["trail_price"]), env)),
+      trail_points: unwrap(evalExpr(callArg(node.args, 9, ["trail_points"]), env)),
+      trail_offset: unwrap(evalExpr(callArg(node.args, 10, ["trail_offset"]), env)),
+      price: num(env.ctx.close) ?? undefined,
+      time: num(env.ctx.time) ?? undefined,
+      ohlc: {
+        open: num(env.ctx.open) ?? undefined,
+        high: num(env.ctx.high) ?? undefined,
+        low: num(env.ctx.low) ?? undefined,
+        close: num(env.ctx.close) ?? undefined,
+      },
+    });
     return NA;
   }
   if (fname === "strategy.close_all") {
@@ -1704,6 +2137,8 @@ function evalCall(node: Call, env: Env): Value {
   }
   const riskVal = evalStrategyRiskCall(fname, node, env);
   if (riskVal !== undefined) return riskVal;
+  const seriesVal = evalStrategySeriesCall(fname, node, env);
+  if (seriesVal !== undefined) return seriesVal;
   const tradeVal = evalStrategyTradeCall(fname, node, env);
   if (tradeVal !== undefined) return tradeVal;
   if (fname != null && fname.endsWith(".new")) {
@@ -1730,7 +2165,11 @@ function evalKc(node: Call, env: Env, site: string): Value {
   let high = num(env.ctx.high);
   let low = num(env.ctx.low);
   let close = srcArg(node, env);
-  let length = lenArg(node, env, 1);
+  // Python 3-arg reference form dispatches on _is_period_like(args[1])
+  // (volatility.py ~250 / basic.py ~451): a non-period-like length is ignored
+  // → same as absent (na period 0). The legacy 4-arg form below coerces via
+  // _expect_int (fractional floors) and stays ungated.
+  let length = periodLikeArg(node, env, 1, ["length"]) ?? 0;
   let mult = numArg(node, env, 2, ["mult", "multiplier"], 1);
   if (positional.length >= 4) {
     high = unwrap(evalExpr(positional[0]!.value, env));
@@ -1847,11 +2286,72 @@ function numArg(node: Call, env: Env, index: number, names: string[], fallback:
 
 function unwrap(value: Value): Cell {
   if (value == null) return NA;
+  // Python True/False (e.g. `barmerge.*`) coerce to 1/0 like compile's `num()`
+  // (True == 1) — the interpret Value pipeline is number-centric.
+  if (typeof value === "boolean") return value ? 1 : 0;
   if (typeof value === "number") return Number.isFinite(value) ? value : NA;
+  if (isStrategyCashAmount(value)) return Number.isFinite(value.value) ? value.value : NA;
   // Objects (PineArray / Matrix / Color / tuples) are not cells — not na.
   return NA;
 }
 
+/** Store array slots as-is; only coerce non-finite numbers to `na`. */
+function storeValue(value: Value): unknown {
+  if (value == null) return null;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  return value;
+}
+
+function asArrayValue(value: unknown): Value {
+  return value as Value;
+}
+
+/** Python `_parse_sort_args` — `(id)`, `(id, order)`, `(id, order, sort_field)`, or bare field. */
+function parseSortArgs(node: Call, env: Env): { order: "asc" | "desc"; sortField: unknown } {
+  const orderExpr = callArg(node.args, 1, ["order"]);
+  const fieldExpr = callArg(node.args, 2, ["sort_field"]);
+  const second = orderExpr == null ? undefined : evalExpr(orderExpr, env);
+  const third = fieldExpr == null ? undefined : evalExpr(fieldExpr, env);
+  if (fieldExpr != null) {
+    return { order: isDescendingOrder(second) ? "desc" : "asc", sortField: sortFieldValue(third) };
+  }
+  if (orderExpr == null) return { order: "asc", sortField: null };
+  if (second == null) return { order: "asc", sortField: null };
+  if (typeof second === "string") {
+    const low = second.toLowerCase();
+    if (low === "ascending" || low === "descending" || low === "asc" || low === "desc") {
+      return { order: isDescendingOrder(second) ? "desc" : "asc", sortField: null };
+    }
+    return { order: "asc", sortField: second };
+  }
+  if (typeof second === "number" && Number.isFinite(second)) {
+    if (second === 1 || second === -1) {
+      return { order: isDescendingOrder(second) ? "desc" : "asc", sortField: null };
+    }
+    return { order: "asc", sortField: second };
+  }
+  return { order: isDescendingOrder(second) ? "desc" : "asc", sortField: null };
+}
+
+function isDescendingOrder(orderArg: Value | undefined): boolean {
+  if (orderArg == null) return false;
+  if (typeof orderArg === "number") return orderArg < 0;
+  if (typeof orderArg === "string") return orderArg.toLowerCase().includes("desc");
+  return false;
+}
+
+function sortFieldValue(value: Value | undefined): unknown {
+  if (value == null) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return null;
+}
+
+function evalSortField(node: Call, env: Env): unknown {
+  const raw = evalExpr(callArg(node.args, 2, ["sort_field"]), env);
+  return sortFieldValue(raw);
+}
+
 function formatRunError(err: unknown): string {
   if (err instanceof Error) {
     const msg = (err.message || err.name || "runtime error").split("\n")[0]!.trim();
@@ -1865,7 +2365,185 @@ function formatRunError(err: unknown): string {
 }
 
 function isPlainInputs(extra: RuntimeOptions | InputOverrides): extra is InputOverrides {
-  return !("inputs" in extra) && !("broker" in extra) && !("timeframe" in extra) && !("libraries" in extra);
+  return (
+    !("inputs" in extra) &&
+    !("broker" in extra) &&
+    !("timeframe" in extra) &&
+    !("libraries" in extra) &&
+    !("mode" in extra) &&
+    !("timeout_seconds" in extra)
+  );
+}
+
+function resolveLibraries(libs?: LibraryRegistry | LibrarySourceSpec[] | null): LibraryRegistry {
+  if (libs instanceof LibraryRegistry) return libs;
+  const reg = new LibraryRegistry();
+  if (libs == null) return reg;
+  for (const lib of libs) {
+    if (lib == null || typeof lib !== "object") continue;
+    const ns = String(lib.namespace ?? "");
+    const name = String(lib.name ?? "");
+    const source = String(lib.source ?? "");
+    const rawVer = lib.version;
+    const ver = typeof rawVer === "number" && Number.isFinite(rawVer) ? Math.trunc(rawVer) : 1;
+    if (ns && name && source) reg.registerSource(ns, name, ver, source);
+  }
+  return reg;
+}
+
+function emptyCompileResult(
+  n: number,
+  error: string,
+  extra?: Pick<RuntimeResult, "auto_backend" | "compile_fallback_reason">,
+): RuntimeResult {
+  return {
+    series: {},
+    plots: [],
+    plot_meta: [],
+    count: n,
+    script_name: null,
+    script_type: "indicator",
+    mode: "compile",
+    error,
+    error_kind: "compile",
+    ...extra,
+  };
+}
+
+function barsToColumns(ohlcv: OHLCVBar[]): {
+  open: Array<number | null>;
+  high: Array<number | null>;
+  low: Array<number | null>;
+  close: Array<number | null>;
+  volume: Array<number | null>;
+  time: Array<number | null>;
+} {
+  const n = ohlcv.length;
+  const open: Array<number | null> = new Array(n);
+  const high: Array<number | null> = new Array(n);
+  const low: Array<number | null> = new Array(n);
+  const close: Array<number | null> = new Array(n);
+  const volume: Array<number | null> = new Array(n);
+  const time: Array<number | null> = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const b = ohlcv[i]!;
+    const c = b.close ?? null;
+    close[i] = c;
+    open[i] = b.open ?? c;
+    high[i] = b.high ?? c;
+    low[i] = b.low ?? c;
+    volume[i] = b.volume ?? 1;
+    time[i] = b.time ?? i * 60_000;
+  }
+  return { open, high, low, close, volume, time };
+}
+
+function packCompiled(
+  source: string,
+  ohlcv: OHLCVBar[],
+  inputs?: InputOverrides,
+  libraries?: LibraryRegistry,
+): RuntimeResult {
+  const compiled = compileScript(source, {
+    getLibrary: (ns, name, ver) => libraries?.getSource(ns, name, ver) ?? null,
+  });
+  const cols = barsToColumns(ohlcv);
+  // compileScript().run() is the raw dict (engine CompileHostResult may already strip).
+  const raw = compiled.run(cols.open, cols.high, cols.low, cols.close, cols.volume, cols.time, {
+    inputs,
+  }) as Record<
+    string,
+    unknown
+  > & {
+    __events?: StrategyEvent[];
+    __fills?: Array<{ bar: number; id: string; side: "buy" | "sell"; qty: number; price: number; type?: "fill" }>;
+    __position_size?: number;
+    __netprofit?: number;
+    __equity?: number;
+    __strategy?: StrategySummary;
+    __drawings?: DrawingEvent[];
+    __logs?: LogRecord[];
+  };
+  const events = raw.__events;
+  const fillsIn = raw.__fills;
+  const strategy = raw.__strategy;
+  const drawings = raw.__drawings;
+  const logs = raw.__logs;
+  const series: Record<string, Array<number | null>> = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (key.startsWith("__")) continue;
+    series[key] = value as Array<number | null>;
+  }
+  const plot_meta = compiled.plots;
+  const first = plot_meta[0]?.title;
+  return {
+    series,
+    plots: first != null ? (series[first] ?? []) : [],
+    plot_meta,
+    count: ohlcv.length,
+    script_name: null,
+    script_type: events != null || strategy != null ? "strategy" : "indicator",
+    mode: "compile",
+    ...(events != null ? { events } : {}),
+    ...(fillsIn != null
+      ? {
+          fills: fillsIn.map((f) =>
+            f.type === "fill" ? (f as RuntimeFill) : { type: "fill" as const, ...f },
+          ),
+        }
+      : {}),
+    ...(strategy != null ? { strategy } : {}),
+    ...(drawings != null ? { drawings } : {}),
+    ...(logs != null ? { logs } : {}),
+  };
+}
+
+function runCompiled(
+  source: string,
+  ohlcv: OHLCVBar[],
+  host: { inputs?: InputOverrides; libraries?: LibraryRegistry },
+): RuntimeResult {
+  const elig = compileEligible(source);
+  if (!elig.ok) return emptyCompileResult(ohlcv.length, elig.reason ?? "ineligible");
+  try {
+    return packCompiled(source, ohlcv, host.inputs, host.libraries);
+  } catch (err) {
+    const msg = err instanceof CompileError ? err.message : formatRunError(err);
+    return emptyCompileResult(ohlcv.length, msg);
+  }
+}
+
+function runAuto(
+  source: string,
+  tree: AST,
+  ohlcv: OHLCVBar[],
+  host: {
+    symbol?: string;
+    inputs?: InputOverrides;
+    broker?: BrokerSettings;
+    timeframe?: string | null;
+    libraries?: LibraryRegistry;
+    timeout_seconds?: number | null;
+  },
+): RuntimeResult {
+  const elig = compileEligible(source);
+  if (elig.ok) {
+    try {
+      const compiled = packCompiled(source, ohlcv, host.inputs, host.libraries);
+      compiled.auto_backend = "compile";
+      return compiled;
+    } catch (err) {
+      const reason = err instanceof CompileError ? err.message : formatRunError(err);
+      const out = interpretTree(tree, ohlcv, host);
+      out.auto_backend = "interpret";
+      out.compile_fallback_reason = reason;
+      return out;
+    }
+  }
+  const out = interpretTree(tree, ohlcv, host);
+  out.auto_backend = "interpret";
+  out.compile_fallback_reason = elig.reason;
+  return out;
 }
 
 function mergeInputs(
@@ -1899,6 +2577,16 @@ 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;
+  env.alertFireBars.set(key, env.barIndex);
+  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" };
+}
+
 function inputTitle(node: Call): string | null {
   const named = namedStringArg(node.args, "title");
   if (named != null) return named;
@@ -1986,6 +2674,153 @@ function evalStrategyRiskCall(fname: string | null, node: Call, env: Env): Value
   return undefined;
 }
 
+function evalStrategyAttr(node: Attribute, env: Env): Value | undefined {
+  const path = attrPath(node);
+  if (path == null || !path.startsWith("strategy.")) return undefined;
+  return strategySeriesValue(path, env);
+}
+
+/** Zero-arg `strategy.*` series / constants, plus identity FX stubs. */
+function evalStrategySeriesCall(fname: string | null, node: Call, env: Env): Value | undefined {
+  if (fname == null || !fname.startsWith("strategy.")) return undefined;
+  if (fname === "strategy.convert_to_account" || fname === "strategy.convert_to_symbol") {
+    const arg = callArg(node.args, 0, ["value"]);
+    if (arg == null) return 1;
+    return unwrap(evalExpr(arg, env));
+  }
+  if (fname === "strategy.default_entry_qty") {
+    const arg = callArg(node.args, 0, ["percent_equity"]);
+    const pct = arg == null ? 100 : unwrap(evalExpr(arg, env));
+    if (pct == null || !Number.isFinite(pct)) return NA;
+    return (env.book.initialCapital * (pct / 100)) / 100;
+  }
+  if (fname === "strategy.opentrades.capital_held") return env.book.capitalHeld();
+  return strategySeriesValue(fname, env);
+}
+
+function strategySeriesValue(path: string, env: Env): Value | undefined {
+  const book = env.book;
+  const mark = num(env.ctx.close) ?? 0;
+  switch (path) {
+    case "strategy.long":
+    case "strategy.direction.long":
+      return "long";
+    case "strategy.short":
+    case "strategy.direction.short":
+      return "short";
+    case "strategy.direction.all":
+      return "all";
+    case "strategy.position_size":
+      return book.position.qty;
+    case "strategy.position_avg_price":
+      return book.position.avgPrice;
+    case "strategy.position_entry_name":
+      return book.position_entry_name;
+    case "strategy.netprofit":
+      return book.netprofit();
+    case "strategy.openprofit":
+      return book.openprofit(mark);
+    case "strategy.equity":
+      return book.equity(mark);
+    case "strategy.opentrades":
+      return book.opentrades;
+    case "strategy.closedtrades":
+      return book.closedtrades;
+    case "strategy.closedtrades.first_index":
+      return book.closedtrades_first_index;
+    case "strategy.wintrades":
+      return book.wintrades;
+    case "strategy.losstrades":
+      return book.losstrades;
+    case "strategy.eventrades":
+      return book.eventrades;
+    case "strategy.grossprofit":
+      return book.grossprofit;
+    case "strategy.grossloss":
+      return book.grossloss;
+    case "strategy.avg_trade":
+      return book.avgTrade();
+    case "strategy.avg_winning_trade":
+      return book.avgWinningTrade();
+    case "strategy.avg_losing_trade":
+      return book.avgLosingTrade();
+    case "strategy.netprofit_percent":
+      return book.netprofitPercent(mark);
+    case "strategy.openprofit_percent":
+      return book.openprofitPercent(mark);
+    case "strategy.grossprofit_percent":
+      return book.grossprofitPercent();
+    case "strategy.grossloss_percent":
+      return book.grosslossPercent();
+    case "strategy.avg_trade_percent":
+      return book.avgTradePercent();
+    case "strategy.avg_winning_trade_percent":
+      return book.avgWinningTradePercent();
+    case "strategy.avg_losing_trade_percent":
+      return book.avgLosingTradePercent();
+    case "strategy.max_drawdown":
+      return book.maxDrawdown();
+    case "strategy.max_drawdown_percent":
+      return book.maxDrawdownPercent();
+    case "strategy.max_runup":
+      return book.maxRunup();
+    case "strategy.max_runup_percent":
+      return book.maxRunupPercent();
+    case "strategy.percent_profitable":
+    case "strategy.winrate":
+      return book.percentProfitable();
+    case "strategy.profitfactor":
+    case "strategy.profit_factor":
+      return book.profitFactor();
+    case "strategy.initial_capital":
+      return book.initialCapital;
+    case "strategy.commission":
+      return 0;
+    case "strategy.cash":
+      return strategyCashAmount(book.cash(mark));
+    case "strategy.fixed":
+      return "fixed";
+    case "strategy.percent_of_equity":
+      return "percent_of_equity";
+    case "strategy.leverage":
+      return book.leverage;
+    case "strategy.margin_liquidation_price":
+      return book.marginLiquidationPrice();
+    case "strategy.avg_price_stock":
+      return "stock";
+    case "strategy.avg_price_futures":
+      return "futures";
+    case "strategy.avg_price_inverse":
+      return "inverse";
+    case "strategy.account_currency":
+      return book.account_currency;
+    case "strategy.default_entry_qty":
+      return (book.initialCapital * (100 / 100)) / 100;
+    case "strategy.max_contracts_held_all":
+      return book.maxContractsHeldAll();
+    case "strategy.max_contracts_held_long":
+      return book.maxContractsHeldLong();
+    case "strategy.max_contracts_held_short":
+      return book.maxContractsHeldShort();
+    case "strategy.opentrades.capital_held":
+      return book.capitalHeld();
+    case "strategy.oca.none":
+      return "none";
+    case "strategy.oca.cancel":
+      return "cancel";
+    case "strategy.oca.reduce":
+      return "reduce";
+    case "strategy.commission.percent":
+      return "percent";
+    case "strategy.commission.cash_per_order":
+      return "cash_per_order";
+    case "strategy.commission.cash_per_contract":
+      return "cash_per_contract";
+    default:
+      return undefined;
+  }
+}
+
 function evalStrategyTradeCall(fname: string | null, node: Call, env: Env): Value | undefined {
   if (fname == null || !fname.startsWith("strategy.")) return undefined;
   const idx = unwrap(evalExpr(callArg(node.args, 0, ["trade_num", "trade_index", "index"]), env));
@@ -1994,32 +2829,54 @@ function evalStrategyTradeCall(fname: string | null, node: Call, env: Env): Valu
   const book = env.book;
   switch (fname) {
     case "strategy.closedtrades.entry_bar_index":
-      return book.closedEntryBar(i);
+      return book.closedEntryBar(i) ?? 0;
     case "strategy.closedtrades.entry_price":
-      return book.closedEntryPrice(i);
+      return book.closedEntryPrice(i) ?? 0;
     case "strategy.closedtrades.exit_bar_index":
-      return book.closedExitBar(i);
+      return book.closedExitBar(i) ?? 0;
     case "strategy.closedtrades.exit_price":
-      return book.closedExitPrice(i);
+      return book.closedExitPrice(i) ?? 0;
     case "strategy.closedtrades.profit":
-      return book.closedProfit(i);
+      return book.closedProfit(i) ?? 0;
     case "strategy.closedtrades.size":
-      return book.closedSize(i);
+      return book.closedSize(i) ?? 0;
     case "strategy.closedtrades.entry_id":
     case "strategy.closedtrades.exit_id":
-      return book.closedId(i);
+      return book.closedId(i) ?? "";
     case "strategy.closedtrades.commission":
-      return book.closedCommission(i);
+      return book.closedCommission(i) ?? 0;
+    case "strategy.closedtrades.entry_time":
+      return book.closedEntryTime(i);
+    case "strategy.closedtrades.exit_time":
+      return book.closedExitTime(i);
+    case "strategy.closedtrades.entry_comment":
+      return book.closedEntryComment(i);
+    case "strategy.closedtrades.exit_comment":
+      return book.closedExitComment(i);
+    case "strategy.closedtrades.max_drawdown":
+      return book.closedMaxDrawdown(i);
+    case "strategy.closedtrades.max_runup":
+      return book.closedMaxRunup(i);
     case "strategy.opentrades.entry_bar_index":
-      return book.openEntryBar(i);
+      return book.openEntryBar(i) ?? 0;
     case "strategy.opentrades.entry_price":
-      return book.openEntryPrice(i);
+      return book.openEntryPrice(i) ?? 0;
     case "strategy.opentrades.size":
-      return book.openSize(i);
+      return book.openSize(i) ?? 0;
     case "strategy.opentrades.entry_id":
-      return book.openId(i);
+      return book.openId(i) ?? "";
     case "strategy.opentrades.profit":
-      return book.openProfit(i, mark);
+      return book.openProfit(i, mark) ?? 0;
+    case "strategy.opentrades.entry_time":
+      return book.openEntryTime(i);
+    case "strategy.opentrades.entry_comment":
+      return book.openEntryComment(i);
+    case "strategy.opentrades.commission":
+      return book.openCommission(i);
+    case "strategy.opentrades.max_drawdown":
+      return book.openMaxDrawdown(i);
+    case "strategy.opentrades.max_runup":
+      return book.openMaxRunup(i);
     default:
       return undefined;
   }
@@ -2039,7 +2896,12 @@ function evalRequestSecurity(node: Call, env: Env): Cell {
 }
 
 function evalRequestCall(fname: string, node: Call, env: Env): Cell {
-  if (fname === "request.security" || fname === "request.security_lower_tf") {
+  if (
+    fname === "request.security" ||
+    fname === "request.security_lower_tf" ||
+    fname === "security" ||
+    fname === "security_lower_tf"
+  ) {
     return evalRequestSecurity(node, env);
   }
   const host = { symbol: env.symbol, timeframe: env.timeframe };
@@ -2097,7 +2959,7 @@ function evalMathCall(fname: string | null, node: Call, env: Env): Cell | undefi
   if (fname === "math.todegrees") return mathToDegrees(cellArg(node, env, 0, ["radians", "x"]));
   if (fname === "math.toradians") return mathToRadians(cellArg(node, env, 0, ["degrees", "x"]));
   if (fname === "math.isfinite") return mathIsFinite(cellArg(node, env, 0, ["number", "x"]));
-  if (fname === "math.random") {
+  if (fname === "math.random" || fname === "random") {
     const a0 = callArg(node.args, 0, ["min"]);
     const a1 = callArg(node.args, 1, ["max"]);
     return mathRandom(
@@ -2105,7 +2967,7 @@ function evalMathCall(fname: string | null, node: Call, env: Env): Cell | undefi
       a1 == null ? undefined : unwrap(evalExpr(a1, env)),
     );
   }
-  if (fname === "math.round_to_mintick") {
+  if (fname === "math.round_to_mintick" || fname === "round_to_mintick") {
     const tick = typeof env.ctx["syminfo.mintick"] === "number" ? (env.ctx["syminfo.mintick"] as number) : 0.01;
     return mathRoundToMintick(cellArg(node, env, 0, ["number", "x"]), tick);
   }
@@ -2120,6 +2982,37 @@ function allCellArgs(node: Call, env: Env): Cell[] {
   return asArgs(node.args).map((a) => unwrap(evalExpr(a.value, env)));
 }
 
+/**
+ * Python `_is_period_like` (pynescript core.py ~3427) at the cell level: only
+ * whole numbers are period-like (7.0 → 7; 7.5 / na / non-numbers fail). TA
+ * handlers gate period-only / period-first overload forms on this check — a
+ * non-period-like length arg is IGNORED and the call behaves exactly as if
+ * the arg were absent (builtin default or na-period path; same call-site
+ * state key/reset behavior). Returns null when the arg must be treated as
+ * absent; a passing whole number is returned as-is.
+ */
+function periodLikeCell(v: Cell): number | null {
+  return typeof v === "number" && Number.isInteger(v) ? v : null;
+}
+
+/** `periodLikeCell` over call arg *index* (positional or kwarg *names*). */
+function periodLikeArg(node: Call, env: Env, index: number, names: string[]): number | null {
+  return periodLikeCell(unwrap(evalExpr(callArg(node.args, index, names), env)));
+}
+
+/** Positional (non-kwarg) argument count — detects period-only/period-first forms. */
+function positionalCount(node: Call): number {
+  return asArgs(node.args).filter((a) => argKeyword(a) == null).length;
+}
+
+/** True when a keyword argument named one of *names* is present. */
+function hasKwarg(node: Call, names: string[]): boolean {
+  return asArgs(node.args).some((a) => {
+    const kw = argKeyword(a);
+    return kw != null && names.includes(kw);
+  });
+}
+
 function lenOrDefault(
   node: Call,
   env: Env,
@@ -2139,10 +3032,31 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   const ta = env.ta as TaAny;
   if (fname === "ta.highest" || fname === "highest") {
     if (typeof ta.highest !== "function") return NA;
+    if (positionalCount(node) <= 1 && !hasKwarg(node, ["source", "series"])) {
+      // Python 1-arg period-only form (basic.py:222-233 via _expect_series
+      // allow_period_only): source defaults to the context high series and
+      // the length gates on _is_period_like → non-period-like → na period 0.
+      return (ta.highest as TaEngine["highest"]).call(
+        env.ta,
+        site,
+        num(env.ctx.high),
+        periodLikeArg(node, env, 0, ["length"]) ?? 0,
+      );
+    }
     return (ta.highest as TaEngine["highest"]).call(env.ta, site, srcArg(node, env), lenArg(node, env, 1));
   }
   if (fname === "ta.lowest" || fname === "lowest") {
     if (typeof ta.lowest !== "function") return NA;
+    if (positionalCount(node) <= 1 && !hasKwarg(node, ["source", "series"])) {
+      // Python 1-arg period-only form (basic.py:235-246): source defaults to
+      // the context low series; length gated like ta.highest.
+      return (ta.lowest as TaEngine["lowest"]).call(
+        env.ta,
+        site,
+        num(env.ctx.low),
+        periodLikeArg(node, env, 0, ["length"]) ?? 0,
+      );
+    }
     return (ta.lowest as TaEngine["lowest"]).call(env.ta, site, srcArg(node, env), lenArg(node, env, 1));
   }
   if (fname === "ta.stdev" || fname === "stdev") {
@@ -2194,6 +3108,20 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   if (fname === "ta.bb" || fname === "bb") {
     if (typeof ta.bb !== "function") return NA;
+    if (
+      positionalCount(node) === 2 &&
+      !hasKwarg(node, ["source", "series"]) &&
+      periodLikeArg(node, env, 0, ["source", "series", "length"]) != null
+    ) {
+      // Python period-first form (basic.py:394-401): (length, mult) with the
+      // series defaulting to the context close. Dispatch gates slot 0 on
+      // _is_period_like, so a series first slot stays on the 3-arg form.
+      const length = periodLikeArg(node, env, 0, ["source", "series", "length"])!;
+      const multRaw = unwrap(evalExpr(callArg(node.args, 1, ["mult", "multiplier"]), env));
+      const mult = typeof multRaw === "number" && Number.isFinite(multRaw) ? multRaw : Number.NaN;
+      const r = (ta.bb as TaEngine["bb"]).call(env.ta, site, num(env.ctx.close), length, mult);
+      return tupleOf([r.mid, r.up, r.lo]);
+    }
     const r = (ta.bb as TaEngine["bb"]).call(
       env.ta,
       site,
@@ -2227,6 +3155,29 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   if (fname === "ta.vwma" || fname === "vwma") {
     if (typeof ta.vwma !== "function") return NA;
+    if (positionalCount(node) <= 1 && !hasKwarg(node, ["volume"])) {
+      // Python 1-arg period-only form (basic.py:80-88): close + volume from
+      // the chart context; length gates on _is_period_like → non-period-like
+      // → na period 0.
+      return (ta.vwma as TaEngine["vwma"]).call(
+        env.ta,
+        site,
+        num(env.ctx.close),
+        num(env.ctx.volume),
+        periodLikeArg(node, env, 0, ["length"]) ?? 0,
+      );
+    }
+    if (positionalCount(node) >= 3 || hasKwarg(node, ["volume"])) {
+      // Python 3-arg community form (basic.py:89-100): (source, volume,
+      // length). A period-like middle slot swaps volume back to the context
+      // series (basic.py:93/97) — cells are last samples, mirroring
+      // _is_period_like's series-last-sample check.
+      const periodRaw = unwrap(evalExpr(callArg(node.args, 2, ["length", "period"]), env));
+      const period = typeof periodRaw === "number" && Number.isFinite(periodRaw) ? periodRaw : 0;
+      const volLike = periodLikeArg(node, env, 1, ["volume"]) != null;
+      const vol = volLike ? num(env.ctx.volume) : unwrap(evalExpr(callArg(node.args, 1, ["volume"]), env));
+      return (ta.vwma as TaEngine["vwma"]).call(env.ta, site, srcArg(node, env), vol, period);
+    }
     return (ta.vwma as TaEngine["vwma"]).call(
       env.ta,
       site,
@@ -2237,21 +3188,43 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   if (fname === "ta.cci" || fname === "cci") {
     if (typeof ta.cci !== "function") return NA;
-    const h = num(env.ctx.high);
-    const l = num(env.ctx.low);
-    const c = srcArg(node, env);
-    const tp = h != null && l != null && c != null ? (h + l + c) / 3 : c;
-    return (ta.cci as TaEngine["cci"]).call(env.ta, site, tp, lenArg(node, env, 1));
+    if (positionalCount(node) >= 4) {
+      // Python legacy 4-arg form (oscillators.py:178-187): typical price of
+      // the given (high, low, close) series.
+      const h = unwrap(evalExpr(callArg(node.args, 0, ["high"]), env));
+      const l = unwrap(evalExpr(callArg(node.args, 1, ["low"]), env));
+      const c = unwrap(evalExpr(callArg(node.args, 2, ["close"]), env));
+      const tp = h != null && l != null && c != null ? (h + l + c) / 3 : c;
+      return (ta.cci as TaEngine["cci"]).call(env.ta, site, tp, lenArg(node, env, 3));
+    }
+    if (positionalCount(node) <= 1 && !hasKwarg(node, ["source", "series"])) {
+      // Python 1-arg period-only form (oscillators.py:159-171): typical price
+      // from the context high/low/close (hlc3 fallback); length gates on
+      // _is_period_like → non-period-like → na period 0.
+      return (ta.cci as TaEngine["cci"]).call(
+        env.ta,
+        site,
+        hlc3(env),
+        periodLikeArg(node, env, 0, ["length"]) ?? 0,
+      );
+    }
+    // Python 2-arg form (oscillators.py:172-177): CCI over the source itself
+    // (_cci(series, series, series, period) → tp = series). SoT correction:
+    // the previous blend of context high/low into the source matched no
+    // Python dispatch arm.
+    return (ta.cci as TaEngine["cci"]).call(env.ta, site, srcArg(node, env), lenArg(node, env, 1));
   }
   if (fname === "ta.wpr" || fname === "wpr") {
     if (typeof ta.willr !== "function") return NA;
+    // Python 1-arg period-only form gates length via _is_period_like
+    // (oscillators.py ~198): non-period-like → ignored → na period 0.
     return (ta.willr as TaEngine["willr"]).call(
       env.ta,
       site,
       num(env.ctx.high),
       num(env.ctx.low),
       num(env.ctx.close),
-      lenArg(node, env, 0),
+      periodLikeArg(node, env, 0, ["length"]) ?? 0,
     );
   }
   if (fname === "ta.willr" || fname === "willr") {
@@ -2262,28 +3235,41 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
       num(env.ctx.high),
       num(env.ctx.low),
       num(env.ctx.close),
-      lenArg(node, env, 0),
+      periodLikeArg(node, env, 0, ["length"]) ?? 0,
     );
   }
   if (fname === "ta.stoch" || fname === "stoch") {
     if (typeof ta.stoch !== "function") return NA;
     const positional = asArgs(node.args).filter((a) => argKeyword(a) == null);
-    const highArg = callArg(node.args, 1, ["high"]);
-    if (highArg == null && positional.length <= 1) {
+    if (!hasKwarg(node, ["high"]) && positional.length <= 2) {
+      let length: number;
+      if (positional.length === 2) {
+        // Python 2-arg community form (kLength, dPeriod) — both slots gate on
+        // _is_period_like (oscillators.py:73-78); dPeriod is ignored and %K
+        // is returned over the context close/high/low.
+        const k = periodLikeArg(node, env, 0, ["length"]);
+        const d = periodLikeArg(node, env, 1, ["d", "smooth"]);
+        length = k != null && d != null ? k : 0;
+      } else {
+        // Python 1-arg period-only form gates length via _is_period_like
+        // (oscillators.py ~58): non-period-like → ignored → na period 0.
+        length = periodLikeArg(node, env, 0, ["length"]) ?? 0;
+      }
       return (ta.stoch as TaEngine["stoch"]).call(
         env.ta,
         site,
         num(env.ctx.close),
         num(env.ctx.high),
         num(env.ctx.low),
-        lenArg(node, env, 0),
+        length,
       );
     }
+    // reference Pine form: source, high, low, length
     return (ta.stoch as TaEngine["stoch"]).call(
       env.ta,
       site,
       srcArg(node, env),
-      unwrap(evalExpr(highArg, env)),
+      unwrap(evalExpr(callArg(node.args, 1, ["high"]), env)),
       unwrap(evalExpr(callArg(node.args, 2, ["low"]), env)),
       lenArg(node, env, 3),
     );
@@ -2351,6 +3337,16 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   if (fname === "ta.highestbars" || fname === "highestbars") {
     if (typeof ta.highestbars !== "function") return NA;
+    if (positionalCount(node) <= 1 && !hasKwarg(node, ["source", "series"])) {
+      // Python 1-arg period-only form (basic.py:248-269): source defaults to
+      // the context high series; length gates on _is_period_like.
+      return (ta.highestbars as TaEngine["highestbars"]).call(
+        env.ta,
+        site,
+        num(env.ctx.high),
+        periodLikeArg(node, env, 0, ["length"]) ?? 0,
+      );
+    }
     return (ta.highestbars as TaEngine["highestbars"]).call(
       env.ta,
       site,
@@ -2360,6 +3356,16 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   if (fname === "ta.lowestbars" || fname === "lowestbars") {
     if (typeof ta.lowestbars !== "function") return NA;
+    if (positionalCount(node) <= 1 && !hasKwarg(node, ["source", "series"])) {
+      // Python 1-arg period-only form (basic.py:271-291): source defaults to
+      // the context low series; length gates like ta.highestbars.
+      return (ta.lowestbars as TaEngine["lowestbars"]).call(
+        env.ta,
+        site,
+        num(env.ctx.low),
+        periodLikeArg(node, env, 0, ["length"]) ?? 0,
+      );
+    }
     return (ta.lowestbars as TaEngine["lowestbars"]).call(
       env.ta,
       site,
@@ -2416,7 +3422,21 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   if (fname === "ta.pivothigh" || fname === "pivothigh") {
     if (typeof ta.pivothigh !== "function") return NA;
-    return (ta.pivothigh as TaEngine["pivothigh"]).call(
+    if (
+      positionalCount(node) === 2 &&
+      !hasKwarg(node, ["source", "series"]) &&
+      periodLikeArg(node, env, 0, ["leftbars", "left"]) != null &&
+      periodLikeArg(node, env, 1, ["rightbars", "right"]) != null
+    ) {
+      // Python period-first form (basic.py:1007-1010): both slots gate on
+      // _is_period_like and the source defaults to the context high series.
+      // A non-period-like slot errors in Python; the repo gated-form
+      // convention treats it as absent → the call falls through to na.
+      const left = periodLikeArg(node, env, 0, ["leftbars", "left"])!;
+      const right = periodLikeArg(node, env, 1, ["rightbars", "right"])!;
+      return (ta.pivothigh as TaEngine["pivothigh"]).call(env.ta, site, num(env.ctx.high), left, right);
+    }
+    return (ta.pivothigh as TaEngine["pivothigh"]).call(
       env.ta,
       site,
       srcArg(node, env),
@@ -2426,6 +3446,18 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   if (fname === "ta.pivotlow" || fname === "pivotlow") {
     if (typeof ta.pivotlow !== "function") return NA;
+    if (
+      positionalCount(node) === 2 &&
+      !hasKwarg(node, ["source", "series"]) &&
+      periodLikeArg(node, env, 0, ["leftbars", "left"]) != null &&
+      periodLikeArg(node, env, 1, ["rightbars", "right"]) != null
+    ) {
+      // Python period-first form (basic.py:1036-1039): source defaults to
+      // the context low series; slot gating mirrors ta.pivothigh.
+      const left = periodLikeArg(node, env, 0, ["leftbars", "left"])!;
+      const right = periodLikeArg(node, env, 1, ["rightbars", "right"])!;
+      return (ta.pivotlow as TaEngine["pivotlow"]).call(env.ta, site, num(env.ctx.low), left, right);
+    }
     return (ta.pivotlow as TaEngine["pivotlow"]).call(
       env.ta,
       site,
@@ -2442,6 +3474,8 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
     if (typeof ta.mfi !== "function") return NA;
     const positional = asArgs(node.args).filter((a) => a.name == null);
     if (positional.length <= 1) {
+      // Python 1-arg period-only form gates length via _is_period_like
+      // (volume.py ~108): non-period-like → ignored → na period 0.
       return (ta.mfi as TaEngine["mfi"]).call(
         env.ta,
         site,
@@ -2449,7 +3483,7 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
         num(env.ctx.low),
         num(env.ctx.close),
         num(env.ctx.volume),
-        lenArg(node, env, 0),
+        periodLikeArg(node, env, 0, ["length"]) ?? 0,
       );
     }
     if (positional.length === 2) {
@@ -2500,13 +3534,44 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   if (fname === "ta.adx" || fname === "adx") {
     if (typeof ta.adx !== "function") return NA;
+    if (positionalCount(node) >= 4) {
+      // Python legacy 4-arg form (common.py:718-726): (high, low, close,
+      // length) with explicit series.
+      return (ta.adx as TaEngine["adx"]).call(
+        env.ta,
+        site,
+        srcArg(node, env),
+        unwrap(evalExpr(callArg(node.args, 1, ["low"]), env)),
+        unwrap(evalExpr(callArg(node.args, 2, ["close"]), env)),
+        lenArg(node, env, 3),
+      );
+    }
+    if (positionalCount(node) === 2 && !hasKwarg(node, ["high", "low", "close"])) {
+      // Python 2-arg form (diLength, adxSmoothing) (common.py:709-717): both
+      // slots gate on _is_period_like and the ADX period is the SECOND slot —
+      // diLength is accepted but unused by the kernel dispatch. A
+      // non-period-like slot → treated as absent → default 14 (same
+      // convention as the 1-arg form below).
+      const di = periodLikeArg(node, env, 0, ["diLength", "length"]);
+      const smooth = periodLikeArg(node, env, 1, ["adxSmoothing", "adxlen"]);
+      return (ta.adx as TaEngine["adx"]).call(
+        env.ta,
+        site,
+        num(env.ctx.high),
+        num(env.ctx.low),
+        num(env.ctx.close),
+        di != null && smooth != null ? smooth : 14,
+      );
+    }
+    // Python 1-arg period-only form gates length via _is_period_like
+    // (common.py ~701): non-period-like → ignored → default 14 (as absent).
     return (ta.adx as TaEngine["adx"]).call(
       env.ta,
       site,
       num(env.ctx.high),
       num(env.ctx.low),
       num(env.ctx.close),
-      lenOrDefault(node, env, 0, ["length"], 14),
+      periodLikeArg(node, env, 0, ["length"]) ?? 14,
     );
   }
   if (fname === "ta.correlation" || fname === "correlation") {
@@ -2537,12 +3602,15 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
     if (typeof ta.tsi !== "function") return NA;
     const positional = asArgs(node.args).filter((a) => a.name == null);
     if (positional.length === 2) {
+      // Python 2-arg period-first form gates BOTH slots via _is_period_like
+      // (oscillators.py ~299): args[0]=short, args[1]=long; a non-period-like
+      // slot is ignored → TS default (13/25), as if the slot were absent.
       return (ta.tsi as TaEngine["tsi"]).call(
         env.ta,
         site,
         num(env.ctx.close),
-        lenOrDefault(node, env, 1, ["long", "long_length"], 25),
-        lenOrDefault(node, env, 0, ["short", "short_length"], 13),
+        periodLikeArg(node, env, 1, ["long", "long_length"]) ?? 25,
+        periodLikeArg(node, env, 0, ["short", "short_length"]) ?? 13,
       );
     }
     return (ta.tsi as TaEngine["tsi"]).call(
@@ -2651,27 +3719,47 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
       num(env.ctx.volume),
     );
   }
-  if (fname === "ta.pvt" || fname === "pvt") {
+  if (fname === "ta.pvt" || fname === "pvt" || fname === "ta.vpt" || fname === "vpt") {
     if (typeof ta.pvt !== "function") return NA;
     return (ta.pvt as TaEngine["pvt"]).call(env.ta, site, num(env.ctx.close), num(env.ctx.volume));
   }
   if (fname === "ta.wad" || fname === "wad") {
     if (typeof ta.wad !== "function") return NA;
+    const positional = asArgs(node.args).filter((a) => argKeyword(a) == null);
+    if (positional.length >= 4) {
+      return (ta.wad as TaEngine["wad"]).call(
+        env.ta,
+        site,
+        unwrap(evalExpr(callArg(node.args, 0, ["high"]), env)),
+        unwrap(evalExpr(callArg(node.args, 1, ["low"]), env)),
+        unwrap(evalExpr(callArg(node.args, 2, ["close"]), env)),
+        unwrap(evalExpr(callArg(node.args, 3, ["volume"]), env)),
+      );
+    }
     return (ta.wad as TaEngine["wad"]).call(
       env.ta,
       site,
       num(env.ctx.high),
       num(env.ctx.low),
       num(env.ctx.close),
+      num(env.ctx.volume),
     );
   }
   if (fname === "ta.nvi" || fname === "nvi") {
     if (typeof ta.nvi !== "function") return NA;
-    return (ta.nvi as TaEngine["nvi"]).call(env.ta, site, num(env.ctx.close), num(env.ctx.volume));
+    const cArg = callArg(node.args, 0, ["source", "close"]);
+    const vArg = callArg(node.args, 1, ["volume"]);
+    const close = cArg == null ? num(env.ctx.close) : unwrap(evalExpr(cArg, env));
+    const volume = vArg == null ? num(env.ctx.volume) : unwrap(evalExpr(vArg, env));
+    return (ta.nvi as TaEngine["nvi"]).call(env.ta, site, close, volume);
   }
   if (fname === "ta.pvi" || fname === "pvi") {
     if (typeof ta.pvi !== "function") return NA;
-    return (ta.pvi as TaEngine["pvi"]).call(env.ta, site, num(env.ctx.close), num(env.ctx.volume));
+    const cArg = callArg(node.args, 0, ["source", "close"]);
+    const vArg = callArg(node.args, 1, ["volume"]);
+    const close = cArg == null ? num(env.ctx.close) : unwrap(evalExpr(cArg, env));
+    const volume = vArg == null ? num(env.ctx.volume) : unwrap(evalExpr(vArg, env));
+    return (ta.pvi as TaEngine["pvi"]).call(env.ta, site, close, volume);
   }
   if (fname === "ta.iii" || fname === "iii") {
     if (typeof ta.iii !== "function") return NA;
@@ -2686,16 +3774,98 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   if (fname === "ta.wvad" || fname === "wvad") {
     if (typeof ta.wvad !== "function") return NA;
+    const positional = asArgs(node.args).filter((a) => argKeyword(a) == null);
+    if (positional.length >= 4) {
+      return (ta.wvad as TaEngine["wvad"]).call(
+        env.ta,
+        site,
+        unwrap(evalExpr(callArg(node.args, 0, ["high"]), env)),
+        unwrap(evalExpr(callArg(node.args, 1, ["low"]), env)),
+        unwrap(evalExpr(callArg(node.args, 2, ["close"]), env)),
+        unwrap(evalExpr(callArg(node.args, 3, ["volume"]), env)),
+        lenOrDefault(node, env, 4, ["length", "period"], 20),
+      );
+    }
     return (ta.wvad as TaEngine["wvad"]).call(
       env.ta,
       site,
-      num(env.ctx.open),
       num(env.ctx.high),
       num(env.ctx.low),
       num(env.ctx.close),
       num(env.ctx.volume),
+      // Python 1-arg period-only form gates length via _is_period_like
+      // (volume.py ~586/~620): non-period-like → ignored → default 20 (0-arg
+      // fallback), exactly as if the arg were absent.
+      periodLikeArg(node, env, 0, ["length", "period"]) ?? 20,
+    );
+  }
+  if (fname === "ta.cmf" || fname === "cmf") {
+    if (typeof ta.cmf !== "function") return NA;
+    const positional = asArgs(node.args).filter((a) => argKeyword(a) == null);
+    if (positional.length >= 5) {
+      return (ta.cmf as TaEngine["cmf"]).call(
+        env.ta,
+        site,
+        unwrap(evalExpr(callArg(node.args, 1, ["high"]), env)),
+        unwrap(evalExpr(callArg(node.args, 2, ["low"]), env)),
+        unwrap(evalExpr(callArg(node.args, 0, ["close", "source"]), env)),
+        unwrap(evalExpr(callArg(node.args, 3, ["volume"]), env)),
+        lenOrDefault(node, env, 4, ["length", "period"], 20),
+      );
+    }
+    return (ta.cmf as TaEngine["cmf"]).call(
+      env.ta,
+      site,
+      num(env.ctx.high),
+      num(env.ctx.low),
+      num(env.ctx.close),
+      num(env.ctx.volume),
+      // Python 1-arg period-only form gates length via _is_period_like
+      // (volume.py ~659/~681): non-period-like → ignored → default 20, as
+      // if the arg were absent.
+      periodLikeArg(node, env, 0, ["length", "period"]) ?? 20,
     );
   }
+  if (fname === "ta.klinger" || fname === "klinger") {
+    if (typeof ta.klinger !== "function") return NA;
+    return (ta.klinger as TaEngine["klinger"]).call(
+      env.ta,
+      site,
+      unwrap(evalExpr(callArg(node.args, 2, ["close"]), env)),
+      unwrap(evalExpr(callArg(node.args, 3, ["volume"]), env)),
+      lenOrDefault(node, env, 4, ["fast_period", "fast", "fastlen"], 0),
+      lenOrDefault(node, env, 5, ["slow_period", "slow", "slowlen"], 0),
+    );
+  }
+  if (fname === "ta.ao" || fname === "ta.aroon") {
+    // Python parity (pynescript base.py / oscillators.py):
+    // "ao"/"aroon" are absent from _TA_KWARG_ORDERS and their handlers carry no
+    // _KWARG_ORDER, so kwargs fall through the legacy path of
+    // _merge_kwargs_into_args (base.py ~603): kwarg VALUES are appended
+    // positionally after the positional args, in kwarg iteration order —
+    // the names are ignored (ta.ao(slow=10) binds fast=10; ta.ao(len=8)
+    // binds fast=8; ta.aroon(3, length=5) binds length=3).
+    const list = asArgs(node.args);
+    const merged: Cell[] = [];
+    for (const a of list) {
+      if (argKeyword(a) == null) merged.push(unwrap(evalExpr(a.value, env)));
+    }
+    for (const a of list) {
+      if (argKeyword(a) != null) merged.push(unwrap(evalExpr(argValue(a), env)));
+    }
+    // Python handlers gate each length slot on _is_period_like (core.py ~3427):
+    // only whole numbers pass (7.0 → 7; 7.5 / bool / na / non-numbers fail).
+    // A non-period-like arg is IGNORED and the builtin default is used.
+    const periodLike = periodLikeCell;
+    if (fname === "ta.ao") {
+      const fast = merged.length >= 1 ? periodLike(merged[0]!) : null;
+      const slow = merged.length >= 2 ? periodLike(merged[1]!) : null;
+      return env.ta.ao(site, num(env.ctx.high), num(env.ctx.low), fast ?? 5, slow ?? 34);
+    }
+    const length = merged.length >= 1 ? periodLike(merged[0]!) : null;
+    const r = env.ta.aroon(site, num(env.ctx.high), num(env.ctx.low), length ?? 14);
+    return tupleOf([r.down, r.up]);
+  }
   if (fname === "ta.pivot_point_levels") {
     if (typeof ta.pivotPoints !== "function") return NA;
     const r = (ta.pivotPoints as TaEngine["pivotPoints"]).call(
@@ -2707,6 +3877,80 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
     );
     return tupleOf([r.pp, r.r1, r.s1, r.r2, r.s2]);
   }
+  if (fname === "ta.uo" || fname === "uo") {
+    return env.ta.uo(
+      site,
+      num(env.ctx.high),
+      num(env.ctx.low),
+      num(env.ctx.close),
+      lenArg(node, env, 0),
+      lenArg(node, env, 1),
+      lenArg(node, env, 2),
+    );
+  }
+  if (fname === "ta.rci" || fname === "rci") {
+    return env.ta.rci(site, srcArg(node, env), lenArg(node, env, 1));
+  }
+  if (fname === "ta.dpo" || fname === "dpo") {
+    return env.ta.dpo(site, num(env.ctx.close), lenArg(node, env, 0));
+  }
+  if (fname === "ta.kst" || fname === "kst") {
+    return env.ta.kst(
+      site,
+      num(env.ctx.close),
+      lenArg(node, env, 0),
+      lenArg(node, env, 1),
+      lenArg(node, env, 2),
+      lenArg(node, env, 3),
+    );
+  }
+  if (fname === "ta.stochrsi" || fname === "stochrsi") {
+    return env.ta.stochRsi(site, num(env.ctx.close), lenArg(node, env, 0), lenArg(node, env, 1));
+  }
+  if (fname === "ta.donchian" || fname === "donchian") {
+    return env.ta.donchian(site, num(env.ctx.high), num(env.ctx.low), lenArg(node, env, 0));
+  }
+  if (fname === "ta.ichimoku" || fname === "ichimoku") {
+    return env.ta.ichimoku(
+      site,
+      num(env.ctx.high),
+      num(env.ctx.low),
+      lenArg(node, env, 0),
+      lenArg(node, env, 1),
+    );
+  }
+  if (fname === "ta.bb_pct" || fname === "bb_pct") {
+    return env.ta.bbPct(
+      site,
+      num(env.ctx.close),
+      lenArg(node, env, 0),
+      numArg(node, env, 1, ["std_dev", "mult", "std"], 2),
+    );
+  }
+  if (fname === "ta.emv" || fname === "emv") {
+    return env.ta.emv(
+      site,
+      num(env.ctx.high),
+      num(env.ctx.low),
+      num(env.ctx.volume),
+      lenArg(node, env, 0),
+    );
+  }
+  if (fname === "ta.fractal" || fname === "fractal") {
+    return env.ta.fractal(site, num(env.ctx.high), num(env.ctx.low), lenArg(node, env, 0));
+  }
+  if (fname === "ta.atr_stop" || fname === "atr_stop") {
+    const atr = unwrap(evalExpr(callArg(node.args, 0, ["atr", "atr_value"]), env));
+    const multRaw = unwrap(evalExpr(callArg(node.args, 1, ["multiplier", "mult"]), env));
+    const mult = multRaw == null || !Number.isFinite(multRaw) ? 2 : multRaw;
+    return env.ta.atrStop(num(env.ctx.close), atr, mult);
+  }
+  if (fname === "ta.zigzag" || fname === "zigzag") {
+    const thRaw = unwrap(evalExpr(callArg(node.args, 1, ["threshold", "percent", "deviation"]), env));
+    const th = thRaw == null || !Number.isFinite(thRaw) ? 5 : thRaw;
+    const z = env.ta.zigzag(site, srcArg(node, env), th);
+    return tupleOf([z.high, z.low, z.dir]);
+  }
   return undefined;
 }
 
@@ -2723,37 +3967,74 @@ function asArray(value: Value): PineArray | null {
   if (value && typeof value === "object" && "__array" in value) {
     const elts = (value as ArrayVal).elts;
     const arr = new PineArray();
-    for (const e of elts) arr.push(unwrap(e));
+    for (const e of elts) arr.push(storeValue(e));
     return arr;
   }
   return null;
 }
 
+/** Every `array.new*` alias Python registers in `_array_builtin_map`. */
+const ARRAY_NEW_FNS = new Set([
+  "array.new",
+  "array.new_bool",
+  "array.new_int",
+  "array.new_float",
+  "array.new_string",
+  "array.new_color",
+  "array.newbool",
+  "array.newint",
+  "array.newfloat",
+  "array.newstring",
+  "array.newcolor",
+  "array.newlabel",
+  "array.newline",
+  "array.newbox",
+  "array.newtable",
+  "array.newpolyline",
+  "array.newlinefill",
+  "array.new_label",
+  "array.new_line",
+  "array.new_box",
+  "array.new_table",
+  "array.new_polyline",
+  "array.new_linefill",
+  "array.new_chart.point",
+]);
+
+function isArrayNew(fname: string | null): boolean {
+  const name = arrayBuiltin(fname);
+  return name != null && ARRAY_NEW_FNS.has(name);
+}
+
+function arrayBuiltin(fname: string | null): string | null {
+  if (fname == null || !fname.startsWith("array.")) return null;
+  const lt = fname.indexOf("<");
+  return lt >= 0 ? fname.slice(0, lt) : fname;
+}
+
 function evalArrayCall(fname: string | null, node: Call, env: Env): Value | undefined {
-  if (
-    fname === "array.new_float" ||
-    fname === "array.new" ||
-    fname === "array.new_int"
-  ) {
+  const aname = arrayBuiltin(fname);
+  if (isArrayNew(fname)) {
     const size = unwrap(evalExpr(callArg(node.args, 0, ["size"]), env)) ?? 0;
-    const initial = unwrap(evalExpr(callArg(node.args, 1, ["initial_value"]), env));
+    const initialArg = callArg(node.args, 1, ["initial_value"]);
+    const initial = initialArg == null ? undefined : storeValue(evalExpr(initialArg, env));
     return new PineArray(size, initial);
   }
-  if (fname === "array.push") {
+  if (aname === "array.push") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    const v = unwrap(evalExpr(callArg(node.args, 1, ["value"]), env));
+    const v = storeValue(evalExpr(callArg(node.args, 1, ["value"]), env));
     arr?.push(v);
     return NA;
   }
-  if (fname === "array.get") {
+  if (aname === "array.get") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
     const i = unwrap(evalExpr(callArg(node.args, 1, ["index"]), env));
-    return arr ? arr.get(i ?? 0) : NA;
+    return arr ? asArrayValue(arr.get(i ?? 0)) : NA;
   }
-  if (fname === "array.set") {
+  if (aname === "array.set") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
     const i = unwrap(evalExpr(callArg(node.args, 1, ["index"]), env));
-    const v = unwrap(evalExpr(callArg(node.args, 2, ["value"]), env));
+    const v = storeValue(evalExpr(callArg(node.args, 2, ["value"]), env));
     if (arr && i != null) arr.set(i, v);
     return NA;
   }
@@ -2763,7 +4044,7 @@ function evalArrayCall(fname: string | null, node: Call, env: Env): Value | unde
   }
   if (fname === "array.pop") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return arr ? arr.pop() : NA;
+    return arr ? asArrayValue(arr.pop()) : NA;
   }
   if (fname === "array.clear") {
     asArray(evalExpr(callArg(node.args, 0, ["id"]), env))?.clear();
@@ -2771,40 +4052,40 @@ function evalArrayCall(fname: string | null, node: Call, env: Env): Value | unde
   }
   if (fname === "array.unshift") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    arr?.unshift(unwrap(evalExpr(callArg(node.args, 1, ["value"]), env)));
+    arr?.unshift(storeValue(evalExpr(callArg(node.args, 1, ["value"]), env)));
     return NA;
   }
   if (fname === "array.shift") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return arr ? arr.shift() : NA;
+    return arr ? asArrayValue(arr.shift()) : NA;
   }
   if (fname === "array.includes") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return arr?.includes(unwrap(evalExpr(callArg(node.args, 1, ["value"]), env))) ? 1 : 0;
+    return arr?.includes(storeValue(evalExpr(callArg(node.args, 1, ["value"]), env))) ? 1 : 0;
   }
   if (fname === "array.first") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return arr ? arr.first() : NA;
+    return arr ? asArrayValue(arr.first()) : NA;
   }
   if (fname === "array.last") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return arr ? arr.last() : NA;
+    return arr ? asArrayValue(arr.last()) : NA;
   }
   if (fname === "array.insert") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
     const i = unwrap(evalExpr(callArg(node.args, 1, ["index"]), env));
-    const v = unwrap(evalExpr(callArg(node.args, 2, ["value"]), env));
+    const v = storeValue(evalExpr(callArg(node.args, 2, ["value"]), env));
     if (arr && i != null) arr.insert(i, v);
     return NA;
   }
   if (fname === "array.remove") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
     const i = unwrap(evalExpr(callArg(node.args, 1, ["index"]), env));
-    return arr && i != null ? arr.remove(i) : NA;
+    return arr && i != null ? asArrayValue(arr.remove(i)) : NA;
   }
   if (fname === "array.fill") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    arr?.fill(unwrap(evalExpr(callArg(node.args, 1, ["value"]), env)));
+    arr?.fill(storeValue(evalExpr(callArg(node.args, 1, ["value"]), env)));
     return NA;
   }
   if (fname === "array.slice") {
@@ -2824,14 +4105,13 @@ function evalArrayCall(fname: string | null, node: Call, env: Env): Value | unde
   }
   if (fname === "array.sort") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    const orderRaw = evalExpr(callArg(node.args, 1, ["order"]), env);
-    const order = typeof orderRaw === "string" && orderRaw.toLowerCase().includes("desc") ? "desc" : "asc";
-    arr?.sort(order);
+    const parsed = parseSortArgs(node, env);
+    arr?.sort(parsed.order, parsed.sortField);
     return NA;
   }
   if (fname === "array.indexof") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return arr ? arr.indexof(unwrap(evalExpr(callArg(node.args, 1, ["value"]), env))) : NA;
+    return arr ? arr.indexof(storeValue(evalExpr(callArg(node.args, 1, ["value"]), env))) : NA;
   }
   if (fname === "array.avg") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
@@ -2854,19 +4134,14 @@ function evalArrayCall(fname: string | null, node: Call, env: Env): Value | unde
     const sep = evalAsString(callArg(node.args, 1, ["separator", "sep"]), env);
     return arr ? arr.join(sep ?? ",") : NA;
   }
-  if (fname === "array.new_bool" || fname === "array.new_string") {
-    const size = unwrap(evalExpr(callArg(node.args, 0, ["size"]), env)) ?? 0;
-    const initial = unwrap(evalExpr(callArg(node.args, 1, ["initial_value"]), env));
-    return new PineArray(size, initial);
-  }
   if (fname === "array.from") {
     const arr = new PineArray();
-    for (const a of asArgs(node.args)) arr.push(unwrap(evalExpr(a.value, env)));
+    for (const a of asArgs(node.args)) arr.push(storeValue(evalExpr(a.value, env)));
     return arr;
   }
   if (fname === "array.lastindexof") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return arr ? arr.lastIndexOf(unwrap(evalExpr(callArg(node.args, 1, ["value"]), env))) : NA;
+    return arr ? arr.lastIndexOf(storeValue(evalExpr(callArg(node.args, 1, ["value"]), env))) : NA;
   }
   if (fname === "array.concat") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
@@ -2899,15 +4174,18 @@ function evalArrayCall(fname: string | null, node: Call, env: Env): Value | unde
   }
   if (fname === "array.binary_search") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return arr ? arr.binarySearch(unwrap(evalExpr(callArg(node.args, 1, ["value"]), env))) : NA;
+    const value = storeValue(evalExpr(callArg(node.args, 1, ["value"]), env));
+    return arr ? arr.binarySearch(value, evalSortField(node, env)) : NA;
   }
   if (fname === "array.binary_search_leftmost") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return arr ? arr.binarySearchLeftmost(unwrap(evalExpr(callArg(node.args, 1, ["value"]), env))) : NA;
+    const value = storeValue(evalExpr(callArg(node.args, 1, ["value"]), env));
+    return arr ? arr.binarySearchLeftmost(value, evalSortField(node, env)) : NA;
   }
   if (fname === "array.binary_search_rightmost") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return arr ? arr.binarySearchRightmost(unwrap(evalExpr(callArg(node.args, 1, ["value"]), env))) : NA;
+    const value = storeValue(evalExpr(callArg(node.args, 1, ["value"]), env));
+    return arr ? arr.binarySearchRightmost(value, evalSortField(node, env)) : NA;
   }
   if (fname === "array.stdev") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
@@ -2943,10 +4221,9 @@ function evalArrayCall(fname: string | null, node: Call, env: Env): Value | unde
   }
   if (fname === "array.sort_indices") {
     const arr = asArray(evalExpr(callArg(node.args, 0, ["id"]), env));
-    const orderRaw = evalExpr(callArg(node.args, 1, ["order"]), env);
-    const order = typeof orderRaw === "string" && orderRaw.toLowerCase().includes("desc") ? "desc" : "asc";
+    const parsed = parseSortArgs(node, env);
     if (!arr) return NA;
-    const idx = arr.sortIndices(order);
+    const idx = arr.sortIndices(parsed.order, parsed.sortField);
     if (idx == null) return NA;
     const out = new PineArray();
     for (const i of idx) out.push(i);
@@ -3048,20 +4325,20 @@ function evalMatrixCall(fname: string | null, node: Call, env: Env): Value | und
     const rows = unwrap(evalExpr(callArg(node.args, 0, ["rows"]), env)) ?? 0;
     const cols = unwrap(evalExpr(callArg(node.args, 1, ["columns", "cols"]), env)) ?? 0;
     const initialArg = callArg(node.args, 2, ["initial_value", "initial"]);
-    const initial = initialArg == null ? undefined : unwrap(evalExpr(initialArg, env));
+    const initial = initialArg == null ? undefined : storeValue(evalExpr(initialArg, env));
     return new PineMatrix(rows, cols, initial);
   }
   if (name === "matrix.get") {
     const m = asMatrix(evalExpr(callArg(node.args, 0, ["id"]), env));
     const row = unwrap(evalExpr(callArg(node.args, 1, ["row"]), env));
     const col = unwrap(evalExpr(callArg(node.args, 2, ["column", "col"]), env));
-    return m ? m.get(row ?? 0, col ?? 0) : NA;
+    return m ? asArrayValue(m.get(row ?? 0, col ?? 0)) : NA;
   }
   if (name === "matrix.set") {
     const m = asMatrix(evalExpr(callArg(node.args, 0, ["id"]), env));
     const row = unwrap(evalExpr(callArg(node.args, 1, ["row"]), env));
     const col = unwrap(evalExpr(callArg(node.args, 2, ["column", "col"]), env));
-    const v = unwrap(evalExpr(callArg(node.args, 3, ["value"]), env));
+    const v = storeValue(evalExpr(callArg(node.args, 3, ["value"]), env));
     if (m && row != null && col != null) m.set(row, col, v);
     return NA;
   }
@@ -3075,7 +4352,7 @@ function evalMatrixCall(fname: string | null, node: Call, env: Env): Value | und
   }
   if (name === "matrix.fill") {
     const m = asMatrix(evalExpr(callArg(node.args, 0, ["id"]), env));
-    const v = unwrap(evalExpr(callArg(node.args, 1, ["value"]), env));
+    const v = storeValue(evalExpr(callArg(node.args, 1, ["value"]), env));
     m?.fill(v);
     return NA;
   }
@@ -3274,14 +4551,115 @@ function evalMatrixCall(fname: string | null, node: Call, env: Env): Value | und
     const m = asMatrix(evalExpr(callArg(node.args, 0, ["id"]), env));
     const col = unwrap(evalExpr(callArg(node.args, 1, ["column", "col"]), env)) ?? 0;
     const orderRaw = evalExpr(callArg(node.args, 2, ["order"]), env);
-    const order = typeof orderRaw === "string" && orderRaw.toLowerCase().includes("desc") ? "desc" : "asc";
-    m?.sort(col, order);
+    const order = isDescendingOrder(orderRaw) ? "desc" : "asc";
+    const sortField = sortFieldValue(evalExpr(callArg(node.args, 3, ["sort_field"]), env));
+    m?.sort(col, order, sortField);
     return NA;
   }
+  if (name === "matrix.sort_indices") {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id"]), env));
+    if (!m) return NA;
+    const col = unwrap(evalExpr(callArg(node.args, 1, ["column", "col"]), env)) ?? 0;
+    const orderRaw = evalExpr(callArg(node.args, 2, ["order"]), env);
+    const order = isDescendingOrder(orderRaw) ? "desc" : "asc";
+    const sortField = sortFieldValue(evalExpr(callArg(node.args, 3, ["sort_field"]), env));
+    const idx = m.sortIndices(col, order, sortField);
+    const out = new PineArray();
+    for (const i of idx) out.push(i);
+    return out;
+  }
   if (name === "matrix.median") {
     const m = asMatrix(evalExpr(callArg(node.args, 0, ["id"]), env));
     return m ? m.median() : NA;
   }
+  if (
+    name === "matrix.sum_row" ||
+    name === "matrix.avg_row" ||
+    name === "matrix.min_row" ||
+    name === "matrix.max_row" ||
+    name === "matrix.mode_row"
+  ) {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env));
+    const i = unwrap(evalExpr(callArg(node.args, 1, ["row", "index"]), env));
+    if (!m || i == null) return NA;
+    if (name === "matrix.sum_row") return m.sumRow(i);
+    if (name === "matrix.avg_row") return m.avgRow(i);
+    if (name === "matrix.min_row") return m.minRow(i);
+    if (name === "matrix.max_row") return m.maxRow(i);
+    return m.modeRow(i) as Value;
+  }
+  if (
+    name === "matrix.sum_col" ||
+    name === "matrix.avg_col" ||
+    name === "matrix.min_col" ||
+    name === "matrix.max_col" ||
+    name === "matrix.mode_col"
+  ) {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env));
+    const i = unwrap(evalExpr(callArg(node.args, 1, ["column", "col", "index"]), env));
+    if (!m || i == null) return NA;
+    if (name === "matrix.sum_col") return m.sumCol(i);
+    if (name === "matrix.avg_col") return m.avgCol(i);
+    if (name === "matrix.min_col") return m.minCol(i);
+    if (name === "matrix.max_col") return m.maxCol(i);
+    return m.modeCol(i) as Value;
+  }
+  if (name === "matrix.copy_row") {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env));
+    const i = unwrap(evalExpr(callArg(node.args, 1, ["row", "index"]), env));
+    if (!m || i == null) return NA;
+    const arr = new PineArray();
+    for (const v of m.copyRow(i)) arr.push(v);
+    return arr;
+  }
+  if (name === "matrix.copy_col") {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env));
+    const i = unwrap(evalExpr(callArg(node.args, 1, ["column", "col", "index"]), env));
+    if (!m || i == null) return NA;
+    const arr = new PineArray();
+    for (const v of m.copyCol(i)) arr.push(v);
+    return arr;
+  }
+  if (name === "matrix.fill_row") {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env));
+    const i = unwrap(evalExpr(callArg(node.args, 1, ["row", "index"]), env));
+    const v = storeValue(evalExpr(callArg(node.args, 2, ["value"]), env));
+    if (m && i != null) m.fillRow(i, v);
+    return NA;
+  }
+  if (name === "matrix.fill_col") {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env));
+    const i = unwrap(evalExpr(callArg(node.args, 1, ["column", "col", "index"]), env));
+    const v = storeValue(evalExpr(callArg(node.args, 2, ["value"]), env));
+    if (m && i != null) m.fillCol(i, v);
+    return NA;
+  }
+  if (name === "matrix.fill_diagonal") {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env));
+    const v = storeValue(evalExpr(callArg(node.args, 1, ["value"]), env));
+    m?.fillDiagonal(v);
+    return NA;
+  }
+  if (name === "matrix.reverse_rows") {
+    asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env))?.reverseRows();
+    return NA;
+  }
+  if (name === "matrix.reverse_cols") {
+    asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env))?.reverseCols();
+    return NA;
+  }
+  if (name === "matrix.stdev") {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env));
+    return m ? m.stdev() : NA;
+  }
+  if (name === "matrix.variance") {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env));
+    return m ? m.variance() : NA;
+  }
+  if (name === "matrix.mode_all") {
+    const m = asMatrix(evalExpr(callArg(node.args, 0, ["id", "matrix"]), env));
+    return m ? (m.modeAll() as Value) : NA;
+  }
   if (name === "matrix.mode") {
     const m = asMatrix(evalExpr(callArg(node.args, 0, ["id"]), env));
     return m ? m.mode() : NA;
@@ -3301,125 +4679,808 @@ function evalMatrixCall(fname: string | null, node: Call, env: Env): Value | und
   return undefined;
 }
 
+function isChartPoint(value: Value): value is ChartPointVal {
+  return typeof value === "object" && value !== null && (value as ChartPointVal).__chartPoint === true;
+}
+
+function makeChartPoint(index: number | null, time: number | null, price: number | null): ChartPointVal {
+  const x = index ?? time;
+  return { __chartPoint: true, index, time, x, y: price, price };
+}
+
+function chartPointField(obj: ChartPointVal, attr: string): Value {
+  if (attr === "__chartPoint" || !Object.prototype.hasOwnProperty.call(obj, attr)) return NA;
+  const v = obj[attr as keyof ChartPointVal];
+  if (typeof v === "number") return Number.isFinite(v) ? v : NA;
+  return NA;
+}
+
+function drawingAllKind(name: string): DrawingKind | null {
+  if (
+    name === "line" ||
+    name === "label" ||
+    name === "box" ||
+    name === "table" ||
+    name === "polyline" ||
+    name === "linefill"
+  ) {
+    return name;
+  }
+  return null;
+}
+
+function drawingAllArray(env: Env, kind: DrawingKind): PineArray {
+  const arr = new PineArray();
+  for (const id of env.drawings.allIds(kind)) arr.push(id);
+  return arr;
+}
+
+function drawId(node: Call, env: Env): number | null {
+  return unwrap(evalExpr(callArg(node.args, 0, ["id", "table_id", "table"]), env));
+}
+
+function drawNum(node: Call, env: Env, index: number, names: string[]): number | null {
+  const e = callArg(node.args, index, names);
+  return e == null ? null : unwrap(evalExpr(e, env));
+}
+
+function drawRaw(node: Call, env: Env, index: number, names: string[]): unknown {
+  const e = callArg(node.args, index, names);
+  if (e == null) return undefined;
+  const v = evalExpr(e, env);
+  if (typeof v === "string" || typeof v === "boolean" || isChartPoint(v) || v instanceof PineArray) return v;
+  const n = unwrap(v);
+  return n != null ? n : v;
+}
+
+function drawText(node: Call, env: Env, index: number, names: string[], fallback = ""): string {
+  const e = callArg(node.args, index, names);
+  if (e == null) return fallback;
+  const s = evalAsString(e, env);
+  if (s != null) return s;
+  const v = evalExpr(e, env);
+  if (typeof v === "string") return v;
+  const n = unwrap(v);
+  return n == null ? fallback : String(n);
+}
+
+function putFinite(extra: Record<string, unknown>, key: string, value: number | null | undefined): void {
+  if (value != null && Number.isFinite(value)) extra[key] = value;
+}
+
+function optionalCoord(node: Call, env: Env, index: number, names: string[], fallback: number): number | null {
+  const e = callArg(node.args, index, names);
+  if (e == null) return fallback;
+  return unwrap(evalExpr(e, env));
+}
+
+function pointXY(p: ChartPointVal): { x: number; y: number } {
+  const x = p.index ?? p.time ?? p.x ?? 0;
+  const y = p.price ?? p.y ?? 0;
+  return { x: x ?? 0, y: y ?? 0 };
+}
+
+function pointsFromValue(value: Value): unknown[] {
+  const arr = asArray(value);
+  if (!arr) return [];
+  return arr.toValues().filter((p) => p != null);
+}
+
 function evalDrawingCall(fname: string | null, node: Call, env: Env): Value | undefined {
+  if (fname == null) return undefined;
+  const book = env.drawings;
+
+  if (fname === "line" || fname === "box" || fname === "label" || fname === "table" || fname === "polyline" || fname === "linefill") {
+    const e = callArg(node.args, 0, ["id", "x"]);
+    return e == null ? NA : evalExpr(e, env);
+  }
+
   if (fname === "line.new") {
-    return env.drawings.lineNew(env.barIndex);
+    const extra: Record<string, unknown> = {};
+    putFinite(extra, "x1", optionalCoord(node, env, 0, ["x1"], 0));
+    putFinite(extra, "y1", optionalCoord(node, env, 1, ["y1"], 0));
+    putFinite(extra, "x2", optionalCoord(node, env, 2, ["x2"], 0));
+    putFinite(extra, "y2", optionalCoord(node, env, 3, ["y2"], 0));
+    const xloc = drawRaw(node, env, 4, ["xloc"]);
+    if (xloc !== undefined) extra.xloc = xloc;
+    const color = drawRaw(node, env, 5, ["color"]);
+    if (color !== undefined) extra.color = color;
+    putFinite(extra, "width", drawNum(node, env, 6, ["width"]));
+    const style = drawRaw(node, env, 7, ["style"]);
+    if (style !== undefined) extra.style = style;
+    const extend = drawRaw(node, env, 8, ["extend"]);
+    if (extend !== undefined) extra.extend = extend;
+    return book.lineNew(env.barIndex, extra);
   }
   if (fname === "label.new") {
-    const text = evalAsString(callArg(node.args, 2, ["text"]), env);
-    return env.drawings.labelNew(env.barIndex, text ?? undefined);
+    const pointKw = callArg(node.args, -1, ["point"]);
+    const a0 = callArg(node.args, 0, ["x", "point"]);
+    const v0 = pointKw != null ? evalExpr(pointKw, env) : a0 != null ? evalExpr(a0, env) : NA;
+    const extra: Record<string, unknown> = {};
+    let text: string;
+    if (isChartPoint(v0)) {
+      const xy = pointXY(v0);
+      extra.x = xy.x;
+      extra.y = xy.y;
+      text = drawText(node, env, pointKw != null ? 0 : 1, ["text"]);
+    } else {
+      putFinite(extra, "x", a0 == null ? 0 : unwrap(v0));
+      putFinite(extra, "y", optionalCoord(node, env, 1, ["y"], 0));
+      text = drawText(node, env, 2, ["text"]);
+    }
+    const tooltip = drawRaw(node, env, 12, ["tooltip"]);
+    if (tooltip !== undefined) extra.tooltip = tooltip;
+    const style = drawRaw(node, env, 13, ["style"]);
+    if (style !== undefined) extra.style = style;
+    return book.labelNew(env.barIndex, text, extra);
   }
   if (fname === "box.new") {
-    return env.drawings.boxNew(env.barIndex);
+    const extra: Record<string, unknown> = {};
+    putFinite(extra, "left", optionalCoord(node, env, 0, ["left"], 0));
+    putFinite(extra, "top", optionalCoord(node, env, 1, ["top"], 0));
+    putFinite(extra, "right", optionalCoord(node, env, 2, ["right"], 0));
+    putFinite(extra, "bottom", optionalCoord(node, env, 3, ["bottom"], 0));
+    const bgcolor = drawRaw(node, env, 6, ["bgcolor"]);
+    if (bgcolor !== undefined) extra.bgcolor = bgcolor;
+    const text = callArg(node.args, -1, ["text"]);
+    if (text != null) extra.text = drawText(node, env, -1, ["text"]);
+    return book.boxNew(env.barIndex, extra);
   }
   if (fname === "alert") {
     const msg = evalAlertMessage(callArg(node.args, 0, ["message"]), env);
-    env.drawings.alert(env.barIndex, msg);
+    book.alert(env.barIndex, msg);
     return NA;
   }
-  if (fname === "table.new") return env.drawings.tableNew(env.barIndex);
-  if (fname === "polyline.new") return env.drawings.polylineNew(env.barIndex);
-  if (fname === "linefill.new") {
-    const a = unwrap(evalExpr(callArg(node.args, 0, ["id1"]), env));
-    const b = unwrap(evalExpr(callArg(node.args, 1, ["id2"]), env));
-    return env.drawings.linefillNew(
-      env.barIndex,
-      a == null ? undefined : a,
-      b == null ? undefined : b,
-    );
+  if (fname === "table.new") {
+    const extra: Record<string, unknown> = {};
+    const position = drawRaw(node, env, 0, ["position"]);
+    if (position !== undefined) extra.position = position;
+    putFinite(extra, "rows", drawNum(node, env, 1, ["rows"]));
+    putFinite(extra, "columns", drawNum(node, env, 2, ["columns"]));
+    return book.tableNew(env.barIndex, extra);
+  }
+  if (fname === "polyline.new") {
+    const extra: Record<string, unknown> = {};
+    const ptsExpr = callArg(node.args, 0, ["points"]);
+    extra.points = ptsExpr == null ? [] : pointsFromValue(evalExpr(ptsExpr, env));
+    const closed = drawRaw(node, env, 1, ["closed"]);
+    if (closed !== undefined) extra.closed = closed;
+    const color = drawRaw(node, env, 3, ["color"]);
+    if (color !== undefined) extra.color = color;
+    putFinite(extra, "width", drawNum(node, env, 4, ["width"]));
+    return book.polylineNew(env.barIndex, extra);
+  }
+  if (fname === "linefill.new" || fname === "line.fill") {
+    const a = unwrap(evalExpr(callArg(node.args, 0, ["id1", "line1"]), env));
+    const b = unwrap(evalExpr(callArg(node.args, 1, ["id2", "line2"]), env));
+    const extra: Record<string, unknown> = {};
+    if (a != null) extra.id1 = a;
+    if (b != null) extra.id2 = b;
+    const color = drawRaw(node, env, 2, ["color"]);
+    if (color !== undefined) extra.color = color;
+    return book.linefillNew(env.barIndex, extra);
+  }
+
+  if (fname.endsWith(".all")) {
+    const kind = drawingAllKind(fname.slice(0, -4));
+    if (kind != null) return drawingAllArray(env, kind);
+  }
+
+  if (fname === "chart.point.new" || fname === "chart.point.from_time") {
+    const time = drawNum(node, env, 0, ["time"]);
+    const priceExpr = callArg(node.args, 1, ["price"]);
+    const price = priceExpr == null ? 0 : unwrap(evalExpr(priceExpr, env));
+    if (price == null) return NA;
+    return makeChartPoint(null, time, price);
+  }
+  if (fname === "chart.point.from_index") {
+    const index = drawNum(node, env, 0, ["index"]);
+    const priceExpr = callArg(node.args, 1, ["price"]);
+    const price = priceExpr == null ? 0 : unwrap(evalExpr(priceExpr, env));
+    if (price == null || index == null) return NA;
+    return makeChartPoint(Math.trunc(index), null, price);
+  }
+  if (fname === "chart.point.now") {
+    const priceExpr = callArg(node.args, 0, ["price"]);
+    const price = priceExpr == null ? 0 : unwrap(evalExpr(priceExpr, env));
+    if (price == null) return NA;
+    const time = unwrap(env.ctx.time) ?? env.barTimes[env.barIndex] ?? null;
+    return makeChartPoint(env.barIndex, time, price);
+  }
+  if (fname === "chart.point.copy") {
+    const raw = evalExpr(callArg(node.args, 0, ["point"]), env);
+    if (isChartPoint(raw)) return makeChartPoint(raw.index, raw.time, raw.price);
+    return makeChartPoint(null, null, 0);
+  }
+
+  if (fname === "line.copy" || fname === "label.copy" || fname === "box.copy" || fname === "polyline.copy") {
+    const id = drawId(node, env);
+    if (id == null) return NA;
+    const copied = book.copy(id);
+    return copied == null ? NA : copied;
+  }
+
+  if (fname === "line.delete" || fname === "label.delete" || fname === "box.delete" || fname === "table.delete" || fname === "polyline.delete" || fname === "linefill.delete") {
+    const id = drawId(node, env);
+    if (id != null) {
+      if (fname === "line.delete") book.lineDelete(id);
+      else if (fname === "label.delete") book.labelDelete(id);
+      else if (fname === "box.delete") book.boxDelete(id);
+      else if (fname === "table.delete") book.tableDelete(id);
+      else if (fname === "polyline.delete") book.polylineDelete(id);
+      else book.linefillDelete(id);
+    }
+    return NA;
+  }
+
+  if (fname === "line.get_x1") {
+    const id = drawId(node, env);
+    return id != null ? book.lineGetX1(id) : NA;
+  }
+  if (fname === "line.get_y1") {
+    const id = drawId(node, env);
+    return id != null ? book.lineGetY1(id) : NA;
+  }
+  if (fname === "line.get_x2") {
+    const id = drawId(node, env);
+    return id != null ? book.lineGetX2(id) : NA;
+  }
+  if (fname === "line.get_y2") {
+    const id = drawId(node, env);
+    return id != null ? book.lineGetY2(id) : NA;
+  }
+  if (fname === "line.get_price") {
+    const id = drawId(node, env);
+    const x = drawNum(node, env, 1, ["x"]);
+    return id != null && x != null ? book.lineGetPrice(id, x) : NA;
+  }
+  if (fname === "label.get_x") {
+    const id = drawId(node, env);
+    return id == null ? 0 : (book.labelGetX(id) ?? 0);
   }
+  if (fname === "label.get_y") {
+    const id = drawId(node, env);
+    return id == null ? 0 : (book.labelGetY(id) ?? 0);
+  }
+  if (fname === "label.get_text") {
+    const id = drawId(node, env);
+    return id == null ? "" : (book.labelGetText(id) ?? "");
+  }
+  if (fname === "box.get_left") {
+    const id = drawId(node, env);
+    return id == null ? 0 : (book.boxGetLeft(id) ?? 0);
+  }
+  if (fname === "box.get_right") {
+    const id = drawId(node, env);
+    return id == null ? 0 : (book.boxGetRight(id) ?? 0);
+  }
+  if (fname === "box.get_top") {
+    const id = drawId(node, env);
+    return id == null ? 0 : (book.boxGetTop(id) ?? 0);
+  }
+  if (fname === "box.get_bottom") {
+    const id = drawId(node, env);
+    return id == null ? 0 : (book.boxGetBottom(id) ?? 0);
+  }
+  if (fname === "table.cell_get_text") {
+    const id = drawId(node, env);
+    const row = drawNum(node, env, 1, ["row"]);
+    const col = drawNum(node, env, 2, ["column"]);
+    if (id == null) return "";
+    return book.tableCellGetText(id, col, row) ?? "";
+  }
+  if (fname === "linefill.get_line1") {
+    const id = drawId(node, env);
+    return id != null ? book.linefillGetLine1(id) : NA;
+  }
+  if (fname === "linefill.get_line2") {
+    const id = drawId(node, env);
+    return id != null ? book.linefillGetLine2(id) : NA;
+  }
+  if (fname === "polyline.get_points") {
+    const id = drawId(node, env);
+    const arr = new PineArray();
+    if (id != null) for (const p of book.polylineGetPoints(id)) arr.push(p);
+    return arr;
+  }
+
   if (fname === "line.set_xy") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
+    const id = drawId(node, env);
     if (id != null) {
-      env.drawings.lineSetXy(
+      book.lineSetXy(
         id,
-        unwrap(evalExpr(callArg(node.args, 1, ["x1"]), env)) ?? 0,
-        unwrap(evalExpr(callArg(node.args, 2, ["y1"]), env)) ?? 0,
-        unwrap(evalExpr(callArg(node.args, 3, ["x2"]), env)) ?? 0,
-        unwrap(evalExpr(callArg(node.args, 4, ["y2"]), env)) ?? 0,
+        drawNum(node, env, 1, ["x1"]) ?? 0,
+        drawNum(node, env, 2, ["y1"]) ?? 0,
+        drawNum(node, env, 3, ["x2"]) ?? 0,
+        drawNum(node, env, 4, ["y2"]) ?? 0,
       );
     }
     return NA;
   }
-  if (fname === "label.set_text") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    if (id != null) env.drawings.labelSetText(id, evalAsString(callArg(node.args, 1, ["text"]), env) ?? "");
+  if (fname === "line.set_xy1") {
+    const id = drawId(node, env);
+    if (id != null) book.lineSetXy1(id, drawNum(node, env, 1, ["x1", "x"]) ?? 0, drawNum(node, env, 2, ["y1", "y"]) ?? 0);
     return NA;
   }
-  if (fname === "line.delete" || fname === "label.delete" || fname === "box.delete") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    if (id != null) {
-      if (fname === "line.delete") env.drawings.lineDelete(id);
-      else if (fname === "label.delete") env.drawings.labelDelete(id);
-      else env.drawings.boxDelete(id);
-    }
+  if (fname === "line.set_xy2") {
+    const id = drawId(node, env);
+    if (id != null) book.lineSetXy2(id, drawNum(node, env, 1, ["x2", "x"]) ?? 0, drawNum(node, env, 2, ["y2", "y"]) ?? 0);
+    return NA;
+  }
+  if (fname === "line.set_x1") {
+    const id = drawId(node, env);
+    if (id != null) book.lineSetX1(id, drawNum(node, env, 1, ["x1", "x"]));
+    return NA;
+  }
+  if (fname === "line.set_y1") {
+    const id = drawId(node, env);
+    if (id != null) book.lineSetY1(id, drawNum(node, env, 1, ["y1", "y"]));
+    return NA;
+  }
+  if (fname === "line.set_x2") {
+    const id = drawId(node, env);
+    if (id != null) book.lineSetX2(id, drawNum(node, env, 1, ["x2", "x"]));
+    return NA;
+  }
+  if (fname === "line.set_y2") {
+    const id = drawId(node, env);
+    if (id != null) book.lineSetY2(id, drawNum(node, env, 1, ["y2", "y"]));
     return NA;
   }
   if (fname === "line.set_color") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    if (id != null) env.drawings.lineSetColor(id, evalAsString(callArg(node.args, 1, ["color"]), env) ?? "");
+    const id = drawId(node, env);
+    if (id != null) book.lineSetColor(id, drawRaw(node, env, 1, ["color"]));
     return NA;
   }
-  if (fname === "line.get_price") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    const x = unwrap(evalExpr(callArg(node.args, 1, ["x"]), env));
-    return id != null && x != null ? env.drawings.lineGetPrice(id, x) : NA;
+  if (fname === "line.set_width") {
+    const id = drawId(node, env);
+    if (id != null) book.lineSetWidth(id, drawRaw(node, env, 1, ["width"]));
+    return NA;
   }
-  if (fname === "line.get_x1") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return id != null ? env.drawings.getX1(id) : NA;
+  if (fname === "line.set_style") {
+    const id = drawId(node, env);
+    if (id != null) book.lineSetStyle(id, drawRaw(node, env, 1, ["style"]));
+    return NA;
   }
-  if (fname === "line.get_y1") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return id != null ? env.drawings.getY1(id) : NA;
+  if (fname === "line.set_extend") {
+    const id = drawId(node, env);
+    if (id != null) book.lineSetExtend(id, drawRaw(node, env, 1, ["extend"]));
+    return NA;
   }
-  if (fname === "line.get_x2") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return id != null ? env.drawings.getX2(id) : NA;
+  if (fname === "line.set_xloc") {
+    const id = drawId(node, env);
+    if (id != null) book.lineSetXloc(id, drawRaw(node, env, 1, ["xloc"]));
+    return NA;
   }
-  if (fname === "line.get_y2") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return id != null ? env.drawings.getY2(id) : NA;
+  if (fname === "line.set_first_point") {
+    const id = drawId(node, env);
+    const p = evalExpr(callArg(node.args, 1, ["point"]), env);
+    if (id != null && isChartPoint(p)) {
+      const xy = pointXY(p);
+      book.lineSetXy1(id, xy.x, xy.y);
+    }
+    return NA;
   }
-  if (fname === "label.get_text") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    return id != null ? env.drawings.labelGetText(id) : NA;
+  if (fname === "line.set_second_point") {
+    const id = drawId(node, env);
+    const p = evalExpr(callArg(node.args, 1, ["point"]), env);
+    if (id != null && isChartPoint(p)) {
+      const xy = pointXY(p);
+      book.lineSetXy2(id, xy.x, xy.y);
+    }
+    return NA;
+  }
+
+  if (fname === "label.set_text") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetText(id, drawText(node, env, 1, ["text"]));
+    return NA;
   }
   if (fname === "label.set_xy") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
+    const id = drawId(node, env);
+    if (id != null) book.labelSetXy(id, drawNum(node, env, 1, ["x"]) ?? 0, drawNum(node, env, 2, ["y"]) ?? 0);
+    return NA;
+  }
+  if (fname === "label.set_x") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetX(id, drawNum(node, env, 1, ["x"]));
+    return NA;
+  }
+  if (fname === "label.set_y") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetY(id, drawNum(node, env, 1, ["y"]));
+    return NA;
+  }
+  if (fname === "label.set_color") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetColor(id, drawRaw(node, env, 1, ["color"]));
+    return NA;
+  }
+  if (fname === "label.set_style") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetStyle(id, drawRaw(node, env, 1, ["style"]));
+    return NA;
+  }
+  if (fname === "label.set_size") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetSize(id, drawRaw(node, env, 1, ["size"]));
+    return NA;
+  }
+  if (fname === "label.set_tooltip") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetTooltip(id, drawRaw(node, env, 1, ["tooltip"]));
+    return NA;
+  }
+  if (fname === "label.set_textalign") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetTextalign(id, drawRaw(node, env, 1, ["textalign", "halign"]));
+    return NA;
+  }
+  if (fname === "label.set_textcolor") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetTextcolor(id, drawRaw(node, env, 1, ["color", "textcolor"]));
+    return NA;
+  }
+  if (fname === "label.set_text_font_family") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetTextFontFamily(id, drawRaw(node, env, 1, ["font_family", "text_font_family"]));
+    return NA;
+  }
+  if (fname === "label.set_text_halign") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetTextHalign(id, drawRaw(node, env, 1, ["halign", "text_halign"]));
+    return NA;
+  }
+  if (fname === "label.set_text_valign") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetTextValign(id, drawRaw(node, env, 1, ["valign", "text_valign"]));
+    return NA;
+  }
+  if (fname === "label.set_text_size") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetTextSize(id, drawRaw(node, env, 1, ["size", "text_size"]));
+    return NA;
+  }
+  if (fname === "label.set_text_formatting") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetTextFormatting(id, drawRaw(node, env, 1, ["formatting", "text_formatting"]));
+    return NA;
+  }
+  if (fname === "label.set_border_color") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetBorderColor(id, drawRaw(node, env, 1, ["color"]));
+    return NA;
+  }
+  if (fname === "label.set_border_width") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetBorderWidth(id, drawRaw(node, env, 1, ["width"]));
+    return NA;
+  }
+  if (fname === "label.set_border_style") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetBorderStyle(id, drawRaw(node, env, 1, ["style"]));
+    return NA;
+  }
+  if (fname === "label.set_xloc") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetXloc(id, drawRaw(node, env, 1, ["xloc"]));
+    return NA;
+  }
+  if (fname === "label.set_yloc") {
+    const id = drawId(node, env);
+    if (id != null) book.labelSetYloc(id, drawRaw(node, env, 1, ["yloc"]));
+    return NA;
+  }
+  if (fname === "label.set_point") {
+    const id = drawId(node, env);
+    const p = evalExpr(callArg(node.args, 1, ["point"]), env);
+    if (id != null && isChartPoint(p)) {
+      const xy = pointXY(p);
+      book.labelSetXy(id, xy.x, xy.y);
+    }
+    return NA;
+  }
+
+  if (fname === "box.set_lefttop" || fname === "box.set_corners") {
+    const id = drawId(node, env);
     if (id != null) {
-      env.drawings.labelSetXy(
+      book.boxSetCorners(
         id,
-        unwrap(evalExpr(callArg(node.args, 1, ["x"]), env)) ?? 0,
-        unwrap(evalExpr(callArg(node.args, 2, ["y"]), env)) ?? 0,
+        drawNum(node, env, 1, ["left", "x1"]) ?? 0,
+        drawNum(node, env, 2, ["top", "y1"]) ?? 0,
+        drawNum(node, env, 3, ["right", "x2"]) ?? 0,
+        drawNum(node, env, 4, ["bottom", "y2"]) ?? 0,
       );
     }
     return NA;
   }
-  if (fname === "box.set_lefttop" || fname === "box.set_corners") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
+  if (fname === "box.set_left") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetLeft(id, drawNum(node, env, 1, ["left"]));
+    return NA;
+  }
+  if (fname === "box.set_right") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetRight(id, drawNum(node, env, 1, ["right"]));
+    return NA;
+  }
+  if (fname === "box.set_top") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetTop(id, drawNum(node, env, 1, ["top"]));
+    return NA;
+  }
+  if (fname === "box.set_bottom") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetBottom(id, drawNum(node, env, 1, ["bottom"]));
+    return NA;
+  }
+  if (fname === "box.set_bgcolor") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetBgcolor(id, drawRaw(node, env, 1, ["color", "bgcolor"]));
+    return NA;
+  }
+  if (fname === "box.set_border_color") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetBorderColor(id, drawRaw(node, env, 1, ["color"]));
+    return NA;
+  }
+  if (fname === "box.set_border_width") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetBorderWidth(id, drawRaw(node, env, 1, ["width"]));
+    return NA;
+  }
+  if (fname === "box.set_border_style") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetBorderStyle(id, drawRaw(node, env, 1, ["style"]));
+    return NA;
+  }
+  if (fname === "box.set_extend") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetExtend(id, drawRaw(node, env, 1, ["extend"]));
+    return NA;
+  }
+  if (fname === "box.set_xloc") {
+    const id = drawId(node, env);
+    if (id != null) {
+      book.boxSetLeft(id, drawNum(node, env, 1, ["left"]));
+      book.boxSetRight(id, drawNum(node, env, 2, ["right"]));
+      book.boxSetXloc(id, drawRaw(node, env, 3, ["xloc"]));
+    }
+    return NA;
+  }
+  if (fname === "box.set_closed") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetClosed(id, drawRaw(node, env, 1, ["closed"]));
+    return NA;
+  }
+  if (fname === "box.set_rightbottom") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetRightBottom(id, drawNum(node, env, 1, ["right"]), drawNum(node, env, 2, ["bottom"]));
+    return NA;
+  }
+  if (fname === "box.set_text") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetText(id, drawText(node, env, 1, ["text"]));
+    return NA;
+  }
+  if (fname === "box.set_text_color") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetTextColor(id, drawRaw(node, env, 1, ["color", "text_color"]));
+    return NA;
+  }
+  if (fname === "box.set_text_font_family") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetTextFontFamily(id, drawRaw(node, env, 1, ["font_family"]));
+    return NA;
+  }
+  if (fname === "box.set_text_halign") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetTextHalign(id, drawRaw(node, env, 1, ["halign"]));
+    return NA;
+  }
+  if (fname === "box.set_text_valign") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetTextValign(id, drawRaw(node, env, 1, ["valign"]));
+    return NA;
+  }
+  if (fname === "box.set_text_size") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetTextSize(id, drawRaw(node, env, 1, ["size"]));
+    return NA;
+  }
+  if (fname === "box.set_text_formatting") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetTextFormatting(id, drawRaw(node, env, 1, ["formatting"]));
+    return NA;
+  }
+  if (fname === "box.set_text_wrap") {
+    const id = drawId(node, env);
+    if (id != null) book.boxSetTextWrap(id, drawRaw(node, env, 1, ["wrap"]));
+    return NA;
+  }
+  if (fname === "box.set_top_left_point") {
+    const id = drawId(node, env);
+    const p = evalExpr(callArg(node.args, 1, ["point"]), env);
+    if (id != null && isChartPoint(p)) {
+      const xy = pointXY(p);
+      book.boxSetLeftTop(id, xy.x, xy.y);
+    }
+    return NA;
+  }
+  if (fname === "box.set_bottom_right_point") {
+    const id = drawId(node, env);
+    const p = evalExpr(callArg(node.args, 1, ["point"]), env);
+    if (id != null && isChartPoint(p)) {
+      const xy = pointXY(p);
+      book.boxSetRightBottom(id, xy.x, xy.y);
+    }
+    return NA;
+  }
+
+  if (fname === "table.cell") {
+    const id = drawId(node, env);
+    const col = drawNum(node, env, 1, ["column"]);
+    const row = drawNum(node, env, 2, ["row"]);
+    const textArg = callArg(node.args, 3, ["text"]);
+    const text = textArg == null ? undefined : drawText(node, env, 3, ["text"]);
+    if (id != null && col != null && row != null) book.tableCell(id, col, row, text);
+    return NA;
+  }
+  if (fname === "table.cell_set_text") {
+    const id = drawId(node, env);
+    const row = drawNum(node, env, 1, ["row"]);
+    const col = drawNum(node, env, 2, ["column"]);
+    if (id != null) book.tableCellSetText(id, col, row, drawText(node, env, 3, ["text"]));
+    return NA;
+  }
+  if (
+    fname === "table.cell_set_text_color" ||
+    fname === "table.cell_set_bgcolor" ||
+    fname === "table.cell_set_border_color" ||
+    fname === "table.cell_set_border_width" ||
+    fname === "table.cell_set_tooltip"
+  ) {
+    const id = drawId(node, env);
+    const row = drawNum(node, env, 1, ["row"]);
+    const col = drawNum(node, env, 2, ["column"]);
+    const field =
+      fname === "table.cell_set_text_color"
+        ? "text_color"
+        : fname === "table.cell_set_bgcolor"
+          ? "bgcolor"
+          : fname === "table.cell_set_border_color"
+            ? "border_color"
+            : fname === "table.cell_set_border_width"
+              ? "border_width"
+              : "tooltip";
+    if (id != null) book.tableCellSetField(id, col, row, field, drawRaw(node, env, 3, ["color", "width", "tooltip", "text"]));
+    return NA;
+  }
+  if (
+    fname === "table.cell_set_width" ||
+    fname === "table.cell_set_height" ||
+    fname === "table.cell_set_text_halign" ||
+    fname === "table.cell_set_text_valign" ||
+    fname === "table.cell_set_text_size" ||
+    fname === "table.cell_set_text_font_family" ||
+    fname === "table.cell_set_text_formatting"
+  ) {
+    const id = drawId(node, env);
+    const col = drawNum(node, env, 1, ["column", "col"]);
+    const row = drawNum(node, env, 2, ["row"]);
+    const field = fname.slice("table.cell_set_".length);
+    if (id != null) book.tableCellSetField(id, col, row, field, drawRaw(node, env, 3, ["width", "height", "halign", "valign", "size", "font_family", "formatting"]));
+    return NA;
+  }
+  if (fname === "table.set_position") {
+    const id = drawId(node, env);
+    if (id != null) book.tableSetPosition(id, drawRaw(node, env, 1, ["position"]));
+    return NA;
+  }
+  if (fname === "table.set_bgcolor") {
+    const id = drawId(node, env);
+    if (id != null) book.tableSetBgcolor(id, drawRaw(node, env, 1, ["color", "bgcolor"]));
+    return NA;
+  }
+  if (fname === "table.set_border_color") {
+    const id = drawId(node, env);
+    if (id != null) book.tableSetBorderColor(id, drawRaw(node, env, 1, ["color"]));
+    return NA;
+  }
+  if (fname === "table.set_border_width") {
+    const id = drawId(node, env);
+    if (id != null) book.tableSetBorderWidth(id, drawRaw(node, env, 1, ["width"]));
+    return NA;
+  }
+  if (fname === "table.set_frame_color") {
+    const id = drawId(node, env);
+    if (id != null) book.tableSetFrameColor(id, drawRaw(node, env, 1, ["color"]));
+    return NA;
+  }
+  if (fname === "table.set_frame_width") {
+    const id = drawId(node, env);
+    if (id != null) book.tableSetFrameWidth(id, drawRaw(node, env, 1, ["width"]));
+    return NA;
+  }
+  if (fname === "table.clear") {
+    const id = drawId(node, env);
+    if (id != null) {
+      const a1 = callArg(node.args, 1, ["start_row"]);
+      if (a1 == null) book.tableClear(id);
+      else {
+        book.tableClear(
+          id,
+          drawNum(node, env, 1, ["start_row"]),
+          drawNum(node, env, 2, ["start_column", "start_col"]),
+          drawNum(node, env, 3, ["end_row"]),
+          drawNum(node, env, 4, ["end_column", "end_col"]),
+        );
+      }
+    }
+    return NA;
+  }
+  if (fname === "table.merge_cells") {
+    const id = drawId(node, env);
     if (id != null) {
-      env.drawings.boxSetCorners(
+      book.tableMergeCells(
         id,
-        unwrap(evalExpr(callArg(node.args, 1, ["left", "x1"]), env)) ?? 0,
-        unwrap(evalExpr(callArg(node.args, 2, ["top", "y1"]), env)) ?? 0,
-        unwrap(evalExpr(callArg(node.args, 3, ["right", "x2"]), env)) ?? 0,
-        unwrap(evalExpr(callArg(node.args, 4, ["bottom", "y2"]), env)) ?? 0,
+        drawNum(node, env, 1, ["start_row"]),
+        drawNum(node, env, 2, ["start_column", "start_col"]),
+        drawNum(node, env, 3, ["end_row"]),
+        drawNum(node, env, 4, ["end_column", "end_col"]),
       );
     }
     return NA;
   }
-  if (fname === "label.set_color") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    if (id != null) env.drawings.labelSetColor(id, evalAsString(callArg(node.args, 1, ["color"]), env) ?? "");
+
+  if (fname === "linefill.set_color") {
+    const id = drawId(node, env);
+    if (id != null) book.linefillSetColor(id, drawRaw(node, env, 1, ["color"]));
     return NA;
   }
-  if (fname === "table.cell") {
-    const id = unwrap(evalExpr(callArg(node.args, 0, ["id"]), env));
-    const col = unwrap(evalExpr(callArg(node.args, 1, ["column"]), env));
-    const row = unwrap(evalExpr(callArg(node.args, 2, ["row"]), env));
-    const text = evalAsString(callArg(node.args, 3, ["text"]), env) ?? undefined;
-    if (id != null && col != null && row != null) env.drawings.tableCell(id, col, row, text);
+  if (fname === "polyline.set_points") {
+    const id = drawId(node, env);
+    if (id != null) book.polylineSetPoints(id, pointsFromValue(evalExpr(callArg(node.args, 1, ["points"]), env)));
+    return NA;
+  }
+  if (fname === "polyline.set_line_color") {
+    const id = drawId(node, env);
+    if (id != null) book.polylineSetLineColor(id, drawRaw(node, env, 1, ["color"]));
+    return NA;
+  }
+  if (fname === "polyline.set_line_width") {
+    const id = drawId(node, env);
+    if (id != null) book.polylineSetLineWidth(id, drawRaw(node, env, 1, ["width"]));
+    return NA;
+  }
+  if (fname === "polyline.set_line_style") {
+    const id = drawId(node, env);
+    if (id != null) book.polylineSetLineStyle(id, drawRaw(node, env, 1, ["style"]));
+    return NA;
+  }
+  if (fname === "polyline.set_fill_color") {
+    const id = drawId(node, env);
+    if (id != null) book.polylineSetFillColor(id, drawRaw(node, env, 1, ["fill_color", "color"]));
+    return NA;
+  }
+  if (fname === "polyline.set_curved") {
+    const id = drawId(node, env);
+    if (id != null) book.polylineSetCurved(id, drawRaw(node, env, 1, ["curved"]));
+    return NA;
+  }
+  if (fname === "polyline.set_force_overlay") {
+    const id = drawId(node, env);
+    if (id != null) book.polylineSetForceOverlay(id, drawRaw(node, env, 1, ["force_overlay"]));
+    return NA;
+  }
+  if (fname === "polyline.set_closed") {
+    const id = drawId(node, env);
+    if (id != null) book.polylineSetClosed(id, drawRaw(node, env, 1, ["closed"]));
+    return NA;
+  }
+  if (fname === "polyline.set_xloc") {
+    const id = drawId(node, env);
+    if (id != null) book.polylineSetXloc(id, drawRaw(node, env, 1, ["xloc"]));
     return NA;
   }
   return undefined;
@@ -3767,9 +5828,54 @@ function evalTimeCall(fname: string | null, node: Call, env: Env): Value | undef
     const ms = calendarMs(node, env);
     return ms == null ? NA : timeTradingDay(ms);
   }
+  if (fname === "time_close") return barTimeClose(env);
+  if (fname === "timenow") {
+    const seeded = env.ctx.timenow;
+    if (typeof seeded === "number" && Number.isFinite(seeded)) return seeded;
+    if (typeof env.lastBarTime === "number" && Number.isFinite(env.lastBarTime)) return env.lastBarTime;
+    const t = env.ctx.time;
+    return typeof t === "number" && Number.isFinite(t) ? t : NA;
+  }
   return undefined;
 }
 
+function barTimeClose(env: Env): number {
+  const close = env.ctx.time_close;
+  if (typeof close === "number" && Number.isFinite(close)) return close;
+  const open = env.ctx.time;
+  return typeof open === "number" && Number.isFinite(open) ? open : 0;
+}
+
+function timeframeChange(node: Call, env: Env): Cell {
+  const arg = callArg(node.args, 0, ["timeframe", "tf"]);
+  if (arg == null) return 0;
+  const raw = evalExpr(arg, env);
+  const tf = typeof raw === "string" ? raw : typeof raw === "number" && Number.isFinite(raw) ? String(raw) : null;
+  if (tf == null || tf.trim() === "") return 0;
+  const curr = env.ctx.time;
+  if (typeof curr !== "number" || !Number.isFinite(curr)) return 0;
+  const hist = env.series.get("time");
+  const prev = hist != null && hist.length >= 2 ? hist.get(1) : null;
+  return timeframePeriodChanged(curr, prev, tf, env.barIndex) ? 1 : 0;
+}
+
+/** Python `split_symbol` / `extract_prefix`: text before the first `:`, else `""`. */
+function extractPrefix(symbol: string): string {
+  const s = symbol.trim();
+  const i = s.indexOf(":");
+  return i < 0 ? "" : s.slice(0, i);
+}
+
+function syminfoPrefix(node: Call, env: Env): string {
+  const arg = callArg(node.args, 0, ["tickerid", "symbol"]);
+  if (arg == null) return extractPrefix(env.symbol);
+  const raw = evalExpr(arg, env);
+  if (raw instanceof TickerId) return extractPrefix(raw.symbol);
+  if (typeof raw === "string") return extractPrefix(raw);
+  if (typeof raw === "number" && Number.isFinite(raw)) return extractPrefix(String(raw));
+  return "";
+}
+
 function calendarMs(node: Call, env: Env): number | null {
   const arg = callArg(node.args, 0, ["time", "timestamp"]);
   if (arg == null) return num(env.ctx.time);