fix(live-debugger): emit correct sourcemaps for instrumented functions

Live Debugger probes capture stack traces from instrumented functions.
For those traces to point at the right place in the user's source, the
source map for each transformed file must (a) carry segments for the
purely-injected probe code and (b) report positions in the original
source rather than in whatever intermediate buffer the transform was
handed.

For (a), wrap each function body's boundary characters (the opening
`{`, the closing `}`, and the trailing terminator of any leading
directive) via `MagicString#update` rather than `appendLeft`. `update`
routes content through `Mappings.addEdit`, which emits one source-map
segment per line of the new content anchored at the boundary
character's original location; `appendLeft` content goes through
`Mappings.advance` and produces no segments at all. Combined with
`hires: true`, every injected line resolves back to the function it
wraps, and the preamble and postamble can stay multi-line and readable
in the bundled output.

For (b), compose the magic-string delta map with the input source map
produced by the previous loader (e.g. `builtin:swc-loader` stripping
TypeScript types). With `enforce: 'post'` the transform sees the
post-loader buffer, so magic-string anchors to positions in *that*
buffer and labels them with the original file path. Without
composition the bundler reports those post-loader positions as if they
were original-source positions — captured probe stack frames in
production resolved to import statements near the top of the file
rather than the function body. Compose via `@jridgewell/remapping`
(already in the lockfile via `unplugin`) using the `inputSourceMap`
exposed by unplugin's native build context on webpack/rspack;
rollup/vite/esbuild compose maps through their own pipelines and don't
need this. Fall back to the un-composed map and log at error level —
matching the `Instrumentation Error` precedent in the same handler —
when composition throws, so a single malformed input map doesn't kill
instrumentation for every other file.

The integration test that exercises the full rspack pipeline uses a
non-identity input map (a banner-shift loader that shifts source line
numbers) so composition is validated end-to-end; an identity shim is
indistinguishable from no composition.

Author: watson

.yarn/cache/@jridgewell-trace-mapping-npm-0.3.31-1ae81d75ac-da0283270e.zip

