From 7d86ed0b4b5c0e1e96e15973805e0245e00485cc 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 1/5] 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 5de35fc69..c172c3419 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 000000000..0d572c5fd
--- /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 000000000..427a6dacb
--- /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 6042d43cacea6a1ce48f123683aef8923dbe3bc2 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 2/5] =?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 427a6dacb..28b0bdf49 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 adf58d9adb7c8b1c777d00e09c5f9c1cbb8b5ed0 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 3/5] =?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 0d572c5fd..f0bdd27cf 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 28b0bdf49..187504d7d 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 05449f090413d9dc8db0bba28af846a7daceef4d 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 4/5] =?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 187504d7d..96d7b9e0c 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 019f5dd8835b05cc1a99ea22158bc8dab0c82428 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 5/5] =?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 f0bdd27cf..f20374ff2 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");