CoreErrorCodes

const CoreErrorCodes: {
  ALLOCATION_LIMIT_EXCEEDED: "ALLOCATION_LIMIT_EXCEEDED";
  BIGINT_DIVISION_BY_ZERO: "BIGINT_DIVISION_BY_ZERO";
  BIGINT_INEXACT_OPERAND: "BIGINT_INEXACT_OPERAND";
  BIGINT_POW_LIMIT_EXCEEDED: "BIGINT_POW_LIMIT_EXCEEDED";
  BIGINT_SHIFT_LIMIT_EXCEEDED: "BIGINT_SHIFT_LIMIT_EXCEEDED";
  BUILTIN_ARITY_MISMATCH: "BUILTIN_ARITY_MISMATCH";
  CONFIG_PATH_NOT_FOUND: "CONFIG_PATH_NOT_FOUND";
  CONFIG_PROPERTY_NOT_FOUND: "CONFIG_PROPERTY_NOT_FOUND";
  CONFIG_SECTION_NOT_FOUND: "CONFIG_SECTION_NOT_FOUND";
  DATE_OFFSET_LIMIT_EXCEEDED: "DATE_OFFSET_LIMIT_EXCEEDED";
  DOCUMENT_TOO_LARGE: "DOCUMENT_TOO_LARGE";
  EVALUATION_ERROR: "EVALUATION_ERROR";
  EXPRESSION_TOO_COMPLEX: "EXPRESSION_TOO_COMPLEX";
  EXPRESSION_TOO_LONG: "EXPRESSION_TOO_LONG";
  FUNCTION_ARITY_MISMATCH: "FUNCTION_ARITY_MISMATCH";
  FUNCTION_BODY_MUST_BE_SYNCHRONOUS: "FUNCTION_BODY_MUST_BE_SYNCHRONOUS";
  FUNCTION_CALL_LIMIT_EXCEEDED: "FUNCTION_CALL_LIMIT_EXCEEDED";
  FUNCTION_RECURSION_LIMIT_EXCEEDED: "FUNCTION_RECURSION_LIMIT_EXCEEDED";
  GLOBAL_VARIABLE_NOT_RESOLVED: "GLOBAL_VARIABLE_NOT_RESOLVED";
  INSTRUCTION_LIMIT_EXCEEDED: "INSTRUCTION_LIMIT_EXCEEDED";
  INTERNAL_MISSING_ANONYMOUS_BODY: "INTERNAL_MISSING_ANONYMOUS_BODY";
  INTERNAL_MISSING_FUNCTION_BODY: "INTERNAL_MISSING_FUNCTION_BODY";
  INTERNAL_RATIONAL_PARSE: "INTERNAL_RATIONAL_PARSE";
  INVALID_CONFIG_PATH: "INVALID_CONFIG_PATH";
  INVALID_NUMBER_LITERAL: "INVALID_NUMBER_LITERAL";
  INVALID_PHRASE_PATTERN: "INVALID_PHRASE_PATTERN";
  INVALID_RATE_UNIT: "INVALID_RATE_UNIT";
  INVALID_TIME_LITERAL: "INVALID_TIME_LITERAL";
  INVALID_TIMECODE_UNIT: "INVALID_TIMECODE_UNIT";
  MALFORMED_BYTECODE_BIGINT_LITERAL: "MALFORMED_BYTECODE_BIGINT_LITERAL";
  MALFORMED_BYTECODE_BODY_KIND: "MALFORMED_BYTECODE_BODY_KIND";
  MALFORMED_BYTECODE_CONSTANT_INDEX: "MALFORMED_BYTECODE_CONSTANT_INDEX";
  MALFORMED_BYTECODE_OPERAND_TYPE: "MALFORMED_BYTECODE_OPERAND_TYPE";
  MALFORMED_BYTECODE_PROGRAM: "MALFORMED_BYTECODE_PROGRAM";
  MALFORMED_BYTECODE_TRUNCATED: "MALFORMED_BYTECODE_TRUNCATED";
  MAP_REDUCE_ASYNC_UNSUPPORTED: "MAP_REDUCE_ASYNC_UNSUPPORTED";
  NESTING_DEPTH_EXCEEDED: "NESTING_DEPTH_EXCEEDED";
  NO_MATCHING_PHRASE_ALTERNATIVE: "NO_MATCHING_PHRASE_ALTERNATIVE";
  NO_PREFIX_PARSELET: "NO_PREFIX_PARSELET";
  NORMALIZED_TOKEN_LIMIT_EXCEEDED: "NORMALIZED_TOKEN_LIMIT_EXCEEDED";
  OPCODE_POOL_EXHAUSTED: "OPCODE_POOL_EXHAUSTED";
  PACKAGE_ENGINE_VERSION_INVALID_RANGE: "PACKAGE_ENGINE_VERSION_INVALID_RANGE";
  PACKAGE_ENGINE_VERSION_MISMATCH: "PACKAGE_ENGINE_VERSION_MISMATCH";
  PARSE_ERROR: "PARSE_ERROR";
  PHRASE_KEYWORD_MISMATCH: "PHRASE_KEYWORD_MISMATCH";
  PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED: "PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED";
  PLUGIN_KEYWORD_COLLISION: "PLUGIN_KEYWORD_COLLISION";
  PLUGIN_OPERATOR_COLLISION: "PLUGIN_OPERATOR_COLLISION";
  PLUGIN_UNIT_COLLISION: "PLUGIN_UNIT_COLLISION";
  SOLVE_REQUIRES_VARIABLE_NAME: "SOLVE_REQUIRES_VARIABLE_NAME";
  STACK_LIMIT_EXCEEDED: "STACK_LIMIT_EXCEEDED";
  STACK_UNDERFLOW: "STACK_UNDERFLOW";
  SYMBOLIC_ASYNC_UNSUPPORTED: "SYMBOLIC_ASYNC_UNSUPPORTED";
  SYMBOLIC_DERIVATIVE_ORDER_LIMIT: "SYMBOLIC_DERIVATIVE_ORDER_LIMIT";
  SYMBOLIC_DIVISION_BY_ZERO: "SYMBOLIC_DIVISION_BY_ZERO";
  SYMBOLIC_FACTOR_LIMIT_EXCEEDED: "SYMBOLIC_FACTOR_LIMIT_EXCEEDED";
  SYMBOLIC_INTEGRAL_UNSUPPORTED: "SYMBOLIC_INTEGRAL_UNSUPPORTED";
  SYMBOLIC_JACOBIAN_NO_VARIABLES: "SYMBOLIC_JACOBIAN_NO_VARIABLES";
  SYMBOLIC_NODE_LIMIT_EXCEEDED: "SYMBOLIC_NODE_LIMIT_EXCEEDED";
  SYMBOLIC_NONFINITE_OPERAND: "SYMBOLIC_NONFINITE_OPERAND";
  SYMBOLIC_RATIONAL_OVERFLOW: "SYMBOLIC_RATIONAL_OVERFLOW";
  SYMBOLIC_REQUIRES_VARIABLE_NAME: "SYMBOLIC_REQUIRES_VARIABLE_NAME";
  SYMBOLIC_SOLVE_INCOMPLETE: "SYMBOLIC_SOLVE_INCOMPLETE";
  SYMBOLIC_SOLVE_UNSUPPORTED: "SYMBOLIC_SOLVE_UNSUPPORTED";
  SYMBOLIC_TAYLOR_DEGREE_LIMIT: "SYMBOLIC_TAYLOR_DEGREE_LIMIT";
  SYMBOLIC_TAYLOR_INEXACT: "SYMBOLIC_TAYLOR_INEXACT";
  SYMBOLIC_UNSUPPORTED_FUNCTION: "SYMBOLIC_UNSUPPORTED_FUNCTION";
  THEREFORE_ASYNC_UNSUPPORTED: "THEREFORE_ASYNC_UNSUPPORTED";
  THEREFORE_REQUIRES_EXPRESSION: "THEREFORE_REQUIRES_EXPRESSION";
  TOO_MANY_ANONYMOUS_BODIES: "TOO_MANY_ANONYMOUS_BODIES";
  TOO_MANY_FUNCTION_DEFINITIONS: "TOO_MANY_FUNCTION_DEFINITIONS";
  TOO_MANY_NUMERIC_CONSTANTS: "TOO_MANY_NUMERIC_CONSTANTS";
  TOO_MANY_STRING_CONSTANTS: "TOO_MANY_STRING_CONSTANTS";
  UNDEFINED_FUNCTION: "UNDEFINED_FUNCTION";
  UNDEFINED_VARIABLE: "UNDEFINED_VARIABLE";
  UNEXPECTED_END: "UNEXPECTED_END";
  UNEXPECTED_END_OF_INPUT: "UNEXPECTED_END_OF_INPUT";
  UNEXPECTED_ERROR: "UNEXPECTED_ERROR";
  UNEXPECTED_PENDING_RESULT: "UNEXPECTED_PENDING_RESULT";
  UNEXPECTED_TOKEN_TYPE: "UNEXPECTED_TOKEN_TYPE";
  UNEXPECTED_TRAILING_TOKEN: "UNEXPECTED_TRAILING_TOKEN";
  UNKNOWN_ERROR: "UNKNOWN_ERROR";
  UNKNOWN_FUNCTION: "UNKNOWN_FUNCTION";
  UNTERMINATED_STRING: "UNTERMINATED_STRING";
  USER_FUNCTION_ASYNC_UNSUPPORTED: "USER_FUNCTION_ASYNC_UNSUPPORTED";
  USER_FUNCTION_INVALID_PARAM_NAME: "USER_FUNCTION_INVALID_PARAM_NAME";
  USER_FUNCTION_NO_PARAMS: "USER_FUNCTION_NO_PARAMS";
};

