From 302cf366bc97d2fafd0f99de2362f798b3a36f0c Mon Sep 17 00:00:00 2001
From: Dennis van der Stelt <dvdstelt@gmail.com>
Date: Tue, 24 Mar 2026 11:03:59 +0000
Subject: [PATCH 1/6] =?UTF-8?q?=F0=9F=90=9B=20Fix=20stack=20trace=20format?=
 =?UTF-8?q?ter=20mangling=20exception=20messages?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The atRegex used \s* (zero or more whitespace, unanchored) which
matched "at" inside words like "that" in exception messages,
discarding everything before the match. Anchor to line start with
\s+ so only indented stack frame lines are parsed as frames.
---
 src/Frontend/src/components/messages/StacktraceFormatter.vue | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Frontend/src/components/messages/StacktraceFormatter.vue b/src/Frontend/src/components/messages/StacktraceFormatter.vue
index e1a6180ba9..5de35fc698 100644
--- a/src/Frontend/src/components/messages/StacktraceFormatter.vue
+++ b/src/Frontend/src/components/messages/StacktraceFormatter.vue
@@ -89,7 +89,7 @@ const detectLanguagesInOrder = (text: string): Language[] => {
 const formatStackTrace = (stackTrace: string, selectedLang: Language): Element[] => {
   const lines = stackTrace.split("\n");
   const fileAndLineNumberRegEx = new RegExp(`${selectedLang.in} (.+):${selectedLang.line} (\\d+)`);
-  const atRegex = new RegExp(`(\\s*)(${selectedLang.at}) (.+?)\\((.*?)\\)`);
+  const atRegex = new RegExp(`^(\\s+)(${selectedLang.at}) (.+?)\\((.*?)\\)`);
 
   return lines.map((line) => {
     const match = line.match(atRegex);

From fa0c71309b5ff88f0bced0b1dd58affc0b3950cc Mon Sep 17 00:00:00 2001
From: John Simons <john.simons@particular.net>
Date: Wed, 25 Mar 2026 08:29:10 +1000
Subject: [PATCH 2/6] Refactor stack trace formatter and add unit tests

Extract formatting logic from the Vue component into a dedicated TypeScript module to improve maintainability and enable unit testing. Includes a comprehensive test suite covering multiple languages and regression tests for exception message parsing.
---
 .../messages/StacktraceFormatter.vue          |  93 +-----
 .../stacktraceFormatter.spec.ts               | 293 ++++++++++++++++++
 .../stacktraceFormatter.ts                    |  86 +++++
 3 files changed, 381 insertions(+), 91 deletions(-)
 create mode 100644 src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
 create mode 100644 src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts

diff --git a/src/Frontend/src/components/messages/StacktraceFormatter.vue b/src/Frontend/src/components/messages/StacktraceFormatter.vue
index 5de35fc698..c172c34195 100644
--- a/src/Frontend/src/components/messages/StacktraceFormatter.vue
+++ b/src/Frontend/src/components/messages/StacktraceFormatter.vue
@@ -1,5 +1,6 @@
 <script lang="ts" setup>
 import { ref, watch } from "vue";
+import { type Language, type StackTraceElement, languages, detectLanguagesInOrder, formatStackTrace } from "./StacktraceFormatter/stacktraceFormatter";
 
 // Define TypeScript interfaces for settings and supported languages
 interface NetStackOptions {
@@ -13,26 +14,6 @@ interface NetStackOptions {
   line?: string;
 }
 
-interface Language {
-  name: string;
-  at: string;
-  in: string;
-  line: string;
-}
-
-type Text = string;
-
-interface Node {
-  params: Array<{ name: string; type: string }>;
-  type: string;
-  lineNumber?: number;
-  file?: string;
-  method: string;
-  spaces: string;
-}
-
-type Element = Text | Node;
-
 // Props
 const props = withDefaults(defineProps<{ stackTrace: string; options?: NetStackOptions }>(), {
   options: () => ({
@@ -47,80 +28,10 @@ const props = withDefaults(defineProps<{ stackTrace: string; options?: NetStackO
   }),
 });
 
-// Supported languages and their keywords
-const languages: Language[] = [
-  { name: "english", at: "at", in: "in", line: "line" },
-  { name: "danish", at: "ved", in: "i", line: "linje" },
-  { name: "german", at: "bei", in: "in", line: "Zeile" },
-  { name: "spanish", at: "en", in: "en", line: "línea" },
-  { name: "russian", at: "в", in: "в", line: "строка" },
-  { name: "chinese", at: "在", in: "位置", line: "行号" },
-];
-
 // Reactive variables and setup state
-const formattedStack = ref<Element[]>([]);
+const formattedStack = ref<StackTraceElement[]>([]);
 const selectedLanguage = ref<Language>(languages[0]);
 
-// Helper function to detect languages in the stack trace
-const detectLanguagesInOrder = (text: string): Language[] => {
-  const languageRegexes = {
-    english: /\s+at .*?\)/g,
-    danish: /\s+ved .*?\)/g,
-    german: /\s+bei .*?\)/g,
-    spanish: /\s+en .*?\)/g,
-    russian: /\s+в .*?\)/g,
-    chinese: /\s+在 .*?\)/g,
-  };
-
-  const detectedLanguages: Language[] = [];
-  for (const lang in languageRegexes) {
-    if (languageRegexes[lang as keyof typeof languageRegexes].test(text)) {
-      const foundLang = languages.find((l) => l.name === lang);
-      if (foundLang) {
-        detectedLanguages.push(foundLang);
-      }
-    }
-  }
-
-  return detectedLanguages;
-};
-
-// Core formatting logic
-const formatStackTrace = (stackTrace: string, selectedLang: Language): Element[] => {
-  const lines = stackTrace.split("\n");
-  const fileAndLineNumberRegEx = new RegExp(`${selectedLang.in} (.+):${selectedLang.line} (\\d+)`);
-  const atRegex = new RegExp(`^(\\s+)(${selectedLang.at}) (.+?)\\((.*?)\\)`);
-
-  return lines.map((line) => {
-    const match = line.match(atRegex);
-    if (match) {
-      const [, spaces, , methodWithType, paramsWithFile] = match;
-
-      const [type, method] = (() => {
-        const parts = methodWithType.split(".");
-        const method = parts.pop() ?? "";
-        const type = parts.join(".");
-        return [type, method];
-      })();
-
-      const params = paramsWithFile.split(", ").map((param) => {
-        const [paramType, paramName] = param.split(" ");
-        return { name: paramName, type: paramType };
-      });
-
-      const matchFile = line.match(fileAndLineNumberRegEx);
-      let file, lineNumber;
-      if (matchFile) {
-        [, file, lineNumber] = matchFile;
-      }
-
-      return <Node>{ method, type, params, file, lineNumber, spaces };
-    } else {
-      return line;
-    }
-  });
-};
-
 // Process the provided stack trace
 const processStackTrace = (): void => {
   const rawContent = props.stackTrace;
diff --git a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
new file mode 100644
index 0000000000..0d572c5fd3
--- /dev/null
+++ b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
@@ -0,0 +1,293 @@
+import { describe, expect, test } from "vitest";
+import { detectLanguagesInOrder, formatStackTrace, languages, type StackTraceFrame } from "./stacktraceFormatter";
+
+function frame(result: unknown): StackTraceFrame {
+  return result as StackTraceFrame;
+}
+
+const english = languages.find((l) => l.name === "english")!;
+const danish = languages.find((l) => l.name === "danish")!;
+const german = languages.find((l) => l.name === "german")!;
+const spanish = languages.find((l) => l.name === "spanish")!;
+const russian = languages.find((l) => l.name === "russian")!;
+const chinese = languages.find((l) => l.name === "chinese")!;
+
+describe("detectLanguagesInOrder", () => {
+  test("detects English stack trace", () => {
+    const trace = "   at System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("english");
+  });
+
+  test("detects Danish stack trace", () => {
+    const trace = "   ved System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("danish");
+  });
+
+  test("detects German stack trace", () => {
+    const trace = "   bei System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("german");
+  });
+
+  test("detects Spanish stack trace", () => {
+    const trace = "   en System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("spanish");
+  });
+
+  test("detects Russian stack trace", () => {
+    const trace = "   в System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("russian");
+  });
+
+  test("detects Chinese stack trace", () => {
+    const trace = "   在 System.String.Format(String format)";
+    const result = detectLanguagesInOrder(trace);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("chinese");
+  });
+
+  test("returns empty array for plain text with no stack frames", () => {
+    const result = detectLanguagesInOrder("This is not a stack trace");
+    expect(result).toHaveLength(0);
+  });
+});
+
+describe("formatStackTrace", () => {
+  describe("exception message lines are not mangled (bug fix)", () => {
+    // Regression test: the regex previously matched 'at' inside words like 'that',
+    // causing exception message text to be parsed as stack frames and dropped from output.
+    test("preserves SQL exception message containing 'at' followed by parenthesized text", () => {
+      const trace = [
+        "System.Data.SqlClient.SqlException (0x80131904): A network-related or instance-specific error occurred while establishing a connection to SQL Server. The server was not found or was not accessible. Verify that the instance name is correct and that SQL Server is configured to allow remote connections. (provider: Named Pipes Provider, error: 40 - Could not open a connection to SQL Server)",
+        "   at System.Data.SqlClient.SqlConnection.Open()",
+      ].join("\n");
+
+      const result = formatStackTrace(trace, english);
+
+      expect(typeof result[0]).toBe("string");
+      expect(result[0] as string).toContain("Verify that the instance name is correct");
+      expect(result[0] as string).toContain("provider: Named Pipes Provider");
+    });
+
+    test("exception message line with parenthesized content is not parsed as a frame", () => {
+      const trace = "System.Exception: Something went wrong (see inner exception for details)";
+      const result = formatStackTrace(trace, english);
+      expect(result).toHaveLength(1);
+      expect(typeof result[0]).toBe("string");
+    });
+  });
+
+  describe("English stack frames", () => {
+    test("parses a simple frame with no parameters and no file info", () => {
+      const trace = "   at System.String.Format()";
+      const result = formatStackTrace(trace, english);
+      expect(result).toHaveLength(1);
+      const f = frame(result[0]);
+      expect(f.type).toBe("System.String");
+      expect(f.method).toBe("Format");
+      expect(f.file).toBeUndefined();
+      expect(f.lineNumber).toBeUndefined();
+      expect(f.spaces).toBe("   ");
+    });
+
+    test("parses a frame with one parameter", () => {
+      const trace = "   at System.Int32.Parse(String s)";
+      const result = formatStackTrace(trace, english);
+      const f = frame(result[0]);
+      expect(f.type).toBe("System.Int32");
+      expect(f.method).toBe("Parse");
+      expect(f.params).toEqual([{ type: "String", name: "s" }]);
+    });
+
+    test("parses a frame with multiple parameters", () => {
+      const trace = "   at System.Number.ParseInt32(ReadOnlySpan`1 value, NumberStyles styles, NumberFormatInfo info)";
+      const result = formatStackTrace(trace, english);
+      const f = frame(result[0]);
+      expect(f.type).toBe("System.Number");
+      expect(f.method).toBe("ParseInt32");
+      expect(f.params).toEqual([
+        { type: "ReadOnlySpan`1", name: "value" },
+        { type: "NumberStyles", name: "styles" },
+        { type: "NumberFormatInfo", name: "info" },
+      ]);
+    });
+
+    test("parses a frame with file path and line number", () => {
+      const trace = "   at MyNamespace.IntParser.Execute(String s) in C:\\apps\\MyNamespace\\IntParser.cs:line 13";
+      const result = formatStackTrace(trace, english);
+      const f = frame(result[0]);
+      expect(f.type).toBe("MyNamespace.IntParser");
+      expect(f.method).toBe("Execute");
+      expect(f.file).toBe("C:\\apps\\MyNamespace\\IntParser.cs");
+      expect(f.lineNumber).toBe("13");
+    });
+
+    test("passes non-frame lines through as strings", () => {
+      const trace = [
+        "System.ApplicationException: Runtime error",
+        " ---> System.FormatException: The input string was not formatted correctly.",
+        "   at System.Number.ThrowOverflowOrFormatException(ParsingStatus status, TypeCode type)",
+        "   --- End of stack trace from previous location ---",
+      ].join("\n");
+
+      const result = formatStackTrace(trace, english);
+      expect(typeof result[0]).toBe("string");
+      expect(typeof result[1]).toBe("string");
+      expect(typeof result[2]).toBe("object");
+      expect(typeof result[3]).toBe("string");
+    });
+
+    test("parses a deeply namespaced type and method", () => {
+      const trace = "   at MyApp.Controllers.AccountController.ChangeEmail(String secret)";
+      const result = formatStackTrace(trace, english);
+      const f = frame(result[0]);
+      expect(f.type).toBe("MyApp.Controllers.AccountController");
+      expect(f.method).toBe("ChangeEmail");
+      expect(f.params).toEqual([{ type: "String", name: "secret" }]);
+    });
+
+    test("preserves indentation whitespace in spaces field", () => {
+      const trace = "      at System.String.Format()";
+      const result = formatStackTrace(trace, english);
+      const f = frame(result[0]);
+      expect(f.spaces).toBe("      ");
+    });
+
+    test("parses full real-world English trace with mixed frame and non-frame lines", () => {
+      const trace = [
+        "System.ApplicationException: Runtime error",
+        " ---> System.FormatException: The input string was not formatted correctly.",
+        "   at System.Number.ThrowOverflowOrFormatException(ParsingStatus status, TypeCode type)",
+        "   at System.Number.ParseInt32(ReadOnlySpan`1 value, NumberStyles styles, NumberFormatInfo info)",
+        "   at System.Int32.Parse(String s)",
+        "   at MyNamespace.IntParser.Execute(String s) in C:\\apps\\MyNamespace\\IntParser.cs:line 13",
+        "   --- End of stack trace from previous location where exception was thrown ---",
+        "   at MyNamespace.Program.Main(String[] args) in C:\\apps\\MyNamespace\\Program.cs:line 13",
+      ].join("\n");
+
+      const result = formatStackTrace(trace, english);
+      expect(typeof result[0]).toBe("string");
+      expect(typeof result[1]).toBe("string");
+      expect(typeof result[2]).toBe("object");
+      expect(typeof result[3]).toBe("object");
+      expect(typeof result[4]).toBe("object");
+      expect(typeof result[5]).toBe("object");
+      expect(typeof result[6]).toBe("string");
+      expect(typeof result[7]).toBe("object");
+
+      const executeFrame = frame(result[5]);
+      expect(executeFrame.file).toBe("C:\\apps\\MyNamespace\\IntParser.cs");
+      expect(executeFrame.lineNumber).toBe("13");
+    });
+
+    test("preserves ServiceBus exception message containing URLs and parenthesized content", () => {
+      const trace = [
+        "Azure.Messaging.ServiceBus.ServiceBusException: The lock supplied is invalid. Either the lock expired, or the message has already been removed from the queue, or was received by a different receiver instance. (MessageLockLost). For troubleshooting information, see https://aka.ms/azsdk/net/servicebus/exceptions/troubleshoot.",
+        "   at Azure.Messaging.ServiceBus.Amqp.AmqpReceiver.ThrowLockLostException()",
+        "   at Azure.Messaging.ServiceBus.Amqp.AmqpReceiver.DisposeMessageAsync(Guid lockToken, Outcome outcome, TimeSpan timeout)",
+      ].join("\n");
+
+      const result = formatStackTrace(trace, english);
+      expect(typeof result[0]).toBe("string");
+      expect(result[0] as string).toContain("ServiceBusException");
+      expect(result[0] as string).toContain("MessageLockLost");
+
+      const f = frame(result[1]);
+      expect(f.type).toBe("Azure.Messaging.ServiceBus.Amqp.AmqpReceiver");
+      expect(f.method).toBe("ThrowLockLostException");
+    });
+  });
+
+  describe("Danish stack frames", () => {
+    test("parses a Danish frame with file and line", () => {
+      const trace = "   ved MyNamespace.IntParser.Execute(String s) i C:\\apps\\MyNamespace\\IntParser.cs:linje 13";
+      const result = formatStackTrace(trace, danish);
+      const f = frame(result[0]);
+      expect(f.type).toBe("MyNamespace.IntParser");
+      expect(f.method).toBe("Execute");
+      expect(f.file).toBe("C:\\apps\\MyNamespace\\IntParser.cs");
+      expect(f.lineNumber).toBe("13");
+    });
+
+    test("passes non-frame Danish lines through as strings", () => {
+      const trace = "System.ApplicationException: Kørselsfejl";
+      const result = formatStackTrace(trace, danish);
+      expect(typeof result[0]).toBe("string");
+    });
+  });
+
+  describe("German stack frames", () => {
+    test("parses a German frame with file and line", () => {
+      const trace = "   bei MyNamespace.IntParser.Execute(String s) in C:\\apps\\MyNamespace\\IntParser.cs:Zeile 13";
+      const result = formatStackTrace(trace, german);
+      const f = frame(result[0]);
+      expect(f.type).toBe("MyNamespace.IntParser");
+      expect(f.method).toBe("Execute");
+      expect(f.file).toBe("C:\\apps\\MyNamespace\\IntParser.cs");
+      expect(f.lineNumber).toBe("13");
+    });
+  });
+
+  describe("Spanish stack frames", () => {
+    test("parses a Spanish frame type and method", () => {
+      const trace = "   en WinForm_gRPC.Form1.btnLogin_Click(Object sender, EventArgs e) en C:\\Users\\2590\\source\\repos\\WinForm_gRPC\\WinForm_gRPC\\Form1.cs:línea 135";
+      const result = formatStackTrace(trace, spanish);
+      const f = frame(result[0]);
+      expect(f.type).toBe("WinForm_gRPC.Form1");
+      expect(f.method).toBe("btnLogin_Click");
+      expect(f.lineNumber).toBe("135");
+    });
+  });
+
+  describe("Russian stack frames", () => {
+    test("parses a Russian frame type and method", () => {
+      const trace = "   в MyNamespace.IntParser.Execute(String s) в C:\\apps\\MyNamespace\\IntParser.cs:строка 13";
+      const result = formatStackTrace(trace, russian);
+      const f = frame(result[0]);
+      expect(f.type).toBe("MyNamespace.IntParser");
+      expect(f.method).toBe("Execute");
+      expect(f.lineNumber).toBe("13");
+    });
+  });
+
+  describe("Chinese stack frames", () => {
+    test("parses a Chinese frame without file info", () => {
+      const trace = "   在 System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()";
+      const result = formatStackTrace(trace, chinese);
+      const f = frame(result[0]);
+      expect(f.type).toBe("System.Runtime.ExceptionServices.ExceptionDispatchInfo");
+      expect(f.method).toBe("Throw");
+    });
+  });
+
+  describe("edge cases", () => {
+    test("returns single text element for a plain string with no stack frames", () => {
+      const result = formatStackTrace("This is not a stack trace", english);
+      expect(result).toHaveLength(1);
+      expect(typeof result[0]).toBe("string");
+      expect(result[0]).toBe("This is not a stack trace");
+    });
+
+    test("empty string produces one empty string element", () => {
+      const result = formatStackTrace("", english);
+      expect(result).toHaveLength(1);
+      expect(result[0]).toBe("");
+    });
+
+    test("frame line without leading whitespace is not parsed as a frame", () => {
+      // The fix: requires at least one whitespace before 'at'
+      const trace = "at System.String.Format(String format)";
+      const result = formatStackTrace(trace, english);
+      expect(typeof result[0]).toBe("string");
+    });
+  });
+});
diff --git a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
new file mode 100644
index 0000000000..427a6dacbf
--- /dev/null
+++ b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
@@ -0,0 +1,86 @@
+export interface Language {
+  name: string;
+  at: string;
+  in: string;
+  line: string;
+}
+
+export type StackTraceText = string;
+
+export interface StackTraceFrame {
+  params: Array<{ name: string; type: string }>;
+  type: string;
+  lineNumber?: number;
+  file?: string;
+  method: string;
+  spaces: string;
+}
+
+export type StackTraceElement = StackTraceText | StackTraceFrame;
+
+export const languages: Language[] = [
+  { name: "english", at: "at", in: "in", line: "line" },
+  { name: "danish", at: "ved", in: "i", line: "linje" },
+  { name: "german", at: "bei", in: "in", line: "Zeile" },
+  { name: "spanish", at: "en", in: "en", line: "línea" },
+  { name: "russian", at: "в", in: "в", line: "строка" },
+  { name: "chinese", at: "在", in: "位置", line: "行号" },
+];
+
+export const detectLanguagesInOrder = (text: string): Language[] => {
+  const languageRegexes = {
+    english: /\s+at .*?\)/g,
+    danish: /\s+ved .*?\)/g,
+    german: /\s+bei .*?\)/g,
+    spanish: /\s+en .*?\)/g,
+    russian: /\s+в .*?\)/g,
+    chinese: /\s+在 .*?\)/g,
+  };
+
+  const detectedLanguages: Language[] = [];
+  for (const lang in languageRegexes) {
+    if (languageRegexes[lang as keyof typeof languageRegexes].test(text)) {
+      const foundLang = languages.find((l) => l.name === lang);
+      if (foundLang) {
+        detectedLanguages.push(foundLang);
+      }
+    }
+  }
+
+  return detectedLanguages;
+};
+
+export const formatStackTrace = (stackTrace: string, selectedLang: Language): StackTraceElement[] => {
+  const lines = stackTrace.split("\n");
+  const fileAndLineNumberRegEx = new RegExp(`${selectedLang.in} (.+):${selectedLang.line} (\\d+)`);
+  const atRegex = new RegExp(`^(\\s+)(${selectedLang.at}) (.+?)\\((.*?)\\)`);
+
+  return lines.map((line) => {
+    const match = line.match(atRegex);
+    if (match) {
+      const [, spaces, , methodWithType, paramsWithFile] = match;
+
+      const [type, method] = (() => {
+        const parts = methodWithType.split(".");
+        const method = parts.pop() ?? "";
+        const type = parts.join(".");
+        return [type, method];
+      })();
+
+      const params = paramsWithFile.split(", ").map((param) => {
+        const [paramType, paramName] = param.split(" ");
+        return { name: paramName, type: paramType };
+      });
+
+      const matchFile = line.match(fileAndLineNumberRegEx);
+      let file, lineNumber;
+      if (matchFile) {
+        [, file, lineNumber] = matchFile;
+      }
+
+      return <StackTraceFrame>{ method, type, params, file, lineNumber, spaces };
+    } else {
+      return line;
+    }
+  });
+};

