@atlaspack/core 2.12.1-canary.3431 → 2.12.1-canary.3434

package/lib/Atlaspack.js

@@ -151,6 +151,11 @@ class Atlaspack {
     if (this.#initialized) {
       return;
     }
+    const featureFlags = {
+      ..._featureFlags().DEFAULT_FEATURE_FLAGS,
+      ...this.#initialOptions.featureFlags
+    };
+    (0, _featureFlags().setFeatureFlags)(featureFlags);
     await _sourceMap().init;
     await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
     try {
@@ -162,7 +167,10 @@ class Atlaspack {
       // Fallthrough
       _logger().default.warn(e);
     }
-    let resolvedOptions = await (0, _resolveOptions.default)(this.#initialOptions);
+    let resolvedOptions = await (0, _resolveOptions.default)({
+      ...this.#initialOptions,
+      featureFlags
+    });
     this.#resolvedOptions = resolvedOptions;
     let rustAtlaspack;
     if (resolvedOptions.featureFlags.atlaspackV3) {
@@ -192,7 +200,6 @@ class Atlaspack {
         }
       });
     }
-    (0, _featureFlags().setFeatureFlags)(resolvedOptions.featureFlags);
     let {
       config
     } = await (0, _AtlaspackConfigRequest.loadAtlaspackConfig)(resolvedOptions);
@@ -520,6 +527,9 @@ class Atlaspack {
     });
     return this.#farm.takeHeapSnapshot();
   }
