Specification · v1

Limits

v1 is built to sit in an execution path that untrusted input can reach. Every input is bounded, and hostile input is refused in linear time before any recursive parsing.

1. Limits

Limit	Default	Ceiling	Diagnostic
`maxSourceBytes`: source size in UTF-8 bytes	65,536	16 MiB	`limit[source-size]`
`maxNesting`: depth of `{ ( [` outside strings, comments and source tags	20	256	`limit[nesting-or-tokens]`
`maxTokens`: words (runs of letters and digits that start with a letter)	6,000	1,000,000	`limit[nesting-or-tokens]`
`maxBooleanOperators`: occurrences of the text `AND` or `OR`	256	100,000	`limit[boolean-tokens]`
`maxConditionDepth`: depth of one clause's condition tree	16	256	`limit[condition-depth]`

A caller may lower any limit for a call. It cannot raise one past its ceiling. A value outside 1 … ceiling is a usage error.

Condition depth is the exception in ulang-lite 0.1.0: validation reads the top-level maxConditionDepth option, not limits.maxConditionDepth, and that option is not checked against the ceiling (see errata E2).

AND and OR are counted as substrings, so FORBID counts once (it contains OR). The count is a cheap upper bound on work, not a count of operators.

2. The bounds scan

One left-to-right pass over the source with constant state. Strings, // and # comments, and [SOURCE:…] tags are skipped. Everything else is checked, and the first problem found is reported:

empty source, or more than maxSourceBytes (checked first, over the whole source);
the text NOT: unsupported[not-operator];
+, *, / (other than //), ^, or - not directly followed by a digit: unsupported[arithmetic];
more than maxBooleanOperators occurrences of AND/OR;
nesting deeper than maxNesting, or more than maxTokens words.

Items 2 to 5 are checked at each character, so whichever problem occurs earliest in the source is the one reported.

The scan is why NOT and arithmetic produce unsupported diagnostics before any syntax error elsewhere in the file, and why a name that contains NOT anywhere is refused (see Syntax §7).

3. During parsing and validation

Parser recursion is bounded by maxNesting. Exceeding it reports limit[nesting-or-tokens] at the opening bracket.
Each clause's condition depth is checked against maxConditionDepth while types are checked. Parentheses add no depth.
Literals are checked against the exact numeric domain: limit[integer-range], limit[float-range].

Together these bound the parser's stack by maxNesting and each condition's depth by maxConditionDepth, whatever the input.