@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/dist/worker.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearWorkerBuildCaches = clearWorkerBuildCaches;
+exports.runTransform = runTransform;
+exports.runValidate = runValidate;
+exports.runPackage = runPackage;
+exports.childInit = childInit;
+exports.invalidateRequireCache = invalidateRequireCache;
+exports.ping = ping;
+const utils_1 = require("@atlaspack/utils");
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const BundleGraph_1 = __importDefault(require("./BundleGraph"));
+const Transformation_1 = __importDefault(require("./Transformation"));
+const ReporterRunner_1 = require("./ReporterRunner");
+const PackagerRunner_1 = __importDefault(require("./PackagerRunner"));
+const Validation_1 = __importDefault(require("./Validation"));
+const AtlaspackConfig_1 = require("./AtlaspackConfig");
+const registerCoreWithSerializer_1 = require("./registerCoreWithSerializer");
+const build_cache_1 = require("@atlaspack/build-cache");
+const source_map_1 = require("@atlaspack/source-map");
+// @ts-expect-error TS2305
+const rust_1 = require("@atlaspack/rust");
+const workers_1 = __importDefault(require("@atlaspack/workers"));
+const feature_flags_1 = require("@atlaspack/feature-flags");
+require("@atlaspack/cache"); // register with serializer
+require("@atlaspack/package-manager");
+require("@atlaspack/fs");
+// /flow-to-ts helpers
+(0, registerCoreWithSerializer_1.registerCoreWithSerializer)();
+// TODO: this should eventually be replaced by an in memory cache layer
+let atlaspackConfigCache = new Map();
+function loadOptions(ref, workerApi) {
+    return (0, nullthrows_1.default)(workerApi.getSharedReference(ref));
+}
+async function loadConfig(cachePath, options) {
+    let config = atlaspackConfigCache.get(cachePath);
+    if (config && config.options === options) {
+        return config;
+    }
+    let processedConfig = (0, nullthrows_1.default)(await options.cache.get(cachePath));
+    config = new AtlaspackConfig_1.AtlaspackConfig(processedConfig, options);
+    atlaspackConfigCache.set(cachePath, config);
+    (0, feature_flags_1.setFeatureFlags)(options.featureFlags);
+    return config;
+}
+function clearWorkerBuildCaches() {
+    utils_1.loadConfig.clear();
+    (0, build_cache_1.clearBuildCaches)();
+}
+async function runTransform(workerApi, opts) {
+    let { optionsRef, configCachePath, ...rest } = opts;
+    let options = loadOptions(optionsRef, workerApi);
+    let config = await loadConfig(configCachePath, options);
+    return new Transformation_1.default({
+        workerApi,
+        options,
+        // @ts-expect-error TS2783
+        config,
+        ...rest,
+    }).run();
+}
+async function runValidate(workerApi, opts) {
+    let { optionsRef, configCachePath, ...rest } = opts;
+    let options = loadOptions(optionsRef, workerApi);
+    let config = await loadConfig(configCachePath, options);
+    return new Validation_1.default({
+        workerApi,
+        // @ts-expect-error TS2783
+        report: ReporterRunner_1.reportWorker.bind(null, workerApi),
+        options,
+        // @ts-expect-error TS2783
+        config,
+        ...rest,
+    }).run();
+}
+async function runPackage(workerApi, { bundle, bundleGraphReference, configCachePath, optionsRef, previousDevDeps, invalidDevDeps, previousInvalidations, }) {
+    let bundleGraph = workerApi.getSharedReference(bundleGraphReference);
+    (0, assert_1.default)(bundleGraph instanceof BundleGraph_1.default);
+    let options = loadOptions(optionsRef, workerApi);
+    let atlaspackConfig = await loadConfig(configCachePath, options);
+    let runner = new PackagerRunner_1.default({
+        config: atlaspackConfig,
+        options,
+        // @ts-expect-error TS2322
+        report: workers_1.default.isWorker() ? ReporterRunner_1.reportWorker.bind(null, workerApi) : ReporterRunner_1.report,
+        previousDevDeps,
+        previousInvalidations,
+    });
+    return runner.run(bundleGraph, bundle, invalidDevDeps);
+}
+async function childInit() {
+    await source_map_1.init;
+    await (0, rust_1.init)?.();
+}
+const PKG_RE = /node_modules[/\\]((?:@[^/\\]+[/\\][^/\\]+)|[^/\\]+)(?!.*[/\\]node_modules[/\\])/;
+function invalidateRequireCache(workerApi, file) {
+    if (process.env.ATLASPACK_BUILD_ENV === 'test') {
+        // Delete this module and all children in the same node_modules folder
+        let module = require.cache[file];
+        if (module) {
+            delete require.cache[file];
+            let pkg = file.match(PKG_RE)?.[1];
+            for (let child of module.children) {
+                if (pkg === child.id.match(PKG_RE)?.[1]) {
+                    invalidateRequireCache(workerApi, child.id);
+                }
+            }
+        }
+        atlaspackConfigCache.clear();
+        return;
+    }
+    throw new Error('invalidateRequireCache is only for tests');
+}
+/**
+ * This is used to wait until workers are responding to messages.
+ */
+function ping() {
+    return true;
+}