Defined in: packages/engine/src/errors/ErrorCode.ts:30

Codes used directly by the parser/VM/engine/errors layers themselves confirmed against the current source, not aspirational. Grouped by pipeline stage via the comments, not a naming prefix (these predate any naming convention and renaming them is out of scope for introducing the catalog, only NEW codes need to follow a scoped/prefixed style, see STACK_UNDERFLOW etc. below).

Type Declaration

ALLOCATION_LIMIT_EXCEEDED

readonly ALLOCATION_LIMIT_EXCEEDED: "ALLOCATION_LIMIT_EXCEEDED" = "ALLOCATION_LIMIT_EXCEEDED";

One evaluation asking for more elements (collection Values, matrix cells) than vm.maxAllocatedElements allows. The counter the two limits above cannot be: both are checked between opcodes, so neither can see what a single opcode allocates inside a loop of its own. See vm/AllocationBudget.ts. Recoverable, since it describes this expression rather than the engine.

BIGINT_DIVISION_BY_ZERO

readonly BIGINT_DIVISION_BY_ZERO: "BIGINT_DIVISION_BY_ZERO" = "BIGINT_DIVISION_BY_ZERO";

10n / 0n and 10n mod 0n. Deliberately NOT what 1 / 0 does, which is Infinity: a bigint division is exact integer division (7n / 2n is 3n), and integer division by zero has no answer, exactly as it has none in C, Java, Python or JavaScript’s own BigInt. Previously V8’s own RangeError, relabelled UNEXPECTED_ERROR. Recoverable; see vm/VMConversion.ts’s bigIntDivisionByZero().

