@atlaspack/core 2.35.0 → 2.36.0

package/src/requests/WriteBundleRequest.ts

@@ -41,12 +41,15 @@ import {PluginTracer, tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {fromEnvironmentId} from '../EnvironmentManager';
-import SourceMap from '@atlaspack/source-map';
+import SourceMap, {decodeVLQ, encodeVLQ} from '@atlaspack/source-map';
 
 const HASH_REF_PREFIX_LEN = HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = HASH_REF_PREFIX.length + 32 - 1;
 const HASH_REF_PLACEHOLDER_LEN = HASH_REF_PREFIX_LEN + HASH_REF_HASH_LEN;
 
+// The JSON key prefix we scan for in the source map stream.
+const MAPPINGS_KEY_BUF = Buffer.from('"mappings":"');
+
 export type HashRefReplacement = {
   line: number;
   column: number;
@@ -187,35 +190,17 @@ async function run({input, options, api}) {
 
   const hasSourceMap = await options.cache.has(mapKey);
   if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+    const mapEntry = await options.cache.getBlob(mapKey);
     let mapStream: Readable;
     if (
       getFeatureFlag('fixSourceMapHashRefs') &&
       bundleReplacements &&
       bundleReplacements.length > 0
     ) {
-      const mapEntry = await options.cache.getBlob(mapKey);
-      const mapBuffer = Buffer.isBuffer(mapEntry)
-        ? mapEntry
-        : Buffer.from(mapEntry);
-      const projectRoot =
-        typeof options.projectRoot === 'string'
-          ? options.projectRoot
-          : String(options.projectRoot);
-      const sourceMap = new SourceMap(projectRoot, mapBuffer);
-      applyReplacementsToSourceMap(sourceMap, bundleReplacements);
-      const mapJson = await sourceMap.stringify({
-        format: 'string',
-        file: name,
-        sourceRoot: computeSourceMapRoot(bundle, options),
-      });
-      mapStream = blobToStream(
-        Buffer.from(
-          typeof mapJson === 'string' ? mapJson : JSON.stringify(mapJson),
-          'utf8',
-        ),
+      mapStream = blobToStream(mapEntry).pipe(
+        new SourceMapHashRefRewriteStream(bundleReplacements),
       );
     } else {
-      const mapEntry = await options.cache.getBlob(mapKey);
       mapStream = blobToStream(mapEntry);
     }
     await writeFiles(
@@ -269,6 +254,201 @@ export function applyReplacementsToSourceMap(
   }
 }
 
+/**
+ * Applies hash-ref replacement column offsets directly to a VLQ mappings
+ * string without deserializing the full source map into a native struct.
+ *
+ * Each replacement r describes a hash-ref that was substituted in the output
+ * file.  r.column is in the progressively-shifted post-replacement coordinate
+ * space (matching the already-shifted source map state after all previous
+ * offsetColumns calls), so thresholds are applied sequentially against the
+ * running absCol values exactly as the native offsetColumns implementation does.
+ */
+export function applyReplacementsToVLQMappings(
+  mappings: string,
+  replacements: HashRefReplacement[],
+): string {
+  if (replacements.length === 0) return mappings;
+
+  // Group replacements by line (0-indexed), sorted by column ascending.
+  const byLine = new Map<number, HashRefReplacement[]>();
+  for (const r of replacements) {
+    let arr = byLine.get(r.line);
+    if (!arr) {
+      arr = [];
+      byLine.set(r.line, arr);
+    }
+    arr.push(r);
+  }
+  for (const arr of byLine.values()) {
+    arr.sort((a, b) => a.column - b.column);
+  }
+
+  const lines = mappings.split(';');
+  const resultLines: string[] = [];
+
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const lineReps = byLine.get(lineIdx);
+    if (!lineReps || lineReps.length === 0) {
+      resultLines.push(lines[lineIdx]);
+      continue;
+    }
+
+    const line = lines[lineIdx];
+    if (!line) {
+      resultLines.push('');
+      continue;
+    }
+
+    // Decode segment column deltas to absolute columns.
+    const segments = line.split(',');
+    const colVlqEnds: number[] = [];
+    const absCols: number[] = [];
+    let absCol = 0;
+    for (const seg of segments) {
+      const {value: colDelta, nextPos} = decodeVLQ(seg, 0);
+      absCol += colDelta;
+      colVlqEnds.push(nextPos);
+      absCols.push(absCol);
+    }
+
+    // Apply each replacement's column shift sequentially against the
+    // current absCol values (which have already been adjusted by previous
+    // replacements on this line), mirroring the sequential offsetColumns calls.
+    for (const r of lineReps) {
+      const delta = r.newLength - r.originalLength;
+      if (delta === 0) continue;
+      const threshold = r.column + r.originalLength;
+      for (let i = 0; i < absCols.length; i++) {
+        if (absCols[i] >= threshold) {
+          absCols[i] += delta;
+        }
+      }
+    }
+
+    // Re-encode with updated absolute columns; only the leading column VLQ
+    // field of each segment changes – the tail bytes are sliced unchanged.
+    const resultSegments: string[] = [];
+    let prevAbsCol = 0;
+    for (let i = 0; i < segments.length; i++) {
+      const newDelta = absCols[i] - prevAbsCol;
+      prevAbsCol = absCols[i];
+      resultSegments.push(
+        encodeVLQ(newDelta) + segments[i].slice(colVlqEnds[i]),
+      );
+    }
+
+    resultLines.push(resultSegments.join(','));
+  }
+
+  return resultLines.join(';');
+}
+
+type StreamState = 'scanning' | 'buffering' | 'passthrough';
+
+/**
+ * A Transform stream that rewrites the "mappings" VLQ field of a source map
+ * JSON to account for hash-ref replacements, without ever loading the full
+ * JSON object or the native Rust SourceMapInner into memory.
+ *
+ * Field order in cached source maps (from partialVlqMapToSourceMap / toVLQ):
+ *   mappings → sources → sourcesContent → names → version → file → sourceRoot
+ *
+ * "mappings" is the very first field, so we scan only a tiny header before
+ * switching to zero-copy passthrough for the bulk sourcesContent bytes.
+ */
+export class SourceMapHashRefRewriteStream extends Transform {
+  private replacements: HashRefReplacement[];
+  private state: StreamState;
+  private scanBuf: Buffer;
+  private mappingsBufs: Buffer[];
+
+  constructor(replacements: HashRefReplacement[]) {
+    super();
+    this.replacements = replacements;
+    this.state = 'scanning';
+    this.scanBuf = Buffer.alloc(0);
+    this.mappingsBufs = [];
+  }
+
+  // @ts-expect-error TS7006
+  _transform(chunk: Buffer, _encoding: string, cb): void {
+    if (this.state === 'passthrough') {
+      this.push(chunk);
+      cb();
+      return;
+    }
+
+    if (this.state === 'scanning') {
+      const combined = Buffer.concat([this.scanBuf, chunk]);
+      const idx = combined.indexOf(MAPPINGS_KEY_BUF);
+
+      if (idx === -1) {
+        // Key not yet found – hold back enough bytes to handle a split key.
+        const keepLen = Math.min(combined.length, MAPPINGS_KEY_BUF.length - 1);
+        if (combined.length > keepLen) {
+          this.push(combined.slice(0, combined.length - keepLen));
+        }
+        this.scanBuf = combined.slice(combined.length - keepLen);
+        cb();
+        return;
+      }
+
+      // Emit everything up to and including the key.
+      const keyEnd = idx + MAPPINGS_KEY_BUF.length;
+      this.push(combined.slice(0, keyEnd));
+      this.scanBuf = Buffer.alloc(0);
+      this.state = 'buffering';
+      this._bufferingTransform(combined.slice(keyEnd), cb);
+      return;
+    }
+
+    // state === 'buffering'
+    this._bufferingTransform(chunk, cb);
+  }
+
+  // @ts-expect-error TS7006
+  private _bufferingTransform(chunk: Buffer, cb): void {
+    // Mappings values contain only base64 chars, ';', and ',' – no escaping –
+    // so scanning for the closing '"' (0x22) is safe.
+    const closeIdx = chunk.indexOf(0x22);
+
+    if (closeIdx === -1) {
+      this.mappingsBufs.push(chunk);
+      cb();
+      return;
+    }
+
+    this.mappingsBufs.push(chunk.slice(0, closeIdx));
+
+    // VLQ chars are all ASCII (<128), so latin1 round-trips without loss.
+    const mappingsStr = Buffer.concat(this.mappingsBufs).toString('latin1');
+    const rewritten = applyReplacementsToVLQMappings(
+      mappingsStr,
+      this.replacements,
+    );
+    this.push(Buffer.from(rewritten, 'latin1'));
+
+    // Emit the closing '"' and everything remaining in one push.
+    this.push(chunk.slice(closeIdx));
+
+    this.state = 'passthrough';
+    this.mappingsBufs = [];
+    cb();
+  }
+
+  // @ts-expect-error TS7006
+  _flush(cb): void {
+    if (this.state === 'scanning' && this.scanBuf.length > 0) {
+      this.push(this.scanBuf);
+    } else if (this.state === 'buffering') {
+      // Malformed JSON – flush whatever we buffered as-is.
+      this.push(Buffer.concat(this.mappingsBufs));
+    }
+    cb();
+  }
+}
+
 /**
  * Computes the sourceRoot for a source map file. This is the relative path from
  * the output directory back to the project root, so that source paths (stored

package/test/requests/WriteBundleRequest.test.ts

@@ -1,7 +1,10 @@
 import assert from 'assert';
+import {Readable} from 'stream';
 import SourceMap from '@atlaspack/source-map';
 import {
   applyReplacementsToSourceMap,
+  applyReplacementsToVLQMappings,
+  SourceMapHashRefRewriteStream,
   type HashRefReplacement,
 } from '../../src/requests/WriteBundleRequest';
 
@@ -69,6 +72,35 @@ function buildCodeWithHashRefs(
   };
 }
 
+/**
+ * Drains a Readable stream into a single Buffer.
+ */
+function streamToBuffer(stream: Readable): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    stream.on('data', (chunk: Buffer) => chunks.push(chunk));
+    stream.on('end', () => resolve(Buffer.concat(chunks)));
+    stream.on('error', reject);
+  });
+}
+
+/**
+ * Cross-checks applyReplacementsToVLQMappings against the native
+ * applyReplacementsToSourceMap by building a SourceMap, running both
+ * implementations, and asserting identical VLQ output.
+ */
+function crossCheck(sm: SourceMap, replacements: HashRefReplacement[]): void {
+  const vlqBefore = sm.toVLQ().mappings;
+  const vlqResult = applyReplacementsToVLQMappings(vlqBefore, replacements);
+  applyReplacementsToSourceMap(sm, replacements);
+  const nativeResult = sm.toVLQ().mappings;
+  assert.strictEqual(
+    vlqResult,
+    nativeResult,
+    `VLQ result differs from native:\n  VLQ:    ${vlqResult}\n  native: ${nativeResult}`,
+  );
+}
+
 describe('applyReplacementsToSourceMap', () => {
   describe('with correct replacement coordinates', () => {
     it('should correctly adjust a single HASH_REF replacement', () => {
@@ -237,3 +269,334 @@ describe('applyReplacementsToSourceMap', () => {
     });
   });
 });
+
+describe('applyReplacementsToVLQMappings', () => {
+  it('returns the same string for empty replacements', () => {
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: 10},
+      original: {line: 1, column: 0},
+      source: 'test.js',
+    });
+    const vlq = sm.toVLQ().mappings;
+    assert.strictEqual(applyReplacementsToVLQMappings(vlq, []), vlq);
+  });
+
+  it('returns the same string for a zero-delta replacement', () => {
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: 30},
+      original: {line: 1, column: 0},
+      source: 'test.js',
+    });
+    const vlq = sm.toVLQ().mappings;
+    const repl: HashRefReplacement[] = [
+      {line: 0, column: 0, originalLength: 10, newLength: 10},
+    ];
+    assert.strictEqual(applyReplacementsToVLQMappings(vlq, repl), vlq);
+  });
+
+  it('single replacement agrees with native', () => {
+    const {correctReplacements, identifierPositions} = buildCodeWithHashRefs([
+      {type: 'hashref'},
+      {type: 'code', text: ';var x=SOME_IDENT;'},
+    ]);
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: identifierPositions.get('SOME_IDENT')!},
+      original: {line: 10, column: 5},
+      source: 'test.js',
+    });
+    crossCheck(sm, correctReplacements);
+  });
+
+  it('multiple replacements on the same line agree with native', () => {
+    const {correctReplacements, identifierPositions} = buildCodeWithHashRefs([
+      {type: 'hashref'},
+      {type: 'code', text: ';var a=IDENT_ALPHA;require("'},
+      {type: 'hashref'},
+      {type: 'code', text: '");var b=IDENT_BETA;require("'},
+      {type: 'hashref'},
+      {type: 'code', text: '");var c=IDENT_GAMMA;'},
+    ]);
+    const sm = new SourceMap('/');
+    for (const [name, origLine] of [
+      ['IDENT_ALPHA', 10],
+      ['IDENT_BETA', 20],
+      ['IDENT_GAMMA', 30],
+    ] as const) {
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get(name)!},
+        original: {line: origLine, column: 0},
+        source: 'test.js',
+      });
+    }
+    crossCheck(sm, correctReplacements);
+  });
+
+  it('10 replacements on the same line agree with native', () => {
+    const segments: Array<{type: 'code'; text: string} | {type: 'hashref'}> =
+      [];
+    for (let i = 0; i < 10; i++) {
+      segments.push({type: 'hashref'});
+      segments.push({
+        type: 'code',
+        text: `;var x${i}=TARGET_${String(i).padStart(2, '0')};require("`,
+      });
+    }
+    segments.push({type: 'code', text: '");'});
+
+    const {correctReplacements, identifierPositions} =
+      buildCodeWithHashRefs(segments);
+
+    const sm = new SourceMap('/');
+    for (let i = 0; i < 10; i++) {
+      const name = `TARGET_${String(i).padStart(2, '0')}`;
+      sm.addIndexedMapping({
+        generated: {line: 1, column: identifierPositions.get(name)!},
+        original: {line: (i + 1) * 10, column: 0},
+        source: 'test.js',
+      });
+    }
+    crossCheck(sm, correctReplacements);
+  });
+
+  it('mapping before the threshold is unaffected', () => {
+    const {correctReplacements, identifierPositions} = buildCodeWithHashRefs([
+      {type: 'code', text: 'var BEFORE_HASH=1;'},
+      {type: 'hashref'},
+      {type: 'code', text: ';var AFTER_HASH=2;'},
+    ]);
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: identifierPositions.get('BEFORE_HASH')!},
+      original: {line: 1, column: 0},
+      source: 'test.js',
+    });
+    sm.addIndexedMapping({
+      generated: {line: 1, column: identifierPositions.get('AFTER_HASH')!},
+      original: {line: 2, column: 0},
+      source: 'test.js',
+    });
+    crossCheck(sm, correctReplacements);
+  });
+
+  it('mapping on a different line is unaffected', () => {
+    const sm = new SourceMap('/');
+    // Line 0 (VLQ line index 0): hash ref at col 0, mapping at col 50
+    // Line 1 (VLQ line index 1): mapping at col 5 – should be untouched
+    sm.addIndexedMapping({
+      generated: {line: 1, column: 50},
+      original: {line: 10, column: 0},
+      source: 'test.js',
+    });
+    sm.addIndexedMapping({
+      generated: {line: 2, column: 5},
+      original: {line: 20, column: 0},
+      source: 'test.js',
+    });
+
+    const replacements: HashRefReplacement[] = [
+      {
+        line: 0,
+        column: 0,
+        originalLength: HASH_REF_LEN,
+        newLength: REPLACEMENT_LEN,
+      },
+    ];
+
+    const vlqBefore = sm.toVLQ().mappings;
+    const vlqResult = applyReplacementsToVLQMappings(vlqBefore, replacements);
+    applyReplacementsToSourceMap(sm, replacements);
+
+    // Verify the line-1 mapping is unchanged by checking parsed values
+    const mappings = sm.getMap().mappings;
+    const line2Mapping = mappings.find((m) => m.original?.line === 20);
+    assert.ok(line2Mapping, 'Line 2 mapping should exist');
+    assert.strictEqual(line2Mapping!.generated.column, 5);
+
+    // Also verify VLQ agrees with native
+    assert.strictEqual(vlqResult, sm.toVLQ().mappings);
+  });
+});
+
+describe('SourceMapHashRefRewriteStream', () => {
+  async function applyStream(
+    json: string,
+    replacements: HashRefReplacement[],
+    chunkSize?: number,
+  ): Promise<string> {
+    const inputBuf = Buffer.from(json, 'utf8');
+    let readable: Readable;
+    if (chunkSize != null) {
+      readable = new Readable({
+        read() {
+          let offset = 0;
+          while (offset < inputBuf.length) {
+            this.push(inputBuf.slice(offset, offset + chunkSize));
+            offset += chunkSize;
+          }
+          this.push(null);
+        },
+      });
+    } else {
+      readable = Readable.from([inputBuf]);
+    }
+    const outBuf = await streamToBuffer(
+      readable.pipe(new SourceMapHashRefRewriteStream(replacements)),
+    );
+    return outBuf.toString('utf8');
+  }
+
+  it('full round-trip: mappings field is correctly rewritten', async () => {
+    const {correctReplacements, identifierPositions} = buildCodeWithHashRefs([
+      {type: 'hashref'},
+      {type: 'code', text: ';var x=SOME_IDENT;'},
+    ]);
+
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: identifierPositions.get('SOME_IDENT')!},
+      original: {line: 10, column: 5},
+      source: 'test.js',
+    });
+
+    const vlqBefore = sm.toVLQ().mappings;
+    const expectedMappings = applyReplacementsToVLQMappings(
+      vlqBefore,
+      correctReplacements,
+    );
+
+    const mapJson = await sm.stringify({format: 'string'});
+    const outputJson = await applyStream(
+      mapJson as string,
+      correctReplacements,
+    );
+    const parsed = JSON.parse(outputJson);
+
+    assert.strictEqual(parsed.mappings, expectedMappings);
+  });
+
+  it('bytes after mappings (sourcesContent) pass through unchanged', async () => {
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: 30},
+      original: {line: 5, column: 0},
+      source: 'test.js',
+    });
+    sm.setSourceContent('test.js', 'const x = 1;\nconst y = 2;\n');
+
+    const replacements: HashRefReplacement[] = [
+      {
+        line: 0,
+        column: 0,
+        originalLength: HASH_REF_LEN,
+        newLength: REPLACEMENT_LEN,
+      },
+    ];
+
+    const mapJson = (await sm.stringify({format: 'string'})) as string;
+    const outputJson = await applyStream(mapJson, replacements);
+    const parsedInput = JSON.parse(mapJson);
+    const parsedOutput = JSON.parse(outputJson);
+
+    // sourcesContent must be byte-for-byte identical
+    assert.deepStrictEqual(
+      parsedOutput.sourcesContent,
+      parsedInput.sourcesContent,
+    );
+    assert.deepStrictEqual(parsedOutput.sources, parsedInput.sources);
+    assert.deepStrictEqual(parsedOutput.names, parsedInput.names);
+  });
+
+  it('handles chunk boundaries mid-key', async () => {
+    const {correctReplacements, identifierPositions} = buildCodeWithHashRefs([
+      {type: 'hashref'},
+      {type: 'code', text: ';var x=SOME_IDENT;'},
+    ]);
+
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: identifierPositions.get('SOME_IDENT')!},
+      original: {line: 10, column: 5},
+      source: 'test.js',
+    });
+
+    const vlqBefore = sm.toVLQ().mappings;
+    const expectedMappings = applyReplacementsToVLQMappings(
+      vlqBefore,
+      correctReplacements,
+    );
+
+    const mapJson = (await sm.stringify({format: 'string'})) as string;
+
+    // Test multiple chunk sizes to exercise boundary conditions.
+    for (const chunkSize of [1, 3, 7, 11, 13]) {
+      const outputJson = await applyStream(
+        mapJson,
+        correctReplacements,
+        chunkSize,
+      );
+      const parsed = JSON.parse(outputJson);
+      assert.strictEqual(
+        parsed.mappings,
+        expectedMappings,
+        `Chunk size ${chunkSize}: mappings mismatch`,
+      );
+    }
+  });
+
+  it('handles chunk boundaries mid-value', async () => {
+    // Use a source map with a longer mappings string to ensure the VLQ value
+    // spans multiple chunks for small chunk sizes.
+    const sm = new SourceMap('/');
+    for (let i = 0; i < 20; i++) {
+      sm.addIndexedMapping({
+        generated: {line: 1, column: i * 5},
+        original: {line: i + 1, column: 0},
+        source: 'test.js',
+      });
+    }
+
+    const replacements: HashRefReplacement[] = [
+      {
+        line: 0,
+        column: 10,
+        originalLength: HASH_REF_LEN,
+        newLength: REPLACEMENT_LEN,
+      },
+    ];
+
+    const vlqBefore = sm.toVLQ().mappings;
+    const expectedMappings = applyReplacementsToVLQMappings(
+      vlqBefore,
+      replacements,
+    );
+
+    const mapJson = (await sm.stringify({format: 'string'})) as string;
+
+    for (const chunkSize of [1, 5, 8]) {
+      const outputJson = await applyStream(mapJson, replacements, chunkSize);
+      const parsed = JSON.parse(outputJson);
+      assert.strictEqual(
+        parsed.mappings,
+        expectedMappings,
+        `Chunk size ${chunkSize}: mappings mismatch`,
+      );
+    }
+  });
+
+  it('no-op for empty replacements – output equals input', async () => {
+    const sm = new SourceMap('/');
+    sm.addIndexedMapping({
+      generated: {line: 1, column: 10},
+      original: {line: 1, column: 0},
+      source: 'test.js',
+    });
+
+    const mapJson = (await sm.stringify({format: 'string'})) as string;
+    const outputJson = await applyStream(mapJson, []);
+
+    assert.strictEqual(outputJson, mapJson);
+  });
+});