Limits reference

Every ceiling an Indicator runs under, in one place: the declaration caps the sheet validator enforces, the runtime ceilings the sandbox enforces on every evaluation, the data-plane bounds, and the package bounds. Each row gives the exact number, what it protects, the shape that hits it, and the refusal it produces. kScript (legacy) documents its sandbox the same way; the mapping between the two lists is at the end, because most kScript limits count objects a script creates at run time and an Indicator declares almost everything once.

Declaration caps

Checked by the same schema at author, build, install, and publish, so a sheet over a cap fails in the Problems lane or on om wrun build, never on a chart. Every refusal names the path (boxes.0.top, renderers.2.size).

Names share one namespace across outputs, boxes, segments, renderers, and drawings; color_by, width_by, and shape_where cannot name their own output; each ladder half without the other is refused by name. The full validation list is at the end of Script definition.

Runtime ceilings

Enforced on every evaluation by the sandbox, on the chart and on your machine alike. A breach refuses the WHOLE evaluation by name; nothing is truncated, clamped, or silently dropped.

The export contract is checked statically before any of this: the four exports with exact signatures, exported memory when the cell, string, or polyline channel is imported, every present draw import with its exact signature, and an import set limited to the ABI's allowlist (a rejection lists the legal set and, for a draw import under an older contract, names abi_version "wrun-3" as the way in). Those messages are in Common errors.

Data-plane bounds

Package bounds

Nothing from a package executes at install time, the module runs sandboxed (no filesystem, no network, no order capability), and an install verifies wasm_sha256 before every run.

kScript (legacy) limits, mapped

Notes that save debugging time

• max_cells is a contract, not a hint. Size the buffer from the generated in_<input>_capacity (tuples x width), and give a book input a max_depth so the cap is knowable: 2 x max_depth tuples.
• Strings never truncate. Pick max_bytes for the longest line the slot will ever carry; the generated builder counts the bytes a line REQUIRES, so an oversize line refuses by name instead of clipping.
• Most caps are counts of declarations. You meet them at build time, in the Problems lane or on om wrun build, and the message names the field. A repeating shape is one declaration gated per bar with when, never one declaration per occurrence.
• The render cap counts expanded bytes. Thirty-two text renderers over a long history with long strings is the shape that reaches 2 MiB; leave slots unwritten on quiet bars so those rows select nothing.
• Delete what you no longer draw. A handle stays alive until delete(); the per-kind cap is met by the tracker that creates a zone on every pivot and never frees one. Keep a bounded pool of ids and delete the oldest before reusing its id, and re-send only the handles that changed on a bar (the calls-per-bar cap counts every setter).
• Allocate once. Buffers are sized at module start or in init() from a param's max; per-bar allocation is the one pattern that both slows a long history and trips the no-growth rule.

Example: the caps as contracts

A book-imbalance Indicator that sizes everything from its declarations: max_depth bounds the fetch, max_cells is exactly twice it, the cell buffer comes from the generated capacity, and the readout slot is sized for its longest line:

import { book, input, line, lower, ohlcv, output, render, string } from "./sdk/declare";
import { in_book_capacity, in_book_cells, in_book_read, in_close } from "./gen/inputs";
import { emitRow, out_imbalance } from "./gen/outputs";
import { sb_clear, sb_int, sb_text, str_depth_sb } from "./gen/strings";

input("close", ohlcv.close);
// max_depth caps each side at 20 levels, so a bar can never carry more than 40 tuples:
// max_cells is a contract, and a bigger block would refuse the whole evaluation.
input("book", book.cells, { max_cells: 40, block_size: 10, max_depth: 20 });
output("imbalance", line, lower, { unit: "ratio" });
// The longest line is "20 bids / 20 asks" (17 bytes); 32 leaves room and stays under the 4096 cap.
string("depth", { max_bytes: 32 });
render.text("depth_mark", { y: "imbalance", text: "depth", size: 10 });

// Sized once from the generated capacity: max_cells x 3 cells per [price, size, side] tuple.
const cells = new StaticArray<f64>(in_book_capacity);
let imbalance: f64 = NaN;
let bids: i32 = 0;
let asks: i32 = 0;

export function init(): void {}

export function state(): i32 {
  in_close();
  const n = in_book_cells();
  if (n <= 0) return 0;
  if (in_book_read(i32(changetype<usize>(cells))) < 0) return 0;
  let bidSize = 0.0;
  let askSize = 0.0;
  bids = 0;
  asks = 0;
  for (let i = 0; i + 2 < n; i += 3) {
    if (cells[i + 2] > 0.0) {
      bidSize += cells[i + 1];
      bids += 1;
    } else {
      askSize += cells[i + 1];
      asks += 1;
    }
  }
  const total = bidSize + askSize;
  imbalance = total > 0.0 ? (bidSize - askSize) / total : NaN;
  return isNaN(imbalance) ? 0 : 1;
}

export function finalize(): void {
  out_imbalance(imbalance);
  sb_clear();
  sb_int(bids);
  sb_text(" bids / ");
  sb_int(asks);
  sb_text(" asks");
  str_depth_sb();
  emitRow();
}

export function reset(): void {
  imbalance = NaN;
  bids = 0;
  asks = 0;
}

Pick the venue's bucket width for block_size first:

om block-sizes --exchange BINANCE_FUTURES