BIGINT_INEXACT_OPERAND

readonly BIGINT_INEXACT_OPERAND: "BIGINT_INEXACT_OPERAND" = "BIGINT_INEXACT_OPERAND";

An operand with no whole-number form (a fraction, an infinity, a NaN) meeting a bigint: 1n + 0.5, 1n & 1.5, 5n/pi. BigInt() answers those with a raw RangeError, which the VM relabelled UNEXPECTED_ERROR, so a typo in the line was reported as an engine fault. Recoverable; see vm/VMConversion.ts’s toBigIntOperand().

BIGINT_POW_LIMIT_EXCEEDED

readonly BIGINT_POW_LIMIT_EXCEEDED: "BIGINT_POW_LIMIT_EXCEEDED" = "BIGINT_POW_LIMIT_EXCEEDED";

The same ceiling for ^, the operator it was written for: 2n ^ 100000 asks for the same 100,001-bit integer 1n << 100000 does, so the two spellings answer the same way. Also new in 1.0.0, and for the same reason: this used to fall through to the double path and answer Infinity. A fractional or negative exponent (4n ^ 0.5, 2n ^ -1) has no exact answer to bound and still uses the double path. See vm/VM.ts’s MAX_EXACT_POW_BITS. Recoverable.

BIGINT_SHIFT_LIMIT_EXCEEDED

readonly BIGINT_SHIFT_LIMIT_EXCEEDED: "BIGINT_SHIFT_LIMIT_EXCEEDED" = "BIGINT_SHIFT_LIMIT_EXCEEDED";

A <</>> with a bigint operand whose exact result would pass MAX_EXACT_SHIFT_BITS, whichever operand is the bigint. Both spellings refuse as of 1.0.0: a bigint on the left used to fall through to x * 2^n in doubles and report a 19,870-digit integer as Infinity. See vm/VM.ts’s bigIntShift(). Recoverable.

BUILTIN_ARITY_MISMATCH

readonly BUILTIN_ARITY_MISMATCH: "BUILTIN_ARITY_MISMATCH" = "BUILTIN_ARITY_MISMATCH";

The same mistake against a BUILT-IN rather than a user-defined function (sqrt(), atan2(1), sqrt(1,2,3)). Separate from FUNCTION_ARITY_MISMATCH above because the two are raised by different opcodes and a host may want to word them differently. Checked at the CALL_BUILTIN dispatch against vm/VMBuiltinArity.ts; recoverable, since it is a typo in the line, not an engine fault.

CONFIG_PATH_NOT_FOUND

readonly CONFIG_PATH_NOT_FOUND: "CONFIG_PATH_NOT_FOUND" = "CONFIG_PATH_NOT_FOUND";

CONFIG_PROPERTY_NOT_FOUND

readonly CONFIG_PROPERTY_NOT_FOUND: "CONFIG_PROPERTY_NOT_FOUND" = "CONFIG_PROPERTY_NOT_FOUND";

CONFIG_SECTION_NOT_FOUND

readonly CONFIG_SECTION_NOT_FOUND: "CONFIG_SECTION_NOT_FOUND" = "CONFIG_SECTION_NOT_FOUND";

DATE_OFFSET_LIMIT_EXCEEDED

readonly DATE_OFFSET_LIMIT_EXCEEDED: "DATE_OFFSET_LIMIT_EXCEEDED" = "DATE_OFFSET_LIMIT_EXCEEDED";

