CoreErrorCodes

const CoreErrorCodes: {
  AGGREGATE_NON_NUMERIC: "AGGREGATE_NON_NUMERIC";
  AGGREGATE_PERCENTAGE_MIXED: "AGGREGATE_PERCENTAGE_MIXED";
  ALLOCATION_LIMIT_EXCEEDED: "ALLOCATION_LIMIT_EXCEEDED";
  AS_CONVERTER_AMBIGUOUS_CASE: "AS_CONVERTER_AMBIGUOUS_CASE";
  AS_CONVERTER_PREFIX_CASE: "AS_CONVERTER_PREFIX_CASE";
  ASYNC_RESOLVER_FAILED: "ASYNC_RESOLVER_FAILED";
  BASE_NOT_FINITE: "BASE_NOT_FINITE";
  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";
  BYTECODE_OPERAND_OUT_OF_RANGE: "BYTECODE_OPERAND_OUT_OF_RANGE";
  CALENDAR_TEMPORAL_UNAVAILABLE: "CALENDAR_TEMPORAL_UNAVAILABLE";
  COLLECTION_TOO_LARGE: "COLLECTION_TOO_LARGE";
  COLOUR_ARITHMETIC: "COLOUR_ARITHMETIC";
  COMBINATION_OVERFLOW: "COMBINATION_OVERFLOW";
  COMPOUND_ASSIGN_ASYNC_UNSUPPORTED: "COMPOUND_ASSIGN_ASYNC_UNSUPPORTED";
  COMPOUND_ASSIGN_REQUIRES_EXPRESSION: "COMPOUND_ASSIGN_REQUIRES_EXPRESSION";
  CONFIG_PATH_NOT_FOUND: "CONFIG_PATH_NOT_FOUND";
  CONFIG_PROPERTY_NOT_FOUND: "CONFIG_PROPERTY_NOT_FOUND";
  CONFIG_SECTION_NOT_FOUND: "CONFIG_SECTION_NOT_FOUND";
  CONSTANT_UNIT_UNSUPPORTED: "CONSTANT_UNIT_UNSUPPORTED";
  CONVERT_NON_NUMERIC: "CONVERT_NON_NUMERIC";
  CURRENCY_RATE_UNAVAILABLE: "CURRENCY_RATE_UNAVAILABLE";
  DATE_CLOCK_INVALID: "DATE_CLOCK_INVALID";
  DATE_OFFSET_LIMIT_EXCEEDED: "DATE_OFFSET_LIMIT_EXCEEDED";
  DECIMAL_DIVISION_BY_ZERO: "DECIMAL_DIVISION_BY_ZERO";
  DECIMAL_INVALID_SCALE: "DECIMAL_INVALID_SCALE";
  DECIMAL_NEGATIVE_POWER: "DECIMAL_NEGATIVE_POWER";
  DESCENDING_RANGE: "DESCENDING_RANGE";
  DETERMINANT_REQUIRES_SQUARE_MATRIX: "DETERMINANT_REQUIRES_SQUARE_MATRIX";
  DIMENSION_MISMATCH: "DIMENSION_MISMATCH";
  DIMENSIONS_EXPECTED_FORM: "DIMENSIONS_EXPECTED_FORM";
  DIRECTION_CONTROL_IN_NAME: "DIRECTION_CONTROL_IN_NAME";
  DOCUMENT_ELEMENT_LIMIT_EXCEEDED: "DOCUMENT_ELEMENT_LIMIT_EXCEEDED";
  DOCUMENT_TOO_LARGE: "DOCUMENT_TOO_LARGE";
  EQUATION_FACTOR_NOT_MATRIX: "EQUATION_FACTOR_NOT_MATRIX";
  EQUATION_FACTOR_UNDEFINED: "EQUATION_FACTOR_UNDEFINED";
  EQUATION_RHS_NOT_MATRIX: "EQUATION_RHS_NOT_MATRIX";
  EQUATION_SEVERAL_UNKNOWNS: "EQUATION_SEVERAL_UNKNOWNS";
  EVALUATION_ERROR: "EVALUATION_ERROR";
  EXPLAIN_ASYNC_UNSUPPORTED: "EXPLAIN_ASYNC_UNSUPPORTED";
  EXPRESSION_TOO_COMPLEX: "EXPRESSION_TOO_COMPLEX";
  EXPRESSION_TOO_LONG: "EXPRESSION_TOO_LONG";
  FACTOR_TOO_LARGE: "FACTOR_TOO_LARGE";
  FACTORIAL_OVERFLOW: "FACTORIAL_OVERFLOW";
  FLOAT_TAKES_NUMBER: "FLOAT_TAKES_NUMBER";
  FROZEN_DATE_EXPECTED: "FROZEN_DATE_EXPECTED";
  FROZEN_UNSUPPORTED: "FROZEN_UNSUPPORTED";
  FROZEN_VALUE_MISSING: "FROZEN_VALUE_MISSING";
  FUNCTION_ARITY_MISMATCH: "FUNCTION_ARITY_MISMATCH";
  FUNCTION_BODY_MUST_BE_SYNCHRONOUS: "FUNCTION_BODY_MUST_BE_SYNCHRONOUS";
  FUNCTION_BODY_READS_LINES: "FUNCTION_BODY_READS_LINES";
  FUNCTION_CALL_LIMIT_EXCEEDED: "FUNCTION_CALL_LIMIT_EXCEEDED";
  FUNCTION_DOMAIN: "FUNCTION_DOMAIN";
  FUNCTION_RECURSION_LIMIT_EXCEEDED: "FUNCTION_RECURSION_LIMIT_EXCEEDED";
  FUNCTION_TAKES_NUMBER: "FUNCTION_TAKES_NUMBER";
  GLOBAL_VARIABLE_NOT_RESOLVED: "GLOBAL_VARIABLE_NOT_RESOLVED";
  GOAL_SEEK_ASYNC_UNSUPPORTED: "GOAL_SEEK_ASYNC_UNSUPPORTED";
  GOAL_SEEK_LINE_NOT_READY: "GOAL_SEEK_LINE_NOT_READY";
  GOAL_SEEK_NESTED: "GOAL_SEEK_NESTED";
  GOAL_SEEK_NO_DOCUMENT: "GOAL_SEEK_NO_DOCUMENT";
  GOAL_SEEK_TARGET_ERROR: "GOAL_SEEK_TARGET_ERROR";
  GOAL_SEEK_TARGET_IS_DEFINITION: "GOAL_SEEK_TARGET_IS_DEFINITION";
  HELD_EXPRESSION_READS_LINES: "HELD_EXPRESSION_READS_LINES";
  INCOMPATIBLE_UNITS: "INCOMPATIBLE_UNITS";
  INFLATION_YEAR_OUT_OF_RANGE: "INFLATION_YEAR_OUT_OF_RANGE";
  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_DATETIME_OP: "INVALID_DATETIME_OP";
  INVALID_DECIMAL_LITERAL: "INVALID_DECIMAL_LITERAL";
  INVALID_FACTORIAL_INPUT: "INVALID_FACTORIAL_INPUT";
  INVALID_INTEGER_OPERAND: "INVALID_INTEGER_OPERAND";
  INVALID_MATRIX_SLICE_BOUND: "INVALID_MATRIX_SLICE_BOUND";
  INVALID_NUMBER_LITERAL: "INVALID_NUMBER_LITERAL";
  INVALID_PHRASE_PATTERN: "INVALID_PHRASE_PATTERN";
  INVALID_RANGE: "INVALID_RANGE";
  INVALID_RANGE_BOUND: "INVALID_RANGE_BOUND";
  INVALID_RATE: "INVALID_RATE";
  INVALID_RATE_UNIT: "INVALID_RATE_UNIT";
  INVALID_TERM: "INVALID_TERM";
  INVALID_TIME_LITERAL: "INVALID_TIME_LITERAL";
  INVALID_TIMECODE_UNIT: "INVALID_TIMECODE_UNIT";
  INVERSE_REQUIRES_SQUARE_MATRIX: "INVERSE_REQUIRES_SQUARE_MATRIX";
  INVISIBLE_CHARACTER_IN_NUMBER: "INVISIBLE_CHARACTER_IN_NUMBER";
  IPV6_ARITHMETIC: "IPV6_ARITHMETIC";
  LABEL_NOT_A_NAME: "LABEL_NOT_A_NAME";
  LINE_FAILED: "LINE_FAILED";
  LINE_NOT_YET_EVALUATED: "LINE_NOT_YET_EVALUATED";
  LINE_REF_NO_DOCUMENT: "LINE_REF_NO_DOCUMENT";
  LINE_RESULT_ERROR: "LINE_RESULT_ERROR";
  LINE_RESULT_PENDING: "LINE_RESULT_PENDING";
  LIST_ARGUMENT_UNSUPPORTED: "LIST_ARGUMENT_UNSUPPORTED";
  LIST_CELL_UNSUPPORTED: "LIST_CELL_UNSUPPORTED";
  LIST_CONDITION_UNSUPPORTED: "LIST_CONDITION_UNSUPPORTED";
  LIST_CONVERSION_UNSUPPORTED: "LIST_CONVERSION_UNSUPPORTED";
  LIST_PERCENTAGE_UNSUPPORTED: "LIST_PERCENTAGE_UNSUPPORTED";
  LIST_ROUNDING_NON_NUMERIC: "LIST_ROUNDING_NON_NUMERIC";
  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";
  MALFORMED_BYTECODE_UNKNOWN_OPCODE: "MALFORMED_BYTECODE_UNKNOWN_OPCODE";
  MAP_COLLECTION_LENGTH_MISMATCH: "MAP_COLLECTION_LENGTH_MISMATCH";
  MAP_REDUCE_ASYNC_UNSUPPORTED: "MAP_REDUCE_ASYNC_UNSUPPORTED";
  MAP_REDUCE_REQUIRES_COLLECTION: "MAP_REDUCE_REQUIRES_COLLECTION";
  MATRIX_CELL_NO_UNIT: "MATRIX_CELL_NO_UNIT";
  MATRIX_CELL_NON_NUMERIC: "MATRIX_CELL_NON_NUMERIC";
  MATRIX_CELL_UNITS_DIFFER: "MATRIX_CELL_UNITS_DIFFER";
  MATRIX_INDEX_NOT_A_MATRIX: "MATRIX_INDEX_NOT_A_MATRIX";
  MATRIX_INDEX_OUT_OF_BOUNDS: "MATRIX_INDEX_OUT_OF_BOUNDS";
  MATRIX_POWER_REQUIRES_SQUARE_MATRIX: "MATRIX_POWER_REQUIRES_SQUARE_MATRIX";
  MATRIX_POWER_REQUIRES_WHOLE_EXPONENT: "MATRIX_POWER_REQUIRES_WHOLE_EXPONENT";
  MATRIX_POWER_UNSUPPORTED: "MATRIX_POWER_UNSUPPORTED";
  MATRIX_UNIT_ALGEBRA: "MATRIX_UNIT_ALGEBRA";
  MATRIX_UNIT_OPERATION_UNSUPPORTED: "MATRIX_UNIT_OPERATION_UNSUPPORTED";
  MULTIPLIER_TAKES_NUMBER: "MULTIPLIER_TAKES_NUMBER";
  NESTING_DEPTH_EXCEEDED: "NESTING_DEPTH_EXCEEDED";
  NETWORK_DISABLED: "NETWORK_DISABLED";
  NO_MATCHING_PHRASE_ALTERNATIVE: "NO_MATCHING_PHRASE_ALTERNATIVE";
  NO_PREFIX_PARSELET: "NO_PREFIX_PARSELET";
  NON_INTEGER_RANGE_BOUND: "NON_INTEGER_RANGE_BOUND";
  NORMALIZED_TOKEN_LIMIT_EXCEEDED: "NORMALIZED_TOKEN_LIMIT_EXCEEDED";
  NORMALIZER_PASS_LIMIT_EXCEEDED: "NORMALIZER_PASS_LIMIT_EXCEEDED";
  NOT_WHOLE_NUMBER: "NOT_WHOLE_NUMBER";
  NUMBER_THEORY_DOMAIN: "NUMBER_THEORY_DOMAIN";
  NUMBER_THEORY_EXPECTED_INTEGER: "NUMBER_THEORY_EXPECTED_INTEGER";
  NUMBER_THEORY_NO_INVERSE: "NUMBER_THEORY_NO_INVERSE";
  OPCODE_POOL_EXHAUSTED: "OPCODE_POOL_EXHAUSTED";
  OTHER_SCRIPT_DIGITS: "OTHER_SCRIPT_DIGITS";
  PACKAGE_ENGINE_VERSION_INVALID_RANGE: "PACKAGE_ENGINE_VERSION_INVALID_RANGE";
  PACKAGE_ENGINE_VERSION_MISMATCH: "PACKAGE_ENGINE_VERSION_MISMATCH";
  PACKAGE_NAME_MISSING: "PACKAGE_NAME_MISSING";
  PACKAGE_RESOLVER_FUNCTION_MISSING: "PACKAGE_RESOLVER_FUNCTION_MISSING";
  PARSE_ERROR: "PARSE_ERROR";
  PASS_WORK_BUDGET_EXCEEDED: "PASS_WORK_BUDGET_EXCEEDED";
  PERCENT_CHANGE_FAILED: "PERCENT_CHANGE_FAILED";
  PERCENT_CHANGE_FROM_ZERO: "PERCENT_CHANGE_FROM_ZERO";
  PERCENT_CHANGE_NEGATIVE_BASE: "PERCENT_CHANGE_NEGATIVE_BASE";
  PERCENTAGE_NOT_FINITE: "PERCENTAGE_NOT_FINITE";
  PERCENTAGE_OF_QUANTITY: "PERCENTAGE_OF_QUANTITY";
  PERCENTAGE_OVERFLOW: "PERCENTAGE_OVERFLOW";
  PERMUTATION_OVERFLOW: "PERMUTATION_OVERFLOW";
  PHRASE_KEYWORD_MISMATCH: "PHRASE_KEYWORD_MISMATCH";
  PLOT_INVALID_RANGE: "PLOT_INVALID_RANGE";
  PLUGIN_CALL_FAILED: "PLUGIN_CALL_FAILED";
  PLUGIN_CALL_FUSION_UNREACHABLE: "PLUGIN_CALL_FUSION_UNREACHABLE";
  PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED: "PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED";
  PLUGIN_FUNCTION_INDEX_TOO_LARGE: "PLUGIN_FUNCTION_INDEX_TOO_LARGE";
  PLUGIN_KEYWORD_COLLISION: "PLUGIN_KEYWORD_COLLISION";
  PLUGIN_OPERATOR_COLLISION: "PLUGIN_OPERATOR_COLLISION";
  PLUGIN_OPERATOR_UNSUPPORTED: "PLUGIN_OPERATOR_UNSUPPORTED";
  PLUGIN_RESULT_NOT_A_VALUE: "PLUGIN_RESULT_NOT_A_VALUE";
  PLUGIN_UNIT_ALIAS_TARGET_UNKNOWN: "PLUGIN_UNIT_ALIAS_TARGET_UNKNOWN";
  PLUGIN_UNIT_ALIAS_UNREACHABLE: "PLUGIN_UNIT_ALIAS_UNREACHABLE";
  PLUGIN_UNIT_COLLISION: "PLUGIN_UNIT_COLLISION";
  POWER_NO_REAL_VALUE: "POWER_NO_REAL_VALUE";
  PROPORTION_DIVIDE_BY_ZERO: "PROPORTION_DIVIDE_BY_ZERO";
  QUANTITY_NON_NUMERIC: "QUANTITY_NON_NUMERIC";
  QUOTIENT_UNDEFINED: "QUOTIENT_UNDEFINED";
  RANGE_BEFORE_ANOTHER_ARGUMENT: "RANGE_BEFORE_ANOTHER_ARGUMENT";
  RANGE_BOUND_GROUP_MALFORMED: "RANGE_BOUND_GROUP_MALFORMED";
  RATE_CONVERT_MEASURE_MISMATCH: "RATE_CONVERT_MEASURE_MISMATCH";
  RATE_CONVERT_NOT_A_RATE: "RATE_CONVERT_NOT_A_RATE";
  RATE_MISSING_DENOMINATOR_UNIT: "RATE_MISSING_DENOMINATOR_UNIT";
  RATE_MUL_LEFT_NOT_A_RATE: "RATE_MUL_LEFT_NOT_A_RATE";
  RATE_MUL_MEASURE_MISMATCH: "RATE_MUL_MEASURE_MISMATCH";
  RATE_MUL_RIGHT_MISSING_UNIT: "RATE_MUL_RIGHT_MISSING_UNIT";
  REDUCE_EMPTY_COLLECTION: "REDUCE_EMPTY_COLLECTION";
  REMAINDER_UNDEFINED: "REMAINDER_UNDEFINED";
  RESIZE_EXPECTED_SHAPE: "RESIZE_EXPECTED_SHAPE";
  SETTLE_TIMEOUT: "SETTLE_TIMEOUT";
  SETTLE_TIMEOUT_INVALID: "SETTLE_TIMEOUT_INVALID";
  SINGULAR_MATRIX: "SINGULAR_MATRIX";
  SNAPSHOT_MALFORMED: "SNAPSHOT_MALFORMED";
  SNAPSHOT_PACKAGE_MISSING: "SNAPSHOT_PACKAGE_MISSING";
  SNAPSHOT_UNSUPPORTED_VALUE: "SNAPSHOT_UNSUPPORTED_VALUE";
  SNAPSHOT_VERSION_MISMATCH: "SNAPSHOT_VERSION_MISMATCH";
  SOLVE_REQUIRES_VARIABLE_NAME: "SOLVE_REQUIRES_VARIABLE_NAME";
  STACK_LIMIT_EXCEEDED: "STACK_LIMIT_EXCEEDED";
  STACK_UNDERFLOW: "STACK_UNDERFLOW";
  STATISTIC_NOT_FINITE: "STATISTIC_NOT_FINITE";
  SYMBOLIC_ASYNC_UNSUPPORTED: "SYMBOLIC_ASYNC_UNSUPPORTED";
  SYMBOLIC_BOUND_INVALID: "SYMBOLIC_BOUND_INVALID";
  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_FORMULA_VALUE_UNSUPPORTED: "SYMBOLIC_FORMULA_VALUE_UNSUPPORTED";
  SYMBOLIC_INTEGRAL_IMPROPER: "SYMBOLIC_INTEGRAL_IMPROPER";
  SYMBOLIC_INTEGRAL_UNSETTLED: "SYMBOLIC_INTEGRAL_UNSETTLED";
  SYMBOLIC_INTEGRAL_UNSUPPORTED: "SYMBOLIC_INTEGRAL_UNSUPPORTED";
  SYMBOLIC_INVERSE_DIMENSION_LIMIT: "SYMBOLIC_INVERSE_DIMENSION_LIMIT";
  SYMBOLIC_JACOBIAN_NO_VARIABLES: "SYMBOLIC_JACOBIAN_NO_VARIABLES";
  SYMBOLIC_LIMIT_DIVERGES: "SYMBOLIC_LIMIT_DIVERGES";
  SYMBOLIC_LIMIT_SIDES_DISAGREE: "SYMBOLIC_LIMIT_SIDES_DISAGREE";
  SYMBOLIC_LIMIT_UNDEFINED: "SYMBOLIC_LIMIT_UNDEFINED";
  SYMBOLIC_LIMIT_UNSETTLED: "SYMBOLIC_LIMIT_UNSETTLED";
  SYMBOLIC_LIMIT_UNSUPPORTED: "SYMBOLIC_LIMIT_UNSUPPORTED";
  SYMBOLIC_NODE_LIMIT_EXCEEDED: "SYMBOLIC_NODE_LIMIT_EXCEEDED";
  SYMBOLIC_NONFINITE_OPERAND: "SYMBOLIC_NONFINITE_OPERAND";
  SYMBOLIC_QUANTITY_OPERAND: "SYMBOLIC_QUANTITY_OPERAND";
  SYMBOLIC_RATIONAL_OVERFLOW: "SYMBOLIC_RATIONAL_OVERFLOW";
  SYMBOLIC_REQUIRES_BOTH_BOUNDS: "SYMBOLIC_REQUIRES_BOTH_BOUNDS";
  SYMBOLIC_REQUIRES_LIMIT_POINT: "SYMBOLIC_REQUIRES_LIMIT_POINT";
  SYMBOLIC_REQUIRES_VARIABLE_NAME: "SYMBOLIC_REQUIRES_VARIABLE_NAME";
  SYMBOLIC_SINGULAR_OR_UNSUPPORTED_PIVOT: "SYMBOLIC_SINGULAR_OR_UNSUPPORTED_PIVOT";
  SYMBOLIC_SOLVE_INCOMPLETE: "SYMBOLIC_SOLVE_INCOMPLETE";
  SYMBOLIC_SOLVE_NO_ROOT_FOUND: "SYMBOLIC_SOLVE_NO_ROOT_FOUND";
  SYMBOLIC_SOLVE_TOO_MANY_ROOTS: "SYMBOLIC_SOLVE_TOO_MANY_ROOTS";
  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";
  TEMPORAL_IMPLEMENTATION_INVALID: "TEMPORAL_IMPLEMENTATION_INVALID";
  TEMPORAL_TIME_ZONE_UNKNOWN: "TEMPORAL_TIME_ZONE_UNKNOWN";
  TERNARY_UNSUPPORTED: "TERNARY_UNSUPPORTED";
  TEXT_ARITHMETIC: "TEXT_ARITHMETIC";
  TEXT_COMPARISON: "TEXT_COMPARISON";
  TEXT_NOT_A_NUMBER: "TEXT_NOT_A_NUMBER";
  THEREFORE_ASYNC_UNSUPPORTED: "THEREFORE_ASYNC_UNSUPPORTED";
  THEREFORE_REQUIRES_EXPRESSION: "THEREFORE_REQUIRES_EXPRESSION";
  TIMECODE_FPS_MISMATCH: "TIMECODE_FPS_MISMATCH";
  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";
  TRACE_NO_DOCUMENT: "TRACE_NO_DOCUMENT";
  TRACE_NO_SUCH_LINE: "TRACE_NO_SUCH_LINE";
  TRIG_UNDEFINED: "TRIG_UNDEFINED";
  TRIP_EXPECTED_AT: "TRIP_EXPECTED_AT";
  UNCERTAINTY_UNIT_MISMATCH: "UNCERTAINTY_UNIT_MISMATCH";
  UNCERTAINTY_WITHOUT_UNIT: "UNCERTAINTY_WITHOUT_UNIT";
  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";
  UNIT_AFTER_UNIT: "UNIT_AFTER_UNIT";
  UNIT_IN_EXPONENT: "UNIT_IN_EXPONENT";
  UNIT_POWER_UNSUPPORTED: "UNIT_POWER_UNSUPPORTED";
  UNIT_PRODUCT_UNSUPPORTED: "UNIT_PRODUCT_UNSUPPORTED";
  UNIT_QUOTIENT_UNSUPPORTED: "UNIT_QUOTIENT_UNSUPPORTED";
  UNIT_RECIPROCAL_UNSUPPORTED: "UNIT_RECIPROCAL_UNSUPPORTED";
  UNIT_ROOT_UNSUPPORTED: "UNIT_ROOT_UNSUPPORTED";
  UNKNOWN_AS_CONVERTER: "UNKNOWN_AS_CONVERTER";
  UNKNOWN_BUILTIN_FUNCTION: "UNKNOWN_BUILTIN_FUNCTION";
  UNKNOWN_ERROR: "UNKNOWN_ERROR";
  UNKNOWN_FUNCTION: "UNKNOWN_FUNCTION";
  UNKNOWN_PLUGIN_FUNCTION: "UNKNOWN_PLUGIN_FUNCTION";
  UNKNOWN_SAVINGS_PERIOD: "UNKNOWN_SAVINGS_PERIOD";
  UNKNOWN_UNIT: "UNKNOWN_UNIT";
  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";
  WEIGHTED_AVERAGE_ZERO_WEIGHT: "WEIGHTED_AVERAGE_ZERO_WEIGHT";
  WHAT_IF_IN_GOAL_SEEK: "WHAT_IF_IN_GOAL_SEEK";
  WHAT_IF_INPUT_NOT_USED: "WHAT_IF_INPUT_NOT_USED";
  WHAT_IF_LINE_OUT_OF_RANGE: "WHAT_IF_LINE_OUT_OF_RANGE";
  WHAT_IF_LIVE_DATA: "WHAT_IF_LIVE_DATA";
  WHAT_IF_NESTED: "WHAT_IF_NESTED";
  WHAT_IF_OVERRIDE_INVALID: "WHAT_IF_OVERRIDE_INVALID";
  WHAT_IF_TARGET_ERROR: "WHAT_IF_TARGET_ERROR";
  WHAT_IF_TARGET_HAS_SEVERAL_ANSWERS: "WHAT_IF_TARGET_HAS_SEVERAL_ANSWERS";
  WHAT_IF_TARGET_NOT_A_CALCULATION: "WHAT_IF_TARGET_NOT_A_CALCULATION";
  WHAT_IF_WRITES_GLOBAL: "WHAT_IF_WRITES_GLOBAL";
  WORKDAY_OFFSET_EXPECTED_DATE: "WORKDAY_OFFSET_EXPECTED_DATE";
  WORKDAYS_BETWEEN_EXPECTED_DATES: "WORKDAYS_BETWEEN_EXPECTED_DATES";
  WORKDAYS_BETWEEN_RANGE_TOO_LARGE: "WORKDAYS_BETWEEN_RANGE_TOO_LARGE";
};

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

