@atlaspack/core 2.34.0 → 2.36.0

package/dist/requests/WriteBundleRequest.js

@@ -36,8 +36,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMapHashRefRewriteStream = void 0;
 exports.default = createWriteBundleRequest;
 exports.applyReplacementsToSourceMap = applyReplacementsToSourceMap;
+exports.applyReplacementsToVLQMappings = applyReplacementsToVLQMappings;
 exports.computeSourceMapRoot = computeSourceMapRoot;
 const constants_1 = require("../constants");
 const nullthrows_1 = __importDefault(require("nullthrows"));
@@ -56,10 +58,12 @@ const profiler_1 = require("@atlaspack/profiler");
 const RequestTracker_1 = require("../RequestTracker");
 const feature_flags_1 = require("@atlaspack/feature-flags");
 const EnvironmentManager_1 = require("../EnvironmentManager");
-const source_map_1 = __importDefault(require("@atlaspack/source-map"));
+const source_map_1 = require("@atlaspack/source-map");
 const HASH_REF_PREFIX_LEN = constants_1.HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = constants_1.HASH_REF_PREFIX.length + 32 - 1;
 const HASH_REF_PLACEHOLDER_LEN = HASH_REF_PREFIX_LEN + constants_1.HASH_REF_HASH_LEN;
+// The JSON key prefix we scan for in the source map stream.
+const MAPPINGS_KEY_BUF = Buffer.from('"mappings":"');
 /**
  * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
  */
