Add JS callstack to console.error callback

[bkaradzic-microsoft]

Problem

Host applications consuming JsRuntimeHost have no way to associate a console.error(...) (or any other console.*) call with the JavaScript call site that produced it. The Console::CallbackT signature only delivers the formatted message and the log level. To get a JS stack today, hosts must monkey-patch console.error from JavaScript (new Error().stack, push as extra arg, call original) -- which both pollutes the global console object and masks the real call site under one or two synthetic frames.

Fix

Add an additive helper:

namespace Babylon::Polyfills::Console
{
    using CallbackT = std::function<void BABYLON_API (const char*, LogLevel)>;
    void BABYLON_API Initialize(Napi::Env env, CallbackT callback);
    std::string BABYLON_API CaptureCurrentJsStack(Napi::Env env);
}

Hosts opt in by calling CaptureCurrentJsStack(env) inside their existing 2-arg CallbackT. The polyfill's own shim frames are skipped, so the top frame is the user's call site.

Babylon::Polyfills::Console::Initialize(env, [env](const char* message, auto level) {
    fprintf(stdout, "%s", message);
    if (level == Babylon::Polyfills::Console::LogLevel::Error) {
        auto stack = Babylon::Polyfills::Console::CaptureCurrentJsStack(env);
        if (!stack.empty()) {
            fprintf(stdout, "\n%s", stack.c_str());
        }
    }
    fflush(stdout);
});

The format of the returned string is engine-defined opaque text -- consumers should treat it as diagnostic-only and not parse.

Why a helper instead of a third CallbackT parameter

The first iteration of this PR added a 3rd const char* jsStack parameter to CallbackT. Reviewer feedback (#166 review thread) rightly pointed out three problems with that approach:

1. Breaking API change. Every existing host with an Initialize(env, [](msg, lvl){ ... }) lambda would have to update.
2. Always-on cost. new Error() + stack format + UTF-8 conversion would run on every console.error even when the host doesn't use the parameter.
3. Unnecessary. When CallbackT fires, the JS frames that produced the console.* call are still alive on the JS stack -- the engine is paused mid-call, one or two C++ transition layers behind. The host can capture from inside the existing 2-arg callback.

The helper-based design fixes all three:

• Non-breaking. Every existing 2-arg CallbackT continues to compile and behave identically. Hosts that don't care about stacks need not change a line.
• No always-on cost. new Error().stack runs only when the host invokes the helper -- per-call, per-level, per-call-site, fully host-controlled.
• Frame-skip count is an implementation detail of the polyfill (the engine new Error() capture skips the Napi wrapper frame already). Hosts don't need to know it.

Internally the helper is currently implemented via N-API new Error().stack; when a cheap N-API stack-capture primitive lands later, the body can be swapped without touching the public API.

Tests

New Console.CaptureCurrentJsStack gtest in Tests/UnitTests/Shared/Shared.cpp: registers a 2-arg CallbackT that calls CaptureCurrentJsStack(env) inside its body, asserts both console.error and console.log paths yield a non-empty stack.

In-tree consumer updates

• Tests/UnitTests/Shared/Shared.cpp -- both Console::Initialize lambdas use the helper.
• Polyfills/Console/Readme.md -- documents the helper alongside the existing Initialize example.

[Copilot]

Pull request overview

This PR extends the Babylon::Polyfills::Console polyfill so host applications can associate console.error(...) output with the originating JavaScript call site by providing a JS stack string to the host callback. This improves diagnostics without requiring JS-side monkey-patching of console.

Changes:

• Updated Babylon::Polyfills::Console::CallbackT to include a third const char* jsStack parameter.
• Implemented best-effort JS stack capture for console.error via new Error().stack and passed it to the callback (empty string for log/warn).
• Updated unit tests and documentation to reflect the new callback signature and behavior.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 4 comments.

File	Description
Tests/UnitTests/Shared/Shared.cpp	Updates Console::Initialize callbacks to the new 3-arg signature and adds a regression test for console.error stack delivery.
Polyfills/Console/Source/Console.cpp	Captures JS stack for LogLevel::Error and passes it into the console callback.
Polyfills/Console/Readme.md	Updates documentation and sample initialization code for the new jsStack callback parameter.
Polyfills/Console/Include/Babylon/Polyfills/Console.h	Updates the public callback type and documents the new jsStack parameter.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[bghgary]

[Reviewed by Copilot on behalf of @bghgary]

Concerns with the contract change; suggesting we reshape this as an additive helper instead of changing CallbackT. Rationale in the inline comment on Console.h.

[Copilot]

Pull request overview

Copilot reviewed 4 out of 4 changed files in this pull request and generated 2 comments.