fix(core): normalize stale inherited stack headers in finding output

Some libraries (e.g. pdf.js) use prototype-based error constructors
where .stack is inherited from a prototype Error, showing a stale
header like "Error" instead of the actual .name and .message.

Detect this mismatch and replace the first line of .stack with the
correct name: message before printing.  Only applies to non-Finding
errors, since cleanErrorStack already rewrites Finding headers.

Author: oetr

packages/core/finding.test.ts

@@ -81,6 +81,53 @@ describe("Finding", () => {
 		);
 		expect(lines[3]).toEqual("");
 	});
+
+	it("print error with inherited/stale stack (e.g. pdf.js BaseException)", () => {
+		const printer = mockPrinter();
+		// Simulate pdf.js's BaseException pattern: .name and .message are own
+		// properties, but .stack is inherited from a prototype Error instance.
+		const proto = new Error();
+		const error = Object.create(proto) as Error;
+		Object.defineProperty(error, "message", {
+			value: "Command token too long: 128",
+		});
+		Object.defineProperty(error, "name", {
+			value: "UnknownErrorException",
+		});
+		// error.stack is inherited from proto — stale "Error" header
+
+		printFinding(error, printer);
+
+		const output = printer.printed();
+		expect(output).toContain("Uncaught Exception:");
+		expect(output).toContain(
+			"UnknownErrorException: Command token too long: 128",
+		);
+		expect(output).not.toMatch(/\nError[:\s]*\n/);
+	});
+
+	it("print error without stack shows name: message", () => {
+		const printer = mockPrinter();
+		const error = { name: "CustomError", message: "something broke" };
+
+		printFinding(error as Error, printer);
+
+		const output = printer.printed();
+		expect(output).toContain("Uncaught Exception:");
+		expect(output).toContain("CustomError: something broke");
+	});
+
+	it("print duck-typed error without .name falls back to Error", () => {
+		const printer = mockPrinter();
+		const error = { message: "oops" };
+
+		printFinding(error as Error, printer);
+
+		const output = printer.printed();
+		expect(output).toContain("Uncaught Exception:");
+		expect(output).toContain("Error: oops");
+		expect(output).not.toContain("undefined");
+	});
 });
 
 function mockPrinter() {

packages/core/finding.ts

@@ -108,9 +108,17 @@ export function printFinding(
 	if (isError(error)) {
 		if (error.stack) {
 			cleanErrorStack(error);
-			print(error.stack);
+			if (error instanceof Finding) {
+				print(error.stack);
+			} else {
+				print(repairStackHeader(error));
+			}
 		} else {
-			print(error.message);
+			if (error instanceof Finding) {
+				print(error.message);
+			} else {
+				print(`${error.name || "Error"}: ${error.message}`);
+			}
 		}
 	} else if (typeof error === "string" || error instanceof String) {
 		print(error.toString());
@@ -167,6 +175,25 @@ export function cleanErrorStack(error: unknown): void {
 		.join("\n");
 }
 
+/**
+ * Fix the first line of error.stack when it doesn't reflect the actual
+ * .name/.message. This happens with legacy constructor patterns (e.g. pdf.js
+ * BaseException) where .stack is inherited from a prototype Error and shows
+ * a stale header from construction time.
+ */
+function repairStackHeader(error: Error): string {
+	const stack = error.stack!;
+	const name = error.name || "Error";
+	const expectedPrefix = error.message ? `${name}: ${error.message}` : name;
+	const firstNewline = stack.indexOf("\n");
+	const firstLine = firstNewline === -1 ? stack : stack.slice(0, firstNewline);
+	if (firstLine === expectedPrefix) {
+		return stack;
+	}
+	const rest = firstNewline === -1 ? "" : stack.slice(firstNewline);
+	return expectedPrefix + rest;
+}
+
 export function errorName(error: unknown): string {
 	if (error instanceof Error) {
 		// error objects