A <date> + N workdays offset outside date.maxOffsetYears/minOffsetYears. Workdays are the one date offset that walks the calendar a day at a time, so the one whose cost is the offset; every other one moves a Date field once. Recoverable.

DOCUMENT_TOO_LARGE

readonly DOCUMENT_TOO_LARGE: "DOCUMENT_TOO_LARGE" = "DOCUMENT_TOO_LARGE";

A document with more lines than performance.maxDocumentLines. The per-line limits above bound what one line may ask for and say nothing about how many lines there are; two hundred thousand of 1 + 1 exhausted the heap on the line records alone. Recoverable.

EVALUATION_ERROR

readonly EVALUATION_ERROR: "EVALUATION_ERROR" = "EVALUATION_ERROR";

EXPRESSION_TOO_COMPLEX

readonly EXPRESSION_TOO_COMPLEX: "EXPRESSION_TOO_COMPLEX" = "EXPRESSION_TOO_COMPLEX";

EXPRESSION_TOO_LONG

readonly EXPRESSION_TOO_LONG: "EXPRESSION_TOO_LONG" = "EXPRESSION_TOO_LONG";

FUNCTION_ARITY_MISMATCH

readonly FUNCTION_ARITY_MISMATCH: "FUNCTION_ARITY_MISMATCH" = "FUNCTION_ARITY_MISMATCH";

FUNCTION_BODY_MUST_BE_SYNCHRONOUS

readonly FUNCTION_BODY_MUST_BE_SYNCHRONOUS: "FUNCTION_BODY_MUST_BE_SYNCHRONOUS" = "FUNCTION_BODY_MUST_BE_SYNCHRONOUS";

A user-defined function body calling an async plugin (weather/stocks/currency/…), rejected at definition time; v1 scope excludes async function bodies.

FUNCTION_CALL_LIMIT_EXCEEDED

readonly FUNCTION_CALL_LIMIT_EXCEEDED: "FUNCTION_CALL_LIMIT_EXCEEDED" = "FUNCTION_CALL_LIMIT_EXCEEDED";

The companion to the code above, and the half it could never see: how MANY user-defined-function calls one evaluation makes, rather than how deeply they nest. A twenty-two-line doubling chain nests twenty-two deep (legal) and makes two million calls (a fatal heap abort). Counted in vm/AllocationBudget.ts, because the tally has to survive executeBytecode() re-entering itself. Recoverable.

FUNCTION_RECURSION_LIMIT_EXCEEDED

readonly FUNCTION_RECURSION_LIMIT_EXCEEDED: "FUNCTION_RECURSION_LIMIT_EXCEEDED" = "FUNCTION_RECURSION_LIMIT_EXCEEDED";

pushCallFrame()’s recursion guard, a nested CALL_USER_FUNCTION re-enters executeBytecode(), so maxInstructions alone can’t catch e.g. f(x) = f(x); this is the dedicated backstop. recoverable: true (the default for .execution()), ordinary user-written infinite recursion, not an engine bug; the guard exists precisely so it surfaces as a clear error instead of overflowing the native call stack uncatchably.

GLOBAL_VARIABLE_NOT_RESOLVED

readonly GLOBAL_VARIABLE_NOT_RESOLVED: "GLOBAL_VARIABLE_NOT_RESOLVED" = "GLOBAL_VARIABLE_NOT_RESOLVED";

New this phase, the Tier-2/LOAD_GLOBAL_VAR hardening: a global variable read before its async preflight resolved, surfaced as a controlled error instead of pushing undefined.

INSTRUCTION_LIMIT_EXCEEDED

readonly INSTRUCTION_LIMIT_EXCEEDED: "INSTRUCTION_LIMIT_EXCEEDED" = "INSTRUCTION_LIMIT_EXCEEDED";

INTERNAL_MISSING_ANONYMOUS_BODY

readonly INTERNAL_MISSING_ANONYMOUS_BODY: "INTERNAL_MISSING_ANONYMOUS_BODY" = "INTERNAL_MISSING_ANONYMOUS_BODY";

MAP_INVOKE/REDUCE_INVOKE’s anonymous-body-index lookup failing. Same class as INTERNAL_MISSING_FUNCTION_BODY above, for the anonymousBodies side-table instead of userFunctionBodies.

INTERNAL_MISSING_FUNCTION_BODY

readonly INTERNAL_MISSING_FUNCTION_BODY: "INTERNAL_MISSING_FUNCTION_BODY" = "INTERNAL_MISSING_FUNCTION_BODY";

DEFINE_USER_FUNCTION’s body-index lookup failing, a compiler/VM invariant violation (the opcode stream referenced a userFunctionBodies slot that doesn’t exist), never a user-input error.

INTERNAL_RATIONAL_PARSE

readonly INTERNAL_RATIONAL_PARSE: "INTERNAL_RATIONAL_PARSE" = "INTERNAL_RATIONAL_PARSE";

