@atlaspack/core 2.34.0 → 2.36.0

package/lib/requests/BundleGraphRequestUtils.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.dumpBundleGraphSnapshot = dumpBundleGraphSnapshot;
 exports.loadPluginConfigWithDevDeps = loadPluginConfigWithDevDeps;
 exports.nameBundle = nameBundle;
 exports.runDevDepRequest = runDevDepRequest;
@@ -14,6 +15,13 @@ function _assert() {
   };
   return data;
 }
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
   _nullthrows = function () {
@@ -21,6 +29,13 @@ function _nullthrows() {
   };
   return data;
 }
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
 function _logger() {
   const data = require("@atlaspack/logger");
   _logger = function () {
@@ -42,7 +57,8 @@ function _utils() {
   };
   return data;
 }
-var _BundleGraph = _interopRequireDefault(require("../public/BundleGraph"));
+var _BundleGraph = require("../BundleGraph");
+var _BundleGraph2 = _interopRequireDefault(require("../public/BundleGraph"));
 var _Bundle = require("../public/Bundle");
 var _InternalConfig = require("../InternalConfig");
 var _DevDepRequest = require("./DevDepRequest");
@@ -75,12 +91,126 @@ function validateBundles(bundleGraph) {
   _assert().default.deepEqual(bundleNames, (0, _utils().unique)(bundleNames), 'Bundles must have unique name. Conflicting names: ' + [...(0, _utils().setSymmetricDifference)(new Set(bundleNames), new Set((0, _utils().unique)(bundleNames)))].join());
 }
 
+/**
+ * Dump a canonical JSON snapshot of the bundle graph for parity comparison.
+ * Gated by ATLASPACK_DUMP_BUNDLE_GRAPH environment variable which specifies the output directory.
+ * The snapshot captures bundle identity, type, contained assets, and bundle group structure
+ * in a deterministic, sorted format suitable for diffing.
+ */
+function dumpBundleGraphSnapshot(bundleGraph, variant) {
+  let outDir = process.env.ATLASPACK_DUMP_BUNDLE_GRAPH;
+  if (!outDir) return;
+  let filename = variant === 'js' ? 'bundle-graph-js.json' : 'bundle-graph-rust.json';
+  let outPath = _path().default.join(outDir, filename);
+  _fs().default.mkdirSync(outDir, {
+    recursive: true
+  });
+  let bundles = bundleGraph.getBundles();
+  let bundlesSnapshot = bundles.map(bundle => {
+    let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
+    let containedAssetNodeIds = bundleGraph._graph.getNodeIdsConnectedFrom(bundleNodeId, _BundleGraph.bundleGraphEdgeTypes.contains);
+    let containedAssets = containedAssetNodeIds.map(nodeId => bundleGraph._graph.getNode(nodeId)).flatMap(node => {
+      if ((node === null || node === void 0 ? void 0 : node.type) !== 'asset') return [];
+      return [{
+        id: node.value.id,
+        filePath: (0, _projectPath.fromProjectPathRelative)(node.value.filePath)
+      }];
+    }).sort((a, b) => a.filePath.localeCompare(b.filePath));
+
+    // Resolve mainEntry and entry asset file paths
+    let mainEntryPath = null;
+    let entryAssetPaths = [];
+    if (bundle.mainEntryId) {
+      let mainEntryNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.mainEntryId);
+      let mainEntryNode = bundleGraph._graph.getNode(mainEntryNodeId);
+      if ((mainEntryNode === null || mainEntryNode === void 0 ? void 0 : mainEntryNode.type) === 'asset') {
+        mainEntryPath = (0, _projectPath.fromProjectPathRelative)(mainEntryNode.value.filePath);
+      }
+    }
+    for (let entryId of bundle.entryAssetIds) {
+      let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(entryId);
+      let entryNode = bundleGraph._graph.getNode(entryNodeId);
+      if ((entryNode === null || entryNode === void 0 ? void 0 : entryNode.type) === 'asset') {
+        entryAssetPaths.push((0, _projectPath.fromProjectPathRelative)(entryNode.value.filePath));
+      }
+    }
+    entryAssetPaths.sort();
+    return {
+      id: bundle.id,
+      type: bundle.type,
+      bundleBehavior: bundle.bundleBehavior ?? null,
+      needsStableName: bundle.needsStableName,
+      isSplittable: bundle.isSplittable,
+      isPlaceholder: bundle.isPlaceholder,
+      mainEntryPath,
+      entryAssetPaths,
+      assets: containedAssets.map(a => a.filePath)
+    };
+  }).sort((a, b) => {
+    // Sort by mainEntryPath first, then by sorted assets as tiebreaker
+    let aKey = a.mainEntryPath || a.assets.join(',');
+    let bKey = b.mainEntryPath || b.assets.join(',');
+    return aKey.localeCompare(bKey);
+  });
+  let bundleGroupsSnapshot = bundleGraph._graph.nodes.flatMap(node => {
+    if ((node === null || node === void 0 ? void 0 : node.type) !== 'bundle_group') return [];
+    let bundleGroup = node.value;
+
+    // Resolve entry asset file path
+    let entryAssetPath = null;
+    try {
+      let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(bundleGroup.entryAssetId);
+      let entryNode = bundleGraph._graph.getNode(entryNodeId);
+      if ((entryNode === null || entryNode === void 0 ? void 0 : entryNode.type) === 'asset') {
+        entryAssetPath = (0, _projectPath.fromProjectPathRelative)(entryNode.value.filePath);
+      }
+    } catch {
+      // Content key not found
+    }
+    let bundlesInGroup = bundleGraph.getBundlesInBundleGroup(bundleGroup);
+    let bundlePaths = bundlesInGroup.map(b => {
+      // Use mainEntry file path if available, otherwise bundle id as fallback
+      if (b.mainEntryId) {
+        try {
+          let nodeId = bundleGraph._graph.getNodeIdByContentKey(b.mainEntryId);
+          let node = bundleGraph._graph.getNode(nodeId);
+          if ((node === null || node === void 0 ? void 0 : node.type) === 'asset') {
+            return (0, _projectPath.fromProjectPathRelative)(node.value.filePath);
+          }
+        } catch {
+          // fallback
+        }
+      }
+      return `[bundle:${b.id}]`;
+    }).sort();
+    return [{
+      entryAssetPath: entryAssetPath ?? `[unknown:${bundleGroup.entryAssetId}]`,
+      bundlePaths
+    }];
+  }).sort((a, b) => a.entryAssetPath.localeCompare(b.entryAssetPath));
+  let totalAssets = bundleGraph._graph.nodes.filter(node => (node === null || node === void 0 ? void 0 : node.type) === 'asset').length;
+  let snapshot = {
+    version: 1,
+    variant,
+    stats: {
+      totalBundles: bundlesSnapshot.length,
+      totalBundleGroups: bundleGroupsSnapshot.length,
+      totalAssets
+    },
+    bundles: bundlesSnapshot,
+    bundleGroups: bundleGroupsSnapshot
+  };
+  _fs().default.writeFileSync(outPath, JSON.stringify(snapshot, null, 2), 'utf8');
+  // eslint-disable-next-line no-console
+  console.log(`[BundleGraphSnapshot] Wrote ${variant} snapshot to ${outPath}`);
+}
+
 /**
  * Names a bundle by running through the configured namers until one returns a name.
  */
 async function nameBundle(namers, internalBundle, internalBundleGraph, options, pluginOptions, configs) {
   const bundle = _Bundle.Bundle.get(internalBundle, internalBundleGraph, options);
-  const bundleGraph = new _BundleGraph.default(internalBundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), options);
+  const bundleGraph = new _BundleGraph2.default(internalBundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), options);
   for (const namer of namers) {
     let measurement;
     try {

package/lib/requests/PackageRequest.js

@@ -70,7 +70,9 @@ async function run({
   let packagingResult;
   if ((0, _featureFlags().getFeatureFlag)('nativePackager') && (0, _featureFlags().getFeatureFlag)('nativePackagerSSRDev') && rustAtlaspack && (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context === 'tesseract' && bundle.type === 'js') {
     // Once this actually does something, the code below will be in an `else` block (i.e. we'll only run one or the other)
-    let result = await rustAtlaspack.package(bundle.id);
+    let result = await rustAtlaspack.package(bundle.id, {
+      inlineRequires: true
+    });
     let error = null;
     [packagingResult, error] = result;
     if (error) {

package/lib/requests/TargetRequest.js

@@ -247,6 +247,7 @@ class TargetResolver {
             name,
             distDir: (0, _projectPath.toProjectPath)(this.options.projectRoot, _path().default.resolve(this.fs.cwd(), distDir)),
             publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+            inlineRequires: descriptor.inlineRequires ?? false,
             env: (0, _Environment.createEnvironment)({
               engines: descriptor.engines,
               context: descriptor.context,
@@ -311,6 +312,7 @@ class TargetResolver {
           name: 'default',
           distDir: (0, _projectPath.toProjectPath)(this.options.projectRoot, this.options.serveOptions.distDir),
           publicUrl: this.options.defaultTargetOptions.publicUrl ?? '/',
+          inlineRequires: false,
           env: (0, _Environment.createEnvironment)({
             context: 'browser',
             engines: {
@@ -670,6 +672,7 @@ class TargetResolver {
           distDir,
           distEntry,
           publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+          inlineRequires: descriptor.inlineRequires ?? false,
           env: (0, _Environment.createEnvironment)({
             engines: descriptor.engines ?? pkgEngines,
             // @ts-expect-error TS2322
@@ -819,6 +822,7 @@ class TargetResolver {
           distDir: (0, _projectPath.toProjectPath)(this.options.projectRoot, descriptor.distDir != null ? _path().default.resolve(pkgDir, descriptor.distDir) : distDir),
           distEntry,
           publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+          inlineRequires: descriptor.inlineRequires ?? false,
           env: (0, _Environment.createEnvironment)({
             engines: descriptor.engines ?? pkgEngines,
             context: descriptor.context,
@@ -889,6 +893,7 @@ class TargetResolver {
         name: 'default',
         distDir: this.options.defaultTargetOptions.distDir ?? (0, _projectPath.toProjectPath)(this.options.projectRoot, _path().default.join(pkgDir, DEFAULT_DIST_DIRNAME)),
         publicUrl: this.options.defaultTargetOptions.publicUrl,
+        inlineRequires: false,
         env: (0, _Environment.createEnvironment)({
           engines: pkgEngines,
           // @ts-expect-error TS2322

package/lib/requests/WriteBundleRequest.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.SourceMapHashRefRewriteStream = void 0;
 exports.applyReplacementsToSourceMap = applyReplacementsToSourceMap;
+exports.applyReplacementsToVLQMappings = applyReplacementsToVLQMappings;
 exports.computeSourceMapRoot = computeSourceMapRoot;
 exports.default = createWriteBundleRequest;
 var _constants = require("../constants");
@@ -78,7 +80,7 @@ function _featureFlags() {
 }
 var _EnvironmentManager = require("../EnvironmentManager");
 function _sourceMap() {
-  const data = _interopRequireDefault(require("@atlaspack/source-map"));
+  const data = require("@atlaspack/source-map");
   _sourceMap = function () {
     return data;
   };
@@ -90,6 +92,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 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;
+
+// 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.
  */
@@ -177,23 +182,13 @@ async function run({
   (0, _DevDepRequest.invalidateDevDeps)(invalidDevDeps, options, config);
   const bundleReplacements = (0, _featureFlags().getFeatureFlag)('fixSourceMapHashRefs') ? [] : undefined;
   await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
-  const hasSourceMap = (0, _featureFlags().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, _featureFlags().getFeatureFlag)('fixSourceMapHashRefs') && bundleReplacements && bundleReplacements.length > 0) {
-      const mapEntry = (0, _featureFlags().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().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'));
+      mapStream = (0, _utils().blobToStream)(mapEntry).pipe(new SourceMapHashRefRewriteStream(bundleReplacements));
     } else {
-      const mapEntry = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.getLargeBlob(mapKey) : 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);
@@ -228,6 +223,178 @@ 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, _sourceMap().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, _sourceMap().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().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();
+  }
+}
+
 /**
  * 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
@@ -238,6 +405,7 @@ function applyReplacementsToSourceMap(sourceMap, replacements) {
  *
  * This logic must stay in sync with PackagerRunner.generateSourceMap.
  */
+exports.SourceMapHashRefRewriteStream = SourceMapHashRefRewriteStream;
 function computeSourceMapRoot(bundle, options) {
   let name = (0, _nullthrows().default)(bundle.name);
   let filePath = (0, _projectPath.joinProjectPath)(bundle.target.distDir, name);

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/BundleGraphRequestUtils.d.ts

@@ -17,6 +17,13 @@ import type { BundleGraphResult } from './BundleGraphRequest';
  * Throws an assertion error if duplicate bundle names are found.
  */
 export declare function validateBundles(bundleGraph: InternalBundleGraph): void;
+/**
+ * Dump a canonical JSON snapshot of the bundle graph for parity comparison.
+ * Gated by ATLASPACK_DUMP_BUNDLE_GRAPH environment variable which specifies the output directory.
+ * The snapshot captures bundle identity, type, contained assets, and bundle group structure
+ * in a deterministic, sorted format suitable for diffing.
+ */
+export declare function dumpBundleGraphSnapshot(bundleGraph: InternalBundleGraph, variant: 'js' | 'rust'): void;
 /**
  * Names a bundle by running through the configured namers until one returns a name.
  */

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

@@ -4,6 +4,7 @@ import type { StaticRunOpts } from '../RequestTracker';
 import type { Bundle, PackagedBundleInfo, AtlaspackOptions } from '../types';
 import type BundleGraph from '../BundleGraph';
 import type { BundleInfo } from '../PackagerRunner';
+import { Transform } from 'stream';
 import { requestTypes } from '../RequestTracker';
 import SourceMap from '@atlaspack/source-map';
 export type HashRefReplacement = {
@@ -33,6 +34,38 @@ export type WriteBundleRequest = {
  */
 export default function createWriteBundleRequest(input: WriteBundleRequestInput): WriteBundleRequest;
 export declare function applyReplacementsToSourceMap(sourceMap: SourceMap, replacements: HashRefReplacement[]): void;
+/**
+ * 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 declare function applyReplacementsToVLQMappings(mappings: string, replacements: HashRefReplacement[]): string;
+/**
+ * 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 declare class SourceMapHashRefRewriteStream extends Transform {
+    private replacements;
+    private state;
+    private scanBuf;
+    private mappingsBufs;
+    constructor(replacements: HashRefReplacement[]);
+    _transform(chunk: Buffer, _encoding: string, cb: any): void;
+    private _bufferingTransform;
+    _flush(cb: any): 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

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;