feat(core): improve stack trace accuracy in ThatError

Updated `ThatError` to capture the stack trace from the factory caller instead of the constructor. Added a test suite to ensure business code frames are prioritized over internal frames.

Author: tarnishablec

packages/core/__tests__/caller-trace.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import { That } from "@thaterror/core";
+
+describe("ThatError Caller Tracing", () => {
+
+    test("stack trace should start from business code, not factory", () => {
+        const AppError = That({TEST: "msg"});
+        const err = AppError.TEST();
+
+        const stack = err.stack ?? "";
+        const lines = stack.split("\n");
+
+        const topFrame = lines[1] ?? "";
+
+        const pathSegments = new URL(import.meta.url).pathname.split('/');
+        const currentFileName = pathSegments.at(-1) ?? "";
+
+        expect(topFrame).toContain(currentFileName);
+
+        expect(topFrame).not.toContain("define.ts");
+
+        expect(topFrame.length).toBeGreaterThan(0);
+    });
+});

packages/core/src/define.ts

@@ -33,19 +33,20 @@ export function That<const M extends ErrorMap>(
             readonly [CodeField]: Code;
 
             constructor(
+                caller: typeof cases[typeof key],
                 readonly code: Code,
                 args: Payload,
                 readonly scope: symbol,
                 message: string,
-                options?: ErrorOptions
+                options?: ErrorOptions,
             ) {
                 super(message, options);
                 this.name = code;
                 this[CodeField] = code;
                 this[ScopeField] = scope;
                 this[PayloadField] = args;
 
-                Error.captureStackTrace(this, this.constructor);
+                Error.captureStackTrace(this, caller);
             }
 
             is<K extends string, S extends ErrorSpec>(errorCase: ErrorCase<K, S>): this is DefinedError<K, ExtractPayload<S>> {
@@ -68,12 +69,12 @@ export function That<const M extends ErrorMap>(
                     }
                 }
                 const message = (spec as (...a: unknown[]) => string)(...finalArgs);
-                return new InternalBaseError(key, finalArgs as Payload, scope, message, options);
+                return new InternalBaseError(factory, key, finalArgs as Payload, scope, message, options);
             }
 
             if (typeof spec === "string") {
                 options = args[0] as ErrorOptions | undefined;
-                return new InternalBaseError(key, [] as Payload, scope, spec, options);
+                return new InternalBaseError(factory, key, [] as Payload, scope, spec, options);
             }
 
             throw new Error("Invalid ErrorSpec");