@hoox-sh/pynets 0.2.0 → 0.3.0

package/src/runtime/compile/runtime.ts

@@ -32,6 +32,7 @@ import {
   mathMin,
   mathPow,
   mathRound,
+  mathRoundToMintick,
   mathSign,
   mathSin,
   mathSqrt,
@@ -58,7 +59,8 @@ import { LogBook, formatLogParts } from "../log.ts";
 import { resolveCurrencyRate } from "../request.ts";
 import { TaEngine } from "../ta.ts";
 import { utcPartsFromMs, timestamp, weekOfYear, timeTradingDay, type UtcParts } from "../time.ts";
-import { timeframeInSeconds } from "../timeframe.ts";
+import { TickerId } from "../ticker.ts";
+import { timeframeInSeconds, timeframePeriodChanged } from "../timeframe.ts";
 import { compileArray, compileMap, compileMatrix } from "./collections.ts";
 import { createCompileDraw } from "./draw.ts";
 import {
@@ -94,6 +96,11 @@ export function createCompileHelpers(opts?: CompileHelperOpts) {
   const ta = new TaEngine();
   const inputs = opts?.inputs;
   const book = new LogBook();
+  // Python `timeframe_in_seconds` defaults None / "" to "D" (daily, 86400)
+  // before parsing — builtins/timeframe.py:189-190. The shared helper in
+  // timeframe.ts maps na / empty → null, so compile wraps it here to match.
+  const timeframeInSecondsOrDaily = (p: string | null): number | null =>
+    timeframeInSeconds(p == null || p === "" ? "D" : p);
   return {
     na: NA_FN,
     nz,
@@ -174,7 +181,11 @@ export function createCompileHelpers(opts?: CompileHelperOpts) {
     timestamp,
     weekOfYear,
     timeTradingDay,
-    timeframeInSeconds,
+    timeframeInSeconds: timeframeInSecondsOrDaily,
+    timeframeChange,
+    timeClose,
+    roundToMintick,
+    syminfoPrefix,
     strLength,
     strContains,
     strStartsWith,
@@ -295,3 +306,52 @@ function calendarDayofweek(t: unknown): number | null {
 function logBar(bar: unknown): number {
   return typeof bar === "number" && Number.isFinite(bar) ? bar : 0;
 }
+
+/** `timeframe.change`: bar 0 is a new period; empty / unknown tf → false. */
+function timeframeChange(tf: unknown, curr: unknown, prev: unknown, barIndex: unknown): number {
+  const s =
+    typeof tf === "string"
+      ? tf
+      : typeof tf === "number" && Number.isFinite(tf)
+        ? String(tf)
+        : null;
+  if (s == null || s.trim() === "") return 0;
+  if (typeof curr !== "number" || !Number.isFinite(curr)) return 0;
+  const idx = typeof barIndex === "number" && Number.isFinite(barIndex) ? barIndex : null;
+  return timeframePeriodChanged(curr, prev, s, idx) ? 1 : 0;
+}
+
+/**
+ * Next bar open, last bar `time + 86400000`. `0` next-open counts as missing
+ * (interpret beginBar). Compile has no per-bar `time_close` column.
+ */
+function timeClose(barIdx: unknown, timeArr: unknown): number {
+  const i = typeof barIdx === "number" && Number.isFinite(barIdx) ? Math.trunc(barIdx) : 0;
+  const arr = Array.isArray(timeArr) ? (timeArr as Array<number | null | undefined>) : [];
+  const t = arr[i];
+  const tNum = typeof t === "number" && Number.isFinite(t) ? t : 0;
+  if (i + 1 < arr.length) {
+    const next = arr[i + 1] ?? 0;
+    return next !== 0 ? next : tNum;
+  }
+  return Math.trunc(tNum) + 86_400_000;
+}
+
+function roundToMintick(x: unknown): number | null {
+  return mathRoundToMintick(naNum(x), 0.01);
+}
+
+/** 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(tickerid?: unknown): string {
+  if (arguments.length === 0 || tickerid === undefined) return extractPrefix("SYMBOL");
+  if (tickerid instanceof TickerId) return extractPrefix(tickerid.symbol);
+  if (typeof tickerid === "string") return extractPrefix(tickerid);
+  if (typeof tickerid === "number" && Number.isFinite(tickerid)) return extractPrefix(String(tickerid));
+  return "";
+}

package/src/runtime/compile/strategy.ts

@@ -7,8 +7,10 @@
  */
 import {
   StrategyBook,
+  type BarOhlc,
   type BrokerSettings,
   type PlaceEntryOpts,
+  type PlaceExitOpts,
   type StrategyDirection,
   type StrategyEvent,
   type StrategySummary,
@@ -36,16 +38,68 @@ function str(v: unknown, fallback = ""): string {
   return String(v);
 }
 
+function optNum(v: unknown): number | null {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  return null;
+}
+
+function asExitOpts(v: unknown): PlaceExitOpts {
+  if (v == null || typeof v !== "object" || Array.isArray(v)) return {};
+  const rec = v as Record<string, unknown>;
+  return {
+    from_entry: rec.from_entry == null || rec.from_entry === "" ? null : String(rec.from_entry),
+    qty: optNum(rec.qty),
+    qty_percent: optNum(rec.qty_percent),
+    profit: optNum(rec.profit),
+    limit: optNum(rec.limit),
+    loss: optNum(rec.loss),
+    stop: optNum(rec.stop),
+    trail_price: optNum(rec.trail_price),
+    trail_points: optNum(rec.trail_points),
+    trail_offset: optNum(rec.trail_offset),
+    comment: rec.comment == null ? undefined : String(rec.comment),
+  };
+}
+
 export class CompileStrategy {
   readonly book: StrategyBook;
   private bar = 0;
   private mark = 0;
   private time = 0;
+  private ohlc: BarOhlc = {};
 
   constructor(settings?: BrokerSettings) {
     this.book = new StrategyBook(settings);
   }
 
+  /** Apply `strategy(...)` declaration kwargs (every bar, same as interpret). */
+  configure(settings?: unknown): void {
+    if (settings == null || typeof settings !== "object" || Array.isArray(settings)) return;
+    const rec = settings as Record<string, unknown>;
+    const broker: BrokerSettings = {};
+    const commission = optNum(rec.commission);
+    if (commission != null) broker.commission = commission;
+    const slippage = optNum(rec.slippage);
+    if (slippage != null) broker.slippage = slippage;
+    if (rec.pyramiding !== undefined) {
+      const pyr = optNum(rec.pyramiding);
+      broker.pyramiding = pyr == null ? undefined : Math.trunc(pyr);
+    }
+    if (typeof rec.avg_price_model === "string") broker.avg_price_model = rec.avg_price_model;
+    const leverage = optNum(rec.leverage);
+    if (leverage != null) broker.leverage = leverage;
+    const ml = optNum(rec.margin_long);
+    if (ml != null) broker.margin_long = ml;
+    const ms = optNum(rec.margin_short);
+    if (ms != null) broker.margin_short = ms;
+    if (typeof rec.default_qty_type === "string") broker.default_qty_type = rec.default_qty_type;
+    const dqv = optNum(rec.default_qty_value);
+    if (dqv != null) broker.default_qty_value = dqv;
+    if (Object.keys(broker).length) this.book.configure(broker);
+    const capital = optNum(rec.initial_capital);
+    if (capital != null) this.book.initialCapital = capital;
+  }
+
   beginBar(
     bar: unknown,
     open: unknown,
@@ -63,14 +117,16 @@ export class CompileStrategy {
       low: num(low, this.mark),
       close: this.mark,
     };
+    this.ohlc = ohlc;
     this.book.processPending(this.bar, ohlc);
     this.book.markOpenTrades(ohlc.high, ohlc.low, ohlc.close);
   }
 
   entry(id?: unknown, direction?: unknown, qty?: unknown, opts?: PlaceEntryOpts): void {
-    const q = qty == null ? 1 : num(qty, 1);
+    const fillPrice = opts?.price ?? this.mark;
+    const q = qty == null ? this.book.resolveDefaultQty(fillPrice) : num(qty, 1);
     this.book.placeEntry(this.bar, str(id, "entry"), asDir(direction), q, {
-      price: opts?.price ?? this.mark,
+      price: fillPrice,
       time: opts?.time ?? this.time,
       limit: opts?.limit,
       stop: opts?.stop,
@@ -80,8 +136,11 @@ export class CompileStrategy {
     });
   }
 
-  close(id?: unknown, _qty?: unknown): void {
-    this.book.fillClose(this.bar, str(id, ""), this.mark, { time: this.time });
+  close(id?: unknown, qty?: unknown): void {
+    this.book.fillClose(this.bar, str(id, ""), this.mark, {
+      time: this.time,
+      qty: optNum(qty),
+    });
   }
 
   close_all(_comment?: unknown): void {
@@ -100,8 +159,14 @@ export class CompileStrategy {
     this.book.cancelAll(this.bar);
   }
 
-  exit(from_entry?: unknown, _qty?: unknown): void {
-    this.book.fillClose(this.bar, str(from_entry, ""), this.mark, { time: this.time });
+  exit(id?: unknown, opts?: unknown): void {
+    const parsed = asExitOpts(opts);
+    this.book.placeExit(this.bar, str(id, "exit"), {
+      ...parsed,
+      price: this.mark,
+      time: this.time,
+      ohlc: this.ohlc,
+    });
   }
 
   position_size(): number {
@@ -131,6 +196,22 @@ export class CompileStrategy {
     return this.book.closedtrades;
   }
 
+  leverage(): number {
+    return this.book.leverage;
+  }
+
+  margin_liquidation_price(): number | null {
+    return this.book.marginLiquidationPrice();
+  }
+
+  position_avg_price(): number | null {
+    return this.book.position.avgPrice;
+  }
+
+  initial_capital(): number {
+    return this.book.initialCapital;
+  }
+
   risk_allow_entry_in(value?: unknown): void {
     this.book.riskAllowEntryIn(value);
   }

package/src/runtime/compile/types.ts

@@ -58,6 +58,8 @@ export interface EmitCtx {
   usesStrategy: boolean;
   nextSite: number;
   errors: string[];
+  /** `once`-structure fired flags, declared in the bar-loop frame. */
+  onceFlags: string[];
   /** Pine UDF name currently being emitted (null at script scope). */
   currentFunc: string | null;
   /** Formal names of the current UDF. */

package/src/runtime/drawings.ts

@@ -69,6 +69,37 @@ function cellKey(column: unknown, row: unknown): string | undefined {
   return `${column},${row}`;
 }
 
+function asIndex(value: unknown): number | null {
+  if (!isFiniteNumber(value)) return null;
+  return Math.trunc(value);
+}
+
+function parseCellKey(key: string): { col: number; row: number } | undefined {
+  const comma = key.indexOf(",");
+  if (comma < 0) return undefined;
+  const col = Number(key.slice(0, comma));
+  const row = Number(key.slice(comma + 1));
+  if (!isFiniteNumber(col) || !isFiniteNumber(row)) return undefined;
+  return { col, row };
+}
+
+function cloneExtra(extra?: Record<string, unknown>): Record<string, unknown> | undefined {
+  if (extra == null) return undefined;
+  const out: Record<string, unknown> = { ...extra };
+  if (out.cells != null && typeof out.cells === "object" && !Array.isArray(out.cells)) {
+    const cells: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(out.cells as Record<string, unknown>)) {
+      cells[k] = v != null && typeof v === "object" && !Array.isArray(v) ? { ...(v as Record<string, unknown>) } : v;
+    }
+    out.cells = cells;
+  }
+  if (Array.isArray(out.points)) {
+    out.points = out.points.map((p) => (p != null && typeof p === "object" ? { ...(p as Record<string, unknown>) } : p));
+  }
+  if (Array.isArray(out.merged)) out.merged = out.merged.slice();
+  return out;
+}
+
 export class DrawingBook {
   readonly items: DrawingEvent[] = [];
   private readonly byId = new Map<number, DrawingEvent>();
@@ -110,24 +141,33 @@ export class DrawingBook {
     return this.items.filter((e) => e.kind === kind && !e.deleted);
   }
 
+  /** Insertion-order ids of non-deleted objects of *kind* (Python `*.all`). */
+  allIds(kind: DrawingKind): number[] {
+    const ids: number[] = [];
+    for (const [id, ev] of this.byId) {
+      if (ev.kind === kind && !ev.deleted) ids.push(id);
+    }
+    return ids;
+  }
+
   lineNew(bar: number, extra?: Record<string, unknown>): number {
     return this.push("line", bar, { extra, cap: this.maxLines });
   }
 
-  labelNew(bar: number, text?: string): number {
-    return this.push("label", bar, { text, cap: this.maxLabels });
+  labelNew(bar: number, text?: string, extra?: Record<string, unknown>): number {
+    return this.push("label", bar, { text, extra, cap: this.maxLabels });
   }
 
-  boxNew(bar: number): number {
-    return this.push("box", bar, { cap: this.maxBoxes });
+  boxNew(bar: number, extra?: Record<string, unknown>): number {
+    return this.push("box", bar, { extra, cap: this.maxBoxes });
   }
 
-  tableNew(bar: number): number {
-    return this.push("table", bar);
+  tableNew(bar: number, extra?: Record<string, unknown>): number {
+    return this.push("table", bar, { extra });
   }
 
-  polylineNew(bar: number): number {
-    return this.push("polyline", bar, { cap: this.maxPolylines });
+  polylineNew(bar: number, extra?: Record<string, unknown>): number {
+    return this.push("polyline", bar, { extra, cap: this.maxPolylines });
   }
 
   linefillNew(bar: number, extraOrId1?: Record<string, unknown> | number, id2?: number): number {
@@ -364,6 +404,326 @@ export class DrawingBook {
     setAny(extra, "color", color);
   }
 
+  lineSetX1(id: number, x1: unknown): void {
+    this.setKindNum(id, "line", "x1", x1);
+  }
+
+  lineSetY1(id: number, y1: unknown): void {
+    this.setKindNum(id, "line", "y1", y1);
+  }
+
+  lineSetX2(id: number, x2: unknown): void {
+    this.setKindNum(id, "line", "x2", x2);
+  }
+
+  lineSetY2(id: number, y2: unknown): void {
+    this.setKindNum(id, "line", "y2", y2);
+  }
+
+  lineSetXloc(id: number, xloc: unknown): void {
+    this.setKindAny(id, "line", "xloc", xloc);
+  }
+
+  boxGetLeft(id: number): number | null {
+    return this.kindNum(id, "box", "left");
+  }
+
+  boxGetRight(id: number): number | null {
+    return this.kindNum(id, "box", "right");
+  }
+
+  boxGetTop(id: number): number | null {
+    return this.kindNum(id, "box", "top");
+  }
+
+  boxGetBottom(id: number): number | null {
+    return this.kindNum(id, "box", "bottom");
+  }
+
+  boxSetLeft(id: number, left: unknown): void {
+    this.setKindNum(id, "box", "left", left);
+  }
+
+  boxSetRight(id: number, right: unknown): void {
+    this.setKindNum(id, "box", "right", right);
+  }
+
+  boxSetTop(id: number, top: unknown): void {
+    this.setKindNum(id, "box", "top", top);
+  }
+
+  boxSetBottom(id: number, bottom: unknown): void {
+    this.setKindNum(id, "box", "bottom", bottom);
+  }
+
+  boxSetLeftTop(id: number, left: unknown, top: unknown): void {
+    const extra = this.extraOf(id, "box");
+    if (!extra) return;
+    setNum(extra, "left", left);
+    setNum(extra, "top", top);
+  }
+
+  boxSetRightBottom(id: number, right: unknown, bottom: unknown): void {
+    const extra = this.extraOf(id, "box");
+    if (!extra) return;
+    setNum(extra, "right", right);
+    setNum(extra, "bottom", bottom);
+  }
+
+  boxSetBorderWidth(id: number, width: unknown): void {
+    this.setKindNum(id, "box", "border_width", width);
+  }
+
+  boxSetBorderStyle(id: number, style: unknown): void {
+    this.setKindAny(id, "box", "border_style", style);
+  }
+
+  boxSetXloc(id: number, xloc: unknown): void {
+    this.setKindAny(id, "box", "xloc", xloc);
+  }
+
+  boxSetClosed(id: number, closed: unknown): void {
+    this.setKindAny(id, "box", "closed", closed);
+  }
+
+  boxSetTextColor(id: number, color: unknown): void {
+    this.setKindAny(id, "box", "text_color", color);
+  }
+
+  boxSetTextFontFamily(id: number, font: unknown): void {
+    this.setKindAny(id, "box", "text_font_family", font);
+  }
+
+  boxSetTextHalign(id: number, halign: unknown): void {
+    this.setKindAny(id, "box", "text_halign", halign);
+  }
+
+  boxSetTextValign(id: number, valign: unknown): void {
+    this.setKindAny(id, "box", "text_valign", valign);
+  }
+
+  boxSetTextSize(id: number, size: unknown): void {
+    this.setKindAny(id, "box", "text_size", size);
+  }
+
+  boxSetTextFormatting(id: number, formatting: unknown): void {
+    this.setKindAny(id, "box", "text_formatting", formatting);
+  }
+
+  boxSetTextWrap(id: number, wrap: unknown): void {
+    this.setKindAny(id, "box", "text_wrap", wrap);
+  }
+
+  labelSetX(id: number, x: unknown): void {
+    this.setKindNum(id, "label", "x", x);
+  }
+
+  labelSetY(id: number, y: unknown): void {
+    this.setKindNum(id, "label", "y", y);
+  }
+
+  labelSetTextcolor(id: number, color: unknown): void {
+    this.setKindAny(id, "label", "textcolor", color);
+  }
+
+  labelSetTextFontFamily(id: number, font: unknown): void {
+    this.setKindAny(id, "label", "text_font_family", font);
+  }
+
+  labelSetTextHalign(id: number, halign: unknown): void {
+    this.setKindAny(id, "label", "text_halign", halign);
+  }
+
+  labelSetTextValign(id: number, valign: unknown): void {
+    this.setKindAny(id, "label", "text_valign", valign);
+  }
+
+  labelSetTextSize(id: number, size: unknown): void {
+    this.setKindAny(id, "label", "text_size", size);
+  }
+
+  labelSetTextFormatting(id: number, formatting: unknown): void {
+    this.setKindAny(id, "label", "text_formatting", formatting);
+  }
+
+  labelSetBorderColor(id: number, color: unknown): void {
+    this.setKindAny(id, "label", "border_color", color);
+  }
+
+  labelSetBorderWidth(id: number, width: unknown): void {
+    this.setKindNum(id, "label", "border_width", width);
+  }
+
+  labelSetBorderStyle(id: number, style: unknown): void {
+    this.setKindAny(id, "label", "border_style", style);
+  }
+
+  labelSetXloc(id: number, xloc: unknown): void {
+    this.setKindAny(id, "label", "xloc", xloc);
+  }
+
+  labelSetYloc(id: number, yloc: unknown): void {
+    this.setKindAny(id, "label", "yloc", yloc);
+  }
+
+  tableCellGetText(id: number, column: unknown, row: unknown): string | null {
+    const rec = this.cellRec(id, column, row);
+    if (!rec) return null;
+    if (rec.text === undefined) return null;
+    return rec.text == null ? "" : String(rec.text);
+  }
+
+  tableCellSetField(id: number, column: unknown, row: unknown, field: string, value: unknown): void {
+    this.upsertCell(id, column, row, undefined, false);
+    const rec = this.cellRec(id, column, row);
+    if (!rec) return;
+    rec[field] = value;
+  }
+
+  tableSetBgcolor(id: number, color: unknown): void {
+    this.setKindAny(id, "table", "bgcolor", color);
+  }
+
+  tableSetBorderColor(id: number, color: unknown): void {
+    this.setKindAny(id, "table", "border_color", color);
+  }
+
+  tableSetBorderWidth(id: number, width: unknown): void {
+    this.setKindNum(id, "table", "border_width", width);
+  }
+
+  tableSetFrameColor(id: number, color: unknown): void {
+    this.setKindAny(id, "table", "frame_color", color);
+  }
+
+  tableSetFrameWidth(id: number, width: unknown): void {
+    this.setKindNum(id, "table", "frame_width", width);
+  }
+
+  tableClear(
+    id: number,
+    startRow?: unknown,
+    startCol?: unknown,
+    endRow?: unknown,
+    endCol?: unknown,
+  ): void {
+    const extra = this.extraOf(id, "table");
+    if (!extra) return;
+    if (startRow === undefined) {
+      extra.cells = {};
+      return;
+    }
+    const r0 = asIndex(startRow);
+    const c0 = asIndex(startCol);
+    const r1 = asIndex(endRow);
+    const c1 = asIndex(endCol);
+    if (r0 == null || c0 == null || r1 == null || c1 == null) return;
+    const prev = extra.cells;
+    if (prev == null || typeof prev !== "object" || Array.isArray(prev)) return;
+    const cells = prev as Record<string, unknown>;
+    for (const key of Object.keys(cells)) {
+      const parsed = parseCellKey(key);
+      if (parsed == null) continue;
+      if (r0 <= parsed.row && parsed.row <= r1 && c0 <= parsed.col && parsed.col <= c1) {
+        delete cells[key];
+      }
+    }
+  }
+
+  tableMergeCells(
+    id: number,
+    startRow: unknown,
+    startCol: unknown,
+    endRow: unknown,
+    endCol: unknown,
+  ): void {
+    const extra = this.extraOf(id, "table");
+    if (!extra) return;
+    const r0 = asIndex(startRow);
+    const c0 = asIndex(startCol);
+    const r1 = asIndex(endRow);
+    const c1 = asIndex(endCol);
+    if (r0 == null || c0 == null || r1 == null || c1 == null) return;
+    if (r1 < r0 || c1 < c0) return;
+    const prev = extra.merged;
+    const merged = Array.isArray(prev) ? prev : [];
+    if (merged !== prev) extra.merged = merged;
+    merged.push([r0, c0, r1, c1]);
+  }
+
+  polylineGetPoints(id: number): unknown[] {
+    const ev = this.byId.get(id);
+    if (!ev || ev.kind !== "polyline" || ev.deleted) return [];
+    const pts = ev.extra?.points;
+    return Array.isArray(pts) ? pts.slice() : [];
+  }
+
+  polylineSetPoints(id: number, points: unknown): void {
+    const extra = this.extraOf(id, "polyline");
+    if (!extra) return;
+    extra.points = Array.isArray(points) ? points.filter((p) => p != null) : [];
+  }
+
+  polylineSetLineColor(id: number, color: unknown): void {
+    this.setKindAny(id, "polyline", "color", color);
+  }
+
+  polylineSetLineWidth(id: number, width: unknown): void {
+    this.setKindNum(id, "polyline", "width", width);
+  }
+
+  polylineSetLineStyle(id: number, style: unknown): void {
+    this.setKindAny(id, "polyline", "style", style);
+  }
+
+  polylineSetFillColor(id: number, color: unknown): void {
+    this.setKindAny(id, "polyline", "fill_color", color);
+  }
+
+  polylineSetCurved(id: number, curved: unknown): void {
+    this.setKindAny(id, "polyline", "curved", curved);
+  }
+
+  polylineSetForceOverlay(id: number, force: unknown): void {
+    this.setKindAny(id, "polyline", "force_overlay", force);
+  }
+
+  polylineSetClosed(id: number, closed: unknown): void {
+    this.setKindAny(id, "polyline", "closed", closed);
+  }
+
+  polylineSetXloc(id: number, xloc: unknown): void {
+    this.setKindAny(id, "polyline", "xloc", xloc);
+  }
+
+  linefillGetLine1(id: number): number | null {
+    return this.kindNum(id, "linefill", "id1");
+  }
+
+  linefillGetLine2(id: number): number | null {
+    return this.kindNum(id, "linefill", "id2");
+  }
+
+  tableDelete(id: number): void {
+    this.markDeleted(id);
+  }
+
+  polylineDelete(id: number): void {
+    this.markDeleted(id);
+  }
+
+  linefillDelete(id: number): void {
+    this.markDeleted(id);
+  }
+
+  /** Clone a drawing; missing id → null. New object is not marked deleted. */
+  copy(id: number): number | null {
+    const ev = this.byId.get(id);
+    if (!ev) return null;
+    const extra = cloneExtra(ev.extra);
+    return this.push(ev.kind, ev.bar, { text: ev.text, extra, cap: this.capFor(ev.kind) });
+  }
+
   /** Compact non-deleted items for RuntimeResult.drawings. */
   exportForApi(): Array<{
     kind: DrawingKind;
@@ -420,6 +780,43 @@ export class DrawingBook {
     return id;
   }
 
+  private capFor(kind: DrawingKind): number | undefined {
+    if (kind === "line") return this.maxLines;
+    if (kind === "label") return this.maxLabels;
+    if (kind === "box") return this.maxBoxes;
+    if (kind === "polyline") return this.maxPolylines;
+    return undefined;
+  }
+
+  private setKindNum(id: number, kind: DrawingKind, key: string, value: unknown): void {
+    const extra = this.extraOf(id, kind);
+    if (!extra) return;
+    setNum(extra, key, value);
+  }
+
+  private setKindAny(id: number, kind: DrawingKind, key: string, value: unknown): void {
+    const extra = this.extraOf(id, kind);
+    if (!extra) return;
+    setAny(extra, key, value);
+  }
+
+  private kindNum(id: number, kind: DrawingKind, key: string): number | null {
+    const ev = this.byId.get(id);
+    if (!ev || ev.kind !== kind) return null;
+    return this.extraNum(id, key);
+  }
+
+  private cellRec(id: number, column: unknown, row: unknown): Record<string, unknown> | undefined {
+    const extra = this.extraOf(id, "table");
+    const key = cellKey(column, row);
+    if (!extra || key == null) return undefined;
+    const prev = extra.cells;
+    if (prev == null || typeof prev !== "object" || Array.isArray(prev)) return undefined;
+    const cur = (prev as Record<string, unknown>)[key];
+    if (cur == null || typeof cur !== "object" || Array.isArray(cur)) return undefined;
+    return cur as Record<string, unknown>;
+  }
+
   private extraOf(id: number, kind?: DrawingKind): Record<string, unknown> | undefined {
     const ev = this.byId.get(id);
     if (!ev) return undefined;