A finite number whose decimal form could not be read back, which the regex covering every Number.prototype.toString output should make unreachable.

INVALID_CONFIG_PATH

readonly INVALID_CONFIG_PATH: "INVALID_CONFIG_PATH" = "INVALID_CONFIG_PATH";

INVALID_NUMBER_LITERAL

readonly INVALID_NUMBER_LITERAL: "INVALID_NUMBER_LITERAL" = "INVALID_NUMBER_LITERAL";

INVALID_PHRASE_PATTERN

readonly INVALID_PHRASE_PATTERN: "INVALID_PHRASE_PATTERN" = "INVALID_PHRASE_PATTERN";

INVALID_RATE_UNIT

readonly INVALID_RATE_UNIT: "INVALID_RATE_UNIT" = "INVALID_RATE_UNIT";

INVALID_TIME_LITERAL

readonly INVALID_TIME_LITERAL: "INVALID_TIME_LITERAL" = "INVALID_TIME_LITERAL";

Colon-separated numbers that are not a time any clock can show (“24:00”, “9:60”, “100:5”). Raised by the labeled-line fallback, which used to answer them with whatever stood after the colon.

INVALID_TIMECODE_UNIT

readonly INVALID_TIMECODE_UNIT: "INVALID_TIMECODE_UNIT" = "INVALID_TIMECODE_UNIT";

MALFORMED_BYTECODE_BIGINT_LITERAL

readonly MALFORMED_BYTECODE_BIGINT_LITERAL: "MALFORMED_BYTECODE_BIGINT_LITERAL" = "MALFORMED_BYTECODE_BIGINT_LITERAL";

A PUSH_BIGINT pool entry that is not a whole number, e.g. "1.000". BigInt() answers that with a raw SyntaxError.

MALFORMED_BYTECODE_BODY_KIND

readonly MALFORMED_BYTECODE_BODY_KIND: "MALFORMED_BYTECODE_BODY_KIND" = "MALFORMED_BYTECODE_BODY_KIND";

MAP_INVOKE/REDUCE_INVOKE carrying a body kind other than 0/1/2. Used to fall through every arm with no body and recurse into executeBytecode(undefined).

MALFORMED_BYTECODE_CONSTANT_INDEX

readonly MALFORMED_BYTECODE_CONSTANT_INDEX: "MALFORMED_BYTECODE_CONSTANT_INDEX" = "MALFORMED_BYTECODE_CONSTANT_INDEX";

A constant-pool operand indexing a numbers/strings entry that does not exist, or that is not of the pool’s type.

MALFORMED_BYTECODE_OPERAND_TYPE

readonly MALFORMED_BYTECODE_OPERAND_TYPE: "MALFORMED_BYTECODE_OPERAND_TYPE" = "MALFORMED_BYTECODE_OPERAND_TYPE";

A unit or converter name read off the value stack that is not a string. Distinct from the pool case above: the operand is a Value another opcode pushed, not a pool entry.

MALFORMED_BYTECODE_PROGRAM

readonly MALFORMED_BYTECODE_PROGRAM: "MALFORMED_BYTECODE_PROGRAM" = "MALFORMED_BYTECODE_PROGRAM";

executeBytecode() called with something that is not a runnable program at all. Checked before the destructure that used to throw outside the function’s own try/catch.

MALFORMED_BYTECODE_TRUNCATED

readonly MALFORMED_BYTECODE_TRUNCATED: "MALFORMED_BYTECODE_TRUNCATED" = "MALFORMED_BYTECODE_TRUNCATED";

An operand byte read past the end of the stream: the program ends in the middle of an instruction.

MAP_REDUCE_ASYNC_UNSUPPORTED

readonly MAP_REDUCE_ASYNC_UNSUPPORTED: "MAP_REDUCE_ASYNC_UNSUPPORTED" = "MAP_REDUCE_ASYNC_UNSUPPORTED";

A map/reduce transform body (inline expression or user-defined function) calling an async plugin. Same v1 scope restriction as USER_FUNCTION_ASYNC_UNSUPPORTED above, enforced both at parse time (MAP_REDUCE_TRANSFORM_MUST_BE_SYNCHRONOUS, packages/mapreduce/) and as a defense-in-depth runtime backstop here.

NESTING_DEPTH_EXCEEDED

readonly NESTING_DEPTH_EXCEEDED: "NESTING_DEPTH_EXCEEDED" = "NESTING_DEPTH_EXCEEDED";

NO_MATCHING_PHRASE_ALTERNATIVE

readonly NO_MATCHING_PHRASE_ALTERNATIVE: "NO_MATCHING_PHRASE_ALTERNATIVE" = "NO_MATCHING_PHRASE_ALTERNATIVE";

NO_PREFIX_PARSELET

readonly NO_PREFIX_PARSELET: "NO_PREFIX_PARSELET" = "NO_PREFIX_PARSELET";

NORMALIZED_TOKEN_LIMIT_EXCEEDED

