Address PR #66 review comments, verify and close issues #13, #25

.gitignore

@@ -1,2 +1,4 @@
 *.un~
 /node_modules
+
+.DS_Store

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,34 @@ 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 () => {
+    // Verify issue #25: parse() handles async/await stack frames. We throw across
+    // an actual async suspension point (await Promise.resolve()) so the stack
+    // genuinely requires V8 async-stack-trace reconstruction.
+    async function innerAsync() {
+      await Promise.resolve(); // cross a real async boundary before throwing
+      throw new Error('async trace');
+    }
+    async function outerAsync() {
+      await innerAsync();
+    }
+
+    let trace = [];
+    try {
+      await outerAsync();
+    } catch (err) {
+      trace = parse(err);
+    }
+
+    const hasInner = trace.some(t => t.getFunctionName() === 'innerAsync');
+    // V8 async frames are prefixed with 'async ' in the stack string, so the
+    // parsed function name is "async outerAsync" — match both forms.
+    const hasOuter = trace.some(t => (t.getFunctionName() || '').includes('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);
   });
 });