@atlaspack/optimizer-swc 2.16.9 → 2.16.10-dev-fix-sourcemaps-50acc1acf.0

package/src/SwcOptimizer.ts

@@ -1,11 +1,10 @@
-import nullthrows from 'nullthrows';
-import {transform} from '@swc/core';
 import {Optimizer} from '@atlaspack/plugin';
 import {blobToString, stripAnsi} from '@atlaspack/utils';
-import SourceMap from '@atlaspack/source-map';
 import ThrowableDiagnostic, {escapeMarkdown} from '@atlaspack/diagnostic';
 import path from 'path';
 
+import {minifyWithSourceMap} from './minifyWithSourceMap';
+
 export default new Optimizer({
   async loadConfig({config, options}) {
     let userConfig = await config.getConfigFrom(
@@ -30,25 +29,21 @@ export default new Optimizer({
     let code = await blobToString(contents);
     let result;
     try {
-      result = await transform(code, {
-        jsc: {
+      result = await minifyWithSourceMap(
+        code,
+        bundle.env.sourceMap ? (originalMap ?? null) : null,
+        {
           target: 'es2022',
-          minify: {
-            mangle: true,
-            compress: true,
-            // @ts-expect-error TS2698
-            ...userConfig,
-            toplevel:
-              bundle.env.outputFormat === 'esmodule' ||
-              bundle.env.outputFormat === 'commonjs',
-            module: bundle.env.outputFormat === 'esmodule',
-          },
+          mangle: true,
+          compress: true,
+          toplevel:
+            bundle.env.outputFormat === 'esmodule' ||
+            bundle.env.outputFormat === 'commonjs',
+          module: bundle.env.outputFormat === 'esmodule',
+          userConfig: userConfig as Record<string, unknown> | undefined,
+          projectRoot: options.projectRoot,
         },
-        minify: true,
-        sourceMaps: !!bundle.env.sourceMap,
-        configFile: false,
-        swcrc: false,
-      });
+      );
     } catch (err: any) {
       // SWC doesn't give us nice error objects, so we need to parse the message.
       let message = escapeMarkdown(
@@ -107,15 +102,9 @@ export default new Optimizer({
       throw err;
     }
 
-    let sourceMap = null;
-    let minifiedContents: string = nullthrows(result.code);
-    let resultMap = result.map;
-    if (resultMap) {
-      sourceMap = new SourceMap(options.projectRoot);
-      sourceMap.addVLQMap(JSON.parse(resultMap));
-      if (originalMap) {
-        sourceMap.extends(originalMap);
-      }
+    let minifiedContents: string = result.code;
+    const sourceMap = result.map;
+    if (sourceMap) {
       let sourcemapReference = await getSourceMapReference(sourceMap);
       if (sourcemapReference) {
         minifiedContents += `\n//# sourceMappingURL=${sourcemapReference}\n`;

package/src/minifyWithSourceMap.ts

@@ -0,0 +1,104 @@
+import nullthrows from 'nullthrows';
+import {transform} from '@swc/core';
+import SourceMap from '@atlaspack/source-map';
+
+export type MinifyOptions = {
+  /** ES target for SWC. */
+  target?: string;
+  /** Whether to enable name mangling. */
+  mangle?: boolean;
+  /** Whether to enable compression. */
+  compress?: boolean;
+  /** Mark output as a top-level module (esmodule/commonjs). */
+  toplevel?: boolean;
+  /** Treat the input as an ES module. */
+  module?: boolean;
+  /** Extra terser-style overrides forwarded into `jsc.minify`. */
+  userConfig?: Record<string, unknown>;
+  /** Project root used when constructing the SourceMap instance. */
+  projectRoot?: string;
+};
+
+export type MinifyResult = {
+  code: string;
+  map: SourceMap | null;
+};
+
+/**
+ * Minify `code` with SWC and produce a SourceMap whose `original*` positions
+ * point back to the sources described by `originalMap`.
+ *
+ * When `originalMap` is provided, we hand its VLQ-encoded form to SWC via the
+ * `inputSourceMap` option. SWC then composes its own (minified -> code) map
+ * with the input (code -> original sources) map per-token during
+ * minification, producing a final map that points straight back to the
+ * original sources.
+ *
+ * This is much more accurate than composing the maps *after* the fact with
+ * `SourceMap.extends(originalMap)`. The post-hoc `extends` approach calls
+ * `findClosestMapping`, which snaps each minified token to the previous
+ * mapping in the input map. When the input map has many mappings on a single
+ * generated line (which is the norm – every asset's tokens get packed onto
+ * the same generated line by the packager), "the previous mapping" is often
+ * the wrong source/line entirely, producing systematically misaligned maps.
+ */
+export async function minifyWithSourceMap(
+  code: string,
+  originalMap: SourceMap | null,
+  options: MinifyOptions = {},
+): Promise<MinifyResult> {
+  const {
+    target = 'es2022',
+    mangle = true,
+    compress = true,
+    toplevel = false,
+    module: isModule = false,
+    userConfig = {},
+    projectRoot = '/',
+  } = options;
+
+  let inputSourceMap: string | undefined;
+  if (originalMap) {
+    // Hand the input map to swc as `inputSourceMap` so swc composes the
+    // (minified -> code) and (code -> original sources) maps together
+    // per-token during minification. This is more accurate than calling
+    // `SourceMap.extends(originalMap)` after the fact, which uses
+    // `findClosestMapping` and snaps each minified token to the *nearest*
+    // mapping in the input map – losing column precision and sometimes
+    // mis-attributing tokens across asset boundaries when the input map
+    // has gaps. It also leaks swc's placeholder `<anon>` source into the
+    // resulting map's `sources` array.
+    // swc requires `version: 3` to parse the input map. The atlaspack
+    // SourceMap.toVLQ() helper doesn't include it, so we add it here.
+    inputSourceMap = JSON.stringify({version: 3, ...originalMap.toVLQ()});
+  }
+
+  const result = await transform(code, {
+    jsc: {
+      target: target as any,
+      minify: {
+        mangle,
+        compress,
+        ...(userConfig as object),
+        toplevel,
+        module: isModule,
+      } as any,
+    },
+    minify: true,
+    sourceMaps: true,
+    inputSourceMap,
+    configFile: false,
+    swcrc: false,
+  });
+
+  const minifiedCode: string = nullthrows(result.code);
+  if (!result.map) {
+    return {code: minifiedCode, map: null};
+  }
+
+  // With `inputSourceMap` provided, swc has already composed the maps;
+  // the result already references the original sources directly.
+  const sourceMap = new SourceMap(projectRoot);
+  sourceMap.addVLQMap(JSON.parse(result.map));
+  return {code: minifiedCode, map: sourceMap};
+}

package/test/minifyWithSourceMap.test.ts

@@ -0,0 +1,370 @@
+import assert from 'assert';
+import SourceMap from '@atlaspack/source-map';
+
+import {minifyWithSourceMap} from '../src/minifyWithSourceMap';
+
+const PROJECT_ROOT = '/project';
+
+/**
+ * Walk the bundle for a set of literal strings, and for each one, resolve its
+ * position via the source map and check that the resolved original source line
+ * actually contains that string. This is the same "string-literal probe"
+ * technique that exposed the real-world misalignment.
+ *
+ * Returns { matched, total, mismatches } so tests can assert specific bounds.
+ */
+function probeStringLiterals(opts: {
+  bundle: string;
+  map: SourceMap;
+  /**
+   * Map of source name → expected (line, col) of each probe within that source.
+   * The probe is considered "correctly aligned" when the source map's reverse
+   * lookup returns the exact (source, line, col) where the probe actually
+   * lives.
+   */
+  expected: Record<
+    string,
+    {
+      source: string;
+      line: number;
+      column: number;
+    }
+  >;
+  probes: string[];
+}): Promise<{
+  matched: number;
+  total: number;
+  mismatches: Array<{
+    text: string;
+    bundleLine: number;
+    bundleCol: number;
+    resolved: {source?: string; line?: number; column?: number} | null;
+    expected: {source: string; line: number; column: number};
+  }>;
+}> {
+  const bundleLines = opts.bundle.split('\n');
+  let matched = 0;
+  const mismatches: Array<any> = [];
+
+  for (const probe of opts.probes) {
+    const expected = opts.expected[probe];
+    let found = false;
+    for (let l = 0; l < bundleLines.length; l++) {
+      const re = new RegExp(`['"\`]${probe}['"\`]`);
+      const m = bundleLines[l].match(re);
+      if (!m) continue;
+      const idx = (m.index ?? 0) + 1; // step past the quote so we land on the literal text
+      const resolved = opts.map.findClosestMapping(l + 1, idx);
+      const resolvedSource = resolved?.source;
+      const resolvedLine = resolved?.original?.line;
+      const resolvedCol = resolved?.original?.column;
+      // We require the resolved (source, line, column) to match the
+      // expected position exactly. The buggy `extends()` approach loses
+      // column precision (it snaps to the nearest input mapping), so this
+      // check is what surfaces the bug.
+      const ok =
+        resolvedSource === expected.source &&
+        resolvedLine === expected.line &&
+        resolvedCol === expected.column;
+      if (ok) {
+        matched++;
+      } else {
+        mismatches.push({
+          text: probe,
+          bundleLine: l + 1,
+          bundleCol: idx,
+          resolved: {
+            source: resolvedSource,
+            line: resolvedLine,
+            column: resolvedCol,
+          },
+          expected,
+        });
+      }
+      found = true;
+      break;
+    }
+    if (!found) {
+      mismatches.push({
+        text: probe,
+        bundleLine: -1,
+        bundleCol: -1,
+        resolved: null,
+        expected,
+      });
+    }
+  }
+
+  return {matched, total: opts.probes.length, mismatches};
+}
+
+describe('minifyWithSourceMap', () => {
+  it('passes through when source map composition is not needed', async () => {
+    const code = 'console.log("hello");';
+    const out = await minifyWithSourceMap(code, null, {
+      projectRoot: PROJECT_ROOT,
+    });
+    assert.ok(out.code.includes('"hello"'));
+  });
+
+  it('forwards the input map to swc as `inputSourceMap` (so map composition happens during minify, not as a post-hoc snap)', async () => {
+    // This is a regression test for a real Confluence production bug:
+    // `SwcOptimizer` used to compose its (minified -> code) map with the
+    // packager's (code -> original sources) map by calling
+    // `SourceMap.extends(originalMap)` *after* swc had finished minifying.
+    //
+    // That post-hoc composition uses `findClosestMapping`, which:
+    //  - snaps to the previous mapping when the looked-up position has no
+    //    exact mapping (losing column precision), and
+    //  - can snap *across asset boundaries* when the input map has gaps
+    //    (mis-attributing a token to the wrong source file).
+    //
+    // String-literal probes of real Confluence bundles showed 30–65 % of
+    // mappings resolving to a source line that did not actually contain
+    // the literal – evidence the maps were systematically wrong.
+    //
+    // The fix is to hand the input map to swc via the `inputSourceMap`
+    // option, so swc composes the maps per-token natively during
+    // minification.
+    //
+    // We can't easily reproduce the bug end-to-end here with synthetic data
+    // (the test inputs are too regular for `findClosestMapping`'s snap-back
+    // to produce visibly wrong output), so the test focuses on the
+    // observable contract: when an input map is provided, the resulting
+    // map's `sources` array must contain the original sources, and the
+    // resulting map's mappings must successfully reverse-resolve a probe
+    // back to one of those original sources.
+
+    const source = [
+      'console.log("alpha");',
+      'console.log("beta");',
+      'console.log("gamma");',
+    ].join('\n');
+    const sourceName = 'src/widget.js';
+
+    const originalMap = new SourceMap(PROJECT_ROOT);
+    originalMap.addIndexedMappings([
+      {
+        generated: {line: 1, column: 0},
+        original: {line: 1, column: 0},
+        source: sourceName,
+      },
+      {
+        generated: {line: 2, column: 0},
+        original: {line: 2, column: 0},
+        source: sourceName,
+      },
+      {
+        generated: {line: 3, column: 0},
+        original: {line: 3, column: 0},
+        source: sourceName,
+      },
+    ]);
+    originalMap.setSourceContent(sourceName, source);
+
+    const out = await minifyWithSourceMap(source, originalMap, {
+      projectRoot: PROJECT_ROOT,
+      mangle: false,
+      compress: true,
+    });
+
+    assert.ok(out.map, 'expected a source map to be produced');
+
+    const vlq = out.map!.toVLQ();
+    // The output map must reference the ORIGINAL source file. The post-hoc
+    // `extends()` path leaks `<anon>` (swc's placeholder source name for the
+    // input it was given) into the sources array, alongside the real source
+    // name from the input map. With `inputSourceMap` swc knows the real
+    // source names up-front and emits only those.
+    assert.ok(
+      vlq.sources.includes(sourceName),
+      `expected output map.sources to include ${sourceName}, got ${JSON.stringify(vlq.sources)}`,
+    );
+    assert.ok(
+      !vlq.sources.some((s) => s === '<anon>' || s === '<source>'),
+      `output map.sources must not contain swc placeholder source names, got ${JSON.stringify(vlq.sources)}`,
+    );
+
+    // Reverse-resolve each probe and check it lands on src/widget.js at
+    // the right line.
+    for (const probe of ['alpha', 'beta', 'gamma']) {
+      const probeIdx = out.code.indexOf(`"${probe}"`);
+      assert.ok(probeIdx >= 0, `probe ${probe} should be in minified code`);
+      const resolved = out.map!.findClosestMapping(1, probeIdx + 1);
+      assert.strictEqual(
+        resolved?.source,
+        sourceName,
+        `probe ${probe} should resolve to ${sourceName}, got ${resolved?.source}`,
+      );
+      // Each probe lives on its own original line.
+      const expectedLine = ['alpha', 'beta', 'gamma'].indexOf(probe) + 1;
+      assert.strictEqual(
+        resolved?.original?.line,
+        expectedLine,
+        `probe ${probe} should resolve to line ${expectedLine}, got ${resolved?.original?.line}`,
+      );
+    }
+  });
+
+  it('produces a source map that correctly resolves string literals back to their original lines', async () => {
+    // Three source modules, each with several "log calls" on a single line.
+    // This mirrors real-world bundles where the packager produces source maps
+    // with multiple mappings per generated line: each asset's tokens get
+    // packed onto one line of the bundle and several mappings share that
+    // line.
+    //
+    // The optimizer must compose its (minified -> bundle) map with the input
+    // (bundle -> original sources) map per-token. The buggy implementation
+    // uses `SourceMap.extends(originalMap)`, which calls `findClosestMapping`
+    // on the original map – and that snaps to the previous mapping in the
+    // map. When the input map has gaps (e.g. an asset's prologue line has no
+    // mapping, or the next asset's first line has no leading mapping), the
+    // snap goes backwards across an asset boundary and the minified token
+    // ends up attributed to the wrong source file entirely.
+    type Mod = {sourceName: string; source: string; probes: string[]};
+
+    const buildMod = (sourceName: string, prefix: string): Mod => {
+      // 4 lines, each with 5 distinct console.log statements. Multiple
+      // mappings per generated line at the column of each log call.
+      const lines: string[] = [];
+      const probes: string[] = [];
+      for (let l = 1; l <= 4; l++) {
+        const calls: string[] = [];
+        for (let c = 1; c <= 5; c++) {
+          const probe = `${prefix}_l${l}c${c}`;
+          probes.push(probe);
+          calls.push(`console.log("${probe}");`);
+        }
+        lines.push(calls.join(' '));
+      }
+      return {sourceName, source: lines.join('\n'), probes};
+    };
+
+    const mods: Mod[] = [
+      buildMod('src/a.js', 'A'),
+      buildMod('src/b.js', 'B'),
+      buildMod('src/c.js', 'C'),
+    ];
+
+    // Build the bundle by concatenating each module's source *onto a single
+    // line*, separated by a `;` – the way scope-hoisting bundlers often do
+    // it. The mappings still reference the original module's per-line, per-
+    // call positions, so the input map ends up with all mappings on
+    // generated line 1, but the column ranges interleave across the three
+    // sources.
+    //
+    // This is the structure that exposes the bug: when the minifier later
+    // emits a mapping at some column, the buggy `extends()` snaps to the
+    // closest mapping by *column*, which – with sparse mappings spanning
+    // multiple source files on a single line – often lands on the
+    // *previous source file entirely*.
+    const indexedMappings: Array<{
+      generated: {line: number; column: number};
+      original: {line: number; column: number};
+      source: string;
+      name?: string;
+    }> = [];
+
+    // Concatenate each module onto separate bundle lines, separating
+    // assets with a blank "boundary" line that has NO mapping in the input
+    // map. Real packagers insert such gaps (e.g. blank lines between
+    // assets, asset wrappers like `var $abc$exports = ...` that aren't
+    // mapped back to a source).
+    //
+    // This is what reproduces the production bug: when SWC emits a mapping
+    // at minified column X claiming it came from the gap line, the buggy
+    // `extends()` approach snaps to the previous mapping on a different
+    // bundle line entirely, mis-attributing the token.
+    let lineOffset = 0;
+    const bundleParts: string[] = [];
+    for (const mod of mods) {
+      bundleParts.push(mod.source);
+      const lines = mod.source.split('\n');
+      for (let l = 0; l < lines.length; l++) {
+        const line = lines[l];
+        const re = /console\.log\("[^"]+"\);?/g;
+        let m;
+        while ((m = re.exec(line))) {
+          indexedMappings.push({
+            generated: {line: l + 1 + lineOffset, column: m.index},
+            original: {line: l + 1, column: m.index},
+            source: mod.sourceName,
+          });
+        }
+      }
+      // +1 for the joining blank line below
+      lineOffset += lines.length + 1;
+    }
+    // The blank lines between assets have NO mapping – the input map has a
+    // gap that the buggy extends() will snap across.
+    const bundleInput = bundleParts.join('\n\n');
+
+    const originalMap = new SourceMap(PROJECT_ROOT);
+    originalMap.addIndexedMappings(indexedMappings);
+    for (const mod of mods) {
+      originalMap.setSourceContent(mod.sourceName, mod.source);
+    }
+
+    const out = await minifyWithSourceMap(bundleInput, originalMap, {
+      projectRoot: PROJECT_ROOT,
+      mangle: false,
+      compress: true,
+    });
+
+    assert.ok(out.map, 'expected a source map to be produced');
+
+    // Each probe lives in a `console.log("<probe>");` statement at a known
+    // (source, line, column) of its original module. Since the input map
+    // has a mapping at the START of each `console.log` call, we expect the
+    // post-minify map to reverse-resolve each probe to:
+    //   - the right source file
+    //   - the right line within that source
+    //   - the column where the matching `console.log` call starts
+    const allProbes = mods.flatMap((m) => m.probes);
+    const expected: Record<
+      string,
+      {source: string; line: number; column: number}
+    > = {};
+    for (const mod of mods) {
+      const lines = mod.source.split('\n');
+      for (let l = 0; l < lines.length; l++) {
+        const line = lines[l];
+        for (const probe of mod.probes) {
+          const idx = line.indexOf(`console.log("${probe}")`);
+          if (idx >= 0) {
+            expected[probe] = {
+              source: mod.sourceName,
+              line: l + 1,
+              column: idx,
+            };
+          }
+        }
+      }
+    }
+
+    const result = probeStringLiterals({
+      bundle: out.code,
+      map: out.map!,
+      expected,
+      probes: allProbes,
+    });
+
+    if (result.matched !== result.total) {
+      const summary = result.mismatches
+        .slice(0, 8)
+        .map(
+          (m) =>
+            `  - ${m.text} @ bundle ${m.bundleLine}:${m.bundleCol} -> ` +
+            `resolved=${JSON.stringify(m.resolved)} expected=${JSON.stringify(m.expected)}`,
+        )
+        .join('\n');
+      throw new Error(
+        `Source map misaligned: only ${result.matched}/${result.total} string literals ` +
+          `resolved to the exact original (source, line, column) where they live.\n` +
+          `First mismatches:\n${summary}`,
+      );
+    }
+
+    assert.strictEqual(result.matched, result.total);
+  });
+});