Fix crash in error annotator when parser fails at EOF

A parse failure with a missing closing `}` at EOF (e.g.,
`context X is { ... ` with no `}` before EOF) constructs an
`At` whose `endOffset` is one past the end of the last line
computed by `lineRangeOf`. Two `require` calls in
`RiddlParserInput.annotateErrorLine` then threw
`IllegalArgumentException: requirement failed: fail: 58 >= 59`,
which the outer `runMain` catch wrapped as a SEVERE
"Exception Thrown" message, hiding the real error.

The downstream slicing already clamps via `Math.min(...,
data.length)`, so those requires were over-strict, not
load-bearing. Removed them with a comment explaining the
boundary condition.

After the fix, a missing-brace input produces a normal
Error with file location, e.g.:

  [error] badEntity.riddl(5:1->6:2):
  Expected one of ("..." | "}" | ...)

Regression test added at `TopLevelParserTest`. Fixture files
`language/input/riddl-bad/{badDomain,badEntity}.riddl` are
checked in (3 opens, 2 closes). Test asserts no Severe and
that the resulting Error mentions the file and lists `}` in
the expected-tokens set.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: reid-spencer

language/input/riddl-bad/badDomain.riddl

@@ -0,0 +1,3 @@
+domain BadDomain is {
+  include "badEntity.riddl"
+}

language/input/riddl-bad/badEntity.riddl

@@ -0,0 +1,5 @@
+context BadContext is {
+  entity BadEntity is {
+    ???
+}
+

language/jvm-native/src/test/scala/com/ossuminc/riddl/language/parsing/TopLevelParserTest.scala

@@ -147,5 +147,39 @@ class TopLevelParserTest extends ParsingTest {
         case Right(result)  => result.contents.length must be(3)
       }
     }
+    // Regression: a missing closing brace at EOF previously crashed the
+    // error reporter (`annotateErrorLine`) with
+    // `IllegalArgumentException: requirement failed: fail: 58 >= 59`,
+    // which the outer driver caught and surfaced as a SEVERE
+    // "Exception Thrown" message instead of a normal Error with the
+    // offending file/line. Fixture files are at
+    // `language/input/riddl-bad/{badDomain,badEntity}.riddl` and
+    // intentionally have 3 opens / 2 closes.
+    "report a normal Error (not Severe) when closing brace is missing at EOF" in {
+      (_: TestData) =>
+        val url: URL = PathUtils.urlFromCwdPath(
+          Path.of(testInput + "/riddl-bad/badDomain.riddl")
+        )
+        val future = TopLevelParser.parseURL(url)
+        Await.result(future, 10.seconds) match
+          case Right(_) =>
+            fail("Expected the malformed input to fail parsing")
+          case Left(messages: Messages) =>
+            // No Severe / "Exception Thrown" — the error reporter
+            // must not crash on the EOF boundary condition.
+            val severes = messages.filter(_.kind == SevereError)
+            withClue(s"Got severe messages: ${severes.map(_.format).mkString(", ")}\n") {
+              severes mustBe empty
+            }
+            // We do expect an Error from fastparse listing `}` as one
+            // of the expected tokens, located in badEntity.riddl.
+            val errors = messages.filter(_.kind == Error)
+            errors mustNot be(empty)
+            val combined = errors.map(_.format).mkString("\n")
+            combined must include("badEntity.riddl")
+            combined must include("Expected")
+            combined must include("}")
+        end match
+    }
   }
 }

language/shared/src/main/scala/com/ossuminc/riddl/language/parsing/RiddlParserInput.scala

@@ -202,8 +202,12 @@ abstract class RiddlParserInput(using pc: PlatformContext) extends ParserInput {
         s"${index.endOffset} >= 0 && ${index.endOffset} <= ${data.length + 1}"
       )
       val (start, end) = lineRangeOf(index)
-      require(start <= index.offset, s"fail: $start <= ${index.offset}")
-      require(end >= index.endOffset, s"fail: $end >= ${index.endOffset}")
+      // When a parse failure occurs at EOF (e.g., missing closing `}`),
+      // the failure's `At` can have `endOffset` past the end of the line
+      // computed by `lineRangeOf`. The original `require` would crash the
+      // error reporter itself. Downstream slicing already clamps via
+      // `Math.min`, so this defensive code can tolerate the boundary
+      // condition instead of failing.
       val quoted = slice(start, end)
       if quoted.isEmpty then ""
       else {