readonly NORMALIZED_TOKEN_LIMIT_EXCEEDED: "NORMALIZED_TOKEN_LIMIT_EXCEEDED" = "NORMALIZED_TOKEN_LIMIT_EXCEEDED";

OPCODE_POOL_EXHAUSTED

readonly OPCODE_POOL_EXHAUSTED: "OPCODE_POOL_EXHAUSTED" = "OPCODE_POOL_EXHAUSTED";

OpRegistry.allocateOpcode()’s dynamic opcode pool (started at 201) exhausted, too many packages calling it.

PACKAGE_ENGINE_VERSION_INVALID_RANGE

readonly PACKAGE_ENGINE_VERSION_INVALID_RANGE: "PACKAGE_ENGINE_VERSION_INVALID_RANGE" = "PACKAGE_ENGINE_VERSION_INVALID_RANGE";

A package’s declared IEnginePackage.engineVersion isn’t a parseable semver range at all (a typo in the package’s own descriptor).

PACKAGE_ENGINE_VERSION_MISMATCH

readonly PACKAGE_ENGINE_VERSION_MISMATCH: "PACKAGE_ENGINE_VERSION_MISMATCH" = "PACKAGE_ENGINE_VERSION_MISMATCH";

A package’s declared IEnginePackage.engineVersion semver range doesn’t satisfy the running engine’s ENGINE_VERSION. See api/EngineVersionCompatibility.ts.

PARSE_ERROR

readonly PARSE_ERROR: "PARSE_ERROR" = "PARSE_ERROR";

PHRASE_KEYWORD_MISMATCH

readonly PHRASE_KEYWORD_MISMATCH: "PHRASE_KEYWORD_MISMATCH" = "PHRASE_KEYWORD_MISMATCH";

PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED

readonly PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED: "PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED" = "PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED";

VMBuiltins.allocatePluginFunctionIndex()’s 0-255 index pool (a single opcode-stream byte) exhausted.

PLUGIN_KEYWORD_COLLISION

readonly PLUGIN_KEYWORD_COLLISION: "PLUGIN_KEYWORD_COLLISION" = "PLUGIN_KEYWORD_COLLISION";

PLUGIN_OPERATOR_COLLISION

readonly PLUGIN_OPERATOR_COLLISION: "PLUGIN_OPERATOR_COLLISION" = "PLUGIN_OPERATOR_COLLISION";

PLUGIN_UNIT_COLLISION

readonly PLUGIN_UNIT_COLLISION: "PLUGIN_UNIT_COLLISION" = "PLUGIN_UNIT_COLLISION";

SOLVE_REQUIRES_VARIABLE_NAME

readonly SOLVE_REQUIRES_VARIABLE_NAME: "SOLVE_REQUIRES_VARIABLE_NAME" = "SOLVE_REQUIRES_VARIABLE_NAME";

solve’s second argument not being a bare name.

STACK_LIMIT_EXCEEDED

readonly STACK_LIMIT_EXCEEDED: "STACK_LIMIT_EXCEEDED" = "STACK_LIMIT_EXCEEDED";

STACK_UNDERFLOW

readonly STACK_UNDERFLOW: "STACK_UNDERFLOW" = "STACK_UNDERFLOW";

New this phase. See VM.ts’s safePop(): a stack-underflow (corrupted bytecode, a buggy plugin) is now a controlled EngineError instead of a raw TypeError. Category INTERNAL, since it is an engine or plugin fault rather than a typed line, but recoverable: it happened on one line and the engine is still usable.

SYMBOLIC_ASYNC_UNSUPPORTED

readonly SYMBOLIC_ASYNC_UNSUPPORTED: "SYMBOLIC_ASYNC_UNSUPPORTED" = "SYMBOLIC_ASYNC_UNSUPPORTED";

An algebra verb’s expression argument (BIND_UNKNOWN’s body) calling an async plugin. Same v1 scope restriction as the two above, and likewise refused at parse time first (SYMBOLIC_ARGUMENT_MUST_BE_SYNCHRONOUS, packages/symbolic/).

SYMBOLIC_DERIVATIVE_ORDER_LIMIT

readonly SYMBOLIC_DERIVATIVE_ORDER_LIMIT: "SYMBOLIC_DERIVATIVE_ORDER_LIMIT" = "SYMBOLIC_DERIVATIVE_ORDER_LIMIT";

A derivative order outside 0..DERIVATIVE_MAX_ORDER.

SYMBOLIC_DIVISION_BY_ZERO

readonly SYMBOLIC_DIVISION_BY_ZERO: "SYMBOLIC_DIVISION_BY_ZERO" = "SYMBOLIC_DIVISION_BY_ZERO";

Division by an exactly-zero rational. Exact, unlike the double comparison it replaced, which could not distinguish a true zero from 5.551e-17.

SYMBOLIC_FACTOR_LIMIT_EXCEEDED

