@atlaspack/core 2.34.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;
@@ -185,43 +188,19 @@ async function run({input, options, api}) {
     bundleReplacements,
   );
 
-  const hasSourceMap = getFeatureFlag('cachePerformanceImprovements')
-    ? await options.cache.hasLargeBlob(mapKey)
-    : await options.cache.has(mapKey);
+  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 = getFeatureFlag('cachePerformanceImprovements')
-        ? await options.cache.getLargeBlob(mapKey)
-        : 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 = getFeatureFlag('cachePerformanceImprovements')
-        ? await options.cache.getLargeBlob(mapKey)
-        : await options.cache.getBlob(mapKey);
       mapStream = blobToStream(mapEntry);
     }
     await writeFiles(
@@ -275,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/src/resolveOptions.ts

@@ -184,10 +184,8 @@ export default async function resolveOptions(
     const needsRustLmdbCache =
       getFeatureFlag('atlaspackV3') || getFeatureFlag('nativePackager');
 
-    if (!getFeatureFlag('cachePerformanceImprovements')) {
-      if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
-        return new FSCache(outputFS, cacheDir);
-      }
+    if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {
+      return new FSCache(outputFS, cacheDir);
     }
 
     return new LMDBLiteCache(cacheDir);

package/src/types.ts

@@ -112,6 +112,7 @@ export type Target = {
   loc?: InternalSourceLocation | null | undefined;
   pipeline?: string;
   source?: FilePath | Array<FilePath>;
+  inlineRequires?: boolean;
 };
 
 export const SpecifierType = {

package/test/AssetGraph.test.ts

@@ -687,36 +687,4 @@ describe('AssetGraph', () => {
     invariant(node.type === 'asset_group');
     assert(!node.hasDeferred);
   });
-
-  it('should serialize the bundling version and incremental bundling flag', () => {
-    const graph = new AssetGraph();
-    graph.setDisableIncrementalBundling(true);
-    graph.setNeedsBundling();
-    const serialized = serialize(graph);
-    const deserialized = deserialize(serialized);
-
-    assert.equal(deserialized.getBundlingVersion(), 1);
-    assert.equal(deserialized.testing_getDisableIncrementalBundling(), true);
-  });
-
-  describe('setNeedsBundling', () => {
-    it('should increment the bundling version', () => {
-      const graph = new AssetGraph();
-      assert.equal(graph.getBundlingVersion(), 0);
-      graph.setNeedsBundling();
-      assert.equal(graph.getBundlingVersion(), 1);
-      graph.setNeedsBundling();
-      assert.equal(graph.getBundlingVersion(), 2);
-    });
-  });
-
-  describe('canIncrementallyBundle', () => {
-    it('should return true if the bundling version has changed', () => {
-      const graph = new AssetGraph();
-      const lastVersion = graph.getBundlingVersion();
-      assert.equal(graph.canIncrementallyBundle(lastVersion), true);
-      graph.setNeedsBundling();
-      assert.equal(graph.canIncrementallyBundle(lastVersion), false);
-    });
-  });
 });

package/test/RequestTracker.test.ts

@@ -538,171 +538,6 @@ describe('RequestTracker', () => {
       });
     });
   });
