@atlaspack/core 2.33.1 → 2.35.0

package/lib/requests/WriteBundleRequest.js

@@ -3,6 +3,8 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.applyReplacementsToSourceMap = applyReplacementsToSourceMap;
+exports.computeSourceMapRoot = computeSourceMapRoot;
 exports.default = createWriteBundleRequest;
 var _constants = require("../constants");
 function _nullthrows() {
@@ -19,6 +21,13 @@ function _path() {
   };
   return data;
 }
+function _url() {
+  const data = _interopRequireDefault(require("url"));
+  _url = function () {
+    return data;
+  };
+  return data;
+}
 var _Bundle = require("../public/Bundle");
 function _utils() {
   const data = require("@atlaspack/utils");
@@ -68,11 +77,19 @@ function _featureFlags() {
   return data;
 }
 var _EnvironmentManager = require("../EnvironmentManager");
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
+  _sourceMap = 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 }; }
 const HASH_REF_PREFIX_LEN = _constants.HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = _constants.HASH_REF_PREFIX.length + 32 - 1;
+const HASH_REF_PLACEHOLDER_LEN = HASH_REF_PREFIX_LEN + _constants.HASH_REF_HASH_LEN;
 /**
  * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
  */
@@ -158,11 +175,28 @@ async function run({
     invalidDevDeps
   } = await (0, _DevDepRequest.getDevDepRequests)(api);
   (0, _DevDepRequest.invalidateDevDeps)(invalidDevDeps, options, config);
-  await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
-  const hasSourceMap = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.hasLargeBlob(mapKey) : await options.cache.has(mapKey);
+  const bundleReplacements = (0, _featureFlags().getFeatureFlag)('fixSourceMapHashRefs') ? [] : undefined;
+  await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
+  const hasSourceMap = await options.cache.has(mapKey);
   if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
-    const mapEntry = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.getLargeBlob(mapKey) : await options.cache.getBlob(mapKey);
-    await writeFiles((0, _utils().blobToStream)(mapEntry), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
+    let mapStream;
+    if ((0, _featureFlags().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().default)(projectRoot, mapBuffer);
+      applyReplacementsToSourceMap(sourceMap, bundleReplacements);
+      const mapJson = await sourceMap.stringify({
+        format: 'string',
+        file: name,
+        sourceRoot: computeSourceMapRoot(bundle, options)
+      });
+      mapStream = (0, _utils().blobToStream)(Buffer.from(typeof mapJson === 'string' ? mapJson : JSON.stringify(mapJson), 'utf8'));
+    } else {
+      const mapEntry = await options.cache.getBlob(mapKey);
+      mapStream = (0, _utils().blobToStream)(mapEntry);
+    }
+    await writeFiles(mapStream, info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
   }
   let res = {
     filePath,
@@ -176,12 +210,71 @@ async function run({
   api.storeResult(res);
   return res;
 }
+function applyReplacementsToSourceMap(sourceMap, replacements) {
+  if (replacements.length === 0) return;
+  const sorted = [...replacements].sort((a, b) => a.line - b.line || a.column - b.column);
+  for (const r of sorted) {
+    const delta = r.newLength - r.originalLength;
+    if (delta !== 0) {
+      // r.column is in post-replacement coordinates (matching the already-shifted
+      // source map state after previous offsetColumns calls). The end of the
+      // placeholder in these coordinates is simply r.column + r.originalLength.
+      const offsetStartColumn = r.column + r.originalLength;
+      const line1Based = r.line + 1;
+      if (line1Based >= 1 && offsetStartColumn + delta >= 0) {
+        sourceMap.offsetColumns(line1Based, offsetStartColumn, delta);
+      }
+    }
+  }
+}
+
+/**
+ * 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
+ * relative to projectRoot) resolve correctly from the .map file location.
+ *
+ * Returns undefined when sources are inlined (inlineSources), since the browser
+ * doesn't need to fetch them and sourceRoot would be unnecessary.
+ *
+ * This logic must stay in sync with PackagerRunner.generateSourceMap.
+ */
+function computeSourceMapRoot(bundle, options) {
+  let name = (0, _nullthrows().default)(bundle.name);
+  let filePath = (0, _projectPath.joinProjectPath)(bundle.target.distDir, name);
+  let fullPath = (0, _projectPath.fromProjectPath)(options.projectRoot, filePath);
+  let sourceRoot = _path().default.relative(_path().default.dirname(fullPath), options.projectRoot);
+  let inlineSources = false;
+  const bundleEnv = (0, _EnvironmentManager.fromEnvironmentId)(bundle.env);
+  if (bundle.target) {
+    const bundleTargetEnv = (0, _EnvironmentManager.fromEnvironmentId)(bundle.target.env);
+    if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
+      sourceRoot = bundleEnv.sourceMap.sourceRoot;
+    } else if (options.serveOptions && bundleTargetEnv.context === 'browser') {
+      sourceRoot = '/__parcel_source_root';
+    }
+    if (bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources !== undefined) {
+      inlineSources = bundleEnv.sourceMap.inlineSources;
+    } else if (bundleTargetEnv.context !== 'node') {
+      inlineSources = options.mode === 'production';
+    }
+  }
+  let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
+  if ((0, _featureFlags().getFeatureFlag)('omitSourcesContentInMemory') && !isInlineMap) {
+    if (!(bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources === false)) {
+      inlineSources = true;
+    }
+  }
+  if (inlineSources) {
+    return undefined;
+  }
+  return _url().default.format(_url().default.parse(sourceRoot + '/'));
+}
 async function writeFiles(
 // @ts-expect-error TS2503
-inputStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api) {
+inputStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements) {
   let compressors = await config.getCompressors((0, _projectPath.fromProjectPathRelative)(filePath));
   let fullPath = (0, _projectPath.fromProjectPath)(options.projectRoot, filePath);
-  let stream = info.hashReferences.length ? inputStream.pipe(replaceStream(hashRefToNameHash)) : inputStream;
+  let stream = info.hashReferences.length ? inputStream.pipe(replaceStream(hashRefToNameHash, bundleReplacements)) : inputStream;
   let promises = [];
   for (let compressor of compressors) {
     promises.push(
@@ -230,9 +323,25 @@ stream, options, outputFS, filePath, writeOptions, devDeps, api) {
     await (0, _DevDepRequest.runDevDepRequest)(api, devDepRequest);
   }
 }
-function replaceStream(hashRefToNameHash) {
+function advanceLineColumn(line, column, buf) {
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] === 0x0a) {
+      line++;
+      column = 0;
+    } else {
+      column++;
+    }
+  }
+  return {
+    line,
+    column
+  };
+}
+function replaceStream(hashRefToNameHash, replacements) {
   let boundaryStr = Buffer.alloc(0);
   let replaced = Buffer.alloc(0);
+  let outputLine = 0;
+  let outputColumn = 0;
   return new (_stream().Transform)({
     transform(chunk, encoding, cb) {
       let str = Buffer.concat([boundaryStr, Buffer.from(chunk)]);
@@ -250,15 +359,29 @@ function replaceStream(hashRefToNameHash) {
         } else {
           let match = str.subarray(matchI, matchI + HASH_REF_PREFIX_LEN + _constants.HASH_REF_HASH_LEN).toString();
           let replacement = Buffer.from(hashRefToNameHash.get(match) ?? match);
+          // Copy pre-match content FIRST so position calculation includes it
           replaced.set(str.subarray(lastMatchI, matchI), replacedLength);
           replacedLength += matchI - lastMatchI;
+          if (replacements) {
+            const pos = advanceLineColumn(outputLine, outputColumn, replaced.subarray(0, replacedLength));
+            replacements.push({
+              line: pos.line,
+              column: pos.column,
+              originalLength: HASH_REF_PLACEHOLDER_LEN,
+              newLength: replacement.byteLength
+            });
+          }
           replaced.set(replacement, replacedLength);
           replacedLength += replacement.byteLength;
           lastMatchI = matchI + HASH_REF_PREFIX_LEN + _constants.HASH_REF_HASH_LEN;
         }
       }
+      const pushLen = replacedLength - BOUNDARY_LENGTH;
+      const pushed = advanceLineColumn(outputLine, outputColumn, replaced.subarray(0, pushLen));
+      outputLine = pushed.line;
+      outputColumn = pushed.column;
       boundaryStr = replaced.subarray(replacedLength - BOUNDARY_LENGTH, replacedLength);
-      let strUpToBoundary = replaced.subarray(0, replacedLength - BOUNDARY_LENGTH);
+      let strUpToBoundary = replaced.subarray(0, pushLen);
       cb(null, strUpToBoundary);
     },
     flush(cb) {

package/lib/requests/WriteBundlesRequest.js

@@ -40,6 +40,13 @@ function _utils() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/** Length of the hash suffix in output filenames (e.g. .runtime.13dc01ac.js). */
+const NAME_HASH_DISPLAY_LEN = 8;
+
+/** Use at most NAME_HASH_DISPLAY_LEN chars for the name hash so filenames stay short. */
+function nameHashForFilename(hash) {
+  return hash.length <= NAME_HASH_DISPLAY_LEN ? hash : hash.slice(-NAME_HASH_DISPLAY_LEN);
+}
 function reportPackagingProgress(completeBundles, totalBundles) {
   if (!(0, _featureFlags().getFeatureFlag)('cliProgressReportingImprovements')) {
     return;
@@ -92,9 +99,9 @@ async function run({
     // Do not package and write placeholder bundles to disk. We just
     // need to update the name so other bundles can reference it.
     if (bundle.isPlaceholder) {
-      let hash = bundle.id.slice(-8);
-      hashRefToNameHash.set(bundle.hashReference, hash);
-      let name = (0, _nullthrows().default)(bundle.name, `Expected ${bundle.type} bundle to have a name`).replace(bundle.hashReference, hash);
+      const nameHash = nameHashForFilename(bundle.id);
+      hashRefToNameHash.set(bundle.hashReference, nameHash);
+      let name = (0, _nullthrows().default)(bundle.name, `Expected ${bundle.type} bundle to have a name`).replace(bundle.hashReference, nameHash);
       res.set(bundle.id, {
         filePath: (0, _projectPath.joinProjectPath)(bundle.target.distDir, name),
         bundleId: bundle.id,
@@ -143,7 +150,7 @@ async function run({
       }
       bundleInfoMap[bundle.id] = info;
       if (!info.hashReferences.length) {
-        hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash ? info.hash.slice(-8) : bundle.id.slice(-8));
+        hashRefToNameHash.set(bundle.hashReference, nameHashForFilename(options.shouldContentHash ? info.hash : bundle.id));
         let writeBundleRequest = (0, _WriteBundleRequest.default)({
           bundle,
           info,
@@ -195,7 +202,7 @@ function assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, opti
     if (hashRefToNameHash.get(bundle.hashReference) != null) {
       continue;
     }
-    hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash ? (0, _rust().hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)].map(bundleId => bundleInfoMap[bundleId].hash).join(':')).slice(-8) : bundle.id.slice(-8));
+    hashRefToNameHash.set(bundle.hashReference, nameHashForFilename(options.shouldContentHash ? (0, _rust().hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)].map(bundleId => bundleInfoMap[bundleId].hash).join(':')) : bundle.id));
   }
 }
 function getBundlesIncludedInHash(bundleId, bundleInfoMap, included = new Set()) {

package/lib/resolveOptions.js

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

package/lib/types/AssetGraph.d.ts

@@ -9,13 +9,9 @@ type InitOpts = {
     assetGroups?: Array<AssetGroup>;
 };
 type AssetGraphOpts = ContentGraphOpts<AssetGraphNode> & {
-    bundlingVersion?: number;
-    disableIncrementalBundling?: boolean;
     hash?: string | null | undefined;
 };
 type SerializedAssetGraph = SerializedContentGraph<AssetGraphNode> & {
-    bundlingVersion: number;
-    disableIncrementalBundling: boolean;
     hash?: string | null | undefined;
 };
 export declare function nodeFromDep(dep: Dependency): DependencyNode;
@@ -24,40 +20,19 @@ export declare function nodeFromAsset(asset: Asset): AssetNode;
 export declare function nodeFromEntrySpecifier(entry: ProjectPath): EntrySpecifierNode;
 export declare function nodeFromEntryFile(entry: Entry): EntryFileNode;
 export default class AssetGraph extends ContentGraph<AssetGraphNode> {
-    #private;
     onNodeRemoved: ((nodeId: NodeId) => unknown) | null | undefined;
     hash: string | null | undefined;
     envCache: Map<string, Environment>;
-    /**
-     * @deprecated
-     */
     safeToIncrementallyBundle: boolean;
     undeferredDependencies: Set<Dependency>;
     constructor(opts?: AssetGraphOpts | null);
     static deserialize(opts: AssetGraphOpts): AssetGraph;
     serialize(): SerializedAssetGraph;
     /**
-     * Force incremental bundling to be disabled.
-     */
-    setDisableIncrementalBundling(disable: boolean): void;
-    testing_getDisableIncrementalBundling(): boolean;
-    /**
-     * Make sure this asset graph is marked as needing a full bundling pass.
-     */
-    setNeedsBundling(): void;
-    /**
-     * 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(): number;
-    /**
-     * 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: number): boolean;
+    canIncrementallyBundle(): boolean;
     normalizeEnvironment(input: Asset | Dependency | AssetGroup): void;
     setRootConnections({ entries, assetGroups }: InitOpts): void;
     addNode(node: AssetGraphNode): NodeId;

package/lib/types/BundleGraph.d.ts

@@ -87,6 +87,11 @@ export default class BundleGraph {
         publicIdByAssetId: Record<string, string>;
         environmentsJson: string;
     };
+    /**
+     * Serialize only the given asset nodes for native incremental update.
+     * Same node shape and env/omit logic as serializeForNative.
+     */
+    serializeAssetNodesForNative(assetIds: Array<string>): string;
     /**
      * Remove null and undefined values from an object to reduce JSON size.
      * Preserves false, 0, empty strings, and arrays.

package/lib/types/atlaspack-v3/AtlaspackV3.d.ts

@@ -1,4 +1,4 @@
-import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions, CacheStats } from '@atlaspack/rust';
+import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions, CacheStats, PackageOptions } from '@atlaspack/rust';
 import { Diagnostic } from '@atlaspack/diagnostic';
 import type { Event } from '@parcel/watcher';
 import type { NapiWorkerPool as INapiWorkerPool } from '@atlaspack/types';
@@ -27,7 +27,8 @@ export declare class AtlaspackV3 {
     buildAssetGraph(): Promise<any>;
     buildBundleGraph(): Promise<any>;
     loadBundleGraph(bundleGraph: BundleGraph): Promise<void>;
-    package(bundleId: string): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
+    updateBundleGraph(bundleGraph: BundleGraph, changedAssetIds: string[]): Promise<void>;
+    package(bundleId: string, options?: PackageOptions): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
     respondToFsEvents(events: Array<Event>): Promise<boolean>;
     completeCacheSession(): Promise<CacheStats>;
 }

package/lib/types/requests/BundleGraphRequest.d.ts

@@ -14,9 +14,9 @@ type RunInput = {
 } & StaticRunOpts<BundleGraphResult>;
 export type BundleGraphResult = {
     bundleGraph: InternalBundleGraph;
-    assetGraphBundlingVersion: number;
     changedAssets: Map<string, Asset>;
     assetRequests: Array<AssetGroup>;
+    didIncrementallyBundle: boolean;
 };
 type BundleGraphRequest = {
     id: string;

package/lib/types/requests/WriteBundleRequest.d.ts

@@ -1,10 +1,17 @@
 import type { ContentKey } from '@atlaspack/graph';
 import type { Async } from '@atlaspack/types';
 import type { StaticRunOpts } from '../RequestTracker';
-import type { Bundle, PackagedBundleInfo } from '../types';
+import type { Bundle, PackagedBundleInfo, AtlaspackOptions } from '../types';
 import type BundleGraph from '../BundleGraph';
 import type { BundleInfo } from '../PackagerRunner';
 import { requestTypes } from '../RequestTracker';
+import SourceMap from '@atlaspack/source-map';
+export type HashRefReplacement = {
+    line: number;
+    column: number;
+    originalLength: number;
+    newLength: number;
+};
 type WriteBundleRequestInput = {
     bundleGraph: BundleGraph;
     bundle: Bundle;
@@ -25,4 +32,16 @@ export type WriteBundleRequest = {
  * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
  */
 export default function createWriteBundleRequest(input: WriteBundleRequestInput): WriteBundleRequest;
+export declare function applyReplacementsToSourceMap(sourceMap: SourceMap, replacements: HashRefReplacement[]): void;
+/**
+ * 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
+ * relative to projectRoot) resolve correctly from the .map file location.
+ *
+ * Returns undefined when sources are inlined (inlineSources), since the browser
+ * doesn't need to fetch them and sourceRoot would be unnecessary.
+ *
+ * This logic must stay in sync with PackagerRunner.generateSourceMap.
+ */
+export declare function computeSourceMapRoot(bundle: Bundle, options: AtlaspackOptions): string | undefined;
 export {};

package/lib/types/types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.33.1",
+  "version": "2.35.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -23,22 +23,22 @@
   },
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@atlaspack/build-cache": "2.13.11",
-    "@atlaspack/cache": "3.2.48",
+    "@atlaspack/build-cache": "2.13.13",
+    "@atlaspack/cache": "3.2.50",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.29.1",
-    "@atlaspack/fs": "2.15.48",
-    "@atlaspack/graph": "3.6.15",
-    "@atlaspack/logger": "2.14.45",
-    "@atlaspack/package-manager": "2.14.53",
-    "@atlaspack/plugin": "2.14.53",
-    "@atlaspack/profiler": "2.15.14",
-    "@atlaspack/rust": "3.22.1",
-    "@atlaspack/types": "2.15.43",
-    "@atlaspack/utils": "3.3.5",
-    "@atlaspack/workers": "2.14.53",
-    "@atlaspack/source-map": "3.2.8",
+    "@atlaspack/feature-flags": "2.30.1",
+    "@atlaspack/fs": "2.15.50",
+    "@atlaspack/graph": "3.6.17",
+    "@atlaspack/logger": "2.14.47",
+    "@atlaspack/package-manager": "2.14.55",
+    "@atlaspack/plugin": "2.14.55",
+    "@atlaspack/profiler": "2.15.16",
+    "@atlaspack/rust": "3.24.0",
+    "@atlaspack/types": "2.15.45",
+    "@atlaspack/utils": "3.3.7",
+    "@atlaspack/workers": "2.14.55",
+    "@atlaspack/source-map": "3.2.10",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",

package/src/AssetGraph.ts

@@ -41,14 +41,10 @@ type InitOpts = {
 };
 
 type AssetGraphOpts = ContentGraphOpts<AssetGraphNode> & {
-  bundlingVersion?: number;
-  disableIncrementalBundling?: boolean;
   hash?: string | null | undefined;
 };
 
 type SerializedAssetGraph = SerializedContentGraph<AssetGraphNode> & {
-  bundlingVersion: number;
-  disableIncrementalBundling: boolean;
   hash?: string | null | undefined;
 };
 
@@ -121,30 +117,16 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   hash: string | null | undefined;
   envCache: Map<string, Environment>;
 
-  /**
-   * Incremented when the asset graph is modified such that it requires a bundling pass.
-   */
-  #bundlingVersion: number = 0;
-  /**
-   * Force incremental bundling to be disabled.
-   */
-  #disableIncrementalBundling: boolean = false;
-
-  /**
-   * @deprecated
-   */
   safeToIncrementallyBundle: boolean = true;
 
   undeferredDependencies: Set<Dependency>;
 
   constructor(opts?: AssetGraphOpts | null) {
     if (opts) {
-      let {hash, bundlingVersion, disableIncrementalBundling, ...rest} = opts;
+      let {hash, ...rest} = opts;
       // @ts-expect-error TS2345
       super(rest);
       this.hash = hash;
-      this.#bundlingVersion = bundlingVersion ?? 0;
-      this.#disableIncrementalBundling = disableIncrementalBundling ?? false;
     } else {
       super();
       this.setRootNodeId(
@@ -167,64 +149,16 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   serialize(): SerializedAssetGraph {
     return {
       ...super.serialize(),
-      bundlingVersion: this.#bundlingVersion,
-      disableIncrementalBundling: this.#disableIncrementalBundling,
       hash: this.hash,
     };
   }
 
   /**
-   * Force incremental bundling to be disabled.
-   */
-  setDisableIncrementalBundling(disable: boolean) {
-    this.#disableIncrementalBundling = disable;
-  }
-
-  testing_getDisableIncrementalBundling(): boolean {
-    return this.#disableIncrementalBundling;
-  }
-
-  /**
-   * Make sure this asset graph is marked as needing a full bundling pass.
-   */
-  setNeedsBundling() {
-    if (!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(): number {
-    if (!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: number): boolean {
-    if (!getFeatureFlag('incrementalBundlingVersioning')) {
-      return (
-        this.safeToIncrementallyBundle && !this.#disableIncrementalBundling
-      );
-    }
-    return (
-      this.safeToIncrementallyBundle &&
-      this.#bundlingVersion === lastVersion &&
-      !this.#disableIncrementalBundling
-    );
+  canIncrementallyBundle(): boolean {
+    return this.safeToIncrementallyBundle;
   }
 
   // Deduplicates Environments by making them referentially equal
@@ -447,13 +381,11 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         // @ts-expect-error TS2339
         if (!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/src/BundleGraph.ts

@@ -654,6 +654,45 @@ export default class BundleGraph {
     return {nodesJson, edges, publicIdByAssetId, environmentsJson};
   }
 
+  /**
+   * Serialize only the given asset nodes for native incremental update.
+   * Same node shape and env/omit logic as serializeForNative.
+   */
+  serializeAssetNodesForNative(assetIds: Array<string>): string {
+    const start = performance.now();
+
+    if (assetIds.length === 0) {
+      return '[]';
+    }
+
+    const nodes: Array<BundleGraphNode> = [];
+    for (const assetId of assetIds) {
+      const node = this._graph.getNodeByContentKey(assetId);
+      if (node?.type !== 'asset') {
+        continue;
+      }
+      const processedNode = {...node};
+      if (node.value?.env) {
+        processedNode.value = {
+          ...node.value,
+          env: 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.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.