readonly SYMBOLIC_FACTOR_LIMIT_EXCEEDED: "SYMBOLIC_FACTOR_LIMIT_EXCEEDED" = "SYMBOLIC_FACTOR_LIMIT_EXCEEDED";

The rational-root search exceeding FACTOR_MAX_ROOT_CANDIDATES. The candidate set is the product of two divisor sets, so a highly-composite coefficient escapes quickly.

SYMBOLIC_INTEGRAL_UNSUPPORTED

readonly SYMBOLIC_INTEGRAL_UNSUPPORTED: "SYMBOLIC_INTEGRAL_UNSUPPORTED" = "SYMBOLIC_INTEGRAL_UNSUPPORTED";

An expression with no known elementary antiderivative. Reported rather than approximated, since a wrong integral is indistinguishable from a right one at the point of use.

SYMBOLIC_JACOBIAN_NO_VARIABLES

readonly SYMBOLIC_JACOBIAN_NO_VARIABLES: "SYMBOLIC_JACOBIAN_NO_VARIABLES" = "SYMBOLIC_JACOBIAN_NO_VARIABLES";

jacobian called with expressions containing no unknown to differentiate against.

SYMBOLIC_NODE_LIMIT_EXCEEDED

readonly SYMBOLIC_NODE_LIMIT_EXCEEDED: "SYMBOLIC_NODE_LIMIT_EXCEEDED" = "SYMBOLIC_NODE_LIMIT_EXCEEDED";

A tree exceeding SYMBOLIC_MAX_NODES entering the simplifier.

SYMBOLIC_NONFINITE_OPERAND

readonly SYMBOLIC_NONFINITE_OPERAND: "SYMBOLIC_NONFINITE_OPERAND" = "SYMBOLIC_NONFINITE_OPERAND";

NaN or ±Infinity reaching a symbolic expression, neither of which has an exact rational value.

SYMBOLIC_RATIONAL_OVERFLOW

readonly SYMBOLIC_RATIONAL_OVERFLOW: "SYMBOLIC_RATIONAL_OVERFLOW" = "SYMBOLIC_RATIONAL_OVERFLOW";

A coefficient grew past RATIONAL_MAX_BITS, e.g. repeated exact elimination multiplying denominators together.

SYMBOLIC_REQUIRES_VARIABLE_NAME

readonly SYMBOLIC_REQUIRES_VARIABLE_NAME: "SYMBOLIC_REQUIRES_VARIABLE_NAME" = "SYMBOLIC_REQUIRES_VARIABLE_NAME";

An algebra verb’s variable-name argument not being a bare name.

SYMBOLIC_SOLVE_INCOMPLETE

readonly SYMBOLIC_SOLVE_INCOMPLETE: "SYMBOLIC_SOLVE_INCOMPLETE" = "SYMBOLIC_SOLVE_INCOMPLETE";

Some but not all of an equation’s roots were found. Reported rather than returned, because a partial list of roots looks exactly like a complete one.

SYMBOLIC_SOLVE_UNSUPPORTED

readonly SYMBOLIC_SOLVE_UNSUPPORTED: "SYMBOLIC_SOLVE_UNSUPPORTED" = "SYMBOLIC_SOLVE_UNSUPPORTED";

An equation outside what the solver attempts: not a polynomial, above the degree ceiling, or non-linear in the unknown while another unknown is present.

SYMBOLIC_TAYLOR_DEGREE_LIMIT

readonly SYMBOLIC_TAYLOR_DEGREE_LIMIT: "SYMBOLIC_TAYLOR_DEGREE_LIMIT" = "SYMBOLIC_TAYLOR_DEGREE_LIMIT";

A Taylor degree outside 0..TAYLOR_MAX_DEGREE.

SYMBOLIC_TAYLOR_INEXACT

readonly SYMBOLIC_TAYLOR_INEXACT: "SYMBOLIC_TAYLOR_INEXACT" = "SYMBOLIC_TAYLOR_INEXACT";

A Taylor coefficient that does not reduce to an exact number at the expansion point.

SYMBOLIC_UNSUPPORTED_FUNCTION

readonly SYMBOLIC_UNSUPPORTED_FUNCTION: "SYMBOLIC_UNSUPPORTED_FUNCTION" = "SYMBOLIC_UNSUPPORTED_FUNCTION";

A builtin with no symbolic reading (min, random, the finance block, …) applied to an expression still containing an unknown. Returned rather than computing against toNumber()’s placeholder zero.

THEREFORE_ASYNC_UNSUPPORTED

readonly THEREFORE_ASYNC_UNSUPPORTED: "THEREFORE_ASYNC_UNSUPPORTED" = "THEREFORE_ASYNC_UNSUPPORTED";

A "=>"-triggered expression called an async plugin (weather/stocks/currency). Same v1 scope restriction as user-function/map-reduce bodies.

THEREFORE_REQUIRES_EXPRESSION

readonly THEREFORE_REQUIRES_EXPRESSION: "THEREFORE_REQUIRES_EXPRESSION" = "THEREFORE_REQUIRES_EXPRESSION";