From d7949d0349e323698f430de04984db88e1f2d4a8 Mon Sep 17 00:00:00 2001
From: Dennis van der Stelt <dvdstelt@gmail.com>
Date: Wed, 25 Mar 2026 22:20:40 +0000
Subject: [PATCH 3/6] =?UTF-8?q?=F0=9F=90=9B=20Fix=20lineNumber=20type=20to?=
 =?UTF-8?q?=20match=20runtime=20string=20value?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The regex capture group always returns a string, but the interface
declared lineNumber as number. This caused a silent type lie that
the type assertion masked.
---
 .../messages/StacktraceFormatter/stacktraceFormatter.ts         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
index 427a6dacbf..28b0bdf493 100644
--- a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
+++ b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
@@ -10,7 +10,7 @@ export type StackTraceText = string;
 export interface StackTraceFrame {
   params: Array<{ name: string; type: string }>;
   type: string;
-  lineNumber?: number;
+  lineNumber?: string;
   file?: string;
   method: string;
   spaces: string;

From 7002af4a473937889936de293963707b24721315 Mon Sep 17 00:00:00 2001
From: Dennis van der Stelt <dvdstelt@gmail.com>
Date: Wed, 25 Mar 2026 22:21:06 +0000
Subject: [PATCH 4/6] =?UTF-8?q?=F0=9F=90=9B=20Fix=20zero-arg=20frames=20pr?=
 =?UTF-8?q?oducing=20phantom=20param=20entry?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Splitting an empty string on ", " produces [""], resulting in a
bogus { type: "", name: undefined } param for no-argument methods.
Guard with a falsy check so params is an empty array instead.
---
 .../StacktraceFormatter/stacktraceFormatter.spec.ts    |  1 +
 .../StacktraceFormatter/stacktraceFormatter.ts         | 10 ++++++----
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
index 0d572c5fd3..f0bdd27cf2 100644
--- a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
+++ b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
@@ -94,6 +94,7 @@ describe("formatStackTrace", () => {
       const f = frame(result[0]);
       expect(f.type).toBe("System.String");
       expect(f.method).toBe("Format");
+      expect(f.params).toEqual([]);
       expect(f.file).toBeUndefined();
       expect(f.lineNumber).toBeUndefined();
       expect(f.spaces).toBe("   ");
diff --git a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
index 28b0bdf493..187504d7df 100644
--- a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
+++ b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
@@ -67,10 +67,12 @@ export const formatStackTrace = (stackTrace: string, selectedLang: Language): St
         return [type, method];
       })();
 
-      const params = paramsWithFile.split(", ").map((param) => {
-        const [paramType, paramName] = param.split(" ");
-        return { name: paramName, type: paramType };
-      });
+      const params = paramsWithFile
+        ? paramsWithFile.split(", ").map((param) => {
+            const [paramType, paramName] = param.split(" ");
+            return { name: paramName, type: paramType };
+          })
+        : [];
 
       const matchFile = line.match(fileAndLineNumberRegEx);
       let file, lineNumber;

From 2f1d0dfb157893c078af3e2bf2461e785b60b7eb Mon Sep 17 00:00:00 2001
From: Dennis van der Stelt <dvdstelt@gmail.com>
Date: Wed, 25 Mar 2026 22:21:22 +0000
Subject: [PATCH 5/6] =?UTF-8?q?=E2=9C=A8=20Replace=20type=20assertion=20wi?=
 =?UTF-8?q?th=20satisfies=20for=20compile-time=20safety?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The <StackTraceFrame> assertion bypassed structural checking, which
masked the lineNumber type mismatch. Using satisfies lets TypeScript
verify the object literal against the interface.
---
 .../messages/StacktraceFormatter/stacktraceFormatter.ts         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
index 187504d7df..96d7b9e0c8 100644
--- a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
+++ b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.ts
@@ -80,7 +80,7 @@ export const formatStackTrace = (stackTrace: string, selectedLang: Language): St
         [, file, lineNumber] = matchFile;
       }
 