@@ -134,36 +138,16 @@ async function run({ input, options, api }) {
         ? []
         : undefined;
     await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
-    const hasSourceMap = (0, feature_flags_1.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;
         if ((0, feature_flags_1.getFeatureFlag)('fixSourceMapHashRefs') &&
             bundleReplacements &&
             bundleReplacements.length > 0) {
-            const mapEntry = (0, feature_flags_1.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 source_map_1.default(projectRoot, mapBuffer);
-            applyReplacementsToSourceMap(sourceMap, bundleReplacements);
-            const mapJson = await sourceMap.stringify({
-                format: 'string',
-                file: name,
-                sourceRoot: computeSourceMapRoot(bundle, options),
-            });
-            mapStream = (0, utils_1.blobToStream)(Buffer.from(typeof mapJson === 'string' ? mapJson : JSON.stringify(mapJson), 'utf8'));
+            mapStream = (0, utils_1.blobToStream)(mapEntry).pipe(new SourceMapHashRefRewriteStream(bundleReplacements));
         }
         else {
-            const mapEntry = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
-                ? await options.cache.getLargeBlob(mapKey)
-                : await options.cache.getBlob(mapKey);
             mapStream = (0, utils_1.blobToStream)(mapEntry);
         }
         await writeFiles(mapStream, info, hashRefToNameHash, options, config, outputFS, (0, projectPath_1.toProjectPathUnsafe)((0, projectPath_1.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
@@ -198,6 +182,167 @@ function applyReplacementsToSourceMap(sourceMap, replacements) {
         }
     }
 }
+/**
+ * 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.
+ */
+function applyReplacementsToVLQMappings(mappings, replacements) {
+    if (replacements.length === 0)
+        return mappings;
+    // Group replacements by line (0-indexed), sorted by column ascending.
+    const byLine = new Map();
+    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 = [];
+    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 = [];
+        const absCols = [];
+        let absCol = 0;
+        for (const seg of segments) {
+            const { value: colDelta, nextPos } = (0, source_map_1.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 = [];
+        let prevAbsCol = 0;
+        for (let i = 0; i < segments.length; i++) {
+            const newDelta = absCols[i] - prevAbsCol;
+            prevAbsCol = absCols[i];
+            resultSegments.push((0, source_map_1.encodeVLQ)(newDelta) + segments[i].slice(colVlqEnds[i]));
+        }
+        resultLines.push(resultSegments.join(','));
+    }
+    return resultLines.join(';');
+}
+/**
+ * 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.
+ */
+class SourceMapHashRefRewriteStream extends stream_1.Transform {
+    constructor(replacements) {
+        super();
+        this.replacements = replacements;
+        this.state = 'scanning';
+        this.scanBuf = Buffer.alloc(0);
+        this.mappingsBufs = [];
+    }
+    // @ts-expect-error TS7006
+    _transform(chunk, _encoding, cb) {
+        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
+    _bufferingTransform(chunk, cb) {
+        // 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) {
+        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();
+    }
+}
+exports.SourceMapHashRefRewriteStream = SourceMapHashRefRewriteStream;
 /**
  * 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/dist/resolveOptions.js

@@ -133,10 +133,8 @@ async function resolveOptions(initialOptions) {
             return initialOptions.cache;
         }
         const needsRustLmdbCache = (0, feature_flags_1.getFeatureFlag)('atlaspackV3') || (0, feature_flags_1.getFeatureFlag)('nativePackager');
-        if (!(0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            if (!needsRustLmdbCache && !(outputFS instanceof fs_1.NodeFS)) {
-                return new cache_1.FSCache(outputFS, cacheDir);
-            }
+        if (!needsRustLmdbCache && !(outputFS instanceof fs_1.NodeFS)) {
+            return new cache_1.FSCache(outputFS, cacheDir);
         }
         return new cache_1.LMDBLiteCache(cacheDir);
     }

package/lib/AssetGraph.js

@@ -108,32 +108,16 @@ function nodeFromEntryFile(entry) {
 
 // @ts-expect-error TS2417
 class AssetGraph extends _graph().ContentGraph {
-  /**
-   * Incremented when the asset graph is modified such that it requires a bundling pass.
-   */
-  #bundlingVersion = 0;
-  /**
-   * Force incremental bundling to be disabled.
-   */
-  #disableIncrementalBundling = false;
-
-  /**
-   * @deprecated
-   */
   safeToIncrementallyBundle = true;
   constructor(opts) {
     if (opts) {
       let {
         hash,
-        bundlingVersion,
-        disableIncrementalBundling,
         ...rest
       } = opts;
       // @ts-expect-error TS2345
       super(rest);
       this.hash = hash;
-      this.#bundlingVersion = bundlingVersion ?? 0;
-      this.#disableIncrementalBundling = disableIncrementalBundling ?? false;
     } else {
       super();
       this.setRootNodeId(this.addNode({
@@ -151,57 +135,16 @@ class AssetGraph extends _graph().ContentGraph {
   serialize() {
     return {
       ...super.serialize(),
-      bundlingVersion: this.#bundlingVersion,
-      disableIncrementalBundling: this.#disableIncrementalBundling,
       hash: this.hash
     };
   }
 
   /**
-   * Force incremental bundling to be disabled.
-   */
-  setDisableIncrementalBundling(disable) {
-    this.#disableIncrementalBundling = disable;
-  }
-  testing_getDisableIncrementalBundling() {
-    return this.#disableIncrementalBundling;
-  }
-
-  /**
-   * Make sure this asset graph is marked as needing a full bundling pass.
-   */
-  setNeedsBundling() {
-    if (!(0, _featureFlags().getFeatureFlag)('incrementalBundlingVersioning')) {
-      // In legacy mode, we rely solely on safeToIncrementallyBundle to
-      // invalidate incremental bundling, so we skip bumping the version.
-      return;
-    }
-    this.#bundlingVersion += 1;
-  }
-
-  /**
-   * Get the current bundling version.
-   *
-   * Each bundle pass should keep this version around. Whenever an asset graph has a new version,
-   * bundling should be re-run.
-   */
-  getBundlingVersion() {
-    if (!(0, _featureFlags().getFeatureFlag)('incrementalBundlingVersioning')) {
-      return 0;
-    }
-    return this.#bundlingVersion;
-  }
-
-  /**
-   * If the `bundlingVersion` has not changed since the last bundling pass,
-   * we can incrementally bundle, which will not require a full bundling pass
+   * Determine if we can incrementally bundle, which will not require a full bundling pass
    * but just update assets into the bundle graph output.
    */
-  canIncrementallyBundle(lastVersion) {
-    if (!(0, _featureFlags().getFeatureFlag)('incrementalBundlingVersioning')) {
-      return this.safeToIncrementallyBundle && !this.#disableIncrementalBundling;
-    }
-    return this.safeToIncrementallyBundle && this.#bundlingVersion === lastVersion && !this.#disableIncrementalBundling;
+  canIncrementallyBundle() {
+    return this.safeToIncrementallyBundle;
   }
 
   // Deduplicates Environments by making them referentially equal
@@ -381,13 +324,11 @@ class AssetGraph extends _graph().ContentGraph {
         // @ts-expect-error TS2339
         if (!(ctx !== null && ctx !== void 0 && ctx.hasDeferred)) {
           this.safeToIncrementallyBundle = false;
-          this.setNeedsBundling();
           delete traversedNode.hasDeferred;
         }
         actions.skipChildren();
       } else if (traversedNode.type === 'dependency') {
         this.safeToIncrementallyBundle = false;
-        this.setNeedsBundling();
         traversedNode.hasDeferred = false;
       } else if (nodeId !== traversedNodeId) {
         actions.skipChildren();

package/lib/BundleGraph.js

@@ -516,6 +516,44 @@ class BundleGraph {
     };
   }
 
+  /**
+   * Serialize only the given asset nodes for native incremental update.
+   * Same node shape and env/omit logic as serializeForNative.
+   */
+  serializeAssetNodesForNative(assetIds) {
+    const start = performance.now();
+    if (assetIds.length === 0) {
+      return '[]';
+    }
+    const nodes = [];
+    for (const assetId of assetIds) {
+      var _node$value4;
+      const node = this._graph.getNodeByContentKey(assetId);
+      if ((node === null || node === void 0 ? void 0 : node.type) !== 'asset') {
+        continue;
+      }
+      const processedNode = {
+        ...node
+      };
+      if ((_node$value4 = node.value) !== null && _node$value4 !== void 0 && _node$value4.env) {
+        processedNode.value = {
+          ...node.value,
+          env: (0, _EnvironmentManager.fromEnvironmentId)(node.value.env).id
+        };
+      }
+      nodes.push(processedNode);
+    }
+    const optimizedNodes = nodes.map(node => this._omitNulls(node));
+    const nodesJson = JSON.stringify(optimizedNodes);
+    const duration = performance.now() - start;
+    const nodesSizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+    _logger().default.verbose({
+      origin: '@atlaspack/core',
+      message: `serializeAssetNodesForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${nodes.length} nodes`
+    });
+    return nodesJson;
+  }
+
   /**
    * Remove null and undefined values from an object to reduce JSON size.
    * Preserves false, 0, empty strings, and arrays.

package/lib/PackagerRunner.js

@@ -87,13 +87,6 @@ function _profiler() {
   return data;
 }
 var _EnvironmentManager = require("./EnvironmentManager");
-function _featureFlags() {
-  const data = require("@atlaspack/feature-flags");
-  _featureFlags = function () {
-    return data;
-  };
-  return data;
-}
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -437,10 +430,6 @@ class PackagerRunner {
       devDepHashes += await this.getDevDepHashes(inlineBundle);
     }
     let invalidationHash = await (0, _assetUtils.getInvalidationHash)(invalidations, this.options);
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      const hash = (0, _rust().hashString)(_constants.ATLASPACK_VERSION + devDepHashes + invalidationHash + bundle.target.publicUrl + bundleGraph.getHash(bundle) + JSON.stringify(configResults) + JSON.stringify(globalInfoResults) + this.options.mode + (this.options.shouldBuildLazily ? 'lazy' : 'eager'));
-      return _path().default.join(bundle.displayName ?? bundle.name ?? bundle.id, hash);
-    }
     return (0, _rust().hashString)(_constants.ATLASPACK_VERSION + devDepHashes + invalidationHash + bundle.target.publicUrl + bundleGraph.getHash(bundle) + JSON.stringify(configResults) + JSON.stringify(globalInfoResults) + this.options.mode + (this.options.shouldBuildLazily ? 'lazy' : 'eager'));
   }
   async getDevDepHashes(bundle) {
@@ -464,14 +453,14 @@ class PackagerRunner {
     let contentKey = PackagerRunner.getContentKey(cacheKey);
     let mapKey = PackagerRunner.getMapKey(cacheKey);
     let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? isLargeBlob : isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists = isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
-    let mapExists = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await this.options.cache.hasLargeBlob(mapKey) : await this.options.cache.has(mapKey);
+    let mapExists = await this.options.cache.has(mapKey);
     return {
       contents: isLargeBlob ? this.options.cache.getStream(contentKey) : (0, _utils().blobToStream)(await this.options.cache.getBlob(contentKey)),
-      map: mapExists ? (0, _utils().blobToStream)((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await this.options.cache.getLargeBlob(mapKey) : await this.options.cache.getBlob(mapKey)) : null
+      map: mapExists ? (0, _utils().blobToStream)(await this.options.cache.getBlob(mapKey)) : null
     };
   }
   async writeToCache(cacheKeys, type, contents, map) {
@@ -479,13 +468,11 @@ class PackagerRunner {
     let hash;
     // @ts-expect-error TS2702
     let hashReferences = [];
-    let isLargeBlob = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements');
+    let isLargeBlob = false;
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof _stream().Readable) {
-      if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        isLargeBlob = true;
-      }
+      isLargeBlob = true;
       let boundaryStr = '';
       let h = new (_rust().Hash)();
       await this.options.cache.setStream(cacheKeys.content, (0, _utils().blobToStream)(contents).pipe(
@@ -503,27 +490,15 @@ class PackagerRunner {
       size = buffer.byteLength;
       hash = (0, _rust().hashBuffer)(buffer);
       hashReferences = contents.match(_constants.HASH_REF_REGEX) ?? [];
-      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.content, buffer);
-      }
+      await this.options.cache.setBlob(cacheKeys.content, buffer);
     } else {
       size = contents.length;
       hash = (0, _rust().hashBuffer)(contents);
       hashReferences = contents.toString().match(_constants.HASH_REF_REGEX) ?? [];
-      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.content, contents);
-      }
+      await this.options.cache.setBlob(cacheKeys.content, contents);
     }
     if (map != null) {
-      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.map, map);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.map, map);
-      }
+      await this.options.cache.setBlob(cacheKeys.map, map);
     }
     let info = {
       type,
@@ -537,21 +512,12 @@ class PackagerRunner {
     return info;
   }
   static getContentKey(cacheKey) {
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      return `PackagerRunner/${_constants.ATLASPACK_VERSION}/${cacheKey}/content`;
-    }
     return (0, _rust().hashString)(`${cacheKey}:content`);
   }
   static getMapKey(cacheKey) {
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      return `PackagerRunner/${_constants.ATLASPACK_VERSION}/${cacheKey}/map`;
-    }
     return (0, _rust().hashString)(`${cacheKey}:map`);
   }
   static getInfoKey(cacheKey) {
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      return `PackagerRunner/${_constants.ATLASPACK_VERSION}/${cacheKey}/info`;
-    }
     return (0, _rust().hashString)(`${cacheKey}:info`);
   }
 }