-
-  describe('incremental bundling', () => {
-    async function runIncrementalBundlingScenario(
-      incrementalBundlingVersioning: boolean,
-    ) {
-      const fs = new OverlayFS(new MemoryFS(farm), new NodeFS());
-      const appRoot = __dirname;
-      await fs.mkdirp(path.join(appRoot, 'app'));
-      await fs.writeFile(path.join(appRoot, 'app', 'package.json'), '{}');
-      await fs.writeFile(path.join(appRoot, 'app', '.git'), '');
-      await fs.writeFile(
-        path.join(appRoot, 'app', '.parcelrc'),
-        '{"extends":"@atlaspack/config-default"}',
-      );
-      await fs.writeFile(
-        path.join(appRoot, 'app', 'target.js'),
-        'console.log("hello")',
-      );
-
-      const atlaspack = new Atlaspack({
-        featureFlags: {
-          incrementalBundlingVersioning,
-        },
-        workerFarm: farm,
-        entries: [path.join(appRoot, 'app', 'target.js')],
-        cache: new LMDBLiteCache(DEFAULT_OPTIONS.cacheDir),
-        inputFS: fs,
-        outputFS: fs,
-      });
-      await atlaspack._init();
-      const options = atlaspack._getResolvedAtlaspackOptions();
-      const tracker = new RequestTracker({farm, options});
-      let {ref: optionsRef} = await farm.createSharedReference(options, false);
-
-      const getAssetRequests = () =>
-        runRequestSpy
-          .getCalls()
-          .map((call: any) => call.args[0])
-          .filter(
-            (request: any) => request.type === requestTypes.asset_request,
-          );
-
-      // Running the build once builds one asset
-      const runRequestSpy = sinon.spy(tracker, 'runRequest');
-      await tracker.runRequest(
-        createAtlaspackBuildRequest({
-          optionsRef,
-          requestedAssetIds: new Set(),
-        }),
-      );
-      assert.equal(getAssetRequests().length, 1);
-      runRequestSpy.resetHistory();
-
-      // Running the build again with no invalidations does not build any assets
-      await tracker.runRequest(
-        createAtlaspackBuildRequest({
-          optionsRef,
-          requestedAssetIds: new Set(),
-        }),
-      );
-      assert.equal(getAssetRequests().length, 0);
-      runRequestSpy.resetHistory();
-
-      // Running the build again with a file change builds the asset again
-      tracker.respondToFSEvents(
-        [
-          {
-            type: 'update',
-            path: path.join(appRoot, 'app', 'target.js'),
-          },
-        ],
-        Number.MAX_VALUE,
-      );
-      await tracker.runRequest(
-        createAtlaspackBuildRequest({
-          optionsRef,
-          requestedAssetIds: new Set(),
-        }),
-      );
-      assert.equal(getAssetRequests().length, 1);
-      runRequestSpy.resetHistory();
-
-      // Run the asset graph request, but not bundling
-      await fs.writeFile(
-        path.join(appRoot, 'app', 'target.js'),
-        'require("./dep.js")',
-      );
-      await fs.writeFile(
-        path.join(appRoot, 'app', 'dep.js'),
-        'console.log("dep")',
-      );
-      tracker.respondToFSEvents(
-        [
-          {
-            type: 'update',
-            path: path.join(appRoot, 'app', 'target.js'),
-          },
-        ],
-        Number.MAX_VALUE,
-      );
-      const assetGraphRequestResult = await tracker.runRequest(
-        createAssetGraphRequest({
-          name: 'Main',
-          entries: [
-            toProjectPath(
-              path.join(appRoot, 'app'),
-              path.join(appRoot, 'app', 'target.js'),
-            ),
-          ],
-          optionsRef,
-          shouldBuildLazily: false,
-          lazyIncludes: [],
-          lazyExcludes: [],
-          requestedAssetIds: new Set(),
-        }),
-      );
-      assert.equal(getAssetRequests().length, 2);
-      assert.equal(
-        assetGraphRequestResult.assetGraph.safeToIncrementallyBundle,
-        false,
-      );
-
-      // Now make another change
-      tracker.respondToFSEvents(
-        [
-          {
-            type: 'update',
-            path: path.join(appRoot, 'app', 'target.js'),
-          },
-          {
-            type: 'update',
-            path: path.join(appRoot, 'app', 'dep.js'),
-          },
-        ],
-        Number.MAX_VALUE,
-      );
-      // And run the build again
-
-      if (!incrementalBundlingVersioning) {
-        await assert.rejects(async () => {
-          await tracker.runRequest(
-            createAtlaspackBuildRequest({
-              optionsRef,
-              requestedAssetIds: new Set(),
-            }),
-          );
-        });
-      } else {
-        await tracker.runRequest(
-          createAtlaspackBuildRequest({
-            optionsRef,
-            requestedAssetIds: new Set(),
-          }),
-        );
-      }
-    }
-
-    it('throws a content key not found exception without bundling versioning', async () => {
-      await runIncrementalBundlingScenario(false);
-    });
-
-    it('works fine with bundling versioning', async () => {
-      await runIncrementalBundlingScenario(true);
-    });
-  });
 });
 
 describe('cleanUpOrphans', () => {

package/test/TargetRequest.test.ts

@@ -122,6 +122,7 @@ describe('TargetResolver', () => {
         {
           name: 'customA',
           publicUrl: '/',
+          inlineRequires: false,
           distDir: normalizeSeparators(path.resolve('customA')),
           env: createEnvironment({
             context: 'browser',
@@ -142,6 +143,7 @@ describe('TargetResolver', () => {
         {
           name: 'customB',
           publicUrl: '/',
+          inlineRequires: false,
           distEntry: 'b.js',
           distDir: normalizeSeparators(path.resolve('customB')),
           env: createEnvironment({
@@ -175,6 +177,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/common-targets/dist/main',
           distEntry: 'index.js',
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'node',
             engines: {
@@ -209,6 +212,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/common-targets/dist/module',
           distEntry: 'index.js',
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -245,6 +249,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/common-targets/dist/browser',
           distEntry: 'index.js',
           publicUrl: '/assets',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -291,6 +296,7 @@ describe('TargetResolver', () => {
           ),
           distEntry: 'index.js',
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'node',
             engines: {
@@ -334,6 +340,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/custom-targets/dist/main',
           distEntry: 'index.js',
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'node',
             engines: {
@@ -368,6 +375,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/custom-targets/dist/browserModern',
           distEntry: 'index.js',
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -405,6 +413,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/custom-targets/dist/browserLegacy',
           distEntry: 'index.js',
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -459,6 +468,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/custom-targets/dist/main',
           distEntry: 'index.js',
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'node',
             engines: {
@@ -493,6 +503,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/custom-targets/dist/browserModern',
           distEntry: 'index.js',
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -530,6 +541,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/custom-targets/dist/browserLegacy',
           distEntry: 'index.js',
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -576,6 +588,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/custom-targets-distdir/www',
           distEntry: undefined,
           publicUrl: 'www',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -631,6 +644,7 @@ describe('TargetResolver', () => {
           name: 'customB',
           distDir: normalizeSeparators(path.resolve('customB')),
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -673,6 +687,7 @@ describe('TargetResolver', () => {
           name: 'customA',
           distDir: normalizeSeparators(path.resolve('customA')),
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -702,6 +717,7 @@ describe('TargetResolver', () => {
         distDir: 'fixtures/context/dist/main',
         distEntry: 'index.js',
         publicUrl: '/',
+        inlineRequires: false,
         env: createEnvironment({
           context: 'node',
           engines: {
@@ -1073,6 +1089,7 @@ describe('TargetResolver', () => {
         distDir: relative(path.join(fixture, 'dist')),
         distEntry: 'index.mjs',
         publicUrl: '/',
+        inlineRequires: false,
         env: createEnvironment({
           context: 'browser',
           engines: {
@@ -1118,6 +1135,7 @@ describe('TargetResolver', () => {
         distDir: relative(path.join(fixture, 'dist')),
         distEntry: 'index.js',
         publicUrl: '/',
+        inlineRequires: false,
         env: createEnvironment({
           context: 'browser',
           engines: {
@@ -1167,6 +1185,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/common-targets/dist/main',
           distEntry: 'index.js',
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'node',
             engines: {
@@ -1201,6 +1220,7 @@ describe('TargetResolver', () => {
           distDir: 'fixtures/common-targets/dist/browser',
           distEntry: 'index.js',
           publicUrl: '/assets',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -1249,6 +1269,7 @@ describe('TargetResolver', () => {
           name: 'default',
           distDir: serveDistDir,
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -1286,6 +1307,7 @@ describe('TargetResolver', () => {
             path.join(DEFAULT_DISTPATH_FIXTURE_PATHS.none, 'dist'),
           ),
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -1319,6 +1341,7 @@ describe('TargetResolver', () => {
           ),
           distEntry: undefined,
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -1369,6 +1392,7 @@ describe('TargetResolver', () => {
           ),
           distEntry: undefined,
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {
@@ -1409,6 +1433,7 @@ describe('TargetResolver', () => {
           ),
           distEntry: undefined,
           publicUrl: '/',
+          inlineRequires: false,
           env: createEnvironment({
             context: 'browser',
             engines: {