The codes the engine’s own layers raise: the lexer, the parser, the VM, the engine and the document passes, and the errors layer’s own fallbacks. They are grouped by stage in the comments; the names predate any convention and keep their spellings, so a new code follows a scoped, prefixed style such as STACK_UNDERFLOW.

Type Declaration

AGGREGATE_NON_NUMERIC

readonly AGGREGATE_NON_NUMERIC: "AGGREGATE_NON_NUMERIC" = "AGGREGATE_NON_NUMERIC";

A list aggregate (total of, average of, a line range) meeting something that is not a number or a quantity. The message names what it found.

AGGREGATE_PERCENTAGE_MIXED

readonly AGGREGATE_PERCENTAGE_MIXED: "AGGREGATE_PERCENTAGE_MIXED" = "AGGREGATE_PERCENTAGE_MIXED";

An aggregate (sum(10%, 100), average of 10%, 5 m, max(10%, 0.5), total above over a column) meeting a percentage beside a value that is not one. Percentages alone answer a percentage (sum(10%, 20%) is 30%); the message names the percentage and the kind of the other value, and gives the percentage as the number it stands for.

ALLOCATION_LIMIT_EXCEEDED

readonly ALLOCATION_LIMIT_EXCEEDED: "ALLOCATION_LIMIT_EXCEEDED" = "ALLOCATION_LIMIT_EXCEEDED";

One evaluation asking for more elements (list cells, matrix cells) than vm.maxAllocatedElements allows, even inside a single operation. A safety limit that describes this line; the host may raise it.

AS_CONVERTER_AMBIGUOUS_CASE

readonly AS_CONVERTER_AMBIGUOUS_CASE: "AS_CONVERTER_AMBIGUOUS_CASE" = "AS_CONVERTER_AMBIGUOUS_CASE";