+  async unstable_invalidate() {
+    await this._init();
+  }
   async unstable_transform(options) {
     var _options$env;
     if (!this.#initialized) {

package/lib/BundleGraph.js

@@ -44,6 +44,13 @@ var _utils2 = require("./utils");
 var _Environment = require("./public/Environment");
 var _projectPath = require("./projectPath");
 var _constants = require("./constants");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -107,16 +114,19 @@ class BundleGraph {
   /** The internal core Graph structure */
 
   _bundlePublicIds /*: Set<string> */ = new Set();
+  _conditions /*: Map<string, Condition> */ = new Map();
   constructor({
     graph,
     publicIdByAssetId,
     assetPublicIds,
-    bundleContentHashes
+    bundleContentHashes,
+    conditions
   }) {
     this._graph = graph;
     this._assetPublicIds = assetPublicIds;
     this._publicIdByAssetId = publicIdByAssetId;
     this._bundleContentHashes = bundleContentHashes;
+    this._conditions = conditions;
   }
 
   /**
@@ -128,6 +138,8 @@ class BundleGraph {
     let assetGroupIds = new Map();
     let dependencies = new Map();
     let assetGraphNodeIdToBundleGraphNodeId = new Map();
+    let conditions = new Map();
+    let placeholderToDependency = new Map();
     let assetGraphRootNode = assetGraph.rootNodeId != null ? assetGraph.getNode(assetGraph.rootNodeId) : null;
     (0, _assert().default)(assetGraphRootNode != null && assetGraphRootNode.type === 'root');
     assetGraph.dfsFast(nodeId => {
@@ -146,6 +158,17 @@ class BundleGraph {
         }
       } else if (node != null && node.type === 'asset_group') {
         assetGroupIds.set(nodeId, assetGraph.getNodeIdsConnectedFrom(nodeId));
+      } else if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node != null && node.type === 'dependency') {
+        var _dep$meta;
+        // The dependency placeholders in the `importCond` calls that will be in the transformed
+        // code need to be mapped to the "real" dependencies, so we need access to a map of placeholders
+        // to dependencies
+        const dep = node.value;
+        // $FlowFixMe[incompatible-type] Meta is untyped
+        const placeholder = (_dep$meta = dep.meta) === null || _dep$meta === void 0 ? void 0 : _dep$meta.placeholder;
+        if (placeholder != null) {
+          placeholderToDependency.set(placeholder, dep);
+        }
       }
     });
     let walkVisited = new Set();
@@ -153,6 +176,34 @@ class BundleGraph {
       if (walkVisited.has(nodeId)) return;
       walkVisited.add(nodeId);
       let node = (0, _nullthrows().default)(assetGraph.getNode(nodeId));
+      if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.type === 'asset') {
+        const asset = node.value;
+        if (Array.isArray(asset.meta.conditions)) {
+          // $FlowFixMe
+          for (const condition of asset.meta.conditions) {
+            // Resolve the placeholders that were attached to the asset in JSTransformer to dependencies,
+            // as well as create a public id for the condition.
+            const {
+              key,
+              ifTruePlaceholder,
+              ifFalsePlaceholder
+            } = condition;
+            const condHash = (0, _rust().hashString)(`${key}:${ifTruePlaceholder}:${ifFalsePlaceholder}`);
+            const condPublicId = (0, _utils2.getPublicId)(condHash, v => conditions.has(v));
+            if (conditions.has(condHash)) {
+              throw new Error('Unexpected duplicate asset');
+            } else {
+              conditions.set(condHash, {
+                publicId: condPublicId,
+                assets: new Set([asset]),
+                key,
+                ifTrueDependency: (0, _nullthrows().default)(placeholderToDependency.get(ifTruePlaceholder), 'ifTruePlaceholder was undefined'),
+                ifFalseDependency: (0, _nullthrows().default)(placeholderToDependency.get(ifFalsePlaceholder), 'ifFalsePlaceholder was undefined')
+              });
+            }
+          }
+        }
+      }
       if (node.type === 'dependency' && node.value.symbols != null && node.value.env.shouldScopeHoist &&
       // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
       isProduction) {
@@ -338,7 +389,8 @@ class BundleGraph {
       graph,
       assetPublicIds,
       bundleContentHashes: new Map(),
-      publicIdByAssetId
+      publicIdByAssetId,
+      conditions
     });
   }
   serialize() {
@@ -347,7 +399,8 @@ class BundleGraph {
       graph: this._graph.serialize(),
       assetPublicIds: this._assetPublicIds,
       bundleContentHashes: this._bundleContentHashes,
-      publicIdByAssetId: this._publicIdByAssetId
+      publicIdByAssetId: this._publicIdByAssetId,
+      conditions: this._conditions
     };
   }
   static deserialize(serialized) {
@@ -355,7 +408,8 @@ class BundleGraph {
       graph: _graph().ContentGraph.deserialize(serialized.graph),
       assetPublicIds: serialized.assetPublicIds,
       bundleContentHashes: serialized.bundleContentHashes,
-      publicIdByAssetId: serialized.publicIdByAssetId
+      publicIdByAssetId: serialized.publicIdByAssetId,
+      conditions: serialized.conditions
     });
   }
   createBundle(opts) {
@@ -768,7 +822,7 @@ class BundleGraph {
       return true;
     }
     let assetNodeId = (0, _nullthrows().default)(this._graph.getNodeIdByContentKey(asset.id));
-    if (this._graph.getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references).map(id => this._graph.getNode(id)).some(node => (node === null || node === void 0 ? void 0 : node.type) === 'dependency' && node.value.priority === _types.Priority.lazy && node.value.specifierType !== _types.SpecifierType.url)) {
+    if (this._graph.getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references).map(id => this._graph.getNode(id)).some(node => (node === null || node === void 0 ? void 0 : node.type) === 'dependency' && (node.value.priority === _types.Priority.lazy || node.value.priority === _types.Priority.conditional) && node.value.specifierType !== _types.SpecifierType.url)) {
       // If this asset is referenced by any async dependency, it's referenced.
       return true;
     }

package/lib/RequestTracker.js

@@ -465,18 +465,32 @@ class RequestGraph extends _graph().ContentGraph {
       return node;
     });
   }
-  invalidateFileNameNode(node, filePath, matchNodes) {
+  invalidateFileNameNode(node, filePath, matchNodes, invalidateNode) {
     // If there is an edge between this file_name node and one of the original file nodes pointed to
     // by the original file_name node, and the matched node is inside the current directory, invalidate
     // all connected requests pointed to by the file node.
-    let dirname = _path2().default.dirname((0, _projectPath.fromProjectPathRelative)(filePath));
+
     let nodeId = this.getNodeIdByContentKey(node.id);
-    for (let matchNode of matchNodes) {
-      let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
-      if (this.hasEdge(nodeId, matchNodeId, requestGraphEdgeTypes.invalidated_by_create_above) && (0, _utils().isDirectoryInside)((0, _projectPath.fromProjectPathRelative)((0, _projectPath.toProjectPathUnsafe)(matchNode.id)), dirname)) {
-        let connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, requestGraphEdgeTypes.invalidated_by_create);
+    let dirname = _path2().default.dirname((0, _projectPath.fromProjectPathRelative)(filePath));
+    if ((0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation')) {
+      while (dirname !== '/') {
+        if (!this.hasContentKey(dirname)) break;
+        const matchNodeId = this.getNodeIdByContentKey(dirname);
+        if (!this.hasEdge(nodeId, matchNodeId, requestGraphEdgeTypes.invalidated_by_create_above)) break;
+        const connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, requestGraphEdgeTypes.invalidated_by_create);
         for (let connectedNode of connectedNodes) {
-          this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+          invalidateNode(connectedNode, _constants.FILE_CREATE);
+        }
+        dirname = _path2().default.dirname(dirname);
+      }
+    } else {
+      for (let matchNode of matchNodes) {
+        let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
+        if (this.hasEdge(nodeId, matchNodeId, requestGraphEdgeTypes.invalidated_by_create_above) && (0, _utils().isDirectoryInside)((0, _projectPath.fromProjectPathRelative)((0, _projectPath.toProjectPathUnsafe)(matchNode.id)), dirname)) {
+          let connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, requestGraphEdgeTypes.invalidated_by_create);
+          for (let connectedNode of connectedNodes) {
+            this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+          }
         }
       }
     }
@@ -489,7 +503,7 @@ class RequestGraph extends _graph().ContentGraph {
       if (this.hasEdge(nodeId, this.getNodeIdByContentKey(contentKey), requestGraphEdgeTypes.dirname)) {
         let parent = (0, _nullthrows().default)(this.getNodeByContentKey(contentKey));
         (0, _assert().default)(parent.type === FILE_NAME);
-        this.invalidateFileNameNode(parent, (0, _projectPath.toProjectPathUnsafe)(dirname), matchNodes);
+        this.invalidateFileNameNode(parent, (0, _projectPath.toProjectPathUnsafe)(dirname), matchNodes, invalidateNode);
       }
     }
   }
@@ -498,12 +512,38 @@ class RequestGraph extends _graph().ContentGraph {
     let count = 0;
     let predictedTime = 0;
     let startTime = Date.now();
-    const removeOrphans = !(0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation');
+    const enableOptimization = (0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation');
+    const removeOrphans = !enableOptimization;
+    const invalidatedNodes = new Set();
+    const invalidateNode = (nodeId, reason) => {
+      if (enableOptimization && invalidatedNodes.has(nodeId)) {
+        return;
+      }
+      invalidatedNodes.add(nodeId);
+      this.invalidateNode(nodeId, reason);
+    };
+    const aboveCache = new Map();
+    const getAbove = fileNameNodeId => {
+      const cachedResult = aboveCache.get(fileNameNodeId);
+      if (enableOptimization && cachedResult) {
+        return cachedResult;
+      }
+      let above = [];
+      const children = this.getNodeIdsConnectedTo(fileNameNodeId, requestGraphEdgeTypes.invalidated_by_create_above);
+      for (const nodeId of children) {
+        let node = (0, _nullthrows().default)(this.getNode(nodeId));
+        if (node.type === FILE) {
+          above.push(node);
+        }
+      }
+      aboveCache.set(fileNameNodeId, above);
+      return above;
+    };
     for (let {
       path: _path,
       type
     } of events) {
-      if (++count === 256) {
+      if (!enableOptimization && process.env.ATLASPACK_DISABLE_CACHE_TIMEOUT !== 'true' && ++count === 256) {
         let duration = Date.now() - startTime;
         predictedTime = duration * (events.length >> 8);
         if (predictedTime > threshold) {
@@ -550,13 +590,13 @@ class RequestGraph extends _graph().ContentGraph {
         let nodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update);
         for (let connectedNode of nodes) {
           didInvalidate = true;
-          this.invalidateNode(connectedNode, _constants.FILE_UPDATE);
+          invalidateNode(connectedNode, _constants.FILE_UPDATE);
         }
         if (type === 'create') {
           let nodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_create);
           for (let connectedNode of nodes) {
             didInvalidate = true;
-            this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+            invalidateNode(connectedNode, _constants.FILE_CREATE);
           }
         }
       } else if (type === 'create') {
@@ -566,17 +606,10 @@ class RequestGraph extends _graph().ContentGraph {
           let fileNameNodeId = this.getNodeIdByContentKey('file_name:' + basename);
 
           // Find potential file nodes to be invalidated if this file name pattern matches
-          let above = [];
-          for (const nodeId of this.getNodeIdsConnectedTo(fileNameNodeId, requestGraphEdgeTypes.invalidated_by_create_above)) {
-            let node = (0, _nullthrows().default)(this.getNode(nodeId));
-            // these might also be `glob` nodes which get handled below, we only care about files here.
-            if (node.type === FILE) {
-              above.push(node);
-            }
-          }
+          let above = getAbove(fileNameNodeId);
           if (above.length > 0) {
             didInvalidate = true;
-            this.invalidateFileNameNode(fileNameNode, _filePath, above);
+            this.invalidateFileNameNode(fileNameNode, _filePath, above, invalidateNode);
           }
         }
         for (let globeNodeId of this.globNodeIds) {
@@ -586,7 +619,7 @@ class RequestGraph extends _graph().ContentGraph {
             let connectedNodes = this.getNodeIdsConnectedTo(globeNodeId, requestGraphEdgeTypes.invalidated_by_create);
             for (let connectedNode of connectedNodes) {
               didInvalidate = true;
-              this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+              invalidateNode(connectedNode, _constants.FILE_CREATE);
             }
           }
         }
@@ -594,7 +627,7 @@ class RequestGraph extends _graph().ContentGraph {
         let nodeId = this.getNodeIdByContentKey(filePath);
         for (let connectedNode of this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_delete)) {
           didInvalidate = true;
-          this.invalidateNode(connectedNode, _constants.FILE_DELETE);
+          invalidateNode(connectedNode, _constants.FILE_DELETE);
         }
 
         // Delete the file node since it doesn't exist anymore.
@@ -614,7 +647,7 @@ class RequestGraph extends _graph().ContentGraph {
           }
           if (isInvalid) {
             for (let connectedNode of this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update)) {
-              this.invalidateNode(connectedNode, type === 'delete' ? _constants.FILE_DELETE : _constants.FILE_UPDATE);
+              invalidateNode(connectedNode, type === 'delete' ? _constants.FILE_DELETE : _constants.FILE_UPDATE);
             }
             didInvalidate = true;
             this.removeNode(nodeId, removeOrphans);
@@ -632,7 +665,9 @@ class RequestGraph extends _graph().ContentGraph {
       meta: {
         trackableEvent: 'fsevent_response_time',
         duration,
-        predictedTime
+        predictedTime,
+        numberOfEvents: events.length,
+        numberOfInvalidatedNodes: invalidatedNodes.size
       }
     });
     return didInvalidate && this.invalidNodeIds.size > 0;
@@ -1035,7 +1070,16 @@ async function loadRequestGraph(options) {
   let cacheKey = getCacheKey(options);
   let requestGraphKey = `requestGraph-${cacheKey}`;
   let timeout;
-  const snapshotPath = _path2().default.join(options.cacheDir, `snapshot-${cacheKey}` + '.txt');
+  const snapshotKey = `snapshot-${cacheKey}`;
+  const snapshotPath = _path2().default.join(options.cacheDir, snapshotKey + '.txt');
+  _logger().default.verbose({
+    origin: '@atlaspack/core',
+    message: 'Loading request graph',
+    meta: {
+      cacheKey,
+      snapshotKey
+    }
+  });
   if (await options.cache.hasLargeBlob(requestGraphKey)) {
     try {
       let {
@@ -1075,6 +1119,14 @@ async function loadRequestGraph(options) {
       return new RequestGraph();
     }
   }
+  _logger().default.verbose({
+    origin: '@atlaspack/core',
+    message: 'Cache entry for request tracker was not found, initializing a clean cache.',
+    meta: {
+      cacheKey,
+      snapshotKey
+    }
+  });
   return new RequestGraph();
 }
 function logErrorOnBailout(options, snapshotPath, e) {
@@ -1101,6 +1153,9 @@ function logErrorOnBailout(options, snapshotPath, e) {
   }
 }
 function cleanUpOrphans(graph) {
+  if (graph.rootNodeId == null) {
+    return [];
+  }
   const reachableNodes = new Set();
   graph.traverse(nodeId => {
     reachableNodes.add(nodeId);

package/lib/SymbolPropagation.js

@@ -108,7 +108,7 @@ function propagateSymbols({
       namespaceReexportedSymbols.add('*');
     } else {
       for (let incomingDep of incomingDeps) {
-        if (incomingDep.value.symbols == null) {
+        if (incomingDep.value.symbols == null || incomingDep.value.priority === _types.Priority.conditional) {
           if (incomingDep.value.sourceAssetId == null) {
             // The root dependency on non-library builds
             isEntry = true;

package/lib/atlaspack-v3/worker/worker.js

@@ -180,5 +180,6 @@ napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorke
 const PriorityMap = {
   sync: 0,
   parallel: 1,
-  lazy: 2
+  lazy: 2,
+  conditional: 3
 };

package/lib/public/BundleGraph.js

@@ -189,5 +189,73 @@ class BundleGraph {
   getEntryRoot(target) {
     return this.#graph.getEntryRoot(this.#options.projectRoot, (0, _Target.targetToInternalTarget)(target));
   }
+
+  // Given a set of dependencies, return any conditions where those dependencies are either
+  // the true or false dependency for those conditions. This is currently used to work out which
+  // conditions belong to a bundle in packaging.
+  getConditionsForDependencies(deps) {
+    const conditions = new Set();
+    const depIds = deps.map(dep => dep.id);
+    for (const condition of this.#graph._conditions.values()) {
+      if (depIds.includes(condition.ifTrueDependency.id) || depIds.includes(condition.ifFalseDependency.id)) {
+        const [trueAsset, falseAsset] = [condition.ifTrueDependency, condition.ifFalseDependency].map(dep => {
+          const resolved = (0, _nullthrows().default)(this.#graph.resolveAsyncDependency(dep));
+          if (resolved.type === 'asset') {
+            return resolved.value;
+          } else {
+            return this.#graph.getAssetById(resolved.value.entryAssetId);
+          }
+        });
+        conditions.add({
+          publicId: condition.publicId,
+          key: condition.key,
+          ifTrueDependency: (0, _nullthrows().default)(deps.find(dep => dep.id === condition.ifTrueDependency.id), 'ifTrueDependency was null'),
+          ifFalseDependency: (0, _nullthrows().default)(deps.find(dep => dep.id === condition.ifFalseDependency.id), 'ifFalseDependency was null'),
+          ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
+          ifFalseAssetId: this.#graph.getAssetPublicId(falseAsset)
+        });
+      }
+    }
+    return conditions;
+  }
+
+  // This is used to generate information for building a manifest that can
+  // be used by a webserver to understand which conditions are used by which bundles,
+  // and which bundles those conditions require depending on what they evaluate to.
+  getConditionalBundleMapping() {
+    let bundleConditions = new Map();
+
+    // Convert the internal references in conditions to public API references
+    for (const cond of this.#graph._conditions.values()) {
+      let assets = Array.from(cond.assets).map(asset => (0, _nullthrows().default)(this.getAssetById(asset.id)));
+      let bundles = new Set();
+      let ifTrueBundles = [];
+      let ifFalseBundles = [];
+      for (const asset of assets) {
+        const bundlesWithAsset = this.getBundlesWithAsset(asset);
+        for (const bundle of bundlesWithAsset) {
+          bundles.add(bundle);
+        }
+        const assetDeps = this.getDependencies(asset);
+        const depToBundles = dep => {
+          const publicDep = (0, _nullthrows().default)(assetDeps.find(assetDep => dep.id === assetDep.id));
+          const resolved = (0, _nullthrows().default)(this.resolveAsyncDependency(publicDep));
+          (0, _assert().default)(resolved.type === 'bundle_group');
+          return this.getBundlesInBundleGroup(resolved.value);
+        };
+        ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+        ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
+      }
+      for (let bundle of bundles) {
+        const conditions = bundleConditions.get(bundle) ?? new Map();
+        conditions.set(cond.key, {
+          ifTrueBundles,
+          ifFalseBundles
+        });
+        bundleConditions.set(bundle, conditions);
+      }
+    }
+    return bundleConditions;
+  }
 }
 exports.default = BundleGraph;

package/lib/resolveOptions.js

@@ -197,6 +197,8 @@ async function resolveOptions(initialOptions) {
       outputFormat: initialOptions === null || initialOptions === void 0 || (_initialOptions$defau8 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau8 === void 0 ? void 0 : _initialOptions$defau8.outputFormat,
       isLibrary: initialOptions === null || initialOptions === void 0 || (_initialOptions$defau9 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau9 === void 0 ? void 0 : _initialOptions$defau9.isLibrary
     },
+    // unused, feature-flags are set above this to allow this function to use
+    // feature-flags
     featureFlags: {
       ..._featureFlags().DEFAULT_FEATURE_FLAGS,
       ...(initialOptions === null || initialOptions === void 0 ? void 0 : initialOptions.featureFlags)

package/lib/types.js

@@ -13,7 +13,8 @@ const SpecifierType = exports.SpecifierType = {
 const Priority = exports.Priority = {
   sync: 0,
   parallel: 1,
-  lazy: 2
+  lazy: 2,
+  conditional: 3
 };
 
 // Must match package_json.rs in node-resolver-rs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3431+e27623c56",
+  "version": "2.12.1-canary.3434+c61bf3cde",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/diagnostic": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/events": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/feature-flags": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/fs": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/graph": "3.2.1-canary.3431+e27623c56",
-    "@atlaspack/logger": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/package-manager": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/plugin": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/profiler": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/rust": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/types": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/utils": "2.12.1-canary.3431+e27623c56",
-    "@atlaspack/workers": "2.12.1-canary.3431+e27623c56",
+    "@atlaspack/cache": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/diagnostic": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/events": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/feature-flags": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/fs": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/graph": "3.2.1-canary.3434+c61bf3cde",
+    "@atlaspack/logger": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/package-manager": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/plugin": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/profiler": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/rust": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/types": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/utils": "2.12.1-canary.3434+c61bf3cde",
+    "@atlaspack/workers": "2.12.1-canary.3434+c61bf3cde",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -57,5 +57,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "e27623c56ff5bea187652ecb09db27db527ecd9e"
+  "gitHead": "c61bf3cde53d1cdb5ae13541c644a6e3ef5521e1"
 }

package/src/Atlaspack.js

@@ -57,7 +57,7 @@ import {
   fromProjectPathRelative,
 } from './projectPath';
 import {tracer} from '@atlaspack/profiler';
-import {setFeatureFlags} from '@atlaspack/feature-flags';
+import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
 import {AtlaspackV3, toFileSystemV3} from './atlaspack-v3';
 
 registerCoreWithSerializer();
@@ -105,6 +105,12 @@ export default class Atlaspack {
       return;
     }
 
+    const featureFlags = {
+      ...DEFAULT_FEATURE_FLAGS,
+      ...this.#initialOptions.featureFlags,
+    };
+    setFeatureFlags(featureFlags);
+
     await initSourcemaps;
     await initRust?.();
     try {
@@ -117,9 +123,10 @@ export default class Atlaspack {
       logger.warn(e);
     }
 
-    let resolvedOptions: AtlaspackOptions = await resolveOptions(
-      this.#initialOptions,
-    );
+    let resolvedOptions: AtlaspackOptions = await resolveOptions({
+      ...this.#initialOptions,
+      featureFlags,
+    });
     this.#resolvedOptions = resolvedOptions;
 
     let rustAtlaspack: AtlaspackV3;
@@ -152,8 +159,6 @@ export default class Atlaspack {
       });
     }
 
-    setFeatureFlags(resolvedOptions.featureFlags);
-
     let {config} = await loadAtlaspackConfig(resolvedOptions);
     this.#config = new AtlaspackConfig(config, resolvedOptions);
 
@@ -544,6 +549,10 @@ export default class Atlaspack {
     return this.#farm.takeHeapSnapshot();
   }
 
+  async unstable_invalidate(): Promise<void> {
+    await this._init();
+  }
+
   async unstable_transform(
     options: AtlaspackTransformOptions,
   ): Promise<Array<Asset>> {

package/src/BundleGraph.js

@@ -6,6 +6,7 @@ import type {
   Symbol,
   TraversalActions,
   BundleBehavior as IBundleBehavior,
+  ConditionMeta,
 } from '@atlaspack/types';
 import type {
   ContentKey,
@@ -26,6 +27,7 @@ import type {
   Environment,
   InternalSourceLocation,
   Target,
+  Condition,
 } from './types';
 import type AssetGraph from './AssetGraph';
 import type {ProjectPath} from './projectPath';
@@ -46,6 +48,7 @@ import {getBundleGroupId, getPublicId} from './utils';
 import {ISOLATED_ENVS} from './public/Environment';
 import {fromProjectPath, fromProjectPathRelative} from './projectPath';
 import {HASH_REF_PREFIX} from './constants';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 export const bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -91,6 +94,7 @@ type BundleGraphOpts = {|
   bundleContentHashes: Map<string, string>,
   assetPublicIds: Set<string>,
   publicIdByAssetId: Map<string, string>,
+  conditions: Map<string, Condition>,
 |};
 
 type SerializedBundleGraph = {|
@@ -99,6 +103,7 @@ type SerializedBundleGraph = {|
   bundleContentHashes: Map<string, string>,
   assetPublicIds: Set<string>,
   publicIdByAssetId: Map<string, string>,
+  conditions: Map<string, Condition>,
 |};
 
 function makeReadOnlySet<T>(set: Set<T>): $ReadOnlySet<T> {
@@ -139,22 +144,26 @@ export default class BundleGraph {
   /** The internal core Graph structure */
   _graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>;
   _bundlePublicIds /*: Set<string> */ = new Set<string>();
+  _conditions /*: Map<string, Condition> */ = new Map<string, Condition>();
 
   constructor({
     graph,
     publicIdByAssetId,
     assetPublicIds,
     bundleContentHashes,
+    conditions,
   }: {|
     graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>,
     publicIdByAssetId: Map<string, string>,
     assetPublicIds: Set<string>,
     bundleContentHashes: Map<string, string>,
+    conditions: Map<string, Condition>,
   |}) {
     this._graph = graph;
     this._assetPublicIds = assetPublicIds;
     this._publicIdByAssetId = publicIdByAssetId;
     this._bundleContentHashes = bundleContentHashes;
+    this._conditions = conditions;
   }
 
   /**
@@ -171,6 +180,9 @@ export default class BundleGraph {
     let assetGroupIds = new Map();
     let dependencies = new Map();
     let assetGraphNodeIdToBundleGraphNodeId = new Map<NodeId, NodeId>();
+    let conditions = new Map<string, Condition>();
+
+    let placeholderToDependency = new Map<string, Dependency>();
 
     let assetGraphRootNode =
       assetGraph.rootNodeId != null
@@ -195,6 +207,20 @@ export default class BundleGraph {
         }
       } else if (node != null && node.type === 'asset_group') {
         assetGroupIds.set(nodeId, assetGraph.getNodeIdsConnectedFrom(nodeId));
+      } else if (
+        getFeatureFlag('conditionalBundlingApi') &&
+        node != null &&
+        node.type === 'dependency'
+      ) {
+        // The dependency placeholders in the `importCond` calls that will be in the transformed
+        // code need to be mapped to the "real" dependencies, so we need access to a map of placeholders
+        // to dependencies
+        const dep = node.value;
+        // $FlowFixMe[incompatible-type] Meta is untyped
+        const placeholder: string | void = dep.meta?.placeholder;
+        if (placeholder != null) {
+          placeholderToDependency.set(placeholder, dep);
+        }
       }
     });
 
@@ -204,6 +230,51 @@ export default class BundleGraph {
       walkVisited.add(nodeId);
 
       let node = nullthrows(assetGraph.getNode(nodeId));
+
+      if (getFeatureFlag('conditionalBundlingApi') && node.type === 'asset') {
+        const asset = node.value;
+        if (Array.isArray(asset.meta.conditions)) {
+          // $FlowFixMe
+          for (const condition of (asset.meta.conditions: ConditionMeta[])) {
+            // Resolve the placeholders that were attached to the asset in JSTransformer to dependencies,
+            // as well as create a public id for the condition.
+            const {
+              key,
+              ifTruePlaceholder,
+              ifFalsePlaceholder,
+            }: {
+              key: string,
+              ifTruePlaceholder: string,
+              ifFalsePlaceholder: string,
+              ...
+            } = condition;
+
+            const condHash = hashString(
+              `${key}:${ifTruePlaceholder}:${ifFalsePlaceholder}`,
+            );
+            const condPublicId = getPublicId(condHash, v => conditions.has(v));
+
+            if (conditions.has(condHash)) {
+              throw new Error('Unexpected duplicate asset');
+            } else {
+              conditions.set(condHash, {
+                publicId: condPublicId,
+                assets: new Set([asset]),
+                key,
+                ifTrueDependency: nullthrows(
+                  placeholderToDependency.get(ifTruePlaceholder),
+                  'ifTruePlaceholder was undefined',
+                ),
+                ifFalseDependency: nullthrows(
+                  placeholderToDependency.get(ifFalsePlaceholder),
+                  'ifFalsePlaceholder was undefined',
+                ),
+              });
+            }
+          }
+        }
+      }
+
       if (
         node.type === 'dependency' &&
         node.value.symbols != null &&
@@ -440,11 +511,13 @@ export default class BundleGraph {
         );
       }
     }
+
     return new BundleGraph({
       graph,
       assetPublicIds,
       bundleContentHashes: new Map(),
       publicIdByAssetId,
+      conditions,
     });
   }
 
@@ -455,6 +528,7 @@ export default class BundleGraph {
       assetPublicIds: this._assetPublicIds,
       bundleContentHashes: this._bundleContentHashes,
       publicIdByAssetId: this._publicIdByAssetId,
+      conditions: this._conditions,
     };
   }
 
@@ -464,6 +538,7 @@ export default class BundleGraph {
       assetPublicIds: serialized.assetPublicIds,
       bundleContentHashes: serialized.bundleContentHashes,
       publicIdByAssetId: serialized.publicIdByAssetId,
+      conditions: serialized.conditions,
     });
   }
 
@@ -1215,7 +1290,8 @@ export default class BundleGraph {
         .some(
           node =>
             node?.type === 'dependency' &&
-            node.value.priority === Priority.lazy &&
+            (node.value.priority === Priority.lazy ||
+              node.value.priority === Priority.conditional) &&
             node.value.specifierType !== SpecifierType.url,
         )
     ) {

package/src/RequestTracker.js

@@ -818,32 +818,59 @@ export class RequestGraph extends ContentGraph<
     node: FileNameNode,
     filePath: ProjectPath,
     matchNodes: Array<FileNode>,
+    invalidateNode: (NodeId, InvalidateReason) => void,
   ) {
     // If there is an edge between this file_name node and one of the original file nodes pointed to
     // by the original file_name node, and the matched node is inside the current directory, invalidate
     // all connected requests pointed to by the file node.
-    let dirname = path.dirname(fromProjectPathRelative(filePath));
 
     let nodeId = this.getNodeIdByContentKey(node.id);
-    for (let matchNode of matchNodes) {
-      let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
-      if (
-        this.hasEdge(
-          nodeId,
-          matchNodeId,
-          requestGraphEdgeTypes.invalidated_by_create_above,
-        ) &&
-        isDirectoryInside(
-          fromProjectPathRelative(toProjectPathUnsafe(matchNode.id)),
-          dirname,
+    let dirname = path.dirname(fromProjectPathRelative(filePath));
+
+    if (getFeatureFlag('fixQuadraticCacheInvalidation')) {
+      while (dirname !== '/') {
+        if (!this.hasContentKey(dirname)) break;
+        const matchNodeId = this.getNodeIdByContentKey(dirname);
+        if (
+          !this.hasEdge(
+            nodeId,
+            matchNodeId,
+            requestGraphEdgeTypes.invalidated_by_create_above,
+          )
         )
-      ) {
-        let connectedNodes = this.getNodeIdsConnectedTo(
+          break;
+
+        const connectedNodes = this.getNodeIdsConnectedTo(
           matchNodeId,
           requestGraphEdgeTypes.invalidated_by_create,
         );
         for (let connectedNode of connectedNodes) {
-          this.invalidateNode(connectedNode, FILE_CREATE);
+          invalidateNode(connectedNode, FILE_CREATE);
+        }
+
+        dirname = path.dirname(dirname);
+      }
+    } else {
+      for (let matchNode of matchNodes) {
+        let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
+        if (
+          this.hasEdge(
+            nodeId,
+            matchNodeId,
+            requestGraphEdgeTypes.invalidated_by_create_above,
+          ) &&
+          isDirectoryInside(
+            fromProjectPathRelative(toProjectPathUnsafe(matchNode.id)),
+            dirname,
+          )
+        ) {
+          let connectedNodes = this.getNodeIdsConnectedTo(
+            matchNodeId,
+            requestGraphEdgeTypes.invalidated_by_create,
+          );
+          for (let connectedNode of connectedNodes) {
+            this.invalidateNode(connectedNode, FILE_CREATE);
+          }
         }
       }
     }
@@ -866,6 +893,7 @@ export class RequestGraph extends ContentGraph<
           parent,
           toProjectPathUnsafe(dirname),
           matchNodes,
+          invalidateNode,
         );
       }
     }
@@ -880,10 +908,45 @@ export class RequestGraph extends ContentGraph<
     let count = 0;
     let predictedTime = 0;
     let startTime = Date.now();
-    const removeOrphans = !getFeatureFlag('fixQuadraticCacheInvalidation');
+    const enableOptimization = getFeatureFlag('fixQuadraticCacheInvalidation');
+    const removeOrphans = !enableOptimization;
+
+    const invalidatedNodes = new Set();
+    const invalidateNode = (nodeId, reason) => {
+      if (enableOptimization && invalidatedNodes.has(nodeId)) {
+        return;
+      }
+      invalidatedNodes.add(nodeId);
+      this.invalidateNode(nodeId, reason);
+    };
+    const aboveCache = new Map();
+    const getAbove = fileNameNodeId => {
+      const cachedResult = aboveCache.get(fileNameNodeId);
+      if (enableOptimization && cachedResult) {
+        return cachedResult;
+      }
+
+      let above = [];
+      const children = this.getNodeIdsConnectedTo(
+        fileNameNodeId,
+        requestGraphEdgeTypes.invalidated_by_create_above,
+      );
+      for (const nodeId of children) {
+        let node = nullthrows(this.getNode(nodeId));
+        if (node.type === FILE) {
+          above.push(node);
+        }
+      }
+      aboveCache.set(fileNameNodeId, above);
+      return above;
+    };
 
     for (let {path: _path, type} of events) {
-      if (++count === 256) {
+      if (
+        !enableOptimization &&
+        process.env.ATLASPACK_DISABLE_CACHE_TIMEOUT !== 'true' &&
+        ++count === 256
+      ) {
         let duration = Date.now() - startTime;
         predictedTime = duration * (events.length >> 8);
         if (predictedTime > threshold) {
@@ -939,7 +1002,7 @@ export class RequestGraph extends ContentGraph<
 
         for (let connectedNode of nodes) {
           didInvalidate = true;
-          this.invalidateNode(connectedNode, FILE_UPDATE);
+          invalidateNode(connectedNode, FILE_UPDATE);
         }
 
         if (type === 'create') {
@@ -949,7 +1012,7 @@ export class RequestGraph extends ContentGraph<
           );
           for (let connectedNode of nodes) {
             didInvalidate = true;
-            this.invalidateNode(connectedNode, FILE_CREATE);
+            invalidateNode(connectedNode, FILE_CREATE);
           }
         }
       } else if (type === 'create') {
@@ -961,21 +1024,15 @@ export class RequestGraph extends ContentGraph<
           );
 
           // Find potential file nodes to be invalidated if this file name pattern matches
-          let above: Array<FileNode> = [];
-          for (const nodeId of this.getNodeIdsConnectedTo(
-            fileNameNodeId,
-            requestGraphEdgeTypes.invalidated_by_create_above,
-          )) {
-            let node = nullthrows(this.getNode(nodeId));
-            // these might also be `glob` nodes which get handled below, we only care about files here.
-            if (node.type === FILE) {
-              above.push(node);
-            }
-          }
-
+          let above: Array<FileNode> = getAbove(fileNameNodeId);
           if (above.length > 0) {
             didInvalidate = true;
-            this.invalidateFileNameNode(fileNameNode, _filePath, above);
+            this.invalidateFileNameNode(
+              fileNameNode,
+              _filePath,
+              above,
+              invalidateNode,
+            );
           }
         }
 
@@ -990,7 +1047,7 @@ export class RequestGraph extends ContentGraph<
             );
             for (let connectedNode of connectedNodes) {
               didInvalidate = true;
-              this.invalidateNode(connectedNode, FILE_CREATE);
+              invalidateNode(connectedNode, FILE_CREATE);
             }
           }
         }
@@ -1001,7 +1058,7 @@ export class RequestGraph extends ContentGraph<
           requestGraphEdgeTypes.invalidated_by_delete,
         )) {
           didInvalidate = true;
-          this.invalidateNode(connectedNode, FILE_DELETE);
+          invalidateNode(connectedNode, FILE_DELETE);
         }
 
         // Delete the file node since it doesn't exist anymore.
@@ -1033,7 +1090,7 @@ export class RequestGraph extends ContentGraph<
               nodeId,
               requestGraphEdgeTypes.invalidated_by_update,
             )) {
-              this.invalidateNode(
+              invalidateNode(
                 connectedNode,
                 type === 'delete' ? FILE_DELETE : FILE_UPDATE,
               );
@@ -1057,6 +1114,8 @@ export class RequestGraph extends ContentGraph<
         trackableEvent: 'fsevent_response_time',
         duration,
         predictedTime,
+        numberOfEvents: events.length,
+        numberOfInvalidatedNodes: invalidatedNodes.size,
       },
     });
 
@@ -1615,6 +1674,15 @@ async function loadRequestGraph(options): Async<RequestGraph> {
   let timeout;
   const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = path.join(options.cacheDir, snapshotKey + '.txt');
+
+  logger.verbose({
+    origin: '@atlaspack/core',
+    message: 'Loading request graph',
+    meta: {
+      cacheKey,
+      snapshotKey,
+    },
+  });
   if (await options.cache.hasLargeBlob(requestGraphKey)) {
     try {
       let {requestGraph} = await readAndDeserializeRequestGraph(
@@ -1670,6 +1738,15 @@ async function loadRequestGraph(options): Async<RequestGraph> {
     }
   }
 
+  logger.verbose({
+    origin: '@atlaspack/core',
+    message:
+      'Cache entry for request tracker was not found, initializing a clean cache.',
+    meta: {
+      cacheKey,
+      snapshotKey,
+    },
+  });
   return new RequestGraph();
 }
 
@@ -1705,6 +1782,10 @@ function logErrorOnBailout(
 }
 
 export function cleanUpOrphans<N, E: number>(graph: Graph<N, E>): NodeId[] {
+  if (graph.rootNodeId == null) {
+    return [];
+  }
+
   const reachableNodes = new Set();
   graph.traverse(nodeId => {
     reachableNodes.add(nodeId);

package/src/SymbolPropagation.js

@@ -16,7 +16,7 @@ import nullthrows from 'nullthrows';
 import {setEqual} from '@atlaspack/utils';
 import logger from '@atlaspack/logger';
 import {md, convertSourceLocationToHighlight} from '@atlaspack/diagnostic';
-import {BundleBehavior} from './types';
+import {BundleBehavior, Priority} from './types';
 import {fromProjectPathRelative, fromProjectPath} from './projectPath';
 
 export function propagateSymbols({
@@ -101,7 +101,10 @@ export function propagateSymbols({
         namespaceReexportedSymbols.add('*');
       } else {
         for (let incomingDep of incomingDeps) {
-          if (incomingDep.value.symbols == null) {
+          if (
+            incomingDep.value.symbols == null ||
+            incomingDep.value.priority === Priority.conditional
+          ) {
             if (incomingDep.value.sourceAssetId == null) {
               // The root dependency on non-library builds
               isEntry = true;

package/src/atlaspack-v3/worker/worker.js

@@ -217,4 +217,5 @@ const PriorityMap = {
   sync: 0,
   parallel: 1,
   lazy: 2,
+  conditional: 3,
 };

package/src/public/BundleGraph.js

@@ -332,4 +332,110 @@ export default class BundleGraph<TBundle: IBundle>
       targetToInternalTarget(target),
     );
   }
+
+  // Given a set of dependencies, return any conditions where those dependencies are either
+  // the true or false dependency for those conditions. This is currently used to work out which
+  // conditions belong to a bundle in packaging.
+  getConditionsForDependencies(deps: Array<IDependency>): Set<{|
+    publicId: string,
+    key: string,
+    ifTrueDependency: IDependency,
+    ifFalseDependency: IDependency,
+    ifTrueAssetId: string,
+    ifFalseAssetId: string,
+  |}> {
+    const conditions = new Set();
+    const depIds = deps.map(dep => dep.id);
+    for (const condition of this.#graph._conditions.values()) {
+      if (
+        depIds.includes(condition.ifTrueDependency.id) ||
+        depIds.includes(condition.ifFalseDependency.id)
+      ) {
+        const [trueAsset, falseAsset] = [
+          condition.ifTrueDependency,
+          condition.ifFalseDependency,
+        ].map(dep => {
+          const resolved = nullthrows(this.#graph.resolveAsyncDependency(dep));
+          if (resolved.type === 'asset') {
+            return resolved.value;
+          } else {
+            return this.#graph.getAssetById(resolved.value.entryAssetId);
+          }
+        });
+
+        conditions.add({
+          publicId: condition.publicId,
+          key: condition.key,
+          ifTrueDependency: nullthrows(
+            deps.find(dep => dep.id === condition.ifTrueDependency.id),
+            'ifTrueDependency was null',
+          ),
+          ifFalseDependency: nullthrows(
+            deps.find(dep => dep.id === condition.ifFalseDependency.id),
+            'ifFalseDependency was null',
+          ),
+          ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
+          ifFalseAssetId: this.#graph.getAssetPublicId(falseAsset),
+        });
+      }
+    }
+
+    return conditions;
+  }
+
+  // This is used to generate information for building a manifest that can
+  // be used by a webserver to understand which conditions are used by which bundles,
+  // and which bundles those conditions require depending on what they evaluate to.
+  getConditionalBundleMapping(): Map<
+    TBundle,
+    Map<
+      string,
+      {|
+        ifTrueBundles: Array<TBundle>,
+        ifFalseBundles: Array<TBundle>,
+      |},
+    >,
+  > {
+    let bundleConditions = new Map();
+
+    // Convert the internal references in conditions to public API references
+    for (const cond of this.#graph._conditions.values()) {
+      let assets = Array.from(cond.assets).map(asset =>
+        nullthrows(this.getAssetById(asset.id)),
+      );
+      let bundles = new Set<TBundle>();
+      let ifTrueBundles = [];
+      let ifFalseBundles = [];
+      for (const asset of assets) {
+        const bundlesWithAsset = this.getBundlesWithAsset(asset);
+        for (const bundle of bundlesWithAsset) {
+          bundles.add(bundle);
+        }
+        const assetDeps = this.getDependencies(asset);
+        const depToBundles = dep => {
+          const publicDep = nullthrows(
+            assetDeps.find(assetDep => dep.id === assetDep.id),
+          );
+          const resolved = nullthrows(this.resolveAsyncDependency(publicDep));
+          invariant(resolved.type === 'bundle_group');
+          return this.getBundlesInBundleGroup(resolved.value);
+        };
+        ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+        ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
+      }
+
+      for (let bundle of bundles) {
+        const conditions = bundleConditions.get(bundle) ?? new Map();
+
+        conditions.set(cond.key, {
+          ifTrueBundles,
+          ifFalseBundles,
+        });
+
+        bundleConditions.set(bundle, conditions);
+      }
+    }
+
+    return bundleConditions;
+  }
 }

package/src/resolveOptions.js

@@ -231,6 +231,8 @@ export default async function resolveOptions(
       outputFormat: initialOptions?.defaultTargetOptions?.outputFormat,
       isLibrary: initialOptions?.defaultTargetOptions?.isLibrary,
     },
+    // unused, feature-flags are set above this to allow this function to use
+    // feature-flags
     featureFlags: {...DEFAULT_FEATURE_FLAGS, ...initialOptions?.featureFlags},
     parcelVersion: ATLASPACK_VERSION,
   };

package/src/types.js

@@ -115,6 +115,7 @@ export const Priority = {
   sync: 0,
   parallel: 1,
   lazy: 2,
+  conditional: 3,
 };
 
 // Must match package_json.rs in node-resolver-rs.
@@ -542,6 +543,7 @@ export type Bundle = {|
   displayName: ?string,
   pipeline: ?string,
   manualSharedBundle?: ?string,
+  conditions?: Map<string, string>,
 |};
 
 export type BundleNode = {|
@@ -580,3 +582,11 @@ export type ValidationOpts = {|
 |};
 
 export type ReportFn = (event: ReporterEvent) => void | Promise<void>;
+
+export type Condition = {|
+  publicId: string,
+  assets: Set<Asset>,
+  key: string,
+  ifTrueDependency: Dependency,
+  ifFalseDependency: Dependency,
+|};

package/test/PublicBundle.test.js

@@ -42,6 +42,7 @@ describe('Public Bundle', () => {
       assetPublicIds: new Set(),
       publicIdByAssetId: new Map(),
       bundleContentHashes: new Map(),
+      conditions: new Map(),
     });
   });
 

package/test/RequestTracker.test.js

@@ -9,8 +9,10 @@ import RequestTracker, {
 import {Graph} from '@atlaspack/graph';
 import WorkerFarm from '@atlaspack/workers';
 import {DEFAULT_OPTIONS} from './test-utils';
-import {INITIAL_BUILD} from '../src/constants';
+import {FILE_CREATE, FILE_UPDATE, INITIAL_BUILD} from '../src/constants';
 import {makeDeferredWithPromise} from '@atlaspack/utils';
+import {toProjectPath} from '../src/projectPath';
+import {DEFAULT_FEATURE_FLAGS, setFeatureFlags} from '../../feature-flags/src';
 
 const options = DEFAULT_OPTIONS;
 const farm = new WorkerFarm({workerPath: require.resolve('../src/worker.js')});
@@ -449,6 +451,97 @@ describe('RequestTracker', () => {
 
     assert.equal(tracker.graph.getNode(nodeId)?.invalidateReason, 1);
   });
+
+  describe('respondToFSEvents', () => {
+    [true, false].forEach(value => {
+      beforeEach(() => {
+        setFeatureFlags({
+          ...DEFAULT_FEATURE_FLAGS,
+          fixQuadraticCacheInvalidation: value === true ? 'NEW' : 'OLD',
+        });
+      });
+
+      afterEach(() => {
+        setFeatureFlags({
+          ...DEFAULT_FEATURE_FLAGS,
+        });
+      });
+
+      describe(`optimizations feature-flag ${String(value)}`, () => {
+        it('should invalidate file requests on file changes', async () => {
+          let tracker = new RequestTracker({farm, options});
+          await tracker.runRequest({
+            id: 'abc',
+            type: 7,
+            // $FlowFixMe string isn't a valid result
+            run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+              api.invalidateOnFileUpdate(toProjectPath('', 'my-file'));
+              let result = await Promise.resolve('hello');
+              api.storeResult(result);
+            },
+            input: null,
+          });
+          const requestId = tracker.graph.getNodeIdByContentKey('abc');
+          const invalidated = await tracker.respondToFSEvents(
+            [
+              {
+                type: 'update',
+                path: 'my-file',
+              },
+            ],
+            Number.MAX_VALUE,
+          );
+          assert.equal(invalidated, true);
+          assert.equal(
+            tracker.graph.getNode(requestId)?.invalidateReason,
+            FILE_UPDATE,
+          );
+          assert.deepEqual(Array.from(tracker.graph.invalidNodeIds), [
+            requestId,
+          ]);
+        });
+
+        it('should invalidate file name requests with invalidate above invalidations', async () => {
+          let tracker = new RequestTracker({farm, options});
+          await tracker.runRequest({
+            id: 'abc',
+            type: 7,
+            // $FlowFixMe string isn't a valid result
+            run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+              api.invalidateOnFileCreate({
+                fileName: 'package.json',
+                aboveFilePath: toProjectPath(
+                  '',
+                  './node_modules/something/package.json',
+                ),
+              });
+              let result = await Promise.resolve('hello');
+              api.storeResult(result);
+            },
+            input: null,
+          });
+          const requestId = tracker.graph.getNodeIdByContentKey('abc');
+          const invalidated = await tracker.respondToFSEvents(
+            [
+              {
+                type: 'create',
+                path: './package.json',
+              },
+            ],
+            Number.MAX_VALUE,
+          );
+          assert.equal(invalidated, true);
+          assert.equal(
+            tracker.graph.getNode(requestId)?.invalidateReason,
+            FILE_CREATE,
+          );
+          assert.deepEqual(Array.from(tracker.graph.invalidNodeIds), [
+            requestId,
+          ]);
+        });
+      });
+    });
+  });
 });
 
 describe('cleanUpOrphans', () => {