Engine messages

Messages that come from the engine while a script runs or from the platform's limits. One table, with what each means and what to do about it.

Diagnostics covers what the editor finds by reading your script. This page covers what the engine reports while the script runs, and the limits the platform sets. The numbers are on Limits and budgets.

Two words need explaining. The sandbox is the protected process in which the platform runs a script for an alert, with a fixed amount of time and memory. The watchdog is the clock that stops a run that goes on too long. A library here is a module, the thing an import brings in (see Modules and libraries).

A run-time message names the bar where it happened, and the line of the script. If a script ran fine on the history and stops on a new bar, the bar's data is what is different: look at the values on the bar the message names.

The table lists the engine's own words, in English, as the editor shows them. A part that changes is in braces ({n}); a part in square brackets is added only when it applies. Some codes have more than one sentence, for different causes: each has its own row, and the rows after the first start with ↳ and the same code. The codes E5101 to E5142 are errors found when the script is compiled, E5601 to E5640 are errors that stop the script while it runs, and the W- codes are warnings that let it run.

Code	Message	What to do
`E-COMPILE-REPEAT`	Calls of a function with several versions (by parameter type) or of a method name that several types share are nested too deep here: the chart compiles their arguments again for every version. Put the inner call in a variable first	The compiler would have to build a very large number of copies of the same calls. Give the inner call a name with `let`, and use the name.
↳ `E-COMPILE-REPEAT`	This script defines too many functions of one name for the calls it makes of them: the chart compiles every call once for each of them. Give them different names	Give the functions that share a name different names.
`E-IMPORT-COUNT`	This script imports too many libraries: {max} is the most[ (every import counts, the ones inside libraries too)]	Import fewer modules, or combine small ones into one.
`E-IMPORT-CYCLE`	This import is a circle: {chain}. A library cannot import itself, directly or through other libraries (or, for a bundle, through others)	Remove the import that closes the circle. The message names the chain of modules.
`E-IMPORT-DEPTH`	Libraries import each other more than {max} levels deep ({chain})[. Import fewer levels of libraries]	Flatten the modules so that a chain of imports is shorter.
`E-IMPORT-SIZE`	The libraries this script imports are too large together: {max} characters is the most[ (counted once per import)]	Split the modules, or import only the ones this script needs.
↳ `E-IMPORT-SIZE`	Too large to keep: the script may have {entry} characters, the whole {total}, and {modules} modules	The script together with its modules is too big to be stored. Make the script or the modules shorter.
`E-LIMIT-DEPTH`	"{name}" is called more than {max} calls deep: a chain that long should be a loop	Your functions called one another more than 64 levels deep on one bar. A function that calls itself is refused before the run (`E3310`); this message comes from a chain that got past the checker, such as methods that share a name. Turn the chain into a loop, or make it shallower.
`E-LIMIT-DRAW`	A polyline has at most {max} points (this one has {length})	Draw fewer points in one polyline, or split it into several.
↳ `E-LIMIT-DRAW`	The polylines of the script hold {held} points together; the limit is {limit}	Keep fewer polylines, or fewer points in them; delete the ones you no longer show.
`E-LIMIT-HISTORY`	On bar {bar} the script reads {k} bars back; this series keeps {depth} (the most is {cap}).	A read with `[]` went further back than the series keeps. The series keeps as many bars as the text of the script says it reads (a written number, an input with a `max`, arithmetic on those) and never more than 8,192. Give the input a smaller `max` or read fewer bars back. A `na` is only for a value the chart does not have; a read past the limit is an error, never a `na`.
↳ `E-LIMIT-HISTORY`	On bar {bar} {fn} is given a window of {window} bars; the most is {cap}.	The window of a function such as `tech.sma` is longer than any series keeps (8,192). Use a shorter window, or give the input a smaller `max`.
`E-LIMIT-HISTORY-STATIC`	{what} is {k} bars; no series or window keeps more than {cap}. Use a smaller number	An offset or a window length written in the script is more than 8,192. This is found before the script runs. Write a smaller number.
`E-LIMIT-ITEMS`	The {what} is too large: {n} elements (at most {max})	Keep a window of the newest items instead of all of them: remove from the front with `.shift()` as you push.
↳ `E-LIMIT-ITEMS`	The {what} is too large: at least {n} elements (at most {max})	The same limit. The count stopped at the first element over it, so the real size is not known; it is at least {n}.
↳ `E-LIMIT-ITEMS`	The map is too large: {pairs} pairs (at most {maxPairs})	Keep fewer keys in a map; remove the ones you no longer need.
↳ `E-LIMIT-ITEMS`	The matrix is too large: {cells} elements (at most {maxCells})	Make the matrix smaller, or keep several smaller ones.
↳ `E-LIMIT-ITEMS`	The matrix is too large: {rows} rows by {cols} columns (at most {maxSide} of either)	Neither side of a matrix may be longer than the limit; make the matrix shorter or narrower.
`E-LIMIT-MEMORY`	The script holds too much memory on bar {bar}: about {held} bytes; a run may hold {heldCap}.	The arrays, maps, texts, objects, drawings and history of the script held together are more than 134,217,728 bytes at one moment. The bytes are counted in the same way on every machine, not taken from the browser. Keep a window of the newest items, delete what you no longer need, or make fewer and smaller collections.
↳ `E-LIMIT-MEMORY`	The script builds too much on bar {bar}: {built} bytes over the run; a run may build {builtCap}.	All that the script has built over the whole run, even what it already let go, is more than 2,147,483,648 bytes. A loop that builds a large array or text on every bar is the usual cause: build it once, or build less of it.
`E-LIMIT-OPS`	The script takes too long on bar {bar}[ ({at} UTC)]: this bar used more than {barCap} steps (a loop that runs too long, or a very long list or window); one bar may use {barCap}	The script did too much work on one bar. Look for a loop that is too long or that never ends, and for work that could be done once instead of on this bar.
↳ `E-LIMIT-OPS`	The script takes too long on this chart: {steps} steps over {bars} bars; one run may use {runCap}. Make the work of each bar smaller	The whole run did too much work. Do less on each bar, or keep a shorter window.
↳ `E-LIMIT-OPS`	The script takes too long: its function calls branch into too many separate copies of each function	Calls that branch into many copies of one function make the compile too large. Call a function once and keep the result in a variable.
`E-LIMIT-REGEX`	The pattern of text.match is too big: the limit is 256 characters and 2048 instructions	A pattern may have 256 characters, and once its repeats are written out in full (`a{3}` is `aaa`) at most 2,048 instructions; a repeat count is at most 1,000. Write a shorter pattern or smaller counts, or split the work into two matches.
`E-LIMIT-TABLE`	The tables of the script hold {held} cells together; the limit is {maxLive}. Delete a table the script no longer shows (table.delete) before it makes another	Delete a table you no longer show with `table.delete` before you make another, or build the table once on the last bar.
↳ `E-LIMIT-TABLE`	A table has at most {maxCols} columns and {maxRows} rows (this one asks for {cols} × {rows})	Make the table smaller.
↳ `E-LIMIT-TABLE`	A table has at most {maxCells} cells (this one asks for {cols} × {rows} = {cells})	Make the table smaller.
↳ `E-LIMIT-TABLE`	Cell ({c}, {r}) is outside the table ({cols} columns × {rows} rows)	Write only cells inside the table: columns and rows are counted from 0.
`E-LIMIT-TEXT`	{fn} would build a text longer than {textLimit} characters	Build shorter texts; a text that grows on every bar needs a cap.
↳ `E-LIMIT-TEXT`	"{fn}": a map key is at most {keyLimit} characters (this one has {keyLength})	Use a shorter key.
↳ `E-LIMIT-TEXT`	{fn} reads a text of at most {readLimit} characters (this one has {readLength})	Give the function a shorter text.
`E-LIMIT-TIME`	The script ran longer than the time a run may take	The script is too slow for the time one run gets. Do less work per bar, or draw fewer objects.
`E-SANDBOX-BUSY`	the sandbox queue is full	The platform is busy running other scripts. Try again in a moment.
`E-SANDBOX-CRASH`	the sandbox is closed	The platform is restarting. Try again in a moment.
↳ `E-SANDBOX-CRASH`	a worker could not be started	Try again. If it happens every time, send the script to support.
↳ `E-SANDBOX-CRASH`	the worker died while running the script	Try again. If it happens every time with the same script, send the script to support.
↳ `E-SANDBOX-CRASH`	the worker exited while running the script	Try again. If it happens every time with the same script, send the script to support.
`E-SANDBOX-JOB`	a job is an object	A fault of the platform, not of your script. Try again, and if it keeps failing send the script to support.
↳ `E-SANDBOX-JOB`	the job could not be sent: {reason}	A fault of the platform, not of your script. Try again, and if it keeps failing send the script to support.
↳ `E-SANDBOX-JOB`	unknown job kind "{kind}"	A fault of the platform, not of your script. Send the script to support.
↳ `E-SANDBOX-JOB`	{text}	The sandbox reports a failure in its own words. Try again, and if it keeps failing send the script to support.
`E-SANDBOX-OOM`	the script used more memory than a job may (heap limit)	The script holds too much in memory. Keep fewer items, shorter texts and fewer drawings.
↳ `E-SANDBOX-OOM`	the process passed {mb} MB of memory	The script holds too much in memory. Keep fewer items, shorter texts and fewer drawings.
`E-SANDBOX-TIMEOUT`	the script ran longer than {ms} ms	The script took too long to run for an alert. Do less work per bar.
`E-SCRIPT`	{message}	The protected process that runs scripts for alerts ran your script and it stopped with an error of its own. The message carries that error: look it up in Diagnostics or on this page.
`E5000`	{message}	The engine stopped the script with a message that has no code of its own yet. The text is the engine's own sentence; it names the line and says what to change.
`E5001`	Internal error of the formatter: {message}	The formatter could not write the text back. This is a fault of the platform, not of your script. Send the script to support.
`E5101`	A session must be declared at the top of the script (not inside if, for or a function)	Move the session declaration to the top level of the file, before any `if`, loop or function. The `session NAME = …` form is the plain way to declare a session.
`E5102`	alert.send({what} = …) must be written in the script (a text or a number), not computed or read from an input	Write the value in the script as a text or a number (`key = "breakout"`, `cooldown = 3`). It cannot be computed or read from an input.
`E5103`	alert.send(cooldown = …) is a number of bars, 0 or more	Give `cooldown` a number of bars, 0 or more.
`E5104`	id must be a name written in the script, as a text: letters, digits and _, starting with a letter or _	Write `id = "my_plot"`: a name in quotes, made of letters, digits and `_`, starting with a letter or `_`. See Ids.
`E5105`	was must be a text written in the script: the earlier id, or several separated by spaces	Write `was = "old_id"` as a text in the script. To list several earlier ids, separate them with spaces.
`E5106`	was: "{w}" is not a name	Each earlier id in `was` must be a name: letters, digits and `_`, starting with a letter or `_`.
`E5107`	was: "{w}" is the id itself	`was` names an id the plot had before. Remove the id that is the plot's present id.
`E5108`	The id "{written}" is already used by {holder}	Two things in the script cannot share an id. Give one of them another id.
`E5109`	An input's default value must be a constant	The default of an input must be a constant: a number, a text, `true`, `false` or a colour, not a value that depends on the bars.
`E5110`	The options of an input are a list in brackets: [a, b, c]	Write the options of an input as a list in square brackets: `["a", "b", "c"]`.
`E5111`	Every option of an input must be a constant	Write each option of an input as a constant, not as a value that depends on the bars.
`E5112`	{name}(…) must be called on the top level of the script (not inside if, for or a function)	Move the call to the top level of the file, outside any `if`, loop or function. To draw only sometimes, give it a value that is `na` the rest of the time.
`E5113`	level(…) must be called on the top level of the script	Move `hline(…)` to the top level of the file.
`E5114`	level(…) needs a constant price (a number or an input)	Give `hline` a constant price: a number, or an input.
`E5115`	shade(…) must be called on the top level of the script	Move `fill(…)` to the top level of the file.
`E5116`	shade(…) takes two plots or two levels (the values plot(…) / level(…) returned)	Give `fill` the two things it shades between: keep the result of each `plot(…)` or `hline(…)` in a name and pass the names.
`E5117`	alert.when(…) must be called on the top level of the script (not inside if, for or a function)	Move `alert.when(…)` to the top level of the file, outside any `if`, loop or function.
`E5118`	alert.when(…, on = …) must be the text "rises" or "level", written in the script	Write `on = "rises"` or `on = "level"` as a text in the script.
`E5119`	data.series needs an expression to read	Give `data.series` its third argument: the expression to read on the other timeframe.
`E5120`	"{name}" is already declared here; give it a new value with :=	A name is declared once. To give a variable a new value, write `name := value`; to make a second variable, give it another name.
`E5121`	A return is only valid inside a function	`return` belongs inside a `fn`. Remove it, or move the code into a function.
`E5122`	"{name}" is not declared; declare it with = first	Declare the variable before you change it: `mut name = value`, then `name := value`.
`E5123`	Only a variable or a field can be given a new value	Only a variable (`mut`) or a field can be given a new value with `:=`.
`E5124`	Functions are defined at the top level of a script	Write the `fn` at the top level of the file, not inside an `if`, a loop or another function.
`E5125`	Parameter "{name}" is listed twice	Give each parameter of a function its own name.
`E5126`	The library "{path}" is not in your scripts. Add it under My scripts (as a library) and try again	Add the library under My scripts (as a library) and try again.
`E5127`	"{name}" is a function: call it with ( )	A function is used by calling it: add the brackets, `name()`.
`E5128`	"{name}" is not declared	Check the spelling of the name, and declare it above its first use.
`E5129`	"{member}" is not a member of {owner}	Check the name after the dot. The function index lists the names the engine has.
`E5130`	"{d}" is a function: call it with ( )	A function is used by calling it: add the brackets.
`E5131`	"{d}" is not a built-in variable this chart knows	Check the name against the function index. This chart does not have that built-in variable.
`E5132`	{what} takes at most {length} argument(s)	Remove the extra arguments.
`E5133`	{what} has no argument "{name}"	Check the name of the argument against the function. The function index lists the parameters.
`E5134`	Create a {name} with {name}.new(…)	Make the object with its `.new(…)` function, for example `line.new(…)`.
`E5135`	"{name}" is not a function this chart knows	Check the name against the function index.
`E5136`	The library "{lib}" has no function "{fn}"	Check the name of the function against what the library exports.
`E5137`	"{d}" is not supported on this chart yet	This feature is not available on the chart yet. See Limits and budgets.
`E5138`	Only names can be called	Only a name can be called. Put the value in a `let` and call that.
`E5139`	{name}.copy takes the object to copy	Give `.copy` the object to copy.
`E5140`	"{name}" is not a method this chart knows	Check the name of the method against the function index.
`E5141`	This constant is built from other constants too many times over (each one is used twice or more by the next). Put a value in a variable once and use that	A constant that uses other constants twice or more at each step grows too large when the engine folds it. Put a value in a variable once and use the variable.
`E5142`	This is a library: other scripts import it; it does not draw on its own	A library is imported by other scripts and draws nothing on its own. Import it from an indicator or a strategy.
`E5601`	"{fn}": the {what} is na	A function got `na` where it needs a value. Look at the value on the bar the message names (a series is `na` until it has enough bars) and guard it with `nz()` or `??`.
`E5602`	Index {i} is out of bounds (array size is {n})	Check the index against the size of the array before you read it.
`E5603`	"{fn}": the size cannot be negative ({n})	A size is a number from 0 up.
`E5604`	Cannot call "array.pop" on an empty array	Check that the array is not empty before `pop`.
`E5605`	Cannot call "array.shift" on an empty array	Check that the array is not empty before `shift`.
`E5606`	"array.slice": from ({i}) is after to ({j})	`index_from` must not be after `index_to`.
`E5607`	"array.covariance" needs two arrays of the same size ({lengthX} and {lengthY})	Give `covariance` two arrays of the same size.
`E5608`	"map.set": the key is na (a map key must have a value)	A map key needs a value: guard a key that can be `na`.
`E5609`	Row {i} is out of bounds (the matrix has {rows} rows)	Check the row number against the number of rows of the matrix. Rows are counted from 0.
`E5610`	Column {j} is out of bounds (the matrix has {cols} columns)	Check the column number against the number of columns of the matrix. Columns are counted from 0.
`E5611`	{what} {i} is out of bounds (the matrix has {size} {unit})	Check the number against the size of the matrix. Counting starts at 0.
`E5612`	{what} {j} is out of bounds (the matrix has {size} {unit})	Check the number against the size of the matrix. Counting starts at 0.
`E5613`	"{fn}": from_{what} ({i}) is after to_{what} ({j})	The start must not be after the end.
`E5614`	"{fn}" needs a square matrix (this one is {rows}x{cols})	This function works on a matrix with as many rows as columns.
`E5615`	"matrix.new": the size cannot be negative ({rows}x{cols})	A size is a number from 0 up.
`E5616`	"{fn}": the array has {elements} elements but the matrix has {cols} columns	The array must have as many elements as the matrix has columns.
`E5617`	"{fn}": the array has {elements} elements but the matrix has {rows} rows	The array must have as many elements as the matrix has rows.
`E5618`	"{fn}": the matrix has no rows	The matrix is empty: add rows before you call this.
`E5619`	"{fn}": the matrix has no columns	The matrix is empty: add columns before you call this.
`E5620`	"{fn}": a {rowsOld}x{colsOld} matrix ({elements} elements) cannot become {rowsNew}x{colsNew}	The new shape must hold the same number of elements as the matrix has.
`E5621`	"{fn}": the matrices have {colsA} and {colsB} columns	The matrices must have the same number of columns.
`E5622`	"{fn}" needs two matrices of the same size ({rowsA}x{colsA} and {rowsB}x{colsB})	The two matrices must be the same size.
`E5623`	"{fn}": the first matrix has {cols} columns but the second has {rows} rows	The first matrix must have as many columns as the second has rows.
`E5624`	"{fn}": the matrix has {cols} columns but the array has {elements} elements	The array must have as many elements as the matrix has columns.
`E5625`	"{fn}": the power cannot be negative ({p})	The power is a number from 0 up.
`E5626`	A table needs a number of columns and rows	Give the table its number of columns and rows.
`E5627`	Unknown pivot point type "{type}" (Traditional, Fibonacci, Woodie, Classic, DM or Camarilla)	The type is one of Traditional, Fibonacci, Woodie, Classic, DM or Camarilla.
`E5628`	tech.pivot_levels: "developing" cannot be true with the Woodie type	Use `developing = false` with the Woodie type, or another type.
`E5629`	Cannot set "{name}" of na	The drawing was never created, or is `na` on this bar. Create it first, and guard a name that can still be `na`.
`E5630`	"{name}" cannot be set here	That property cannot be changed by the function you called.
`E5631`	"{name}" is not a field of this value	Check the field name against the type of the value.
`E5632`	Cannot call "{name}" on na	The value is `na` on this bar (the object was never created). Create it before you call a method on it.
`E5633`	A {tn} has no method "{name}"	Check the method name against the type of the value.
`E5634`	This script is an indicator: only a strategy (a strategy header at the top) places orders to test	Orders are placed by a strategy. Change the first line of the script to `strategy(…)`, or take the order statements out.
`E5635`	Cannot call "{fn}" on na (the {what} was never created)	The object was never created. Create it before you call the function on it.
`E5636`	"{fn}" needs {expected}, not a {found}	Give the function a value of the kind it needs.
`E5637`	{message}	The script called `log.abort(…)` with this text and stopped on purpose. Look at the condition that leads to the call.
`E5638`	The script stopped (log.abort)	The script called `log.abort(…)` and stopped on purpose. Look at the condition that leads to the call.
`E5639`	The script calls itself too deeply	The script nests too deeply for the engine to follow. A function that calls itself is refused before the script runs (`E3310`), and too long a chain of your functions is `E-LIMIT-DEPTH`, so this one is rare. Make the nesting shallower: put parts of a long expression in `let` lines, or use a loop.
`E5640`	{message}	An error the engine did not expect. The message carries its own words. If it comes again with the same script, send the script to support.
`W-ENGINE-ALERT-CUT`	The message of an alert is cut to {ALERT_TEXT_MAX} characters	Make the message of the alert shorter.
`W-ENGINE-CONST-ARG`	{fn} {name} must be a constant written in the script; it stays at its default value	Write the value in the script as a constant. Until then the option stays at its default.
`W-ENGINE-CURRENCY-RATE`	A currency rate is not available on this chart; it reads 1	The chart has no currency rates, so the call reads 1. Do not rely on a converted value.
`W-ENGINE-HISTORY-OPEN`	Dynamic lookback has no declared upper bound; execution is limited to {cap} bars. Give the input a max	A read such as `x[n]` where nothing in the text of the script limits `n` (an input without a `max`, a parameter of a function, a counter). The script runs, but a series that is read this way keeps up to 8,192 bars, and a read further back stops it (`E-LIMIT-HISTORY`). It is said once for the script. Give the input a `max` so that the script keeps only the bars it can reach.
`W-ENGINE-HTF-NOT-LOADED`	The {period} bars are not available yet; data.series reads na	The bars of that timeframe are not on the chart yet, so the request gives `na`. The chart asks for them and runs the script again.
`W-ENGINE-HTF-RESAMPLED`	The {period} bars are built from the chart's own bars (the market server sent none): they reach only as far back as the chart does	The market server had no bars of that timeframe, so the engine built them from the chart's own bars; they reach back only as far as the chart does.
`W-ENGINE-INDICATOR-TIMEFRAME`	indicator(timeframe=…) is not supported yet: the script runs on the chart's timeframe	Remove `timeframe` from `indicator(…)` and use `data.series` for the other timeframe.
`W-ENGINE-LIBRARY-CHANGED`	The library "{path}" changed since this script was last saved ({was} -> {now}); the script may behave differently	The library was edited after you saved the script. Check what the script does, then save it again.
`W-ENGINE-LIST-INPUT`	The list of the input "{name}" cannot be read as a list: it is empty here	The settings keep a list input as text, and this text is not a list (it was damaged or changed by hand). The script gets an empty list. Open the settings, enter the list again and save.
`W-ENGINE-LOG-DROPPED`	{n} log lines were dropped: a bar keeps {perBar} lines and a run {perRun}	Log fewer lines per bar, or only on the bars you care about.
`W-ENGINE-LOWER-TF`	data.series of a lower timeframe reads the chart's own bars here	A timeframe shorter than the chart's is not loaded. Read a timeframe longer than the chart's, or run the script on a chart with a shorter timeframe.
`W-ENGINE-LOWER-TF-FORM`	data.intrabars reads the chart's own bar here (lower timeframes are not loaded)	Lower timeframes are not loaded here: the call gives the chart's own bar.
`W-ENGINE-OTHER-SYMBOL`	data.series can only read this chart's symbol here; another symbol reads na	Data for another symbol is not available in this release. See Other timeframes and symbols.
`W-ENGINE-RANDOM-SEED`	math.random draws from the run seed {seed} (script {script}, inputs {inputs})	A note, not a fault. A call of `math.random` with no `seed` of its own draws from the run seed shown here, so the same script (the same id, or for an unsaved script the same name) with the same inputs gives the same numbers on every machine; change an input, or the id or name, and the numbers change, while rewriting or reformatting the script does not move them. Give the call a `seed` to make its numbers depend on that number alone. See Random numbers.
`W-ENGINE-REQUEST-NA`	{name} is not available on this chart; it reads na	The chart does not have this data, so it reads `na`. Guard it with `nz()` or `??`.
`W-ENGINE-SOURCE-DEFAULT`	A source input can only default to a price (open, high, low, close, hl2 …) here	Give a `source` input a price as its default: `open`, `high`, `low`, `close`, `hl2` and the like.
`W-ENGINE-STRATEGY-NOT-SIMULATED`	Strategy orders are not simulated on the chart: open the Strategy tester to test it	The chart does not simulate the orders of a strategy. Press Test in the editor to run it in the Strategy Lab.
`W-ENGINE-TEXT-CUT`	A text of a label, box or table cell is cut to {DRAW_TEXT_MAX} characters	Write a shorter text in the label, box or cell.
`W-ENGINE-TICKER-KIND`	The chart kind "{kind}" is not applied here; data.series reads the ordinary candles	A script cannot change the kind of candle a request reads here: the request reads the ordinary candles.
`W-ENGINE-VWAP-NO-VOLUME`	tech.vwap reads na: the bars of this chart have no volume	This symbol's bars carry no volume, so `tech.vwap` cannot be worked out.
`W-ENGINE-ZONE-UNKNOWN`	The time zone "{tz}" is not known; it is read as UTC	Write a time zone name the chart knows, such as `"Europe/London"` or `"America/New_York"`.
`W-OBJECT-LIMIT`	{n} {kind} were dropped: the script keeps the newest {keep} ({param}).[ The oldest dropped was made on bar {at}.][ Raise {param} in the indicator() line (this chart allows up to {allowed})]	The chart keeps the newest lines, labels, boxes or polylines. Raise the setting named in the message in the `indicator()` line, up to what the chart allows, or draw fewer.
↳ `W-OBJECT-LIMIT`	{sloped} sloped fills (linefill between two lines that are not level) are not drawn on this chart yet	A `linefill` between two lines that are not level is not drawn yet. Use a fill between two plots.
↳ `W-OBJECT-LIMIT`	{tables} tables were dropped: the chart keeps the newest 40 tables. Delete a table the script no longer shows (table.delete) before it makes another	Delete a table you no longer show with `table.delete` before you make another.
↳ `W-OBJECT-LIMIT`	{setting} {asked} is cut to {cap} on this chart	Ask for no more than the chart allows.
`W-UNMODELLED`	{fn}: {param} {why}	The engine does not model this option of the function: it reads the option but does not act on it. The message says which, and why.
↳ `W-UNMODELLED`	{fn} {whyWhole}	The engine does not model this function: the script runs, but the function does not do what its name says. The message says why.

