fix: address PR #66 review, fix #29, verify #13 and #25

- Fix issue #29: parse() now captures source location from SyntaxError
  stacks where V8 puts the file:line(:col) as the first line instead of
  an error message. This is returned as the first CallSite frame.
- Source location detection uses robust guards:
  * Excludes lines with ': ' (colon+space) which indicates error messages
  * Excludes URL schemes (http://, https://, etc.)
  * Regex is safe from ReDoS (non-greedy with anchored terminus)
- Refactored parse() internals from map+filter to forEach+push:
  * Identical output behavior (verified with tests)
  * Slightly more memory efficient (1 array vs 2 intermediate arrays)
  * Fully compatible with Node 20+
- Keep engines.node at >=20.0.0
- Fix README: 'All other methods' -> 'The other getter-style methods'
  (boolean predicates return false, not null)
- Add full boundary-frame contract assertions to long-stack-trace test
- Remove dead 'exceptions' parameter from compare() in parse-test
- Add regression test for issue #13 ([object Object] in function name)
  -- confirmed already working with current regex
- Add verification test for issue #25 (async/await) -- confirmed
  resolved on modern Node via V8 async stack traces
- Comprehensive test coverage for #29: SyntaxError with/without column,
  Windows paths, non-regression for Error/TypeError/RangeError, custom
  error types, URL schemes, adversarial ReDoS inputs, forEach output
  equivalence, and memory/shared-state safety

Closes #13
Closes #25
Closes #29

Author: niemyjski

Readme.md

@@ -41,8 +41,8 @@ certain properties can be retrieved with it as noted in the API docs below.
 When parsing an `err.stack` that has crossed the event loop boundary, a
 `CallSite` object is created whose `getFileName()` returns the full dashed
 separator line from the stack, including any leading whitespace such as
-indentation. All other methods of the event loop boundary call site return
-`null`.
+indentation. The other getter-style methods of the event loop boundary call site
+return `null`.
 
 Historically this behavior was often observed together with
 [long-stack-traces](https://github.com/tlrobinson/long-stack-traces), but that package is unmaintained. This module does not depend on it and still supports parsing dashed event-loop boundary markers when

__tests__/get-test.js

@@ -1,6 +1,6 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
-import { get } from "../index.js";
+import { get, parse } from "../index.js";
 
 describe("get", () => {
   it("basic", () => {
@@ -48,4 +48,24 @@ describe("get", () => {
       })();
     })();
   });
+
+  // Verification for https://github.com/felixge/node-stack-trace/issues/25
+  // V8 async stack traces (enabled by default since Node 12) ensure async/await
+  // callers appear in the captured stack.
+  it("async/await stack traces include caller frames", async () => {
+    async function innerAsync() {
+      return new Error('async trace');
+    }
+    async function outerAsync() {
+      return await innerAsync();
+    }
+
+    const err = await outerAsync();
+    const trace = parse(err);
+
+    const hasInner = trace.some(t => t.getFunctionName() === 'innerAsync');
+    const hasOuter = trace.some(t => t.getFunctionName() === 'outerAsync');
+    assert.strictEqual(hasInner, true, 'should include innerAsync frame');
+    assert.strictEqual(hasOuter, true, 'should include outerAsync frame');
+  });
 });

__tests__/long-stack-trace-test.js

@@ -32,5 +32,12 @@ describe("long stack trace", () => {
 
     assert.notStrictEqual(boundary, undefined);
     assert.match(boundary.getFileName(), /-----/);
+    assert.strictEqual(boundary.getFunctionName(), null);
+    assert.strictEqual(boundary.getMethodName(), null);
+    assert.strictEqual(boundary.getTypeName(), null);
+    assert.strictEqual(boundary.getLineNumber(), null);
+    assert.strictEqual(boundary.getColumnNumber(), null);
+    assert.strictEqual(boundary.getEvalOrigin(), null);
+    assert.strictEqual(boundary.isNative(), null);
   });
 });

__tests__/parse-test.js

@@ -15,6 +15,23 @@ describe("parse", () => {
     assert.strictEqual(trace[1].getFileName(), "timers.js");
   });
 