package/lib/AssetGraph.js

@@ -46,7 +46,15 @@ function _graph() {
 }
 var _Dependency = require("./Dependency");
 var _projectPath = require("./projectPath");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _EnvironmentManager = require("./EnvironmentManager");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function nodeFromDep(dep) {
   return {
     id: dep.id,
@@ -63,7 +71,11 @@ function nodeFromDep(dep) {
 }
 function nodeFromAssetGroup(assetGroup) {
   return {
-    id: (0, _rust().hashString)((0, _projectPath.fromProjectPathRelative)(assetGroup.filePath) + assetGroup.env.id + String(assetGroup.isSource) + String(assetGroup.sideEffects) + (assetGroup.code ?? '') + ':' + (assetGroup.pipeline ?? '') + ':' + (assetGroup.query ?? '')),
+    id: (0, _rust().hashString)(
+    // @ts-expect-error TS2345
+    (0, _projectPath.fromProjectPathRelative)(assetGroup.filePath) +
+    // @ts-expect-error TS2345
+    (0, _EnvironmentManager.toEnvironmentId)(assetGroup.env) + String(assetGroup.isSource) + String(assetGroup.sideEffects) + (assetGroup.code ?? '') + ':' + (assetGroup.pipeline ?? '') + ':' + (assetGroup.query ?? '')),
     type: 'asset_group',
     value: assetGroup,
     usedSymbolsDownDirty: true
@@ -93,6 +105,8 @@ function nodeFromEntryFile(entry) {
     value: entry
   };
 }
+
+// @ts-expect-error TS2417
 class AssetGraph extends _graph().ContentGraph {
   safeToIncrementallyBundle = true;
   constructor(opts) {
@@ -101,6 +115,7 @@ class AssetGraph extends _graph().ContentGraph {
         hash,
         ...rest
       } = opts;
+      // @ts-expect-error TS2345
       super(rest);
       this.hash = hash;
     } else {
@@ -114,13 +129,9 @@ class AssetGraph extends _graph().ContentGraph {
     this.undeferredDependencies = new Set();
     this.envCache = new Map();
   }
-
-  // $FlowFixMe[prop-missing]
   static deserialize(opts) {
     return new AssetGraph(opts);
   }
-
-  // $FlowFixMe[prop-missing]
   serialize() {
     return {
       ...super.serialize(),
@@ -128,18 +139,32 @@ class AssetGraph extends _graph().ContentGraph {
     };
   }
 
+  /**
+   * Determine if we can incrementally bundle, which will not require a full bundling pass
+   * but just update assets into the bundle graph output.
+   */
+  canIncrementallyBundle() {
+    return this.safeToIncrementallyBundle;
+  }
+
   // Deduplicates Environments by making them referentially equal
   normalizeEnvironment(input) {
+    if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+      return;
+    }
+
+    // @ts-expect-error TS2345
     let {
       id,
       context
-    } = input.env;
+    } = (0, _EnvironmentManager.fromEnvironmentId)(input.env);
     let idAndContext = `${id}-${context}`;
     let env = this.envCache.get(idAndContext);
     if (env) {
-      input.env = env;
+      input.env = (0, _EnvironmentManager.toEnvironmentRef)(env);
     } else {
-      this.envCache.set(idAndContext, input.env);
+      // @ts-expect-error TS2345
+      this.envCache.set(idAndContext, (0, _EnvironmentManager.fromEnvironmentId)(input.env));
     }
   }
   setRootConnections({
@@ -166,8 +191,6 @@ class AssetGraph extends _graph().ContentGraph {
     let existing = this.getNodeByContentKey(node.id);
     if (existing != null) {
       (0, _assert().default)(existing.type === node.type);
-      // $FlowFixMe[incompatible-type] Checked above
-      // $FlowFixMe[prop-missing]
       existing.value = node.value;
       let existingId = this.getNodeIdByContentKey(node.id);
       this.updateNode(existingId, existing);
@@ -199,13 +222,14 @@ class AssetGraph extends _graph().ContentGraph {
         env: target.env,
         isEntry: true,
         needsStableName: true,
-        symbols: target.env.isLibrary ? new Map([['*', {
+        // @ts-expect-error TS2322
+        symbols: (0, _EnvironmentManager.fromEnvironmentId)(target.env).isLibrary ? new Map([['*', {
           local: '*',
           isWeak: true,
           loc: null
         }]]) : undefined
       }));
-      if (node.value.env.isLibrary) {
+      if ((0, _EnvironmentManager.fromEnvironmentId)(node.value.env).isLibrary) {
         // in library mode, all of the entry's symbols are "used"
         node.usedSymbolsDown.add('*');
         node.usedSymbolsUp.set('*', undefined);
@@ -285,7 +309,10 @@ class AssetGraph extends _graph().ContentGraph {
       if (traversedNode.type === 'asset') {
         let hasDeferred = this.getNodeIdsConnectedFrom(traversedNodeId).some(childNodeId => {
           let childNode = (0, _nullthrows().default)(this.getNode(childNodeId));
-          return childNode.hasDeferred == null ? false : childNode.hasDeferred;
+          // @ts-expect-error TS2339
+          return childNode.hasDeferred == null ? false :
+          // @ts-expect-error TS2339
+          childNode.hasDeferred;
         });
         if (!hasDeferred) {
           delete traversedNode.hasDeferred;
@@ -294,6 +321,7 @@ class AssetGraph extends _graph().ContentGraph {
           hasDeferred
         };
       } else if (traversedNode.type === 'asset_group' && nodeId !== traversedNodeId) {
+        // @ts-expect-error TS2339
         if (!(ctx !== null && ctx !== void 0 && ctx.hasDeferred)) {
           this.safeToIncrementallyBundle = false;
           delete traversedNode.hasDeferred;
@@ -348,7 +376,7 @@ class AssetGraph extends _graph().ContentGraph {
       if (this.undeferredDependencies.has(d)) {
         return false;
       }
-      let depIsDeferrable = d.symbols && !(d.env.isLibrary && d.isEntry) && !d.symbols.has('*') && ![...d.symbols.keys()].some(symbol => {
+      let depIsDeferrable = d.symbols && !((0, _EnvironmentManager.fromEnvironmentId)(d.env).isLibrary && d.isEntry) && !d.symbols.has('*') && ![...d.symbols.keys()].some(symbol => {
         var _resolvedAsset$symbol;
         let assetSymbol = (_resolvedAsset$symbol = resolvedAsset.symbols) === null || _resolvedAsset$symbol === void 0 || (_resolvedAsset$symbol = _resolvedAsset$symbol.get(symbol)) === null || _resolvedAsset$symbol === void 0 ? void 0 : _resolvedAsset$symbol.local;
         return assetSymbol != null && symbols.has(assetSymbol);
@@ -363,6 +391,7 @@ class AssetGraph extends _graph().ContentGraph {
   resolveAssetGroup(assetGroup, assets, correspondingRequest) {
     this.normalizeEnvironment(assetGroup);
     let assetGroupNode = nodeFromAssetGroup(assetGroup);
+    // @ts-expect-error TS2322
     assetGroupNode = this.getNodeByContentKey(assetGroupNode.id);
     if (!assetGroupNode) {
       return;
@@ -432,6 +461,15 @@ class AssetGraph extends _graph().ContentGraph {
           ...depNode.value.meta,
           ...existing.value.resolverMeta
         };
+        if ((0, _featureFlags().getFeatureFlag)('hmrImprovements')) {
+          depNode.value.resolverMeta = existing.value.resolverMeta;
+        }
+      }
+      if ((0, _featureFlags().getFeatureFlag)('hmrImprovements')) {
+        if ((existing === null || existing === void 0 ? void 0 : existing.type) === 'dependency' && existing.value.resolverPriority != null) {
+          depNode.value.priority = existing.value.resolverPriority;
+          depNode.value.resolverPriority = existing.value.resolverPriority;
+        }
       }
       let dependentAsset = dependentAssets.find(a => a.uniqueKey === dep.specifier);
       if (dependentAsset) {

package/lib/Atlaspack.js

@@ -80,7 +80,7 @@ var _PathRequest = _interopRequireDefault(require("./requests/PathRequest"));
 var _Environment = require("./Environment");
 var _Dependency = require("./Dependency");
 function _sourceMap() {
-  const data = require("@parcel/source-map");
+  const data = require("@atlaspack/source-map");
   _sourceMap = function () {
     return data;
   };
@@ -118,42 +118,48 @@ function _featureFlags() {
 var _atlaspackV = require("./atlaspack-v3");
 var _AssetGraphRequest = _interopRequireDefault(require("./requests/AssetGraphRequest"));
 var _AssetGraphRequestRust = require("./requests/AssetGraphRequestRust");
+var _BundleGraphRequestRust = require("./requests/BundleGraphRequestRust");
 var _rustWorkerThreadDylibHack = require("./rustWorkerThreadDylibHack");
-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 }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // eslint-disable-next-line no-unused-vars
+
 (0, _registerCoreWithSerializer.registerCoreWithSerializer)();
 const INTERNAL_TRANSFORM = exports.INTERNAL_TRANSFORM = Symbol('internal_transform');
 const INTERNAL_RESOLVE = exports.INTERNAL_RESOLVE = Symbol('internal_resolve');
-const WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'worker.js');
+let WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'worker.js');
+if (__filename.endsWith('.ts')) {
+  exports.WORKER_PATH = WORKER_PATH = _path().default.join(__dirname, 'worker.ts');
+}
 class Atlaspack {
-  #requestTracker /*: RequestTracker*/;
-  #config /*: AtlaspackConfig*/;
-  #farm /*: WorkerFarm*/;
-  #initialized /*: boolean*/ = false;
-  #disposable /*: Disposable */;
-  #initialOptions /*: InitialAtlaspackOptions */;
-  #reporterRunner /*: ReporterRunner*/;
-  #resolvedOptions /*: ?AtlaspackOptions*/ = null;
-  #optionsRef /*: SharedReference */;
-  #watchAbortController /*: AbortController*/;
-  #watchQueue /*: PromiseQueue<?BuildEvent>*/ = new (_utils2().PromiseQueue)({
+  // @ts-expect-error TS2564
+  #requestTracker;
+  // @ts-expect-error TS2564
+  #config;
+  // @ts-expect-error TS2564
+  #farm;
+  #initialized = false;
+  // @ts-expect-error TS2564
+  #disposable;
+  #initialOptions;
+  // @ts-expect-error TS2564
+  #reporterRunner;
+  #resolvedOptions = null;
+  // @ts-expect-error TS2564
+  #optionsRef;
+  // @ts-expect-error TS2564
+  #watchAbortController;
+  #watchQueue = new (_utils2().PromiseQueue)({
     maxConcurrent: 1
   });
-  #watchEvents /*: ValueEmitter<
-               | {|
-               +error: Error,
-               +buildEvent?: void,
-               |}
-               | {|
-               +buildEvent: BuildEvent,
-               +error?: void,
-               |},
-               > */;
-  #watcherSubscription /*: ?AsyncSubscription*/;
-  #watcherCount /*: number*/ = 0;
-  #requestedAssetIds /*: Set<string>*/ = new Set();
+  // @ts-expect-error TS2564
+  #watchEvents;
+  #watcherSubscription;
+  #watcherCount = 0;
+  #requestedAssetIds = new Set();
+
+  // @ts-expect-error TS2564
+
   constructor(options) {
     this.#initialOptions = options;
   }
@@ -191,7 +197,7 @@ class Atlaspack {
     });
     this.#resolvedOptions = resolvedOptions;
     let rustAtlaspack;
-    if (resolvedOptions.featureFlags.atlaspackV3) {
+    if (resolvedOptions.featureFlags.atlaspackV3 || resolvedOptions.featureFlags.fullNative || resolvedOptions.featureFlags.nativePackager) {
       // eslint-disable-next-line no-unused-vars
       let {
         entries,
@@ -203,8 +209,6 @@ class Atlaspack {
         throw new Error('Atlaspack v3 must be run with lmdb lite cache');
       }
       const lmdb = resolvedOptions.cache.getNativeRef();
-
-      // $FlowFixMe
       const version = require('../package.json').version;
       await lmdb.put('current_session_version', Buffer.from(version));
       let threads = undefined;
@@ -215,16 +219,22 @@ class Atlaspack {
       }
       rustAtlaspack = await _atlaspackV.AtlaspackV3.create({
         ...options,
+        // @ts-expect-error TS2353
         corePath: _path().default.join(__dirname, '..'),
         threads,
         entries: Array.isArray(entries) ? entries : entries == null ? undefined : [entries],
         env: resolvedOptions.env,
         fs: inputFS && new _atlaspackV.FileSystemV3(inputFS),
-        // $FlowFixMe ProjectPath is a string
         defaultTargetOptions: resolvedOptions.defaultTargetOptions,
-        lmdb
+        serveOptions: resolvedOptions.serveOptions,
+        lmdb,
+        featureFlags: resolvedOptions.featureFlags
+      });
+      this.#disposable.add(() => {
+        rustAtlaspack.end();
       });
     }
+    // @ts-expect-error TS2454
     this.rustAtlaspack = rustAtlaspack;
     let {
       config
@@ -270,6 +280,7 @@ class Atlaspack {
     this.#requestTracker = await _RequestTracker.default.init({
       farm: this.#farm,
       options: resolvedOptions,
+      // @ts-expect-error TS2454
       rustAtlaspack
     });
     this.#initialized = true;
@@ -336,6 +347,8 @@ class Atlaspack {
     if (!this.#initialized) {
       await this._init();
     }
+
+    // @ts-expect-error TS7034
     let watchEventsDisposable;
     if (cb) {
       watchEventsDisposable = this.#watchEvents.addListener(({
@@ -355,8 +368,11 @@ class Atlaspack {
       this.#watchQueue.run();
     }
     this.#watcherCount++;
+
+    // @ts-expect-error TS7034
     let unsubscribePromise;
     const unsubscribe = async () => {
+      // @ts-expect-error TS7005
       if (watchEventsDisposable) {
         watchEventsDisposable.dispose();
       }
@@ -374,9 +390,12 @@ class Atlaspack {
     };
     return {
       unsubscribe() {
+        // @ts-expect-error TS7005
         if (unsubscribePromise == null) {
           unsubscribePromise = unsubscribe();
         }
+
+        // @ts-expect-error TS7005
         return unsubscribePromise;
       }
     };
@@ -387,41 +406,83 @@ class Atlaspack {
   } = {
     /*::...null*/
   }) {
-    this.#requestTracker.setSignal(signal);
     let options = (0, _nullthrows().default)(this.#resolvedOptions);
     try {
+      var _this$rustAtlaspack;
       if (options.shouldProfile) {
         await this.startProfiling();
       }
+      if (options.nativeProfiler) {
+        const nativeProfiler = new (_profiler().NativeProfiler)();
+        await nativeProfiler.startProfiling(options.nativeProfiler);
+      }
       if (options.shouldTrace) {
         _profiler().tracer.enable();
+        // We need to ensure the tracer is disabled when Atlaspack is disposed as it is a module level object.
+        // While rare (except for tests), if another instance is created later it should not have tracing enabled.
+        this.#disposable.add(() => {
+          _profiler().tracer.disable();
+        });
       }
       await this.#reporterRunner.report({
         type: 'buildStart'
       });
       this.#requestTracker.graph.invalidateOnBuildNodes();
-      let request = (0, _AtlaspackBuildRequest.default)({
-        optionsRef: this.#optionsRef,
-        requestedAssetIds: this.#requestedAssetIds,
-        signal
-      });
-      let {
-        bundleGraph,
-        bundleInfo,
-        changedAssets,
-        assetRequests
-      } = await this.#requestTracker.runRequest(request, {
-        force: true
-      });
+      let bundleGraph;
+      let bundleInfo;
+      let changedAssets;
+      let assetRequests;
+      let scopeHoistingStats;
+      if ((0, _featureFlags().getFeatureFlag)('fullNative') && this.rustAtlaspack) {
+        let [result, error] = await this.rustAtlaspack.build(eventJson => {
+          let event = JSON.parse(eventJson);
+          this.#reporterRunner.report(event);
+        });
+        if (error) {
+          throw new (_diagnostic().default)({
+            diagnostic: error
+          });
+        }
+        ({
+          bundleGraph,
+          changedAssets
+        } = (0, _BundleGraphRequestRust.getBundleGraph)(result));
+        bundleInfo = new Map((result.bundleInfo ?? []).map(info => [info.bundleId, {
+          filePath: (0, _projectPath.toProjectPath)(options.projectRoot, info.filePath),
+          bundleId: info.bundleId,
+          type: info.type,
+          stats: {
+            size: info.size,
+            time: info.time
+          }
+        }]));
+        assetRequests = result.assetRequests ?? [];
+      } else {
+        let request = (0, _AtlaspackBuildRequest.default)({
+          optionsRef: this.#optionsRef,
+          requestedAssetIds: this.#requestedAssetIds,
+          signal
+        });
+        ({
+          bundleGraph,
+          bundleInfo,
+          changedAssets,
+          assetRequests,
+          scopeHoistingStats
+        } = await this.#requestTracker.runRequest(request, {
+          force: true
+        }));
+      }
       this.#requestedAssetIds.clear();
       await (0, _dumpGraphToGraphViz.default)(
-      // $FlowFixMe
+      // @ts-expect-error TS2345
       this.#requestTracker.graph, 'RequestGraph', _RequestTracker.requestGraphEdgeTypes);
       let event = {
         type: 'buildSuccess',
         changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [id, (0, _Asset.assetFromValue)(asset, options)])),
         bundleGraph: new _BundleGraph.default(bundleGraph, (bundle, bundleGraph, options) => _Bundle.PackagedBundle.getWithInfo(bundle, bundleGraph, options, bundleInfo.get(bundle.id)), options),
         buildTime: Date.now() - startTime,
+        // @ts-expect-error TS7006
         requestBundle: async bundle => {
           let bundleNode = bundleGraph._graph.getNodeByContentKey(bundle.id);
           (0, _assert().default)((bundleNode === null || bundleNode === void 0 ? void 0 : bundleNode.type) === 'bundle', 'Bundle does not exist');
@@ -433,7 +494,8 @@ class Atlaspack {
               bundleGraph: event.bundleGraph,
               buildTime: 0,
               requestBundle: event.requestBundle,
-              unstable_requestStats: {}
+              unstable_requestStats: {},
+              scopeHoistingStats: event.scopeHoistingStats
             };
           }
           for (let assetId of bundleNode.value.entryAssetIds) {
@@ -447,15 +509,23 @@ class Atlaspack {
           }
           let results = await this.#watchQueue.run();
           let result = results.filter(Boolean).pop();
+          // @ts-expect-error TS18049
           if (result.type === 'buildFailure') {
+            // @ts-expect-error TS18049
             throw new BuildError(result.diagnostics);
           }
           return result;
         },
-        unstable_requestStats: this.#requestTracker.flushStats()
+        unstable_requestStats: this.#requestTracker.flushStats(),
+        nativeCacheStats: await ((_this$rustAtlaspack = this.rustAtlaspack) === null || _this$rustAtlaspack === void 0 ? void 0 : _this$rustAtlaspack.completeCacheSession()),
+        scopeHoistingStats
       };
+
+      // @ts-expect-error TS2345
       await this.#reporterRunner.report(event);
-      await this.#requestTracker.runRequest((0, _ValidationRequest.default)({
+      await this.#requestTracker.runRequest(
+      // @ts-expect-error TS2345
+      (0, _ValidationRequest.default)({
         optionsRef: this.#optionsRef,
         assetRequests
       }), {
@@ -464,8 +534,11 @@ class Atlaspack {
       if (this.#reporterRunner.errors.length) {
         throw this.#reporterRunner.errors;
       }
+
+      // @ts-expect-error TS2322
       return event;
     } catch (e) {
+      var _this$rustAtlaspack2;
       if (e instanceof _utils.BuildAbortError) {
         throw e;
       }
@@ -473,9 +546,13 @@ class Atlaspack {
       let event = {
         type: 'buildFailure',
         diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
-        unstable_requestStats: this.#requestTracker.flushStats()
+        unstable_requestStats: this.#requestTracker.flushStats(),
+        nativeCacheStats: await ((_this$rustAtlaspack2 = this.rustAtlaspack) === null || _this$rustAtlaspack2 === void 0 ? void 0 : _this$rustAtlaspack2.completeCacheSession())
       };
+
+      // @ts-expect-error TS2345
       await this.#reporterRunner.report(event);
+      // @ts-expect-error TS2322
       return event;
     } finally {
       if (this.isProfiling) {
@@ -507,10 +584,12 @@ class Atlaspack {
         message: `File watch event emitted with ${events.length} events. Sample event: [${(_events$ = events[0]) === null || _events$ === void 0 ? void 0 : _events$.type}] ${(_events$2 = events[0]) === null || _events$2 === void 0 ? void 0 : _events$2.path}`
       });
       let nativeInvalid = false;
-      if (this.rustAtlaspack) {
+      if ((0, _featureFlags().getFeatureFlag)('atlaspackV3') && this.rustAtlaspack) {
         nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
       }
-      let isInvalid = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
+      let {
+        didInvalidate: isInvalid
+      } = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
       if ((nativeInvalid || isInvalid) && this.#watchQueue.getNumWaiting() === 0) {
         if (this.#watchAbortController) {
           this.#watchAbortController.abort();
@@ -586,7 +665,11 @@ class Atlaspack {
       requestedAssetIds: this.#requestedAssetIds
     };
     const start = Date.now();
-    const result = await this.#requestTracker.runRequest(this.rustAtlaspack != null ? (0, _AssetGraphRequestRust.createAssetGraphRequestRust)(this.rustAtlaspack)(input) : (0, _AssetGraphRequest.default)(input), {
+    const result = await this.#requestTracker.runRequest((0, _featureFlags().getFeatureFlag)('atlaspackV3') && this.rustAtlaspack != null ?
+    // @ts-expect-error TS2345
+    (0, _AssetGraphRequestRust.createAssetGraphRequestRust)(this.rustAtlaspack)(input) :
+    // @ts-expect-error TS2345
+    (0, _AssetGraphRequest.default)(input), {
       force: true
     });
     const duration = Date.now() - start;
@@ -673,6 +756,7 @@ class Atlaspack {
       return null;
     }
     return {
+      // @ts-expect-error TS2322
       filePath: (0, _projectPath.fromProjectPath)(projectRoot, res.filePath),
       code: res.code,
       query: res.query,