"=>" with nothing before it, needs an expression or variable name to solve/simplify.

TOO_MANY_ANONYMOUS_BODIES

readonly TOO_MANY_ANONYMOUS_BODIES: "TOO_MANY_ANONYMOUS_BODIES" = "TOO_MANY_ANONYMOUS_BODIES";

BytecodeBuilder’s anonymousBodies side-table (map/reduce inline transform bodies) exceeding its capacity. Same class as TOO_MANY_FUNCTION_DEFINITIONS above.

TOO_MANY_FUNCTION_DEFINITIONS

readonly TOO_MANY_FUNCTION_DEFINITIONS: "TOO_MANY_FUNCTION_DEFINITIONS" = "TOO_MANY_FUNCTION_DEFINITIONS";

BytecodeBuilder’s userFunctionBodies side-table exceeding its capacity. Same class as TOO_MANY_NUMERIC_CONSTANTS/TOO_MANY_STRING_CONSTANTS below.

TOO_MANY_NUMERIC_CONSTANTS

readonly TOO_MANY_NUMERIC_CONSTANTS: "TOO_MANY_NUMERIC_CONSTANTS" = "TOO_MANY_NUMERIC_CONSTANTS";

TOO_MANY_STRING_CONSTANTS

readonly TOO_MANY_STRING_CONSTANTS: "TOO_MANY_STRING_CONSTANTS" = "TOO_MANY_STRING_CONSTANTS";

UNDEFINED_FUNCTION

readonly UNDEFINED_FUNCTION: "UNDEFINED_FUNCTION" = "UNDEFINED_FUNCTION";

User-defined-function call/definition errors (CALL_USER_FUNCTION/DEFINE_USER_FUNCTION opcodes), calling a name with no matching definition, calling with the wrong argument count, and the deliberate v1 restriction that a function body can’t itself contain async work.

UNDEFINED_VARIABLE

readonly UNDEFINED_VARIABLE: "UNDEFINED_VARIABLE" = "UNDEFINED_VARIABLE";

UNEXPECTED_END

readonly UNEXPECTED_END: "UNEXPECTED_END" = "UNEXPECTED_END";

UNEXPECTED_END_OF_INPUT

readonly UNEXPECTED_END_OF_INPUT: "UNEXPECTED_END_OF_INPUT" = "UNEXPECTED_END_OF_INPUT";

UNEXPECTED_ERROR

readonly UNEXPECTED_ERROR: "UNEXPECTED_ERROR" = "UNEXPECTED_ERROR";

UNEXPECTED_PENDING_RESULT

readonly UNEXPECTED_PENDING_RESULT: "UNEXPECTED_PENDING_RESULT" = "UNEXPECTED_PENDING_RESULT";

unwrapEvalResult()’s pending-when-expecting-value case, a caller-contract violation, not user-input.

UNEXPECTED_TOKEN_TYPE

readonly UNEXPECTED_TOKEN_TYPE: "UNEXPECTED_TOKEN_TYPE" = "UNEXPECTED_TOKEN_TYPE";

UNEXPECTED_TRAILING_TOKEN

readonly UNEXPECTED_TRAILING_TOKEN: "UNEXPECTED_TRAILING_TOKEN" = "UNEXPECTED_TRAILING_TOKEN";

UNKNOWN_ERROR

readonly UNKNOWN_ERROR: "UNKNOWN_ERROR" = "UNKNOWN_ERROR";

UNKNOWN_FUNCTION

readonly UNKNOWN_FUNCTION: "UNKNOWN_FUNCTION" = "UNKNOWN_FUNCTION";

UNTERMINATED_STRING

readonly UNTERMINATED_STRING: "UNTERMINATED_STRING" = "UNTERMINATED_STRING";

A " that never meets its closing partner (lexer/ExpressionLexer.ts’s tokenizeString()). Previously the tokenizer ran off the end of the input and returned what it had, so "abc lexed to an ordinary String and an unterminated literal was indistinguishable from a terminated one.

USER_FUNCTION_ASYNC_UNSUPPORTED

readonly USER_FUNCTION_ASYNC_UNSUPPORTED: "USER_FUNCTION_ASYNC_UNSUPPORTED" = "USER_FUNCTION_ASYNC_UNSUPPORTED";

USER_FUNCTION_INVALID_PARAM_NAME

readonly USER_FUNCTION_INVALID_PARAM_NAME: "USER_FUNCTION_INVALID_PARAM_NAME" = "USER_FUNCTION_INVALID_PARAM_NAME";

User-defined-function definition parsing (f(x, y) = ...), an invalid token where a parameter name was expected.

USER_FUNCTION_NO_PARAMS

readonly USER_FUNCTION_NO_PARAMS: "USER_FUNCTION_NO_PARAMS" = "USER_FUNCTION_NO_PARAMS";

f() = ... with zero parameters, indistinguishable from a plain no-arg function call, so rejected at definition time.