as mw: the target, read regardless of case, could be two units whose prefixes differ only in case (mW and MW), so it is refused rather than guessed (#824).

AS_CONVERTER_PREFIX_CASE

readonly AS_CONVERTER_PREFIX_CASE: "AS_CONVERTER_PREFIX_CASE" = "AS_CONVERTER_PREFIX_CASE";

as MV when only mV is a unit: reading it regardless of case would turn a mega into a milli, so it is refused by name (#824).

ASYNC_RESOLVER_FAILED

readonly ASYNC_RESOLVER_FAILED: "ASYNC_RESOLVER_FAILED" = "ASYNC_RESOLVER_FAILED";

A live value that failed to fetch several times in a row, reported rather than retried again. Editing the line tries again.

BASE_NOT_FINITE

readonly BASE_NOT_FINITE: "BASE_NOT_FINITE" = "BASE_NOT_FINITE";

An infinity or a result with no value written in a base: (1/0) in hex, 2^4000 in binary, hex(1/0). It has no digits; a whole number written with n (2n^4000) keeps every digit.

BIGINT_DIVISION_BY_ZERO

readonly BIGINT_DIVISION_BY_ZERO: "BIGINT_DIVISION_BY_ZERO" = "BIGINT_DIVISION_BY_ZERO";

10n / 0n or 10n mod 0n. A big-integer division is exact, and an exact division by zero has no answer, unlike 1 / 0, which is Infinity.

BIGINT_INEXACT_OPERAND

readonly BIGINT_INEXACT_OPERAND: "BIGINT_INEXACT_OPERAND" = "BIGINT_INEXACT_OPERAND";

A value with no whole-number form (a fraction, an infinity) meeting a big integer: 1n + 0.5, 5n / pi.

BIGINT_POW_LIMIT_EXCEEDED

readonly BIGINT_POW_LIMIT_EXCEEDED: "BIGINT_POW_LIMIT_EXCEEDED" = "BIGINT_POW_LIMIT_EXCEEDED";

A ^ on a big integer whose exact result would be too large to compute (2n ^ 100000). Refused rather than answered as Infinity; a fractional or negative exponent uses doubles instead.

BIGINT_SHIFT_LIMIT_EXCEEDED

readonly BIGINT_SHIFT_LIMIT_EXCEEDED: "BIGINT_SHIFT_LIMIT_EXCEEDED" = "BIGINT_SHIFT_LIMIT_EXCEEDED";

A << or >> on a big integer whose exact result would be too large to compute. Refused rather than answered in doubles as Infinity.

BUILTIN_ARITY_MISMATCH

readonly BUILTIN_ARITY_MISMATCH: "BUILTIN_ARITY_MISMATCH" = "BUILTIN_ARITY_MISMATCH";

A built-in function called with the wrong number of arguments: sqrt(), atan2(1), sqrt(1, 2, 3). Separate from FUNCTION_ARITY_MISMATCH, so a host can word the two differently.

BYTECODE_OPERAND_OUT_OF_RANGE

readonly BYTECODE_OPERAND_OUT_OF_RANGE: "BYTECODE_OPERAND_OUT_OF_RANGE" = "BYTECODE_OPERAND_OUT_OF_RANGE";

A compiled operand outside 0 to 255, or a jump outside the program. A package-authoring fault, reported at compile time rather than letting the program read the wrong constant.

CALENDAR_TEMPORAL_UNAVAILABLE

readonly CALENDAR_TEMPORAL_UNAVAILABLE: "CALENDAR_TEMPORAL_UNAVAILABLE" = "CALENDAR_TEMPORAL_UNAVAILABLE";

calendar: "temporal" was asked for on a runtime with no Temporal. Refused rather than silently computing on Date, because a host that named Temporal did so to be sure what it was computing on. Recoverable.

COLLECTION_TOO_LARGE

readonly COLLECTION_TOO_LARGE: "COLLECTION_TOO_LARGE" = "COLLECTION_TOO_LARGE";

A list or range with more elements than vm.maxCollectionSize allows. A safety limit; the host may raise it.

COLOUR_ARITHMETIC

readonly COLOUR_ARITHMETIC: "COLOUR_ARITHMETIC" = "COLOUR_ARITHMETIC";

A colour in arithmetic, a numeric function, an order or a conversion to a form of a number (#ff0000 + 2, sqrt(#ff0000), #ff0000 < 3). A colour is three channels, not one number; the message points at reading a channel out, as in red(#3366cc).

COMBINATION_OVERFLOW

readonly COMBINATION_OVERFLOW: "COMBINATION_OVERFLOW" = "COMBINATION_OVERFLOW";

A combination count past the largest number a double can hold.

COMPOUND_ASSIGN_ASYNC_UNSUPPORTED

readonly COMPOUND_ASSIGN_ASYNC_UNSUPPORTED: "COMPOUND_ASSIGN_ASYNC_UNSUPPORTED" = "COMPOUND_ASSIGN_ASYNC_UNSUPPORTED";

A running total (+= / -=) whose right-hand side calls an async plugin (weather/stocks/currency). The same v1 scope restriction as the "=>" and user-function bodies.

COMPOUND_ASSIGN_REQUIRES_EXPRESSION

readonly COMPOUND_ASSIGN_REQUIRES_EXPRESSION: "COMPOUND_ASSIGN_REQUIRES_EXPRESSION" = "COMPOUND_ASSIGN_REQUIRES_EXPRESSION";

A compound assignment (name += expr / name -= expr) with nothing on the right, a line half-typed on the way to total += 5.

CONFIG_PATH_NOT_FOUND

readonly CONFIG_PATH_NOT_FOUND: "CONFIG_PATH_NOT_FOUND" = "CONFIG_PATH_NOT_FOUND";

A configuration read or write named a path that does not exist. A host configuration fault.

CONFIG_PROPERTY_NOT_FOUND

readonly CONFIG_PROPERTY_NOT_FOUND: "CONFIG_PROPERTY_NOT_FOUND" = "CONFIG_PROPERTY_NOT_FOUND";

A configuration path whose property does not exist in its section. A host configuration fault.

CONFIG_SECTION_NOT_FOUND

readonly CONFIG_SECTION_NOT_FOUND: "CONFIG_SECTION_NOT_FOUND" = "CONFIG_SECTION_NOT_FOUND";

A configuration path whose section does not exist. A host configuration fault.

CONSTANT_UNIT_UNSUPPORTED

readonly CONSTANT_UNIT_UNSUPPORTED: "CONSTANT_UNIT_UNSUPPORTED" = "CONSTANT_UNIT_UNSUPPORTED";

A physical constant whose unit the engine cannot spell yet, converted or combined with a quantity. The constant stays a plain number.

CONVERT_NON_NUMERIC

readonly CONVERT_NON_NUMERIC: "CONVERT_NON_NUMERIC" = "CONVERT_NON_NUMERIC";

Something with no single amount (a list, text, a date) converted to a unit.

CURRENCY_RATE_UNAVAILABLE

readonly CURRENCY_RATE_UNAVAILABLE: "CURRENCY_RATE_UNAVAILABLE" = "CURRENCY_RATE_UNAVAILABLE";

A conversion between two currencies with no exchange rate available for the pair. A host with live data may prime a rate and evaluate again.

DATE_CLOCK_INVALID

readonly DATE_CLOCK_INVALID: "DATE_CLOCK_INVALID" = "DATE_CLOCK_INVALID";

The clock a host gave a calendar backend (dateCalendarInZone(zone, { now }), createTemporalCalendar(Temporal, { now })) is not a function, answered something that is not a moment Date can hold (NaN, an infinity, a number past 8.64e15, not a number), or threw. Not a function is refused when the backend is built; a bad reading is refused on the line that read the clock (today, now), and the rest of the document goes on (#721, #826).

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 and date.minOffsetYears. Workdays walk the calendar a day at a time, so their cost is the offset.

DECIMAL_DIVISION_BY_ZERO

readonly DECIMAL_DIVISION_BY_ZERO: "DECIMAL_DIVISION_BY_ZERO" = "DECIMAL_DIVISION_BY_ZERO";

An exact decimal division reached the decimal layer with a zero divisor. An engine invariant: the operators refuse a zero divisor first, so this is worth reporting.

DECIMAL_INVALID_SCALE

readonly DECIMAL_INVALID_SCALE: "DECIMAL_INVALID_SCALE" = "DECIMAL_INVALID_SCALE";

An exact decimal built with a negative or fractional scale. An engine invariant, worth reporting.

DECIMAL_NEGATIVE_POWER

readonly DECIMAL_NEGATIVE_POWER: "DECIMAL_NEGATIVE_POWER" = "DECIMAL_NEGATIVE_POWER";

A power of ten asked for with a negative exponent inside the decimal layer. An engine invariant, worth reporting.

DESCENDING_RANGE

readonly DESCENDING_RANGE: "DESCENDING_RANGE" = "DESCENDING_RANGE";

A range whose first bound is above its second (5:1). The message names each bound as written, with the number it came to, and suggests the other order.

DETERMINANT_REQUIRES_SQUARE_MATRIX

readonly DETERMINANT_REQUIRES_SQUARE_MATRIX: "DETERMINANT_REQUIRES_SQUARE_MATRIX" = "DETERMINANT_REQUIRES_SQUARE_MATRIX";

det of a matrix that is not square.

DIMENSION_MISMATCH

readonly DIMENSION_MISMATCH: "DIMENSION_MISMATCH" = "DIMENSION_MISMATCH";

Two matrices of shapes that do not fit the operation: added with different shapes, or multiplied where the columns of the first are not the rows of the second.

DIMENSIONS_EXPECTED_FORM

readonly DIMENSIONS_EXPECTED_FORM: "DIMENSIONS_EXPECTED_FORM" = "DIMENSIONS_EXPECTED_FORM";

A width and a height were written with nothing asked of the pair (1920x1080 on its own). Recoverable.

DIRECTION_CONTROL_IN_NAME

readonly DIRECTION_CONTROL_IN_NAME: "DIRECTION_CONTROL_IN_NAME" = "DIRECTION_CONTROL_IN_NAME";

A name, number or unit holds an invisible character that changes the direction text is shown in (U+202A to U+202E, U+2066 to U+2069, U+200E, U+200F, U+061C), so it would show as something other than what the engine reads. The message names the character by its code point; the reader deletes it. Text in quotes, a comment, a heading and a label keep such characters.

DOCUMENT_ELEMENT_LIMIT_EXCEEDED

readonly DOCUMENT_ELEMENT_LIMIT_EXCEEDED: "DOCUMENT_ELEMENT_LIMIT_EXCEEDED" = "DOCUMENT_ELEMENT_LIMIT_EXCEEDED";

A document whose answers together keep more elements than vm.maxRetainedElements allows. The line that crossed it is refused, and a name it assigned is let go.

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.

EQUATION_FACTOR_NOT_MATRIX

readonly EQUATION_FACTOR_NOT_MATRIX: "EQUATION_FACTOR_NOT_MATRIX" = "EQUATION_FACTOR_NOT_MATRIX";

A matrix equation whose factor is not a matrix.

EQUATION_FACTOR_UNDEFINED

readonly EQUATION_FACTOR_UNDEFINED: "EQUATION_FACTOR_UNDEFINED" = "EQUATION_FACTOR_UNDEFINED";

A matrix equation (A * x = b) naming a factor no line defines yet.

EQUATION_RHS_NOT_MATRIX

readonly EQUATION_RHS_NOT_MATRIX: "EQUATION_RHS_NOT_MATRIX" = "EQUATION_RHS_NOT_MATRIX";

A matrix equation whose right-hand side is not a matrix.

EQUATION_SEVERAL_UNKNOWNS

readonly EQUATION_SEVERAL_UNKNOWNS: "EQUATION_SEVERAL_UNKNOWNS" = "EQUATION_SEVERAL_UNKNOWNS";

An equation on a line of its own with two or more unknowns, as in (salary / 12) * rate / 100 = net. An equation line is solved for its one unknown, so the message says to give the others values above it or to name one with solve.

EVALUATION_ERROR

readonly EVALUATION_ERROR: "EVALUATION_ERROR" = "EVALUATION_ERROR";

A line failed and no more specific code was kept for it. A fallback; the message says what happened.

EXPLAIN_ASYNC_UNSUPPORTED

readonly EXPLAIN_ASYNC_UNSUPPORTED: "EXPLAIN_ASYNC_UNSUPPORTED" = "EXPLAIN_ASYNC_UNSUPPORTED";

explainLine() asked to derive a line that resolves data asynchronously (a live-data or async-plugin line). A derivation is a sequence of settled intermediate values, which a pending result has none of, so the line is refused rather than explained with a hole in it.

EXPRESSION_TOO_COMPLEX

readonly EXPRESSION_TOO_COMPLEX: "EXPRESSION_TOO_COMPLEX" = "EXPRESSION_TOO_COMPLEX";

A line whose complexity score passes validation.maxComplexity. Refused before it is read; the host may raise the limit.

EXPRESSION_TOO_LONG

readonly EXPRESSION_TOO_LONG: "EXPRESSION_TOO_LONG" = "EXPRESSION_TOO_LONG";

A line longer than validation.maxExpressionLength characters. Refused before it is read; the host may raise the limit.

FACTOR_TOO_LARGE

readonly FACTOR_TOO_LARGE: "FACTOR_TOO_LARGE" = "FACTOR_TOO_LARGE";

factor of a whole number past 2^64, which is refused rather than left to run.

FACTORIAL_OVERFLOW

readonly FACTORIAL_OVERFLOW: "FACTORIAL_OVERFLOW" = "FACTORIAL_OVERFLOW";

A factorial past 170!, the largest a double can hold.

FLOAT_TAKES_NUMBER

readonly FLOAT_TAKES_NUMBER: "FLOAT_TAKES_NUMBER" = "FLOAT_TAKES_NUMBER";

float("hello"), float(5 km): float given something with no plain number, text that is not a number or a quantity with a unit. The reader passes a number (#828).

FROZEN_DATE_EXPECTED

readonly FROZEN_DATE_EXPECTED: "FROZEN_DATE_EXPECTED" = "FROZEN_DATE_EXPECTED";

frozen on followed by something that is not a single date at the end of the line (frozen on tuesday, a bare frozen on). Raised at compile time, with an example of the form. A day that does not exist (frozen on 2026-02-30) reports the date literal’s own error instead.

FROZEN_UNSUPPORTED

readonly FROZEN_UNSUPPORTED: "FROZEN_UNSUPPORTED" = "FROZEN_UNSUPPORTED";

frozen on a line with no single answer to keep: a function definition, a global cell write, or a definition part-way through the line. Raised at compile time, naming the shape.

FROZEN_VALUE_MISSING

readonly FROZEN_VALUE_MISSING: "FROZEN_VALUE_MISSING" = "FROZEN_VALUE_MISSING";

A line ending frozen on <day> whose engine holds no value frozen that day, and the day is not today. A recoverable Error value, raised by the VM in place of running the line: a frozen answer is never fetched again, so the line is refused rather than frozen at today’s figure. The message names the day, and the day of the value that is stored when there is one.

FUNCTION_ARITY_MISMATCH

readonly FUNCTION_ARITY_MISMATCH: "FUNCTION_ARITY_MISMATCH" = "FUNCTION_ARITY_MISMATCH";

A function of the reader’s own called with a different number of arguments than it was defined with.

FUNCTION_BODY_MUST_BE_SYNCHRONOUS

readonly FUNCTION_BODY_MUST_BE_SYNCHRONOUS: "FUNCTION_BODY_MUST_BE_SYNCHRONOUS" = "FUNCTION_BODY_MUST_BE_SYNCHRONOUS";

A function definition whose body reaches live data (weather, stocks, a currency rate). Refused when it is defined, since a function body must be synchronous.

FUNCTION_BODY_READS_LINES

readonly FUNCTION_BODY_READS_LINES: "FUNCTION_BODY_READS_LINES" = "FUNCTION_BODY_READS_LINES";

A function definition whose body reads other lines (f(x) = x + prev, x + line 1, a total above, a tag or a table column). Refused when it is defined, since a body runs wherever it is called, with no document lines to read; the value is passed in as an argument instead.

FUNCTION_CALL_LIMIT_EXCEEDED

readonly FUNCTION_CALL_LIMIT_EXCEEDED: "FUNCTION_CALL_LIMIT_EXCEEDED" = "FUNCTION_CALL_LIMIT_EXCEEDED";

One evaluation making more calls to functions of the reader’s own than the budget allows, however shallow each call is. A safety limit against a chain of functions that multiplies its calls.

FUNCTION_DOMAIN

readonly FUNCTION_DOMAIN: "FUNCTION_DOMAIN" = "FUNCTION_DOMAIN";

A function called outside the numbers it is defined for, such as ln(0). The message names the domain.

FUNCTION_RECURSION_LIMIT_EXCEEDED

readonly FUNCTION_RECURSION_LIMIT_EXCEEDED: "FUNCTION_RECURSION_LIMIT_EXCEEDED" = "FUNCTION_RECURSION_LIMIT_EXCEEDED";

A function of the reader’s own that calls itself too deeply, as f(x) = f(x) does. Refused by name rather than overflowing the native stack.

FUNCTION_TAKES_NUMBER

readonly FUNCTION_TAKES_NUMBER: "FUNCTION_TAKES_NUMBER" = "FUNCTION_TAKES_NUMBER";

A function that takes plain numbers given a quantity, as in sin(1 m), or a mix of numbers and quantities.

GLOBAL_VARIABLE_NOT_RESOLVED

readonly GLOBAL_VARIABLE_NOT_RESOLVED: "GLOBAL_VARIABLE_NOT_RESOLVED" = "GLOBAL_VARIABLE_NOT_RESOLVED";

A global :name read before its value arrived from the shared store. It resolves on a later evaluation.

GOAL_SEEK_ASYNC_UNSUPPORTED

readonly GOAL_SEEK_ASYNC_UNSUPPORTED: "GOAL_SEEK_ASYNC_UNSUPPORTED" = "GOAL_SEEK_ASYNC_UNSUPPORTED";

Goal seek targeting a line that depends on live data, which a re-run cannot fetch.

GOAL_SEEK_LINE_NOT_READY

readonly GOAL_SEEK_LINE_NOT_READY: "GOAL_SEEK_LINE_NOT_READY" = "GOAL_SEEK_LINE_NOT_READY";

Goal seek targeting a line with no evaluated expression: below it, past the end, or prose.

GOAL_SEEK_NESTED

readonly GOAL_SEEK_NESTED: "GOAL_SEEK_NESTED" = "GOAL_SEEK_NESTED";

Goal seek run from inside another goal seek’s re-run, or targeting its own line. Refused, since the re-runs would compound.

GOAL_SEEK_NO_DOCUMENT

readonly GOAL_SEEK_NO_DOCUMENT: "GOAL_SEEK_NO_DOCUMENT" = "GOAL_SEEK_NO_DOCUMENT";

Goal seek with no document to re-run: the single-expression entry point, or the batch pass, which evaluates each line once. evaluateDocument and a live editor solve it.

GOAL_SEEK_TARGET_ERROR

readonly GOAL_SEEK_TARGET_ERROR: "GOAL_SEEK_TARGET_ERROR" = "GOAL_SEEK_TARGET_ERROR";

Goal seek whose target line failed while it was being re-run. The message is the line’s own.

GOAL_SEEK_TARGET_IS_DEFINITION

readonly GOAL_SEEK_TARGET_IS_DEFINITION: "GOAL_SEEK_TARGET_IS_DEFINITION" = "GOAL_SEEK_TARGET_IS_DEFINITION";

Goal seek targeting the line that defines a variable, which a re-run would overwrite. The message says to target the line that uses it.

HELD_EXPRESSION_READS_LINES

readonly HELD_EXPRESSION_READS_LINES: "HELD_EXPRESSION_READS_LINES" = "HELD_EXPRESSION_READS_LINES";

A held expression that reads other lines (map(x + prev, 1:3), sum(x + line 1, 1:3), plot x + prev from 0 to 1, der(x^2 + prev, x)). Refused when the line is read, since the expression is worked out away from the line, with no lines to read; the message says to name the line’s value first (p = prev) and use the name.

INCOMPATIBLE_UNITS

readonly INCOMPATIBLE_UNITS: "INCOMPATIBLE_UNITS" = "INCOMPATIBLE_UNITS";

Two quantities that do not measure the same thing met where they must: 5 kg + 3 m, 5 kg to m. The message names both measures.

INFLATION_YEAR_OUT_OF_RANGE

readonly INFLATION_YEAR_OUT_OF_RANGE: "INFLATION_YEAR_OUT_OF_RANGE" = "INFLATION_YEAR_OUT_OF_RANGE";

An inflation adjustment for a year outside the bundled price index.

INSTRUCTION_LIMIT_EXCEEDED

readonly INSTRUCTION_LIMIT_EXCEEDED: "INSTRUCTION_LIMIT_EXCEEDED" = "INSTRUCTION_LIMIT_EXCEEDED";

One evaluation ran more VM instructions than vm.maxInstructions allows. A safety limit against a line that would run too long; the host may raise the limit.

INTERNAL_MISSING_ANONYMOUS_BODY

readonly INTERNAL_MISSING_ANONYMOUS_BODY: "INTERNAL_MISSING_ANONYMOUS_BODY" = "INTERNAL_MISSING_ANONYMOUS_BODY";

A compiled program naming a map or reduce body it does not carry. A compiler or VM fault, worth reporting.

INTERNAL_MISSING_FUNCTION_BODY

readonly INTERNAL_MISSING_FUNCTION_BODY: "INTERNAL_MISSING_FUNCTION_BODY" = "INTERNAL_MISSING_FUNCTION_BODY";

A compiled program naming a function body it does not carry. A compiler or VM fault, worth reporting.

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";

A configuration path not in the section.property form. A host configuration fault.

INVALID_DATETIME_OP

readonly INVALID_DATETIME_OP: "INVALID_DATETIME_OP" = "INVALID_DATETIME_OP";

A date moved by a plain number, or by a quantity that is not a length of time, or to between a date and something that is not one. The message says what a date moves by.

INVALID_DECIMAL_LITERAL

readonly INVALID_DECIMAL_LITERAL: "INVALID_DECIMAL_LITERAL" = "INVALID_DECIMAL_LITERAL";

Text read as an exact decimal that is not one. Raised while a number literal is compiled; the reader fixes the digits.

INVALID_FACTORIAL_INPUT

readonly INVALID_FACTORIAL_INPUT: "INVALID_FACTORIAL_INPUT" = "INVALID_FACTORIAL_INPUT";

A factorial of a negative number or a fraction.

INVALID_INTEGER_OPERAND

readonly INVALID_INTEGER_OPERAND: "INVALID_INTEGER_OPERAND" = "INVALID_INTEGER_OPERAND";

gcd or lcm given a number with no whole value (an infinity, or nothing).

INVALID_MATRIX_SLICE_BOUND

readonly INVALID_MATRIX_SLICE_BOUND: "INVALID_MATRIX_SLICE_BOUND" = "INVALID_MATRIX_SLICE_BOUND";

A matrix slice whose bounds are not ranges.

INVALID_NUMBER_LITERAL

readonly INVALID_NUMBER_LITERAL: "INVALID_NUMBER_LITERAL" = "INVALID_NUMBER_LITERAL";

A number written in a form that does not read as one: a hex, binary or octal literal with a digit its base lacks (0xZZ), or thousands groups that are not three digits long. The reader fixes the digits.

INVALID_PHRASE_PATTERN

readonly INVALID_PHRASE_PATTERN: "INVALID_PHRASE_PATTERN" = "INVALID_PHRASE_PATTERN";

A package declared a phrase pattern whose alternative does not begin with a keyword. An authoring fault, raised when the pattern is built.

INVALID_RANGE

readonly INVALID_RANGE: "INVALID_RANGE" = "INVALID_RANGE";

A range given backwards where order matters: a roll from 6 to 1, or a permutation or combination with more chosen than there are.

INVALID_RANGE_BOUND

readonly INVALID_RANGE_BOUND: "INVALID_RANGE_BOUND" = "INVALID_RANGE_BOUND";

A range (0:3) whose bounds are not plain numbers.

INVALID_RATE

readonly INVALID_RATE: "INVALID_RATE" = "INVALID_RATE";

A rate of interest or inflation that cannot be used: not a percentage, not finite, or at or below -100%.

INVALID_RATE_UNIT

readonly INVALID_RATE_UNIT: "INVALID_RATE_UNIT" = "INVALID_RATE_UNIT";

A rate unit read or built from parts that do not make one: a caller-contract fault inside the engine or a package, or x/y where x is already a rate.

INVALID_TERM

readonly INVALID_TERM: "INVALID_TERM" = "INVALID_TERM";

A loan or savings term that is not a length of time.

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";

A timecode unit read from a string that is not one. A caller-contract fault inside the engine or a package.

INVERSE_REQUIRES_SQUARE_MATRIX

readonly INVERSE_REQUIRES_SQUARE_MATRIX: "INVERSE_REQUIRES_SQUARE_MATRIX" = "INVERSE_REQUIRES_SQUARE_MATRIX";

inv of a matrix that is not square.

INVISIBLE_CHARACTER_IN_NUMBER

readonly INVISIBLE_CHARACTER_IN_NUMBER: "INVISIBLE_CHARACTER_IN_NUMBER" = "INVISIBLE_CHARACTER_IN_NUMBER";

A figure in 0 to 9 holding an invisible character that is not a direction control (a zero-width joiner or non-joiner, a word joiner, a soft hyphen), standing before a colon where a number would be an operand (<U+200D>24:00). The character makes the figure a word, which the labelled-line fallback used to take as a label and answer with what followed the colon. The message names the character by its code point; the reader deletes it. A direction control in the same place is DIRECTION_CONTROL_IN_NAME.

IPV6_ARITHMETIC

readonly IPV6_ARITHMETIC: "IPV6_ARITHMETIC" = "IPV6_ARITHMETIC";

An IPv6 address in arithmetic, a numeric function, a comparison with a number or a conversion with no whole-number reading (fe80::1 + 2). Its 128 bits are past what a number holds exactly; the message points at as int.

LABEL_NOT_A_NAME

readonly LABEL_NOT_A_NAME: "LABEL_NOT_A_NAME" = "LABEL_NOT_A_NAME";

Text before a colon that is a comparison, an assignment, or a calculation or bracketed figure with no word in it (a > b: 1, (1+2): 5, (24):00), so not a label naming the figure after it. Raised by the labelled-line fallback, which used to answer with the figure whatever the text said.

LINE_FAILED

readonly LINE_FAILED: "LINE_FAILED" = "LINE_FAILED";

A line read by another line in the batch pass, when it threw and no code was kept for it. A fallback: the code the line threw is used where there is one.

LINE_NOT_YET_EVALUATED

readonly LINE_NOT_YET_EVALUATED: "LINE_NOT_YET_EVALUATED" = "LINE_NOT_YET_EVALUATED";

A reference to a line below the one reading it, or past the end of the document, which has no answer yet.

LINE_REF_NO_DOCUMENT

readonly LINE_REF_NO_DOCUMENT: "LINE_REF_NO_DOCUMENT" = "LINE_REF_NO_DOCUMENT";

A line reference, total above or another cross-line form evaluated with no document, as evaluateExpression is. Evaluate the line in a document instead.

LINE_RESULT_ERROR

readonly LINE_RESULT_ERROR: "LINE_RESULT_ERROR" = "LINE_RESULT_ERROR";

A reference to a line whose own answer is an error. The referenced line is the one to fix.

LINE_RESULT_PENDING

readonly LINE_RESULT_PENDING: "LINE_RESULT_PENDING" = "LINE_RESULT_PENDING";

A reference to a line still waiting on live data. It resolves when the data arrives.

LIST_ARGUMENT_UNSUPPORTED

readonly LIST_ARGUMENT_UNSUPPORTED: "LIST_ARGUMENT_UNSUPPORTED" = "LIST_ARGUMENT_UNSUPPORTED";

A list of several numbers given to a builtin that reads each argument as one number and has no answer for each cell (gcd([4, 6], 2), root(3, [8, 27]), atan2([1, 2], 1), isprime([2, 4])). The message points at map.

LIST_CELL_UNSUPPORTED

readonly LIST_CELL_UNSUPPORTED: "LIST_CELL_UNSUPPORTED" = "LIST_CELL_UNSUPPORTED";

A list given to a function of one number that is worked out for each cell (sqrt, sin, ln, fact), or added to or taken from a percentage ([true, 2] + 10%), when a cell is not a number (a true or false, a formula with an unknown), when a cell has no real answer (sqrt([4, -9])), or when the answers come in different units.

LIST_CONDITION_UNSUPPORTED

readonly LIST_CONDITION_UNSUPPORTED: "LIST_CONDITION_UNSUPPORTED" = "LIST_CONDITION_UNSUPPORTED";

A list as the condition of an if (if [1, 2] > 0 then 1 else 2), where one true or false is needed. A list compared with a value answers once per cell, so the message points at one cell (v[0] > 5) or at map to choose for each cell.

LIST_CONVERSION_UNSUPPORTED

readonly LIST_CONVERSION_UNSUPPORTED: "LIST_CONVERSION_UNSUPPORTED" = "LIST_CONVERSION_UNSUPPORTED";

A list of several numbers written as one: in scientific notation, as a fraction or a percentage, or in hex, binary or octal ([1234, 5678] as sci). Each value is converted on its own.

LIST_PERCENTAGE_UNSUPPORTED

readonly LIST_PERCENTAGE_UNSUPPORTED: "LIST_PERCENTAGE_UNSUPPORTED" = "LIST_PERCENTAGE_UNSUPPORTED";

A percentage written before a plain list with + or - (10% + [100, 200]), or a percentage as a cell of a plain list ([10%, 20%], map(x%, [10, 20])). A list holds plain numbers, so it would keep the percentage as its fraction and add 0.1 where 10% was meant; the message gives the forms that work, [100, 200] + 10% or the fractions [0.1, 0.2].

LIST_ROUNDING_NON_NUMERIC

readonly LIST_ROUNDING_NON_NUMERIC: "LIST_ROUNDING_NON_NUMERIC" = "LIST_ROUNDING_NON_NUMERIC";

A list rounded (to 2 dp, to 3 sf, round, ceil, floor) that holds a cell with no number to round: a true or false, or a formula with an unknown.

MALFORMED_BYTECODE_BIGINT_LITERAL

readonly MALFORMED_BYTECODE_BIGINT_LITERAL: "MALFORMED_BYTECODE_BIGINT_LITERAL" = "MALFORMED_BYTECODE_BIGINT_LITERAL";

A big-integer constant in the program that is not a whole number, such as "1.000".

MALFORMED_BYTECODE_BODY_KIND

readonly MALFORMED_BYTECODE_BODY_KIND: "MALFORMED_BYTECODE_BODY_KIND" = "MALFORMED_BYTECODE_BODY_KIND";

A map or reduce instruction carrying a body kind other than 0, 1 or 2.

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.

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.

MALFORMED_BYTECODE_UNKNOWN_OPCODE

readonly MALFORMED_BYTECODE_UNKNOWN_OPCODE: "MALFORMED_BYTECODE_UNKNOWN_OPCODE" = "MALFORMED_BYTECODE_UNKNOWN_OPCODE";

An instruction the VM does not have, refused at the offset that carries it (in the error’s context).

MAP_COLLECTION_LENGTH_MISMATCH

readonly MAP_COLLECTION_LENGTH_MISMATCH: "MAP_COLLECTION_LENGTH_MISMATCH" = "MAP_COLLECTION_LENGTH_MISMATCH";

map over several lists of different lengths.

MAP_REDUCE_ASYNC_UNSUPPORTED

readonly MAP_REDUCE_ASYNC_UNSUPPORTED: "MAP_REDUCE_ASYNC_UNSUPPORTED" = "MAP_REDUCE_ASYNC_UNSUPPORTED";

A map or reduce body that reaches live data while it runs. Refused at parse time first (MAP_REDUCE_TRANSFORM_MUST_BE_SYNCHRONOUS); this is the run-time guard.

MAP_REDUCE_REQUIRES_COLLECTION

readonly MAP_REDUCE_REQUIRES_COLLECTION: "MAP_REDUCE_REQUIRES_COLLECTION" = "MAP_REDUCE_REQUIRES_COLLECTION";

map, reduce, sum or prod over something that is not a list or a range (sum(5)); the message names the word typed.

MATRIX_CELL_NO_UNIT

readonly MATRIX_CELL_NO_UNIT: "MATRIX_CELL_NO_UNIT" = "MATRIX_CELL_NO_UNIT";

A list with a unit given a cell that has no amount in it: a true or false, a percentage or a formula beside a quantity ([true, 1 km]).

MATRIX_CELL_NON_NUMERIC

readonly MATRIX_CELL_NON_NUMERIC: "MATRIX_CELL_NON_NUMERIC" = "MATRIX_CELL_NON_NUMERIC";

A list cell that is not a number or a quantity: a list inside a list, text, a date.

MATRIX_CELL_UNITS_DIFFER

readonly MATRIX_CELL_UNITS_DIFFER: "MATRIX_CELL_UNITS_DIFFER" = "MATRIX_CELL_UNITS_DIFFER";

A list whose cells are quantities of different measures ([1 km, 2 kg]), or money in two currencies with no rate between them: a list holds one unit.

MATRIX_INDEX_NOT_A_MATRIX

readonly MATRIX_INDEX_NOT_A_MATRIX: "MATRIX_INDEX_NOT_A_MATRIX" = "MATRIX_INDEX_NOT_A_MATRIX";

[...] indexing or slicing applied to something that is not a matrix.

MATRIX_INDEX_OUT_OF_BOUNDS

readonly MATRIX_INDEX_OUT_OF_BOUNDS: "MATRIX_INDEX_OUT_OF_BOUNDS" = "MATRIX_INDEX_OUT_OF_BOUNDS";

An index or a slice past the edge of the matrix.

MATRIX_POWER_REQUIRES_SQUARE_MATRIX

readonly MATRIX_POWER_REQUIRES_SQUARE_MATRIX: "MATRIX_POWER_REQUIRES_SQUARE_MATRIX" = "MATRIX_POWER_REQUIRES_SQUARE_MATRIX";

A matrix raised to a power that is not square.

MATRIX_POWER_REQUIRES_WHOLE_EXPONENT

readonly MATRIX_POWER_REQUIRES_WHOLE_EXPONENT: "MATRIX_POWER_REQUIRES_WHOLE_EXPONENT" = "MATRIX_POWER_REQUIRES_WHOLE_EXPONENT";

A matrix raised to a power that is not a whole number of 0 or more. ^-1 is the inverse and ^T the transpose.

MATRIX_POWER_UNSUPPORTED

readonly MATRIX_POWER_UNSUPPORTED: "MATRIX_POWER_UNSUPPORTED" = "MATRIX_POWER_UNSUPPORTED";

A matrix used as an exponent, or ^ between a matrix and something with no matrix reading.

MATRIX_UNIT_ALGEBRA

readonly MATRIX_UNIT_ALGEBRA: "MATRIX_UNIT_ALGEBRA" = "MATRIX_UNIT_ALGEBRA";

Matrix algebra on a list with a unit (det([1 km, 2 km; 3 km, 4 km])): a determinant, an inverse, a matrix product or power, or a dot product.

MATRIX_UNIT_OPERATION_UNSUPPORTED

readonly MATRIX_UNIT_OPERATION_UNSUPPORTED: "MATRIX_UNIT_OPERATION_UNSUPPORTED" = "MATRIX_UNIT_OPERATION_UNSUPPORTED";

A list with a unit in an operation its cells cannot take one by one: multiplied by another quantity, a number divided by it, or a percentage added.

MULTIPLIER_TAKES_NUMBER

readonly MULTIPLIER_TAKES_NUMBER: "MULTIPLIER_TAKES_NUMBER" = "MULTIPLIER_TAKES_NUMBER";

"hello" as multiplier, 5 km as multiplier: a multiplier asked of something that is not a plain number or a percentage. The reader converts a number (#829).

NESTING_DEPTH_EXCEEDED

readonly NESTING_DEPTH_EXCEEDED: "NESTING_DEPTH_EXCEEDED" = "NESTING_DEPTH_EXCEEDED";

Brackets, or other nested forms, deeper than the parser allows (validation.maxNestingDepth, 50 by default). A safety limit against input built to exhaust the stack; the reader flattens the line.

NETWORK_DISABLED

readonly NETWORK_DISABLED: "NETWORK_DISABLED" = "NETWORK_DISABLED";

A live-data form evaluated on an engine whose host switched the network off (network.enabled: false, see constants/Configuration.ts’s NetworkConfig). A recoverable Error value, raised by the VM for a currency conversion with no primed rate and for a plugin function that returned a promise, and by createQueryResolver’s plugin function when its preflight was skipped. Names the setting, so the reader knows it is policy rather than an outage.

NO_MATCHING_PHRASE_ALTERNATIVE

readonly NO_MATCHING_PHRASE_ALTERNATIVE: "NO_MATCHING_PHRASE_ALTERNATIVE" = "NO_MATCHING_PHRASE_ALTERNATIVE";

A phrase that starts a form (roll, clamp) followed by none of the words that continue it. The message names the words that may come next.

NO_PREFIX_PARSELET

readonly NO_PREFIX_PARSELET: "NO_PREFIX_PARSELET" = "NO_PREFIX_PARSELET";

A line has something where a value should start that cannot start one: the * in 2 + * 3, the ) in round(3.14, ), the > in (5 km) -> miles. Thrown with a span on the character and, where there is an obvious next step, a suggestion.

NON_INTEGER_RANGE_BOUND

readonly NON_INTEGER_RANGE_BOUND: "NON_INTEGER_RANGE_BOUND" = "NON_INTEGER_RANGE_BOUND";

A range whose bounds are not whole numbers (0.5:3).

NORMALIZED_TOKEN_LIMIT_EXCEEDED

readonly NORMALIZED_TOKEN_LIMIT_EXCEEDED: "NORMALIZED_TOKEN_LIMIT_EXCEEDED" = "NORMALIZED_TOKEN_LIMIT_EXCEEDED";

The normaliser grew a line’s tokens past its safety limit. A guard against a rule that expands without end.

NORMALIZER_PASS_LIMIT_EXCEEDED

readonly NORMALIZER_PASS_LIMIT_EXCEEDED: "NORMALIZER_PASS_LIMIT_EXCEEDED" = "NORMALIZER_PASS_LIMIT_EXCEEDED";

The normaliser was still changing the token stream after its pass budget (maxPasses, 100 by default): a rule chain that never settles. Reported rather than returning whatever the last pass left. Recoverable.

NOT_WHOLE_NUMBER

readonly NOT_WHOLE_NUMBER: "NOT_WHOLE_NUMBER" = "NOT_WHOLE_NUMBER";

A function that counts whole things (fact, nPr) given a fraction.

NUMBER_THEORY_DOMAIN

readonly NUMBER_THEORY_DOMAIN: "NUMBER_THEORY_DOMAIN" = "NUMBER_THEORY_DOMAIN";

A number theory function given a whole number outside what it is defined for: factor(0), a modulus below 1, a negative exponent.

NUMBER_THEORY_EXPECTED_INTEGER

readonly NUMBER_THEORY_EXPECTED_INTEGER: "NUMBER_THEORY_EXPECTED_INTEGER" = "NUMBER_THEORY_EXPECTED_INTEGER";

A number theory function (factor, isprime, modpow) given something that is not a whole number.

NUMBER_THEORY_NO_INVERSE

readonly NUMBER_THEORY_NO_INVERSE: "NUMBER_THEORY_NO_INVERSE" = "NUMBER_THEORY_NO_INVERSE";

modinv of a number that shares a factor with the modulus, so no inverse exists.

OPCODE_POOL_EXHAUSTED

readonly OPCODE_POOL_EXHAUSTED: "OPCODE_POOL_EXHAUSTED" = "OPCODE_POOL_EXHAUSTED";

More packages asked for opcodes of their own than the dynamic opcode range holds. A registration fault.

OTHER_SCRIPT_DIGITS

readonly OTHER_SCRIPT_DIGITS: "OTHER_SCRIPT_DIGITS" = "OTHER_SCRIPT_DIGITS";

A figure in digits from another script (٢٤:00, Total: ٢٤:00, Arabic-Indic for 24) standing before a colon where a number would be an operand. Numbers are read in the digits 0 to 9 only, and the labelled-line fallback used to take the figure as a label and answer with what followed the colon. The message spells the figure in 0 to 9.

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.

PACKAGE_NAME_MISSING

readonly PACKAGE_NAME_MISSING: "PACKAGE_NAME_MISSING" = "PACKAGE_NAME_MISSING";

A package was registered with no name, or an empty one, so nothing could name it to unregister it or report on it (#719).

PACKAGE_RESOLVER_FUNCTION_MISSING

readonly PACKAGE_RESOLVER_FUNCTION_MISSING: "PACKAGE_RESOLVER_FUNCTION_MISSING" = "PACKAGE_RESOLVER_FUNCTION_MISSING";

A package’s createQueryResolver watches for a plugin function the package does not declare, or was built for another package, so the call it waits for would never come (#719).

PARSE_ERROR

readonly PARSE_ERROR: "PARSE_ERROR" = "PARSE_ERROR";

The generic parse failure, kept for a caller that wraps one without a more specific code.

PASS_WORK_BUDGET_EXCEEDED

readonly PASS_WORK_BUDGET_EXCEEDED: "PASS_WORK_BUDGET_EXCEEDED" = "PASS_WORK_BUDGET_EXCEEDED";

A document pass whose cross-line forms together re-ran more lines than vm.maxLineRunsPerPass allows. The line that crossed the budget is refused by name; the host may raise it.

PERCENT_CHANGE_FAILED

readonly PERCENT_CHANGE_FAILED: "PERCENT_CHANGE_FAILED" = "PERCENT_CHANGE_FAILED";

A percentage change that could not be worked out from its two values.

PERCENT_CHANGE_FROM_ZERO

readonly PERCENT_CHANGE_FROM_ZERO: "PERCENT_CHANGE_FROM_ZERO" = "PERCENT_CHANGE_FROM_ZERO";

A percentage change from zero, which no percentage reaches. The message suggests the difference instead.

PERCENT_CHANGE_NEGATIVE_BASE

readonly PERCENT_CHANGE_NEGATIVE_BASE: "PERCENT_CHANGE_NEGATIVE_BASE" = "PERCENT_CHANGE_NEGATIVE_BASE";

A percentage change from a negative base, which has two readings. The message shows how to write the one meant.

PERCENTAGE_NOT_FINITE

readonly PERCENTAGE_NOT_FINITE: "PERCENTAGE_NOT_FINITE" = "PERCENTAGE_NOT_FINITE";

A value written as a percentage that is not a finite number: an infinity a division by zero gave (1/0 as %), or a value that is no number at all.

PERCENTAGE_OF_QUANTITY

readonly PERCENTAGE_OF_QUANTITY: "PERCENTAGE_OF_QUANTITY" = "PERCENTAGE_OF_QUANTITY";

A value written as a percentage that is not a proportion, such as a length.

PERCENTAGE_OVERFLOW

readonly PERCENTAGE_OVERFLOW: "PERCENTAGE_OVERFLOW" = "PERCENTAGE_OVERFLOW";

A value written as a percentage that is too large for its percentage, a hundred times it, to be held, as in 1e308 as %, or that is itself past the largest number that can be held, as in 2^2000 as %.

PERMUTATION_OVERFLOW

readonly PERMUTATION_OVERFLOW: "PERMUTATION_OVERFLOW" = "PERMUTATION_OVERFLOW";

A permutation count past the largest number a double can hold.

PHRASE_KEYWORD_MISMATCH

readonly PHRASE_KEYWORD_MISMATCH: "PHRASE_KEYWORD_MISMATCH" = "PHRASE_KEYWORD_MISMATCH";

A phrase form missing one of its words part-way through (roll between 1 6, with no and). The message names the word expected.

PLOT_INVALID_RANGE

readonly PLOT_INVALID_RANGE: "PLOT_INVALID_RANGE" = "PLOT_INVALID_RANGE";

A plot’s range whose ends are not finite numbers.

PLUGIN_CALL_FAILED

readonly PLUGIN_CALL_FAILED: "PLUGIN_CALL_FAILED" = "PLUGIN_CALL_FAILED";

A plugin function’s promise was rejected. The line reports the rejection’s message rather than waiting again.

PLUGIN_CALL_FUSION_UNREACHABLE

readonly PLUGIN_CALL_FUSION_UNREACHABLE: "PLUGIN_CALL_FUSION_UNREACHABLE" = "PLUGIN_CALL_FUSION_UNREACHABLE";

A package’s callFusions names a word the engine already reads as something other than a plain word (a keyword, a built-in function, a unit), so the call could never fire. Refused at registration.

PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED

readonly PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED: "PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED" = "PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED";

More plugin functions registered than a compiled call can index (65,536). A registration fault.

PLUGIN_FUNCTION_INDEX_TOO_LARGE

readonly PLUGIN_FUNCTION_INDEX_TOO_LARGE: "PLUGIN_FUNCTION_INDEX_TOO_LARGE" = "PLUGIN_FUNCTION_INDEX_TOO_LARGE";

A plugin function’s index past the largest a compiled call can hold (65,535). A registration fault.

PLUGIN_KEYWORD_COLLISION

readonly PLUGIN_KEYWORD_COLLISION: "PLUGIN_KEYWORD_COLLISION" = "PLUGIN_KEYWORD_COLLISION";

A package registered a keyword the engine already has. Refused at registration, since a built-in keyword cannot be overridden.

PLUGIN_OPERATOR_COLLISION

readonly PLUGIN_OPERATOR_COLLISION: "PLUGIN_OPERATOR_COLLISION" = "PLUGIN_OPERATOR_COLLISION";

A package registered an operator the engine already has. Refused at registration, since a built-in operator cannot be overridden.

PLUGIN_OPERATOR_UNSUPPORTED

readonly PLUGIN_OPERATOR_UNSUPPORTED: "PLUGIN_OPERATOR_UNSUPPORTED" = "PLUGIN_OPERATOR_UNSUPPORTED";

A package registered an operator the scanner cannot read: not exactly two characters, or a first character the scanner does not class as an operator. Refused at registration rather than left to never fire.

PLUGIN_RESULT_NOT_A_VALUE

readonly PLUGIN_RESULT_NOT_A_VALUE: "PLUGIN_RESULT_NOT_A_VALUE" = "PLUGIN_RESULT_NOT_A_VALUE";

A plugin function’s promise resolved to something that is not a Value. An authoring fault, reported on the line.

PLUGIN_UNIT_ALIAS_TARGET_UNKNOWN

readonly PLUGIN_UNIT_ALIAS_TARGET_UNKNOWN: "PLUGIN_UNIT_ALIAS_TARGET_UNKNOWN" = "PLUGIN_UNIT_ALIAS_TARGET_UNKNOWN";

A package’s unitAliases maps a word to something that is not a single unit the engine reads (mile, days), so the alias would have nothing to mean. Refused at registration (#762).

PLUGIN_UNIT_ALIAS_UNREACHABLE

readonly PLUGIN_UNIT_ALIAS_UNREACHABLE: "PLUGIN_UNIT_ALIAS_UNREACHABLE" = "PLUGIN_UNIT_ALIAS_UNREACHABLE";

A package’s unitAliases names a word the engine already reads as something other than a plain word (a unit, a keyword, a function), so the alias could never be read. Refused at registration (#762).

PLUGIN_UNIT_COLLISION

readonly PLUGIN_UNIT_COLLISION: "PLUGIN_UNIT_COLLISION" = "PLUGIN_UNIT_COLLISION";

A package registered a unit spelling the engine already has. Refused at registration, since a built-in unit cannot be overridden.

POWER_NO_REAL_VALUE

readonly POWER_NO_REAL_VALUE: "POWER_NO_REAL_VALUE" = "POWER_NO_REAL_VALUE";

A negative number to a fractional power with no real value, as in (-1)^0.5, or a negative number’s root of even degree.

PROPORTION_DIVIDE_BY_ZERO

readonly PROPORTION_DIVIDE_BY_ZERO: "PROPORTION_DIVIDE_BY_ZERO" = "PROPORTION_DIVIDE_BY_ZERO";

proportion whose first term is zero, so there is nothing to scale by.

QUANTITY_NON_NUMERIC

readonly QUANTITY_NON_NUMERIC: "QUANTITY_NON_NUMERIC" = "QUANTITY_NON_NUMERIC";

Something with no single amount combined with a quantity, as in a list plus 5 m.

QUOTIENT_UNDEFINED

readonly QUOTIENT_UNDEFINED: "QUOTIENT_UNDEFINED" = "QUOTIENT_UNDEFINED";

A division with no single answer: 0 / 0 (either zero signed), or an infinity over an infinity. 5 / 0 is ∞ and is not refused.

RANGE_BEFORE_ANOTHER_ARGUMENT

readonly RANGE_BEFORE_ANOTHER_ARGUMENT: "RANGE_BEFORE_ANOTHER_ARGUMENT" = "RANGE_BEFORE_ANOTHER_ARGUMENT";

A whole-number colon pair no clock reads, written as the first of several arguments to sum, total, prod, map or reduce (sum(100:200, 50)): a range is read only as the last argument. Refused by the normaliser; the message says where the range goes.

RANGE_BOUND_GROUP_MALFORMED

readonly RANGE_BOUND_GROUP_MALFORMED: "RANGE_BOUND_GROUP_MALFORMED" = "RANGE_BOUND_GROUP_MALFORMED";

A number in a call written like a grouped range bound whose group is not three digits (sum(1,0000:1), sum(1,00:1)): refused by the lexer, since it is neither one bound nor plainly two arguments. The message says a space after the comma gives two.

RATE_CONVERT_MEASURE_MISMATCH

readonly RATE_CONVERT_MEASURE_MISMATCH: "RATE_CONVERT_MEASURE_MISMATCH" = "RATE_CONVERT_MEASURE_MISMATCH";

A rate’s denominator converted to a unit that measures something else ($50/week in kg).

RATE_CONVERT_NOT_A_RATE

readonly RATE_CONVERT_NOT_A_RATE: "RATE_CONVERT_NOT_A_RATE" = "RATE_CONVERT_NOT_A_RATE";

A conversion of a rate’s denominator applied to a value that is not a rate.

RATE_MISSING_DENOMINATOR_UNIT

readonly RATE_MISSING_DENOMINATOR_UNIT: "RATE_MISSING_DENOMINATOR_UNIT" = "RATE_MISSING_DENOMINATOR_UNIT";

A rate built with / whose right-hand side has no unit to be per.

RATE_MUL_LEFT_NOT_A_RATE

readonly RATE_MUL_LEFT_NOT_A_RATE: "RATE_MUL_LEFT_NOT_A_RATE" = "RATE_MUL_LEFT_NOT_A_RATE";

A rate multiplication whose left-hand side is not a rate.

RATE_MUL_MEASURE_MISMATCH

readonly RATE_MUL_MEASURE_MISMATCH: "RATE_MUL_MEASURE_MISMATCH" = "RATE_MUL_MEASURE_MISMATCH";

A rate multiplied by a quantity that measures something else than what the rate is per ($50/week * 3 kg).

RATE_MUL_RIGHT_MISSING_UNIT

readonly RATE_MUL_RIGHT_MISSING_UNIT: "RATE_MUL_RIGHT_MISSING_UNIT" = "RATE_MUL_RIGHT_MISSING_UNIT";

A rate multiplied by a value with no unit matching what the rate is per.

REDUCE_EMPTY_COLLECTION

readonly REDUCE_EMPTY_COLLECTION: "REDUCE_EMPTY_COLLECTION" = "REDUCE_EMPTY_COLLECTION";

reduce over an empty list with no starting value.

REMAINDER_UNDEFINED

readonly REMAINDER_UNDEFINED: "REMAINDER_UNDEFINED" = "REMAINDER_UNDEFINED";

A remainder with no value: 5 mod 0, or the remainder of an infinite number.

RESIZE_EXPECTED_SHAPE

readonly RESIZE_EXPECTED_SHAPE: "RESIZE_EXPECTED_SHAPE" = "RESIZE_EXPECTED_SHAPE";

A resize was written without one of its parts: the dimensions, the to, the size, or the side it names. Recoverable.

SETTLE_TIMEOUT

readonly SETTLE_TIMEOUT: "SETTLE_TIMEOUT" = "SETTLE_TIMEOUT";

await engine.settle({ timeoutMs }) reached its deadline with live values still being fetched. Rejected rather than resolved, so a caller is never handed a Pending line as if it were settled; the context carries how many were in flight. Recoverable: the lines stay Pending and settle when their fetches land.

SETTLE_TIMEOUT_INVALID

readonly SETTLE_TIMEOUT_INVALID: "SETTLE_TIMEOUT_INVALID" = "SETTLE_TIMEOUT_INVALID";

engine.settle was given a timeoutMs that is not a finite number of zero or more (a negative, NaN, an infinity, text). Rejected, since it is the host’s argument that is wrong.

SINGULAR_MATRIX

readonly SINGULAR_MATRIX: "SINGULAR_MATRIX" = "SINGULAR_MATRIX";

inv of a matrix with no inverse: a zero, or nearly zero, pivot.

SNAPSHOT_MALFORMED

readonly SNAPSHOT_MALFORMED: "SNAPSHOT_MALFORMED" = "SNAPSHOT_MALFORMED";

A snapshot with the right envelope but internally inconsistent contents (an unrecognised number sentinel, an unknown value tag). Distinct from a version mismatch: the format is right, the payload is not.

SNAPSHOT_PACKAGE_MISSING

readonly SNAPSHOT_PACKAGE_MISSING: "SNAPSHOT_PACKAGE_MISSING" = "SNAPSHOT_PACKAGE_MISSING";

A snapshot calls a plugin function that no package registered on the restoring engine provides. Refused rather than restored, since the call would run whatever sits at its old index (#658).

SNAPSHOT_UNSUPPORTED_VALUE

readonly SNAPSHOT_UNSUPPORTED_VALUE: "SNAPSHOT_UNSUPPORTED_VALUE" = "SNAPSHOT_UNSUPPORTED_VALUE";

A value the snapshot format cannot yet represent (a symbolic value or matrix cell, a colour, a split, a chart, an IP subnet). toJSON catches it and leaves the value out (#665).

SNAPSHOT_VERSION_MISMATCH

readonly SNAPSHOT_VERSION_MISMATCH: "SNAPSHOT_VERSION_MISMATCH" = "SNAPSHOT_VERSION_MISMATCH";

fromJSON() handed an object that is not a snapshot at all, or whose serialised-shape version does not match this engine’s reader. The versioning gate that refuses an incompatible snapshot clearly rather than restoring it wrongly. See engine/EngineSnapshot.ts’s assertRestorable().

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";

One evaluation grew the VM stack past vm.maxStackDepth. A safety limit; the reader simplifies the line.

STACK_UNDERFLOW

readonly STACK_UNDERFLOW: "STACK_UNDERFLOW" = "STACK_UNDERFLOW";

The VM read more values than its stack held: corrupted bytecode or a faulty plugin. Worth reporting; the engine stays usable and only this line fails.

STATISTIC_NOT_FINITE

readonly STATISTIC_NOT_FINITE: "STATISTIC_NOT_FINITE" = "STATISTIC_NOT_FINITE";

A standard deviation or variance of a list holding an infinity.

SYMBOLIC_ASYNC_UNSUPPORTED

readonly SYMBOLIC_ASYNC_UNSUPPORTED: "SYMBOLIC_ASYNC_UNSUPPORTED" = "SYMBOLIC_ASYNC_UNSUPPORTED";

An algebra verb’s expression that reaches live data while it runs. Refused at parse time first (SYMBOLIC_ARGUMENT_MUST_BE_SYNCHRONOUS); this is the run-time guard.

SYMBOLIC_BOUND_INVALID

readonly SYMBOLIC_BOUND_INVALID: "SYMBOLIC_BOUND_INVALID" = "SYMBOLIC_BOUND_INVALID";

A bound of integral, an end of solve’s search range, or limit’s point that is not a plain finite number: it carries a unit, still contains an unknown, is not a number, or (for solve and limit) is infinite.

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";

An exact symbolic division by zero, such as expand((x+1)/0): refused where the quotient is written, as a value, and thrown from the rational arithmetic beneath. The zero is exact, so a very small number is not mistaken for one.

SYMBOLIC_FACTOR_LIMIT_EXCEEDED

readonly SYMBOLIC_FACTOR_LIMIT_EXCEEDED: "SYMBOLIC_FACTOR_LIMIT_EXCEEDED" = "SYMBOLIC_FACTOR_LIMIT_EXCEEDED";

factor of a cubic or higher whose rational roots cannot be searched: a coefficient too long a fraction to list its divisors (factor(x^3 - pi)), or a candidate set past FACTOR_MAX_ROOT_CANDIDATES. A quadratic is decided by its discriminant instead and never raises it.

SYMBOLIC_FORMULA_VALUE_UNSUPPORTED

readonly SYMBOLIC_FORMULA_VALUE_UNSUPPORTED: "SYMBOLIC_FORMULA_VALUE_UNSUPPORTED" = "SYMBOLIC_FORMULA_VALUE_UNSUPPORTED";

A name holding a formula written before one of its unknowns had a value (y = x + 1 above x = $5), read after that unknown was given money, a quantity in a unit, a date or text, which the formula cannot take. Returned by the read rather than a formula mixing the value with the unknown (#732).

SYMBOLIC_INTEGRAL_IMPROPER

readonly SYMBOLIC_INTEGRAL_IMPROPER: "SYMBOLIC_INTEGRAL_IMPROPER" = "SYMBOLIC_INTEGRAL_IMPROPER";

A definite integral with an infinite bound, or whose integrand has no finite value somewhere in the range (1/x from 0 to 1). Improper integrals are refused by name rather than evaluated.

SYMBOLIC_INTEGRAL_UNSETTLED

readonly SYMBOLIC_INTEGRAL_UNSETTLED: "SYMBOLIC_INTEGRAL_UNSETTLED" = "SYMBOLIC_INTEGRAL_UNSETTLED";

A definite integral whose numeric estimate did not settle within the quadrature’s budget, which is what an integrand growing without bound inside the range, and so a diverging integral, looks like.

SYMBOLIC_INTEGRAL_UNSUPPORTED

readonly SYMBOLIC_INTEGRAL_UNSUPPORTED: "SYMBOLIC_INTEGRAL_UNSUPPORTED" = "SYMBOLIC_INTEGRAL_UNSUPPORTED";

An indefinite integral with no known elementary antiderivative, reported rather than approximated, since a wrong integral is indistinguishable from a right one at the point of use. For a definite integral, one with no antiderivative that also cannot be evaluated numerically (another unknown in it, or a function with no numeric form).

SYMBOLIC_INVERSE_DIMENSION_LIMIT

readonly SYMBOLIC_INVERSE_DIMENSION_LIMIT: "SYMBOLIC_INVERSE_DIMENSION_LIMIT" = "SYMBOLIC_INVERSE_DIMENSION_LIMIT";

A symbolic matrix inverse larger than the size the symbolic elimination handles.

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_LIMIT_DIVERGES

readonly SYMBOLIC_LIMIT_DIVERGES: "SYMBOLIC_LIMIT_DIVERGES" = "SYMBOLIC_LIMIT_DIVERGES";

A limit where the expression grows without bound (1/x^2 at 0).

SYMBOLIC_LIMIT_SIDES_DISAGREE

readonly SYMBOLIC_LIMIT_SIDES_DISAGREE: "SYMBOLIC_LIMIT_SIDES_DISAGREE" = "SYMBOLIC_LIMIT_SIDES_DISAGREE";

A limit whose left and right sides settle on different values (abs(x)/x at 0). The message names both.

SYMBOLIC_LIMIT_UNDEFINED

readonly SYMBOLIC_LIMIT_UNDEFINED: "SYMBOLIC_LIMIT_UNDEFINED" = "SYMBOLIC_LIMIT_UNDEFINED";

A limit of an expression with no real value near the point on either side.

SYMBOLIC_LIMIT_UNSETTLED

readonly SYMBOLIC_LIMIT_UNSETTLED: "SYMBOLIC_LIMIT_UNSETTLED" = "SYMBOLIC_LIMIT_UNSETTLED";

A limit whose values never settle on one number (sin(1/x) at 0).

SYMBOLIC_LIMIT_UNSUPPORTED

readonly SYMBOLIC_LIMIT_UNSUPPORTED: "SYMBOLIC_LIMIT_UNSUPPORTED" = "SYMBOLIC_LIMIT_UNSUPPORTED";

A limit of an expression that cannot be evaluated numerically: another unknown in it, an imaginary constant, or a function with no numeric form.

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_QUANTITY_OPERAND

readonly SYMBOLIC_QUANTITY_OPERAND: "SYMBOLIC_QUANTITY_OPERAND" = "SYMBOLIC_QUANTITY_OPERAND";

Arithmetic between an unknown and an amount with a unit, such as foo * 5 km =>: a formula has nowhere to keep the unit, so the line is refused rather than answered with the unit dropped.

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_BOTH_BOUNDS

readonly SYMBOLIC_REQUIRES_BOTH_BOUNDS: "SYMBOLIC_REQUIRES_BOTH_BOUNDS" = "SYMBOLIC_REQUIRES_BOTH_BOUNDS";

integral(f, x, a) or solve(eq, x, a): one number after the unknown where the form takes two. A parse error naming the form, rather than a missing closing parenthesis.

SYMBOLIC_REQUIRES_LIMIT_POINT

readonly SYMBOLIC_REQUIRES_LIMIT_POINT: "SYMBOLIC_REQUIRES_LIMIT_POINT" = "SYMBOLIC_REQUIRES_LIMIT_POINT";

limit(f, x) with no point for the unknown to approach.

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_SINGULAR_OR_UNSUPPORTED_PIVOT

readonly SYMBOLIC_SINGULAR_OR_UNSUPPORTED_PIVOT: "SYMBOLIC_SINGULAR_OR_UNSUPPORTED_PIVOT" = "SYMBOLIC_SINGULAR_OR_UNSUPPORTED_PIVOT";

A symbolic matrix inverse that meets a zero pivot, which the elimination does not reorder around.

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_NO_ROOT_FOUND

readonly SYMBOLIC_SOLVE_NO_ROOT_FOUND: "SYMBOLIC_SOLVE_NO_ROOT_FOUND" = "SYMBOLIC_SOLVE_NO_ROOT_FOUND";

A numerically solved equation whose two sides never cross in the range searched. Not “no solution”: a search that found nothing has not shown there is nothing, and the message names the range and what the search cannot see.

SYMBOLIC_SOLVE_TOO_MANY_ROOTS

readonly SYMBOLIC_SOLVE_TOO_MANY_ROOTS: "SYMBOLIC_SOLVE_TOO_MANY_ROOTS" = "SYMBOLIC_SOLVE_TOO_MANY_ROOTS";

A numerically solved equation with more roots in the range than NUMERIC_ROOTS_MAX, as a periodic one has, or whose two sides compare equal across a whole stretch. Declined rather than listed, because a list cut off at the edge of the search would read as complete.

SYMBOLIC_SOLVE_UNSUPPORTED

readonly SYMBOLIC_SOLVE_UNSUPPORTED: "SYMBOLIC_SOLVE_UNSUPPORTED" = "SYMBOLIC_SOLVE_UNSUPPORTED";

An equation outside what the solver attempts: above the degree ceiling, non-linear in the unknown while another unknown is present, or not a polynomial and not evaluable numerically either (another unknown in it, an imaginary constant, a function with no numeric form). A non-polynomial equation in one unknown is solved numerically instead (see symbolic/NumericSolve.ts).

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.

TEMPORAL_IMPLEMENTATION_INVALID

readonly TEMPORAL_IMPLEMENTATION_INVALID: "TEMPORAL_IMPLEMENTATION_INVALID" = "TEMPORAL_IMPLEMENTATION_INVALID";

createTemporalCalendar() was handed something that is not a usable Temporal implementation: no Now.instant, Now.timeZoneId, Instant.fromEpochMilliseconds or PlainDateTime.from. Raised at construction, naming the missing member, rather than letting the first date computation fail on it obscurely.

TEMPORAL_TIME_ZONE_UNKNOWN

readonly TEMPORAL_TIME_ZONE_UNKNOWN: "TEMPORAL_TIME_ZONE_UNKNOWN" = "TEMPORAL_TIME_ZONE_UNKNOWN";

The timeZone given to createTemporalCalendar() is not one the Temporal implementation knows. Raised at construction, so a misspelt zone is a configuration error the host sees once, not a RangeError from inside every date the engine computes.

TERNARY_UNSUPPORTED

readonly TERNARY_UNSUPPORTED: "TERNARY_UNSUPPORTED" = "TERNARY_UNSUPPORTED";

A choice written condition ? value : other (true ? 25 : 30). There is no such operator; the message spells the line as if ... then ... else. Raised by the labelled-line fallback, which used to read true ? 25 as a label and answer 30.

TEXT_ARITHMETIC

readonly TEXT_ARITHMETIC: "TEXT_ARITHMETIC" = "TEXT_ARITHMETIC";

Text used in arithmetic with a number, written after a sign (-"abc"), or given to a numeric function (sqrt("abc")). The message points at as number for text that holds a number.

TEXT_COMPARISON

readonly TEXT_COMPARISON: "TEXT_COMPARISON" = "TEXT_COMPARISON";

Text in an order comparison ("5" > 3, "a" < "b"): text has no order a note would mean. Against a number the message says which side is text and, for text that holds a number, points at as number.

TEXT_NOT_A_NUMBER

readonly TEXT_NOT_A_NUMBER: "TEXT_NOT_A_NUMBER" = "TEXT_NOT_A_NUMBER";

as number or int given text that is not a number.

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.

TIMECODE_FPS_MISMATCH

readonly TIMECODE_FPS_MISMATCH: "TIMECODE_FPS_MISMATCH" = "TIMECODE_FPS_MISMATCH";

Two video timecodes at different frame rates added or subtracted.

TOO_MANY_ANONYMOUS_BODIES

readonly TOO_MANY_ANONYMOUS_BODIES: "TOO_MANY_ANONYMOUS_BODIES" = "TOO_MANY_ANONYMOUS_BODIES";

One line with more map or reduce bodies than a compiled program can index. A safety limit, of the same kind as TOO_MANY_FUNCTION_DEFINITIONS.

TOO_MANY_FUNCTION_DEFINITIONS

readonly TOO_MANY_FUNCTION_DEFINITIONS: "TOO_MANY_FUNCTION_DEFINITIONS" = "TOO_MANY_FUNCTION_DEFINITIONS";

One line defining more functions than a compiled program can index. A safety limit, of the same kind as TOO_MANY_NUMERIC_CONSTANTS.

TOO_MANY_NUMERIC_CONSTANTS

readonly TOO_MANY_NUMERIC_CONSTANTS: "TOO_MANY_NUMERIC_CONSTANTS" = "TOO_MANY_NUMERIC_CONSTANTS";

One line with more distinct number literals than a compiled program can index. A safety limit; the reader splits the line.

TOO_MANY_STRING_CONSTANTS

readonly TOO_MANY_STRING_CONSTANTS: "TOO_MANY_STRING_CONSTANTS" = "TOO_MANY_STRING_CONSTANTS";

One line with more distinct text literals than a compiled program can index. A safety limit; the reader splits the line.

TRACE_NO_DOCUMENT

readonly TRACE_NO_DOCUMENT: "TRACE_NO_DOCUMENT" = "TRACE_NO_DOCUMENT";

traceLine() called with no document to read: the engine has no attached document model and no parseDocument result was passed as options.document. A trace follows one line into the lines above it, so without a document there is nothing to follow.

TRACE_NO_SUCH_LINE

readonly TRACE_NO_SUCH_LINE: "TRACE_NO_SUCH_LINE" = "TRACE_NO_SUCH_LINE";

traceLine() asked for a line number the document does not have (below 1, past the last line, or not a whole number).

TRIG_UNDEFINED

readonly TRIG_UNDEFINED: "TRIG_UNDEFINED" = "TRIG_UNDEFINED";

tan at an odd multiple of a right angle, where the tangent has no value.

TRIP_EXPECTED_AT

readonly TRIP_EXPECTED_AT: "TRIP_EXPECTED_AT" = "TRIP_EXPECTED_AT";

A trip form (cost to drive ...) was written without the at that separates its parts. Recoverable.

UNCERTAINTY_UNIT_MISMATCH

readonly UNCERTAINTY_UNIT_MISMATCH: "UNCERTAINTY_UNIT_MISMATCH" = "UNCERTAINTY_UNIT_MISMATCH";

A tolerance whose unit does not measure what its value does, or that has no rate to reach the value’s currency.

UNCERTAINTY_WITHOUT_UNIT

readonly UNCERTAINTY_WITHOUT_UNIT: "UNCERTAINTY_WITHOUT_UNIT" = "UNCERTAINTY_WITHOUT_UNIT";

A value with a tolerance (5 m +/- 1 cm) converted to a unit or combined with a quantity: a tolerance is read without its unit.

UNDEFINED_FUNCTION

readonly UNDEFINED_FUNCTION: "UNDEFINED_FUNCTION" = "UNDEFINED_FUNCTION";

A call to a function of the reader’s own that no line defines, or a definition the VM could not complete.

UNDEFINED_VARIABLE

readonly UNDEFINED_VARIABLE: "UNDEFINED_VARIABLE" = "UNDEFINED_VARIABLE";

A line reads a name no line above defines. Thrown with no span, and with the nearest defined names in suggestion and context.didYouMean when there are any.

UNEXPECTED_END

readonly UNEXPECTED_END: "UNEXPECTED_END" = "UNEXPECTED_END";

The same as UNEXPECTED_END_OF_INPUT, raised where a line ends before an expression starts at all.

UNEXPECTED_END_OF_INPUT

readonly UNEXPECTED_END_OF_INPUT: "UNEXPECTED_END_OF_INPUT" = "UNEXPECTED_END_OF_INPUT";

A line stops before its expression does: 5 +, (2 + 3, sqrt(. Thrown with an empty span just after the last character, where an editor puts the caret, and a suggestion.

UNEXPECTED_ERROR

readonly UNEXPECTED_ERROR: "UNEXPECTED_ERROR" = "UNEXPECTED_ERROR";

Something other than an EngineError was thrown and normalised. Worth reporting: it is an engine or package fault rather than the reader’s line.

UNEXPECTED_PENDING_RESULT

readonly UNEXPECTED_PENDING_RESULT: "UNEXPECTED_PENDING_RESULT" = "UNEXPECTED_PENDING_RESULT";

A caller that asked for a settled value was handed one still waiting on live data. A caller-contract fault inside the engine, worth reporting.

UNEXPECTED_TOKEN_TYPE

readonly UNEXPECTED_TOKEN_TYPE: "UNEXPECTED_TOKEN_TYPE" = "UNEXPECTED_TOKEN_TYPE";

A form needed one particular thing next and found another: a ) where a , stands, or dice notation (roll 1d6) where a range was expected. Thrown with a span and a suggestion.

UNEXPECTED_TRAILING_TOKEN

readonly UNEXPECTED_TRAILING_TOKEN: "UNEXPECTED_TRAILING_TOKEN" = "UNEXPECTED_TRAILING_TOKEN";

A complete expression followed by more that is not part of it: the , in 1,5 + 1, the 3pm in February 2026 3pm. Thrown rather than answered with the first half, which would be a wrong answer.

UNIT_AFTER_UNIT

readonly UNIT_AFTER_UNIT: "UNIT_AFTER_UNIT" = "UNIT_AFTER_UNIT";

A quantity followed by a second unit, as in 5 kg m: two units side by side are not a unit. The message suggests in for a conversion.

UNIT_IN_EXPONENT

readonly UNIT_IN_EXPONENT: "UNIT_IN_EXPONENT" = "UNIT_IN_EXPONENT";

An exponent carrying a unit, as in 2^(3 m). The message shows where the unit goes instead.

UNIT_POWER_UNSUPPORTED

readonly UNIT_POWER_UNSUPPORTED: "UNIT_POWER_UNSUPPORTED" = "UNIT_POWER_UNSUPPORTED";

A quantity raised to a power that has no unit, as in 2s^2, or a unit written with a power the table does not spell. Only a length squared or cubed has one. A variance of quantities other than lengths, or of percentages, is refused with it too.

UNIT_PRODUCT_UNSUPPORTED

readonly UNIT_PRODUCT_UNSUPPORTED: "UNIT_PRODUCT_UNSUPPORTED" = "UNIT_PRODUCT_UNSUPPORTED";

Two quantities multiplied into something that is not a unit, as in $5 * $3. Lengths multiply into an area or a volume.

UNIT_QUOTIENT_UNSUPPORTED

readonly UNIT_QUOTIENT_UNSUPPORTED: "UNIT_QUOTIENT_UNSUPPORTED" = "UNIT_QUOTIENT_UNSUPPORTED";

Two quantities divided into something that is not a unit: nothing cancels and the result would be a rate of a rate.

UNIT_RECIPROCAL_UNSUPPORTED

readonly UNIT_RECIPROCAL_UNSUPPORTED: "UNIT_RECIPROCAL_UNSUPPORTED" = "UNIT_RECIPROCAL_UNSUPPORTED";

A number divided by a quantity with no reciprocal unit, such as a temperature.

UNIT_ROOT_UNSUPPORTED

readonly UNIT_ROOT_UNSUPPORTED: "UNIT_ROOT_UNSUPPORTED" = "UNIT_ROOT_UNSUPPORTED";

A square or cube root of a quantity whose root has no unit, as in sqrt(4 m), or of a negative area.

UNKNOWN_AS_CONVERTER

readonly UNKNOWN_AS_CONVERTER: "UNKNOWN_AS_CONVERTER" = "UNKNOWN_AS_CONVERTER";

as <name> naming no converter any package registered.

UNKNOWN_BUILTIN_FUNCTION

readonly UNKNOWN_BUILTIN_FUNCTION: "UNKNOWN_BUILTIN_FUNCTION" = "UNKNOWN_BUILTIN_FUNCTION";

A compiled call to a built-in function at an index none is registered at. Reachable only through a compiler or snapshot fault; worth reporting.

UNKNOWN_ERROR

readonly UNKNOWN_ERROR: "UNKNOWN_ERROR" = "UNKNOWN_ERROR";

A thrown value that was not an Error at all, normalised. Worth reporting, as UNEXPECTED_ERROR is.

UNKNOWN_FUNCTION

readonly UNKNOWN_FUNCTION: "UNKNOWN_FUNCTION" = "UNKNOWN_FUNCTION";

A call to a name that is not a function the engine or a package provides. The nearest names are offered where there are any.

UNKNOWN_PLUGIN_FUNCTION

readonly UNKNOWN_PLUGIN_FUNCTION: "UNKNOWN_PLUGIN_FUNCTION" = "UNKNOWN_PLUGIN_FUNCTION";

A parselet emitted a call to a plugin function by a name no registered package declares, or before its package registered. A package-authoring or registration fault, not the reader’s line.

UNKNOWN_SAVINGS_PERIOD

readonly UNKNOWN_SAVINGS_PERIOD: "UNKNOWN_SAVINGS_PERIOD" = "UNKNOWN_SAVINGS_PERIOD";

A savings-goal contribution period that is not one of daily/weekly/monthly/yearly (how long to save $X at $Y <period>). Names the accepted set.

UNKNOWN_UNIT

readonly UNKNOWN_UNIT: "UNKNOWN_UNIT" = "UNKNOWN_UNIT";

A conversion or a unit named something that is not a unit (5 km in mies). The message offers the nearest spellings where there are any.

UNTERMINATED_STRING

readonly UNTERMINATED_STRING: "UNTERMINATED_STRING" = "UNTERMINATED_STRING";

A " that is never closed, as in "abc. Raised by the lexer; the reader closes the text.

USER_FUNCTION_ASYNC_UNSUPPORTED

readonly USER_FUNCTION_ASYNC_UNSUPPORTED: "USER_FUNCTION_ASYNC_UNSUPPORTED" = "USER_FUNCTION_ASYNC_UNSUPPORTED";

A function of the reader’s own whose body reaches live data (weather, stocks, a currency rate). Function bodies must be synchronous.

USER_FUNCTION_INVALID_PARAM_NAME

readonly USER_FUNCTION_INVALID_PARAM_NAME: "USER_FUNCTION_INVALID_PARAM_NAME" = "USER_FUNCTION_INVALID_PARAM_NAME";

A function definition (f(x, y) = ...) with something other than a name where a parameter goes.

USER_FUNCTION_NO_PARAMS

readonly USER_FUNCTION_NO_PARAMS: "USER_FUNCTION_NO_PARAMS" = "USER_FUNCTION_NO_PARAMS";

A function definition with no parameters, f() = ..., which would read the same as a call. A definition needs at least one.

WEIGHTED_AVERAGE_ZERO_WEIGHT

readonly WEIGHTED_AVERAGE_ZERO_WEIGHT: "WEIGHTED_AVERAGE_ZERO_WEIGHT" = "WEIGHTED_AVERAGE_ZERO_WEIGHT";

A weighted average whose weights add up to zero.

WHAT_IF_IN_GOAL_SEEK

readonly WHAT_IF_IN_GOAL_SEEK: "WHAT_IF_IN_GOAL_SEEK" = "WHAT_IF_IN_GOAL_SEEK";

Goal seek targeting a line that holds a what-if or a sweep, whose every probe would re-run the document again.

WHAT_IF_INPUT_NOT_USED

readonly WHAT_IF_INPUT_NOT_USED: "WHAT_IF_INPUT_NOT_USED" = "WHAT_IF_INPUT_NOT_USED";

A what-if overrides a name no line it re-runs mentions, which cannot change any answer and is almost always a misspelling. Thrown by engine.whatIf; returned as an Error value by the line N with ... and sweep forms.

WHAT_IF_LINE_OUT_OF_RANGE

readonly WHAT_IF_LINE_OUT_OF_RANGE: "WHAT_IF_LINE_OUT_OF_RANGE" = "WHAT_IF_LINE_OUT_OF_RANGE";

A what-if or a sweep naming a line the document does not have.

WHAT_IF_LIVE_DATA

readonly WHAT_IF_LIVE_DATA: "WHAT_IF_LIVE_DATA" = "WHAT_IF_LIVE_DATA";

A what-if targeting a line that waits on live data, which a re-run does not fetch.

WHAT_IF_NESTED

readonly WHAT_IF_NESTED: "WHAT_IF_NESTED" = "WHAT_IF_NESTED";

A what-if or a sweep run from inside another one’s re-run of the document.

WHAT_IF_OVERRIDE_INVALID

readonly WHAT_IF_OVERRIDE_INVALID: "WHAT_IF_OVERRIDE_INVALID" = "WHAT_IF_OVERRIDE_INVALID";

engine.whatIf(text, overrides) was given an override whose name is not a variable name, or whose value is not a finite number, text that evaluates on its own, or a Value. Thrown, since it is the host’s argument that is wrong rather than a line of the note.

WHAT_IF_TARGET_ERROR

readonly WHAT_IF_TARGET_ERROR: "WHAT_IF_TARGET_ERROR" = "WHAT_IF_TARGET_ERROR";

A what-if whose target line has no answer with the inputs given. The message is the line’s own.

WHAT_IF_TARGET_HAS_SEVERAL_ANSWERS

readonly WHAT_IF_TARGET_HAS_SEVERAL_ANSWERS: "WHAT_IF_TARGET_HAS_SEVERAL_ANSWERS" = "WHAT_IF_TARGET_HAS_SEVERAL_ANSWERS";

A what-if targeting a line with several inline answers, so there is no one answer to give.

WHAT_IF_TARGET_NOT_A_CALCULATION

readonly WHAT_IF_TARGET_NOT_A_CALCULATION: "WHAT_IF_TARGET_NOT_A_CALCULATION" = "WHAT_IF_TARGET_NOT_A_CALCULATION";

A what-if targeting prose, a heading or a blank line, which has no answer to work out again.

WHAT_IF_WRITES_GLOBAL

readonly WHAT_IF_WRITES_GLOBAL: "WHAT_IF_WRITES_GLOBAL" = "WHAT_IF_WRITES_GLOBAL";

A what-if would re-run a line that sets a global :name. A global is shared with every other document in the process, so the scenario’s value would reach them; refused rather than re-run. Thrown by engine.whatIf; returned as an Error value by the line forms.

WORKDAY_OFFSET_EXPECTED_DATE

readonly WORKDAY_OFFSET_EXPECTED_DATE: "WORKDAY_OFFSET_EXPECTED_DATE" = "WORKDAY_OFFSET_EXPECTED_DATE";

N working days after <x> (or before, from) where <x> is not a date, as in 5 working days after 3.

WORKDAYS_BETWEEN_EXPECTED_DATES

readonly WORKDAYS_BETWEEN_EXPECTED_DATES: "WORKDAYS_BETWEEN_EXPECTED_DATES" = "WORKDAYS_BETWEEN_EXPECTED_DATES";

working days between <a> and <b> where one end is not a date.

WORKDAYS_BETWEEN_RANGE_TOO_LARGE

readonly WORKDAYS_BETWEEN_RANGE_TOO_LARGE: "WORKDAYS_BETWEEN_RANGE_TOO_LARGE" = "WORKDAYS_BETWEEN_RANGE_TOO_LARGE";

working days between two dates further apart than date.maxOffsetYears and date.minOffsetYears allow the count to walk.