@@ -165,7 +165,7 @@ Component,Origin,Licence,Copyright
 @jridgewell/set-array,npm,MIT,Justin Ridgewell (https://www.npmjs.com/package/@jridgewell/set-array)
 @jridgewell/source-map,npm,MIT,Justin Ridgewell (https://www.npmjs.com/package/@jridgewell/source-map)
 @jridgewell/sourcemap-codec,npm,MIT,Justin Ridgewell (https://github.com/jridgewell/sourcemaps/tree/main/packages/sourcemap-codec)
-@jridgewell/trace-mapping,npm,MIT,Justin Ridgewell (https://www.npmjs.com/package/@jridgewell/trace-mapping)
+@jridgewell/trace-mapping,npm,MIT,Justin Ridgewell (https://github.com/jridgewell/sourcemaps/tree/main/packages/trace-mapping)
 @kwsites/file-exists,npm,MIT,Steve King (https://www.npmjs.com/package/@kwsites/file-exists)
 @kwsites/promise-deferred,npm,MIT,Steve King (https://www.npmjs.com/package/@kwsites/promise-deferred)
 @module-federation/error-codes,npm,MIT,zhanghang (https://www.npmjs.com/package/@module-federation/error-codes)

LICENSES-3rdparty.csv

@@ -24,12 +24,14 @@
     },
     "dependencies": {
         "@dd/core": "workspace:*",
+        "@jridgewell/remapping": "2.3.5",
         "chalk": "2.3.1"
     },
     "devDependencies": {
         "@babel/parser": "7.24.5",
         "@babel/traverse": "7.24.5",
         "@babel/types": "7.24.5",
+        "@jridgewell/trace-mapping": "0.3.31",
         "magic-string": "0.30.21",
         "typescript": "5.4.3"
     },

packages/plugins/live-debugger/package.json

@@ -212,6 +212,119 @@ describe('getLiveDebuggerPlugin', () => {
         });
     });
 
+    describe('source-map composition', () => {
+        const LINES_SHIFTED = 4;
+
+        const buildShiftedInputMap = (sourcePath: string, source: string): string =>
+            JSON.stringify({
+                version: 3,
+                sources: [sourcePath],
+                sourcesContent: [source],
+                names: [],
+                mappings:
+                    ';'.repeat(LINES_SHIFTED) +
+                    source
+                        .split('\n')
+                        .map((_, idx) => (idx === 0 ? 'AAAA' : 'AACA'))
+                        .join(';'),
+            });
+
+        const makeBuildContext = (
+            inputSourceMap?: string | null,
+        ): UnpluginBuildContext & UnpluginContext => ({
+            ...mockBuildContext,
+            getNativeBuildContext: () => ({
+                framework: 'rspack',
+                compiler: {} as never,
+                compilation: {} as never,
+                inputSourceMap,
+            }),
+        });
+
+        const callHandler = (
+            ctx: UnpluginBuildContext & UnpluginContext,
+            code: string,
+            id: string,
+        ) => {
+            const pluginContext = getContextMock({
+                buildRoot: '/',
+                getLogger: jest.fn(() => mockLog),
+            });
+            const plugin = getLiveDebuggerPlugin(
+                makeOptions({ include: [], exclude: [] }),
+                pluginContext,
+            );
+            const { handler } = getTransformHook(plugin);
+            const result = handler.call(ctx, code, id);
+            if (typeof result !== 'object' || result === null || !('code' in result)) {
+                throw new Error('Unexpected handler result');
+            }
+            return result;
+        };
+
+        it('composes its delta map with the previous loader so positions resolve to original-source lines', async () => {
+            const original = 'function getDebuggerServicesStatus() { return 0; }';
+            const id = '/src/use-debugger-services.hook.ts';
+            const postLoader = `// banner\n// banner\n// banner\n// banner\n${original}`;
+            const inputMap = buildShiftedInputMap(id, original);
+
+            const ctx = makeBuildContext(inputMap);
+            const result = callHandler(ctx, postLoader, id);
+
+            expect(result.map).toBeDefined();
+
+            const lines = result.code.split('\n');
+            const entryLineIndex = lines.findIndex((line) => line.includes('$dd_entry($dd_p'));
+            expect(entryLineIndex).toBeGreaterThan(-1);
+            const entryColumn = lines[entryLineIndex].indexOf('$dd_entry');
+
+            const { originalPositionFor, TraceMap } = await import('@jridgewell/trace-mapping');
+            const traceMap = new TraceMap(
+                typeof result.map === 'string' ? result.map : JSON.parse(String(result.map)),
+            );
+            const original_pos = originalPositionFor(traceMap, {
+                line: entryLineIndex + 1,
+                column: entryColumn,
+            });
+
+            expect(original_pos.line).toBe(1);
+            expect(original_pos.source).toBe(id);
+        });
+
+        it('returns the magic-string map verbatim when the previous loader did not provide one', async () => {
+            const id = '/src/utils.ts';
+            const code = 'function f() { return 1; }';
+
+            // No inputSourceMap, no getNativeBuildContext at all.
+            const result = callHandler(mockBuildContext, code, id);
+            expect(result.map).toBeDefined();
+
+            const map = JSON.parse(String(result.map));
+            expect(map.sources).toContain(id);
+        });
+
+        it('returns no map when the file has no instrumentable functions', () => {
+            const result = callHandler(mockBuildContext, 'const x = 42;', '/src/utils.ts');
+            expect(result.map).toBeUndefined();
+        });
+
+        it('falls back to the un-composed map and logs an error when composition throws', () => {
+            const id = '/src/utils.ts';
+            const code = 'function f() { return 1; }';
+
+            const ctx = makeBuildContext('not a valid sourcemap, this should throw');
+            const result = callHandler(ctx, code, id);
+
+            expect(result.map).toBeDefined();
+            expect(() => JSON.parse(String(result.map))).not.toThrow();
+
+            expect(mockLog.error).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to compose source map'),
+                expect.objectContaining({ forward: true }),
+            );
+        });
+    });
+
     describe('error handling', () => {
         it('should return original code when transformCode throws', () => {
             jest.isolateModules(() => {

packages/plugins/live-debugger/src/index.test.ts

@@ -4,6 +4,10 @@
 
 import type { GetPlugins, GlobalContext, PluginOptions } from '@dd/core/types';
 import { InjectPosition } from '@dd/core/types';
+import remapping from '@jridgewell/remapping';
+import type { SourceMapInput } from '@jridgewell/remapping';
+import type { SourceMap } from 'magic-string';
+import type { SourceMapCompact, UnpluginBuildContext } from 'unplugin';
 
 import { CONFIG_KEY, PLUGIN_NAME } from './constants';
 import { getRuntimeBootstrap } from './runtime-bootstrap';
@@ -103,9 +107,15 @@ export const getLiveDebuggerPlugin = (
 
                     transformedFileCount++;
 
+                    const inputMap = getInputSourceMap(this);
+                    const composedMap =
+                        result.map && inputMap
+                            ? composeWithInputMap(result.map, inputMap, id, log)
+                            : result.map;
+
                     return {
                         code: result.code,
-                        map: result.map,
+                        map: composedMap,
                     };
                 } catch (e) {
                     log.error(`Instrumentation Error in ${id}: ${e}`, { forward: true });
@@ -158,3 +168,31 @@ export const getPlugins: GetPlugins = ({ options, context }) => {
 
     return [getLiveDebuggerPlugin(validatedOptions, context)];
 };
+
+/**
+ * Return the source map produced by the previous loader, if any.
+ */
+function getInputSourceMap(ctx: UnpluginBuildContext): SourceMapInput | undefined {
+    const native = ctx.getNativeBuildContext?.();
+    return (native as { inputSourceMap?: SourceMapInput })?.inputSourceMap;
+}
+
+/**
+ * Compose a local source map with the previous loader's source map. The result maps instrumented
+ * output directly back to original source coordinates.
+ */
+function composeWithInputMap(
+    instrumentMap: SourceMap,
+    inputMap: SourceMapInput,
+    id: string,
+    log: ReturnType<GlobalContext['getLogger']>,
+): SourceMapCompact | SourceMap {
+    try {
+        return remapping(instrumentMap as unknown as SourceMapInput, (_file, ctx) =>
+            ctx.depth === 1 ? inputMap : null,
+        ) as unknown as SourceMapCompact;
+    } catch (e) {
+        log.error(`Failed to compose source map for ${id}: ${e}`, { forward: true });
+        return instrumentMap;
+    }
+}