@atlaspack/core 2.34.0 → 2.36.0

package/CHANGELOG.md

@@ -1,5 +1,75 @@
 # @atlaspack/core
 
+## 2.36.0
+
+### Minor Changes
+
+- [#1047](https://github.com/atlassian-labs/atlaspack/pull/1047) [`de388ff`](https://github.com/atlassian-labs/atlaspack/commit/de388ff76d39dece97ad475fcccdb6efb6283bfc) Thanks [@marcins](https://github.com/marcins)! - Change approach to source map offset for hashRefs - use a streaming approach to avoid loading large sourcemaps into memory.
+
+### Patch Changes
+
+- [#1025](https://github.com/atlassian-labs/atlaspack/pull/1025) [`f7878b2`](https://github.com/atlassian-labs/atlaspack/commit/f7878b2f19a0a3bbd0e79d0b4a4e1479646043b7) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add native ideal graph bundling algorithm behind nativeBundling feature flag
+
+- Updated dependencies [[`f7878b2`](https://github.com/atlassian-labs/atlaspack/commit/f7878b2f19a0a3bbd0e79d0b4a4e1479646043b7), [`22bb49c`](https://github.com/atlassian-labs/atlaspack/commit/22bb49c5708798d259f98c8b5c10850b2f4f5f1b), [`bddd21a`](https://github.com/atlassian-labs/atlaspack/commit/bddd21a5313974ca333c02b2da1c6f85d1afaaea), [`de388ff`](https://github.com/atlassian-labs/atlaspack/commit/de388ff76d39dece97ad475fcccdb6efb6283bfc)]:
+  - @atlaspack/rust@3.24.1
+  - @atlaspack/source-map@3.3.0
+  - @atlaspack/cache@3.2.51
+  - @atlaspack/fs@2.15.51
+  - @atlaspack/logger@2.14.48
+  - @atlaspack/utils@3.3.8
+  - @atlaspack/package-manager@2.14.56
+  - @atlaspack/profiler@2.15.17
+  - @atlaspack/workers@2.14.56
+  - @atlaspack/graph@3.6.18
+  - @atlaspack/plugin@2.14.56
+  - @atlaspack/types@2.15.46
+
+## 2.35.0
+
+### Minor Changes
+
+- [#1042](https://github.com/atlassian-labs/atlaspack/pull/1042) [`857962a`](https://github.com/atlassian-labs/atlaspack/commit/857962a352bb0aebaf74a8765e8c44d7e875a4e9) Thanks [@marcins](https://github.com/marcins)! - Implement inlineRequires in native packager, add new option to target descriptor
+
+### Patch Changes
+
+- [#1040](https://github.com/atlassian-labs/atlaspack/pull/1040) [`f9aec27`](https://github.com/atlassian-labs/atlaspack/commit/f9aec2736d27afa7a1f2a9701d46e29e566ab352) Thanks [@benjervis](https://github.com/benjervis)! - Add support for star re-exports (`export * from './dep'`) in the Rust symbol tracker.
+
+  This enables proper symbol propagation through barrel files that use star re-exports,
+  allowing tree-shaking to work correctly for these patterns. Includes support for:
+  - Chained star re-exports (multiple levels of `export *`)
+  - Diamond patterns (multiple paths to the same symbol through different star re-exports)
+  - Speculative requirement cleanup (efficient tracking and removal of unsatisfied paths)
+
+  Note: This does not yet handle the ambiguous re-export case where multiple star re-exports
+  provide the same symbol name. That case currently requires runtime namespace fallback and
+  will be addressed in a future update.
+
+- [#1034](https://github.com/atlassian-labs/atlaspack/pull/1034) [`93ec107`](https://github.com/atlassian-labs/atlaspack/commit/93ec10729ad5a328b4320955357339746cd472f3) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - adding incremental bundle graph update for packaging
+
+- [#1036](https://github.com/atlassian-labs/atlaspack/pull/1036) [`e88b258`](https://github.com/atlassian-labs/atlaspack/commit/e88b25808a181fafbe98e5ca278b35bfc0197caf) Thanks [@benjervis](https://github.com/benjervis)! - Fix Rust symbol tracker to correctly handle renamed exports during symbol propagation through barrel files.
+
+- [#1046](https://github.com/atlassian-labs/atlaspack/pull/1046) [`cbc815a`](https://github.com/atlassian-labs/atlaspack/commit/cbc815a23907e081b7203bdea37bd57befdd4b9e) Thanks [@matt-koko](https://github.com/matt-koko)! - we do a little logging for the duplicate content key thing yup
+
+- [#1044](https://github.com/atlassian-labs/atlaspack/pull/1044) [`ad3c822`](https://github.com/atlassian-labs/atlaspack/commit/ad3c8223ab1abce9e8da81239cc56f27d37c7cad) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - cleanup incrementalBundlingVersioning flag
+
+- [#1035](https://github.com/atlassian-labs/atlaspack/pull/1035) [`936209f`](https://github.com/atlassian-labs/atlaspack/commit/936209f3c6c201288720dd62b61e1f538368268c) Thanks [@marcins](https://github.com/marcins)! - Remove `cachePerformanceImprovements` feature flag
+
+- Updated dependencies [[`06bb8c1`](https://github.com/atlassian-labs/atlaspack/commit/06bb8c14657722658c55283835f23ed7e7c6ecb4), [`a2d8e7a`](https://github.com/atlassian-labs/atlaspack/commit/a2d8e7a2444a1d6502239de8b8ceab4227270ec7), [`f9aec27`](https://github.com/atlassian-labs/atlaspack/commit/f9aec2736d27afa7a1f2a9701d46e29e566ab352), [`ecf8b79`](https://github.com/atlassian-labs/atlaspack/commit/ecf8b7931c5516df2117d525cefff5d7e1d20bee), [`93ec107`](https://github.com/atlassian-labs/atlaspack/commit/93ec10729ad5a328b4320955357339746cd472f3), [`a2c5747`](https://github.com/atlassian-labs/atlaspack/commit/a2c574770d2e616576e817801842576ead072532), [`f216e22`](https://github.com/atlassian-labs/atlaspack/commit/f216e227e0aca8a3944f66267d3f75238c732802), [`e88b258`](https://github.com/atlassian-labs/atlaspack/commit/e88b25808a181fafbe98e5ca278b35bfc0197caf), [`ad3c822`](https://github.com/atlassian-labs/atlaspack/commit/ad3c8223ab1abce9e8da81239cc56f27d37c7cad), [`936209f`](https://github.com/atlassian-labs/atlaspack/commit/936209f3c6c201288720dd62b61e1f538368268c), [`857962a`](https://github.com/atlassian-labs/atlaspack/commit/857962a352bb0aebaf74a8765e8c44d7e875a4e9)]:
+  - @atlaspack/rust@3.24.0
+  - @atlaspack/feature-flags@2.30.1
+  - @atlaspack/cache@3.2.50
+  - @atlaspack/fs@2.15.50
+  - @atlaspack/logger@2.14.47
+  - @atlaspack/source-map@3.2.10
+  - @atlaspack/utils@3.3.7
+  - @atlaspack/build-cache@2.13.13
+  - @atlaspack/graph@3.6.17
+  - @atlaspack/plugin@2.14.55
+  - @atlaspack/profiler@2.15.16
+  - @atlaspack/types@2.15.45
+  - @atlaspack/workers@2.14.55
+  - @atlaspack/package-manager@2.14.55
+
 ## 2.34.0
 
 ### Minor Changes

package/dist/AssetGraph.js

@@ -1,19 +1,7 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _AssetGraph_bundlingVersion, _AssetGraph_disableIncrementalBundling;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeFromDep = nodeFromDep;
 exports.nodeFromAssetGroup = nodeFromAssetGroup;
@@ -89,25 +77,12 @@ function nodeFromEntryFile(entry) {
 // @ts-expect-error TS2417
 class AssetGraph extends graph_1.ContentGraph {
     constructor(opts) {
-        /**
-         * Incremented when the asset graph is modified such that it requires a bundling pass.
-         */
-        _AssetGraph_bundlingVersion.set(this, 0);
-        /**
-         * Force incremental bundling to be disabled.
-         */
-        _AssetGraph_disableIncrementalBundling.set(this, false);
-        /**
-         * @deprecated
-         */
         this.safeToIncrementallyBundle = true;
         if (opts) {
-            let { hash, bundlingVersion, disableIncrementalBundling, ...rest } = opts;
+            let { hash, ...rest } = opts;
             // @ts-expect-error TS2345
             super(rest);
             this.hash = hash;
-            __classPrivateFieldSet(this, _AssetGraph_bundlingVersion, bundlingVersion ?? 0, "f");
-            __classPrivateFieldSet(this, _AssetGraph_disableIncrementalBundling, disableIncrementalBundling ?? false, "f");
         }
         else {
             super();
@@ -126,55 +101,15 @@ class AssetGraph extends graph_1.ContentGraph {
     serialize() {
         return {
             ...super.serialize(),
-            bundlingVersion: __classPrivateFieldGet(this, _AssetGraph_bundlingVersion, "f"),
-            disableIncrementalBundling: __classPrivateFieldGet(this, _AssetGraph_disableIncrementalBundling, "f"),
             hash: this.hash,
         };
     }
     /**
-     * Force incremental bundling to be disabled.
-     */
-    setDisableIncrementalBundling(disable) {
-        __classPrivateFieldSet(this, _AssetGraph_disableIncrementalBundling, disable, "f");
-    }
-    testing_getDisableIncrementalBundling() {
-        return __classPrivateFieldGet(this, _AssetGraph_disableIncrementalBundling, "f");
-    }
-    /**
-     * Make sure this asset graph is marked as needing a full bundling pass.
-     */
-    setNeedsBundling() {
-        if (!(0, feature_flags_1.getFeatureFlag)('incrementalBundlingVersioning')) {
-            // In legacy mode, we rely solely on safeToIncrementallyBundle to
-            // invalidate incremental bundling, so we skip bumping the version.
-            return;
-        }
-        __classPrivateFieldSet(this, _AssetGraph_bundlingVersion, __classPrivateFieldGet(this, _AssetGraph_bundlingVersion, "f") + 1, "f");
-    }
-    /**
-     * 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, feature_flags_1.getFeatureFlag)('incrementalBundlingVersioning')) {
-            return 0;
-        }
-        return __classPrivateFieldGet(this, _AssetGraph_bundlingVersion, "f");
-    }
-    /**
-     * 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, feature_flags_1.getFeatureFlag)('incrementalBundlingVersioning')) {
-            return (this.safeToIncrementallyBundle && !__classPrivateFieldGet(this, _AssetGraph_disableIncrementalBundling, "f"));
-        }
-        return (this.safeToIncrementallyBundle &&
-            __classPrivateFieldGet(this, _AssetGraph_bundlingVersion, "f") === lastVersion &&
-            !__classPrivateFieldGet(this, _AssetGraph_disableIncrementalBundling, "f"));
+    canIncrementallyBundle() {
+        return this.safeToIncrementallyBundle;
     }
     // Deduplicates Environments by making them referentially equal
     normalizeEnvironment(input) {
@@ -350,14 +285,12 @@ class AssetGraph extends graph_1.ContentGraph {
                 // @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) {
@@ -587,5 +520,4 @@ class AssetGraph extends graph_1.ContentGraph {
         return this.hash;
     }
 }
-_AssetGraph_bundlingVersion = new WeakMap(), _AssetGraph_disableIncrementalBundling = new WeakMap();
 exports.default = AssetGraph;

package/dist/BundleGraph.js

@@ -449,6 +449,40 @@ 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) {
+        const start = performance.now();
+        if (assetIds.length === 0) {
+            return '[]';
+        }
+        const nodes = [];
+        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: (0, EnvironmentManager_1.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_1.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/dist/PackagerRunner.js

@@ -60,7 +60,6 @@ const DevDepRequest_2 = require("./requests/DevDepRequest");
 const WriteBundleRequest_1 = require("./requests/WriteBundleRequest");
 const profiler_1 = require("@atlaspack/profiler");
 const EnvironmentManager_1 = require("./EnvironmentManager");
-const feature_flags_1 = require("@atlaspack/feature-flags");
 const BOUNDARY_LENGTH = constants_1.HASH_REF_PREFIX.length + 32 - 1;
 // Packager/optimizer configs are not bundle-specific, so we only need to
 // load them once per build.
@@ -366,18 +365,6 @@ class PackagerRunner {
             devDepHashes += await this.getDevDepHashes(inlineBundle);
         }
         let invalidationHash = await (0, assetUtils_1.getInvalidationHash)(invalidations, this.options);
-        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            const hash = (0, rust_1.hashString)(constants_1.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_1.default.join(bundle.displayName ?? bundle.name ?? bundle.id, hash);
-        }
         return (0, rust_1.hashString)(constants_1.ATLASPACK_VERSION +
             devDepHashes +
             invalidationHash +
@@ -407,23 +394,17 @@ class PackagerRunner {
         let contentKey = PackagerRunner.getContentKey(cacheKey);
         let mapKey = PackagerRunner.getMapKey(cacheKey);
         let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-        let contentExists = (0, feature_flags_1.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, feature_flags_1.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_1.blobToStream)(await this.options.cache.getBlob(contentKey)),
             map: mapExists
-                ? (0, utils_1.blobToStream)((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
-                    ? await this.options.cache.getLargeBlob(mapKey)
-                    : await this.options.cache.getBlob(mapKey))
+                ? (0, utils_1.blobToStream)(await this.options.cache.getBlob(mapKey))
                 : null,
         };
     }
@@ -432,12 +413,10 @@ class PackagerRunner {
         let hash;
         // @ts-expect-error TS2702
         let hashReferences = [];
-        let isLargeBlob = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements');
+        let isLargeBlob = false;
         // TODO: don't replace hash references in binary files??
         if (contents instanceof stream_1.Readable) {
-            if (!(0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-                isLargeBlob = true;
-            }
+            isLargeBlob = true;
             let boundaryStr = '';
             let h = new rust_1.Hash();
             await this.options.cache.setStream(cacheKeys.content, (0, utils_1.blobToStream)(contents).pipe(
@@ -456,31 +435,16 @@ class PackagerRunner {
             size = buffer.byteLength;
             hash = (0, rust_1.hashBuffer)(buffer);
             hashReferences = contents.match(constants_1.HASH_REF_REGEX) ?? [];
-            if ((0, feature_flags_1.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_1.hashBuffer)(contents);
             hashReferences = contents.toString().match(constants_1.HASH_REF_REGEX) ?? [];
-            if ((0, feature_flags_1.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, feature_flags_1.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,
@@ -494,21 +458,12 @@ class PackagerRunner {
         return info;
     }
     static getContentKey(cacheKey) {
-        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            return `PackagerRunner/${constants_1.ATLASPACK_VERSION}/${cacheKey}/content`;
-        }
         return (0, rust_1.hashString)(`${cacheKey}:content`);
     }
     static getMapKey(cacheKey) {
-        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            return `PackagerRunner/${constants_1.ATLASPACK_VERSION}/${cacheKey}/map`;
-        }
         return (0, rust_1.hashString)(`${cacheKey}:map`);
     }
     static getInfoKey(cacheKey) {
-        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            return `PackagerRunner/${constants_1.ATLASPACK_VERSION}/${cacheKey}/info`;
-        }
         return (0, rust_1.hashString)(`${cacheKey}:info`);
     }
 }

package/dist/RequestTracker.js

@@ -47,10 +47,9 @@ exports.getBiggestFSEventsInvalidations = getBiggestFSEventsInvalidations;
 const assert_1 = __importStar(require("assert"));
 const path_1 = __importDefault(require("path"));
 const build_cache_1 = require("@atlaspack/build-cache");
-const cache_1 = require("@atlaspack/cache");
 const feature_flags_1 = require("@atlaspack/feature-flags");
 const graph_1 = require("@atlaspack/graph");
-const logger_1 = __importStar(require("@atlaspack/logger"));
+const logger_1 = __importDefault(require("@atlaspack/logger"));
 const rust_1 = require("@atlaspack/rust");
 const utils_1 = require("@atlaspack/utils");
 const nullthrows_1 = __importDefault(require("nullthrows"));
@@ -782,12 +781,8 @@ class RequestTracker {
         }
         else if (node.resultCacheKey != null && ifMatch == null) {
             let key = node.resultCacheKey;
-            if (!(0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-                (0, assert_1.default)(this.options.cache.hasLargeBlob(key));
-            }
-            let cachedResult = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
-                ? (0, nullthrows_1.default)(await this.options.cache.get(key))
-                : (0, build_cache_1.deserialize)(await this.options.cache.getLargeBlob(key));
+            (0, assert_1.default)(this.options.cache.hasLargeBlob(key));
+            let cachedResult = (0, build_cache_1.deserialize)(await this.options.cache.getLargeBlob(key));
             node.result = cachedResult;
             return cachedResult;
         }
@@ -952,32 +947,13 @@ class RequestTracker {
         return { api, subRequestContentKeys };
     }
     async writeToCache(signal) {
-        const options = this.options;
-        async function runCacheImprovements(newPath, oldPath) {
-            if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-                (0, assert_1.default)(options.cache instanceof cache_1.LMDBLiteCache);
-                const result = await newPath(options.cache);
-                return result;
-            }
-            else {
-                const result = await oldPath();
-                return result;
-            }
-        }
         let cacheKey = getCacheKey(this.options);
-        let requestGraphKey = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
-            ? `${cacheKey}/RequestGraph`
-            : `requestGraph-${cacheKey}`;
-        let snapshotKey = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
-            ? `${cacheKey}/snapshot`
-            : `snapshot-${cacheKey}`;
+        let requestGraphKey = `requestGraph-${cacheKey}`;
+        let snapshotKey = `snapshot-${cacheKey}`;
         if (this.options.shouldDisableCache) {
             return;
         }
         let total = 0;
-        await runCacheImprovements(async (cache) => {
-            await cache.getNativeRef().startWriteTransaction();
-        }, () => Promise.resolve());
         try {
             (0, ReporterRunner_1.report)({
                 type: 'cache',
@@ -986,7 +962,7 @@ class RequestTracker {
                 size: this.graph.nodes.length,
             });
             if ((0, feature_flags_1.getFeatureFlag)('environmentDeduplication')) {
-                await (0, EnvironmentManager_1.writeEnvironmentsToCache)(options.cache);
+                await (0, EnvironmentManager_1.writeEnvironmentsToCache)(this.options.cache);
             }
             let serialisedGraph = this.graph.serialize();
             // Delete an existing request graph cache, to prevent invalid states
@@ -995,18 +971,11 @@ class RequestTracker {
                 if (signal?.aborted) {
                     throw new Error('Serialization was aborted');
                 }
-                await runCacheImprovements((cache) => {
-                    (0, logger_1.instrument)(`RequestTracker::writeToCache::cache.put(${key})`, () => {
-                        cache.getNativeRef().putNoConfirm(key, (0, build_cache_1.serialize)(contents));
-                    });
-                    return Promise.resolve();
-                }, async () => {
-                    await this.options.cache.setLargeBlob(key, (0, build_cache_1.serialize)(contents), signal
-                        ? {
-                            signal: signal,
-                        }
-                        : undefined);
-                });
+                await this.options.cache.setLargeBlob(key, (0, build_cache_1.serialize)(contents), signal
+                    ? {
+                        signal: signal,
+                    }
+                    : undefined);
                 total += 1;
                 (0, ReporterRunner_1.report)({
                     type: 'cache',
@@ -1057,13 +1026,6 @@ class RequestTracker {
                 nodeCountsPerBlob,
                 nodes: undefined,
             });
-            await runCacheImprovements(() => serialiseAndSet(`${cacheKey}/cache_metadata`, {
-                version: constants_1.ATLASPACK_VERSION,
-                entries: this.options.entries,
-                mode: this.options.mode,
-                shouldBuildLazily: this.options.shouldBuildLazily,
-                watchBackend: this.options.watchBackend,
-            }), () => Promise.resolve());
             let opts = getWatcherOptions(this.options);
             let snapshotPath = path_1.default.join(this.options.cacheDir, snapshotKey + '.txt');
             await this.options.outputFS.writeSnapshot(this.options.watchDir, snapshotPath, opts);
@@ -1073,11 +1035,6 @@ class RequestTracker {
             if (!signal?.aborted)
                 throw err;
         }
-        finally {
-            await runCacheImprovements(async (cache) => {
-                await cache.getNativeRef().commitWriteTransaction();
-            }, () => Promise.resolve());
-        }
         (0, ReporterRunner_1.report)({ type: 'cache', phase: 'end', total, size: this.graph.nodes.length });
     }
     static async init({ farm, options, rustAtlaspack, }) {
@@ -1093,31 +1050,17 @@ function getWatcherOptions({ watchIgnore = [], cacheDir, watchDir, watchBackend,
     return { ignore, backend: watchBackend };
 }
 function getCacheKey(options) {
-    if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-        const hash = (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${options.watchBackend ?? ''}`);
-        return `RequestTracker/${constants_1.ATLASPACK_VERSION}/${hash}`;
-    }
     return (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${options.watchBackend ?? ''}`);
 }
 function getRequestGraphNodeKey(index, cacheKey) {
-    if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-        return `${cacheKey}/RequestGraph/nodes/${index}`;
-    }
     return `requestGraph-nodes-${index}-${cacheKey}`;
 }
 async function readAndDeserializeRequestGraph(cache, requestGraphKey, cacheKey) {
     let bufferLength = 0;
     const getAndDeserialize = async (key) => {
-        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            const buffer = await cache.getBlob(key);
-            bufferLength += Buffer.byteLength(buffer);
-            return (0, build_cache_1.deserialize)(buffer);
-        }
-        else {
-            const buffer = await cache.getLargeBlob(key);
-            bufferLength += Buffer.byteLength(buffer);
-            return (0, build_cache_1.deserialize)(buffer);
-        }
+        const buffer = await cache.getLargeBlob(key);
+        bufferLength += Buffer.byteLength(buffer);
+        return (0, build_cache_1.deserialize)(buffer);
     };
     let serializedRequestGraph = await getAndDeserialize(requestGraphKey);
     let nodePromises = serializedRequestGraph.nodeCountsPerBlob.map(
@@ -1141,13 +1084,9 @@ async function loadRequestGraph(options) {
         return new RequestGraph();
     }
     let cacheKey = getCacheKey(options);
-    let requestGraphKey = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
-        ? `${cacheKey}/RequestGraph`
-        : `requestGraph-${cacheKey}`;
+    let requestGraphKey = `requestGraph-${cacheKey}`;
     let timeout;
-    const snapshotKey = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
-        ? `${cacheKey}/snapshot`
-        : `snapshot-${cacheKey}`;
+    const snapshotKey = `snapshot-${cacheKey}`;
     const snapshotPath = path_1.default.join(options.cacheDir, snapshotKey + '.txt');
     const commonMeta = {
         cacheKey,
@@ -1170,9 +1109,7 @@ async function loadRequestGraph(options) {
     if ((0, feature_flags_1.getFeatureFlag)('environmentDeduplication')) {
         await (0, EnvironmentManager_1.loadEnvironmentsFromCache)(options.cache);
     }
-    const hasRequestGraphInCache = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
-        ? await options.cache.has(requestGraphKey)
-        : await options.cache.hasLargeBlob(requestGraphKey);
+    const hasRequestGraphInCache = await options.cache.hasLargeBlob(requestGraphKey);
     if (hasRequestGraphInCache) {
         try {
             let { requestGraph } = await readAndDeserializeRequestGraph(options.cache, requestGraphKey, cacheKey);

package/dist/TargetDescriptor.schema.js

@@ -121,6 +121,9 @@ exports.PACKAGE_DESCRIPTOR_SCHEMA = {
                 type: 'string',
             },
         },
+        inlineRequires: {
+            type: 'boolean',
+        },
     },
     additionalProperties: false,
 };

package/dist/UncommittedAsset.js

@@ -16,7 +16,6 @@ const assetUtils_1 = require("./assetUtils");
 const types_1 = require("./types");
 const utils_2 = require("./utils");
 const projectPath_1 = require("./projectPath");
-const feature_flags_1 = require("@atlaspack/feature-flags");
 const EnvironmentManager_1 = require("./EnvironmentManager");
 class UncommittedAsset {
     constructor({ value, options, content, mapBuffer, ast, isASTDirty, code, invalidations, }) {
@@ -209,10 +208,6 @@ class UncommittedAsset {
         this.value.astGenerator = null;
     }
     getCacheKey(key) {
-        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            const filePath = (0, projectPath_1.fromProjectPathRelative)(this.value.filePath);
-            return `Asset/${constants_1.ATLASPACK_VERSION}/${filePath}/${this.value.id}/${key}`;
-        }
         return (0, rust_1.hashString)(constants_1.ATLASPACK_VERSION + key + this.value.id);
     }
     addDependency(opts) {

package/dist/atlaspack-v3/AtlaspackV3.js

@@ -58,8 +58,12 @@ class AtlaspackV3 {
         const { nodesJson, edges, publicIdByAssetId, environmentsJson } = bundleGraph.serializeForNative();
         return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
     }
-    package(bundleId) {
-        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi, bundleId);
+    updateBundleGraph(bundleGraph, changedAssetIds) {
+        const nodesJson = bundleGraph.serializeAssetNodesForNative(changedAssetIds);
+        return (0, rust_1.atlaspackNapiUpdateBundleGraph)(this._atlaspack_napi, nodesJson);
+    }
+    package(bundleId, options) {
+        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi, bundleId, options);
     }
     async respondToFsEvents(events) {
         // @ts-expect-error TS2488