Parts of the engine that load when needed#

The engine is not downloaded when a page opens. It is a few parts that load when a script needs them: the script engine itself (the first script of a visit), the strategy runner (a strategy), and the deterministic mathematics (math.log, math.exp, math.pow and the trigonometric functions: see Numbers). A script that needs a part runs only on a part that was loaded and checked (its version and its fingerprint, and that it belongs to the same build as the page); otherwise it does not start at all, before the first bar, and nothing is calculated with other numbers. There are four messages for it, all described in Diagnostics and none a fault of your script: E-ENGINE-PART-UNAVAILABLE (the part could not be had), E-ENGINE-PART-VERSION (it is not the one this engine was published with), E-CHUNK-SKEW (it belongs to another build of the site) and E-CHUNK-LATE (it was asked for after the run had started).

For alerts: while a part is missing, does not match or belongs to another build, the platform does not evaluate the alerts that depend on it, does not send them, and does not try another version of the part. It records the event so that the team sees it, and it does not mark your alert as broken: the alert starts again by itself when the part is back. The platform reports a missed check rather than make a check with the wrong numbers.

Reading the limit messages#

A limit message says what was passed and by how much. For example, a run that takes too long reads: The script takes too long on bar 0 (2026-09-07 12:10 UTC): this bar used more than the steps one bar may use … (line 3) The bar and the line are where the budget ran out; the cause may be earlier, since a loop that grows with every bar hits the limit late. Limits and budgets lists every number.