+  // Regression test for https://github.com/felixge/node-stack-trace/issues/13
+  it("[object Object] as type name in function", () => {
+    const err = {};
+    err.stack =
+      'Error: Could not do something\n' +
+      '  at [object Object].foo.bar (foo.js:1:2)\n';
+
+    const trace = parse(err);
+    assert.strictEqual(trace[0].getFileName(), 'foo.js');
+    assert.strictEqual(trace[0].getFunctionName(), '[object Object].foo.bar');
+    assert.strictEqual(trace[0].getTypeName(), '[object Object].foo');
+    assert.strictEqual(trace[0].getMethodName(), 'bar');
+    assert.strictEqual(trace[0].getLineNumber(), 1);
+    assert.strictEqual(trace[0].getColumnNumber(), 2);
+    assert.strictEqual(trace[0].isNative(), false);
+  });
+
   it("basic", () => {
     (function testBasic() {
       const err = new Error('something went wrong');
@@ -117,14 +134,10 @@ describe("parse", () => {
         userFrames++;
       }
 
-      function compare(method, exceptions) {
-        let realValue = real[method]();
+      function compare(method) {
+        const realValue = real[method]();
         const parsedValue = parsed[method]();
 
-        if (exceptions && typeof exceptions[i] != 'undefined') {
-          realValue = exceptions[i];
-        }
-
         assert.strictEqual(realValue, parsedValue);
       }
 
@@ -212,4 +225,234 @@ describe("parse", () => {
     assert.strictEqual(callSite0.getColumnNumber(), 14);
     assert.strictEqual(callSite0.isNative(), false);
   });
+
+  // Regression tests for https://github.com/felixge/node-stack-trace/issues/29
+  // SyntaxError stacks include the source location as the first line instead of
+  // the error message. parse() should capture it as the first frame.
+  it("SyntaxError stack includes source location as first frame", () => {
+    const err = {};
+    err.stack =
+      '/path/to/source/file.js:22\n' +
+      '(*$&@#(*!route.validate();\n' +
+      ' ^\n' +
+      '\n' +
+      'SyntaxError: Unexpected token *\n' +
+      '    at createScript (vm.js:80:10)\n' +
+      '    at Object.runInThisContext (vm.js:139:10)';
+
+    const trace = parse(err);
+
+    // First frame should be the source location
+    assert.strictEqual(trace[0].getFileName(), '/path/to/source/file.js');
+    assert.strictEqual(trace[0].getLineNumber(), 22);
+    assert.strictEqual(trace[0].getColumnNumber(), null);
+    assert.strictEqual(trace[0].getFunctionName(), null);
+    assert.strictEqual(trace[0].getTypeName(), null);
+    assert.strictEqual(trace[0].getMethodName(), null);
+    assert.strictEqual(trace[0].isNative(), false);
+
+    // Remaining frames should still be parsed normally
+    assert.strictEqual(trace[1].getFunctionName(), 'createScript');
+    assert.strictEqual(trace[1].getFileName(), 'vm.js');
+    assert.strictEqual(trace[1].getLineNumber(), 80);
+    assert.strictEqual(trace[2].getFunctionName(), 'Object.runInThisContext');
+    assert.strictEqual(trace[2].getFileName(), 'vm.js');
+    assert.strictEqual(trace[2].getLineNumber(), 139);
+  });
+
+  it("SyntaxError stack with column number in source location", () => {
+    const err = {};
+    err.stack =
+      '/path/to/source/file.js:22:5\n' +
+      'unexpected code here\n' +
+      '    ^\n' +
+      '\n' +
+      'SyntaxError: Unexpected identifier\n' +
+      '    at Module._compile (internal/modules/cjs/loader.js:723:23)';
+
+    const trace = parse(err);
+
+    assert.strictEqual(trace[0].getFileName(), '/path/to/source/file.js');
+    assert.strictEqual(trace[0].getLineNumber(), 22);
+    assert.strictEqual(trace[0].getColumnNumber(), 5);
+    assert.strictEqual(trace[0].getFunctionName(), null);
+    assert.strictEqual(trace[0].isNative(), false);
+
+    assert.strictEqual(trace[1].getFunctionName(), 'Module._compile');
+    assert.strictEqual(trace[1].getLineNumber(), 723);
+  });
+
+  it("normal Error stack is not affected by source location detection", () => {
+    const err = {};
+    err.stack =
+      'Error: something went wrong\n' +
+      '    at foo (/path/to/file.js:10:5)\n' +
+      '    at bar (/path/to/file.js:20:3)';
+
+    const trace = parse(err);
+
+    // Should NOT have a source location frame prepended
+    assert.strictEqual(trace.length, 2);
+    assert.strictEqual(trace[0].getFunctionName(), 'foo');
+    assert.strictEqual(trace[0].getFileName(), '/path/to/file.js');
+    assert.strictEqual(trace[1].getFunctionName(), 'bar');
+  });
+
+  it("TypeError stack is not affected by source location detection", () => {
+    const err = {};
+    err.stack =
+      'TypeError: Cannot read property x of undefined\n' +
+      '    at Object.method (/app/index.js:5:10)';
+
+    const trace = parse(err);
+
+    assert.strictEqual(trace.length, 1);
+    assert.strictEqual(trace[0].getFunctionName(), 'Object.method');
+  });
+
+  it("RangeError stack is not affected by source location detection", () => {
+    const err = {};
+    err.stack =
+      'RangeError: Maximum call stack size exceeded\n' +
+      '    at recursive (/app/index.js:3:5)';
+
+    const trace = parse(err);
+
+    assert.strictEqual(trace.length, 1);
+    assert.strictEqual(trace[0].getFunctionName(), 'recursive');
+  });
+
+  it("SyntaxError from require with Windows paths", () => {
+    const err = {};
+    err.stack =
+      'C:\\Users\\dev\\project\\index.js:15\n' +
+      'const x = @invalid;\n' +
+      '          ^\n' +
+      '\n' +
+      'SyntaxError: Invalid or unexpected token\n' +
+      '    at Module._compile (internal/modules/cjs/loader.js:723:23)';
+
+    const trace = parse(err);
+
+    assert.strictEqual(trace[0].getFileName(), 'C:\\Users\\dev\\project\\index.js');
+    assert.strictEqual(trace[0].getLineNumber(), 15);
+    assert.strictEqual(trace[0].getColumnNumber(), null);
+    assert.strictEqual(trace[0].getFunctionName(), null);
+
+    assert.strictEqual(trace[1].getFunctionName(), 'Module._compile');
+  });
+
+  // Edge cases: custom error types that should NOT trigger source location detection
+  it("custom error type (not ending in Error) is not treated as source loc", () => {
+    const err = {};
+    err.stack =
+      'MyException: /path/to/file.js:10\n' +
+      '    at fn (file.js:1:2)';
+
+    const trace = parse(err);
+    // The ": " in "MyException: ..." marks this as an error message line
+    assert.strictEqual(trace.length, 1);
+    assert.strictEqual(trace[0].getFunctionName(), 'fn');
+  });
+
+  it("URL with port number is not treated as source loc", () => {
+    const err = {};
+    err.stack =
+      'http://localhost:3000\n' +
+      '    at fn (file.js:1:2)';
+
+    const trace = parse(err);
+    assert.strictEqual(trace.length, 1);
+    assert.strictEqual(trace[0].getFunctionName(), 'fn');
+  });
+
+  it("https URL with port number is not treated as source loc", () => {
+    const err = {};
+    err.stack =
+      'https://example.com:443\n' +
+      '    at fn (file.js:1:2)';
+
+    const trace = parse(err);
+    assert.strictEqual(trace.length, 1);
+    assert.strictEqual(trace[0].getFunctionName(), 'fn');
+  });
+
+  it("error message containing colon and digits is not treated as source loc", () => {
+    const err = {};
+    err.stack =
+      'MyFault: at line:5\n' +
+      '    at fn (file.js:1:2)';
+
+    const trace = parse(err);
+    assert.strictEqual(trace.length, 1);
+    assert.strictEqual(trace[0].getFunctionName(), 'fn');
+  });
+
+  it("empty first line does not produce source loc frame", () => {
+    const err = {};
+    err.stack =
+      '\n' +
+      '    at fn (file.js:1:2)';
+
+    const trace = parse(err);
+    assert.strictEqual(trace.length, 1);
+    assert.strictEqual(trace[0].getFunctionName(), 'fn');
+  });
+
+  // Behavioral equivalence: forEach produces same results as map+filter would
+  it("non-parseable lines are filtered (no undefined/null in output)", () => {
+    const err = {};
+    err.stack =
+      'Error: test\n' +
+      '    some junk line\n' +
+      '    more junk\n' +
+      '    at fn (file.js:1:2)\n' +
+      '    ~~~not valid~~~\n' +
+      '    at bar (file.js:5:3)';
+
+    const trace = parse(err);
+    // Only valid frames should appear, no undefined entries
+    assert.strictEqual(trace.length, 2);
+    assert.strictEqual(trace[0].getFunctionName(), 'fn');
+    assert.strictEqual(trace[1].getFunctionName(), 'bar');
+    // Verify no entry is undefined or null
+    trace.forEach(site => {
+      assert.notStrictEqual(site, undefined);
+      assert.notStrictEqual(site, null);
+    });
+  });
+
+  it("returns a new array each call (no shared state)", () => {
+    const err = { stack: 'Error: x\n    at fn (file.js:1:2)' };
+    const trace1 = parse(err);
+    const trace2 = parse(err);
+    assert.notStrictEqual(trace1, trace2);
+    assert.deepStrictEqual(trace1.length, trace2.length);
+  });
+
+  // Regex performance: ensure no catastrophic backtracking
+  it("parse regex does not hang on adversarial input", () => {
+    // Construct a line designed to stress the regex with repeated patterns
+    const adversarial = '    at ' + 'a'.repeat(10000) + '(' + 'b'.repeat(10000) + ')';
+    const err = { stack: 'Error: test\n' + adversarial };
+    const start = performance.now();
+    const trace = parse(err);
+    const elapsed = performance.now() - start;
+    // Should complete in well under 100ms even for 20KB lines
+    assert(elapsed < 100, `parse took ${elapsed}ms on adversarial input`);
+    assert.strictEqual(trace.length, 1);
+  });
+
+  it("source loc regex does not hang on adversarial first line", () => {
+    // Construct a first line designed to stress /^(.+?):(\d+)(?::(\d+))?$/
+    const adversarial = 'a'.repeat(50000) + ':1';
+    const err = { stack: adversarial + '\n    at fn (file.js:1:2)' };
+    const start = performance.now();
+    const trace = parse(err);
+    const elapsed = performance.now() - start;
+    assert(elapsed < 100, `parse took ${elapsed}ms on adversarial source loc`);
+    // The long path should be captured as source loc (no ": " or "://")
+    assert.strictEqual(trace[0].getFileName(), 'a'.repeat(50000));
+    assert.strictEqual(trace[0].getLineNumber(), 1);
+  });
 });