-      return <StackTraceFrame>{ method, type, params, file, lineNumber, spaces };
+      return { method, type, params, file, lineNumber, spaces } satisfies StackTraceFrame;
     } else {
       return line;
     }

From 5f01cf99d30064b9fe7e3ab2231f55c44c8ba1df Mon Sep 17 00:00:00 2001
From: Dennis van der Stelt <dvdstelt@gmail.com>
Date: Wed, 25 Mar 2026 22:21:41 +0000
Subject: [PATCH 6/6] =?UTF-8?q?=E2=9A=9C=EF=B8=8F=20Correct=20inaccurate?=
 =?UTF-8?q?=20test=20comments=20about=20regex=20behavior?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The regression comment incorrectly claimed 'at' matched inside words
like 'that'; the actual bug was an unanchored regex. The edge case
comment implied leading-whitespace was a fix when it was always the
existing behavior.
---
 .../StacktraceFormatter/stacktraceFormatter.spec.ts        | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
index f0bdd27cf2..f20374ff29 100644
--- a/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
+++ b/src/Frontend/src/components/messages/StacktraceFormatter/stacktraceFormatter.spec.ts
@@ -63,8 +63,9 @@ describe("detectLanguagesInOrder", () => {
 
 describe("formatStackTrace", () => {
   describe("exception message lines are not mangled (bug fix)", () => {
-    // Regression test: the regex previously matched 'at' inside words like 'that',
-    // causing exception message text to be parsed as stack frames and dropped from output.
+    // Regression test: the atRegex was previously not anchored to the start of the line,
+    // so exception message lines containing ' at ' followed by parenthesized text were
+    // incorrectly matched as stack frames.
     test("preserves SQL exception message containing 'at' followed by parenthesized text", () => {
       const trace = [
         "System.Data.SqlClient.SqlException (0x80131904): A network-related or instance-specific error occurred while establishing a connection to SQL Server. The server was not found or was not accessible. Verify that the instance name is correct and that SQL Server is configured to allow remote connections. (provider: Named Pipes Provider, error: 40 - Could not open a connection to SQL Server)",
@@ -285,7 +286,7 @@ describe("formatStackTrace", () => {
     });
 
     test("frame line without leading whitespace is not parsed as a frame", () => {
-      // The fix: requires at least one whitespace before 'at'
+      // The atRegex requires at least one leading whitespace character, so a bare 'at' at the start of a line is not matched
       const trace = "at System.String.Format(String format)";
       const result = formatStackTrace(trace, english);
       expect(typeof result[0]).toBe("string");