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

package/lib/applyRuntimes.js

@@ -69,9 +69,16 @@ function _utils() {
   };
   return data;
 }
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _EnvironmentManager = require("./EnvironmentManager");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+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 }; }
 function nameRuntimeBundle(bundle, siblingBundle) {
   // We don't run custom namers on runtime bundles as the runtime assumes that they are
   // located at the same nesting level as their owning bundle. Custom naming could
@@ -123,8 +130,10 @@ async function applyRuntimes({
    * order), so that children will always be available when parents try to reference
    * them.
    */
+  // @ts-expect-error TS2304
   let bundles = [];
   bundleGraph.traverseBundles({
+    // @ts-expect-error TS2304
     exit(bundle) {
       bundles.push(bundle);
     }
@@ -158,16 +167,20 @@ async function applyRuntimes({
             filePath,
             isEntry,
             env,
-            priority
+            runtimeAssetRequiringExecutionOnLoad,
+            priority,
+            symbolData
           } of runtimeAssets) {
             let sourceName = _path().default.join(_path().default.dirname(filePath), `runtime-${(0, _rust().hashString)(code)}.${bundle.type}`);
             let assetGroup = {
               code,
+              runtimeAssetRequiringExecutionOnLoad,
               filePath: (0, _projectPath.toProjectPath)(options.projectRoot, sourceName),
-              env: (0, _Environment.mergeEnvironments)(options.projectRoot, bundle.env, env),
+              env: (0, _Environment.mergeEnvironments)(options.projectRoot, (0, _EnvironmentManager.fromEnvironmentId)(bundle.env), env),
               // Runtime assets should be considered source, as they should be
               // e.g. compiled to run in the target environment
-              isSource: true
+              isSource: true,
+              symbolData
             };
             let connectionBundle = bundle;
 
@@ -195,6 +208,8 @@ async function applyRuntimes({
               // been named as this point.
               nameRuntimeBundle(connectionBundle, bundle);
             }
+
+            // @ts-expect-error TS2345
             connectionMap.get(connectionBundle).push({
               bundle: connectionBundle,
               assetGroup,
@@ -233,6 +248,7 @@ async function applyRuntimes({
    */
   let connections = [];
   bundleGraph.traverseBundles({
+    // @ts-expect-error TS2304
     enter(bundle) {
       connections.push(...connectionMap.get(bundle));
     }
@@ -254,6 +270,10 @@ async function applyRuntimes({
     assetGraph: runtimesAssetGraph,
     changedAssets
   } = await reconcileNewRuntimes(api, connections, optionsRef);
+  if ((0, _featureFlags().getFeatureFlag)('skipRuntimeSymbolProp')) {
+    // Apply pre-computed symbol data from runtime assets to skip symbol propagation
+    applyRuntimeSymbolData(runtimesAssetGraph, connections);
+  }
 
   // Convert the runtime AssetGraph into a BundleGraph, this includes assigning
   // the assets their public ids
@@ -340,12 +360,83 @@ async function applyRuntimes({
   }
   return changedAssets;
 }
+
+/**
+ * Apply pre-computed symbol data from runtime assets to the asset graph
+ * to avoid running symbol propagation on runtime code we control.
+ */
+function applyRuntimeSymbolData(assetGraph, connections) {
+  for (let {
+    assetGroup
+  } of connections) {
+    let assetGroupNode = (0, _AssetGraph.nodeFromAssetGroup)(assetGroup);
+    let assetGroupAssetNodeIds = assetGraph.getNodeIdsConnectedFrom(assetGraph.getNodeIdByContentKey(assetGroupNode.id));
+    if (assetGroupAssetNodeIds.length !== 1) {
+      continue;
+    }
+    let runtimeAssetNodeId = assetGroupAssetNodeIds[0];
+    let runtimeAssetNode = assetGraph.getNode(runtimeAssetNodeId);
+    if (!runtimeAssetNode || runtimeAssetNode.type !== 'asset') {
+      continue;
+    }
+    let symbolData = assetGroup.symbolData;
+    if (!symbolData) {
+      // We completely skip symbol propagation for runtime assets, so symbolData
+      // is required
+      throw new Error('Runtime asset is missing symbol data');
+    }
+    if (symbolData.symbols) {
+      // Convert from SymbolData format to internal Asset.symbols format
+      let internalSymbols = new Map();
+      for (let [symbol, data] of symbolData.symbols) {
+        internalSymbols.set(symbol, {
+          local: data.local,
+          loc: data.loc || null,
+          meta: data.meta
+        });
+      }
+      runtimeAssetNode.value.symbols = internalSymbols;
+    }
+    if (symbolData.dependencies && symbolData.dependencies.length > 0) {
+      let outgoingDeps = assetGraph.getNodeIdsConnectedFrom(runtimeAssetNodeId).map(id => assetGraph.getNode(id)).filter(node => (node === null || node === void 0 ? void 0 : node.type) === 'dependency').map(node => node);
+      for (let depSymbolData of symbolData.dependencies) {
+        let matchingDep = outgoingDeps.find(depNode => depNode.value.specifier === depSymbolData.specifier);
+        if (matchingDep) {
+          if (depSymbolData.symbols) {
+            let internalDepSymbols = new Map();
+            for (let [symbol, data] of depSymbolData.symbols) {
+              internalDepSymbols.set(symbol, {
+                local: data.local,
+                loc: data.loc || null,
+                isWeak: data.isWeak,
+                meta: data.meta
+              });
+            }
+            matchingDep.value.symbols = internalDepSymbols;
+          }
+          if (depSymbolData.usedSymbols) {
+            matchingDep.usedSymbolsDown = new Set(depSymbolData.usedSymbols);
+            // For runtime assets, usedSymbolsUp will be the same as usedSymbolsDown
+            // since we know exactly what we're using
+            let usedSymbolsUp = new Map();
+            for (let symbol of depSymbolData.usedSymbols) {
+              // Mark as resolved to external (null) since runtime deps are typically external
+              usedSymbolsUp.set(symbol, null);
+            }
+            matchingDep.usedSymbolsUp = usedSymbolsUp;
+          }
+        }
+      }
+    }
+  }
+}
 function reconcileNewRuntimes(api, connections, optionsRef) {
   let assetGroups = connections.map(t => t.assetGroup);
   let request = (0, _AssetGraphRequest.default)({
     name: 'Runtimes',
     assetGroups,
-    optionsRef
+    optionsRef,
+    skipSymbolProp: (0, _featureFlags().getFeatureFlag)('skipRuntimeSymbolProp') || (0, _featureFlags().getFeatureFlag)('rustSymbolTracker')
   });
 
   // rebuild the graph

package/lib/assetUtils.js

@@ -36,8 +36,6 @@ function _nullthrows() {
   };
   return data;
 }
-var _CommittedAsset = _interopRequireDefault(require("./CommittedAsset"));
-var _UncommittedAsset = _interopRequireDefault(require("./UncommittedAsset"));
 var _loadAtlaspackPlugin = _interopRequireDefault(require("./loadAtlaspackPlugin"));
 var _Asset = require("./public/Asset");
 var _PluginOptions = _interopRequireDefault(require("./public/PluginOptions"));
@@ -66,10 +64,18 @@ function _profiler() {
   return data;
 }
 var _IdentifierRegistry = require("./IdentifierRegistry");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _EnvironmentManager = require("./EnvironmentManager");
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function createAssetIdFromOptions(options) {
   const data = {
-    environmentId: options.env.id,
+    environmentId: (0, _EnvironmentManager.toEnvironmentId)(options.env),
     filePath: options.filePath,
     code: options.code,
     pipeline: options.pipeline,
@@ -151,7 +157,7 @@ async function _generateFromAST(asset) {
       category: 'asset-generate'
     })
   });
-  let mapBuffer = map === null || map === void 0 ? void 0 : map.toBuffer();
+  let mapBuffer = _sourceMap().default.safeToBuffer(map);
   // Store the results in the cache so we can avoid generating again next time
   await Promise.all([asset.options.cache.setStream((0, _nullthrows().default)(asset.value.contentKey), (0, _utils().blobToStream)(content)), mapBuffer != null && asset.options.cache.setBlob((0, _nullthrows().default)(asset.value.mapKey), mapBuffer)]);
   return {
@@ -168,6 +174,7 @@ function getInvalidationId(invalidation) {
     case 'option':
       return 'option:' + invalidation.key;
     default:
+      // @ts-expect-error TS2339
       throw new Error('Unknown invalidation type: ' + invalidation.type);
   }
 }
@@ -195,9 +202,12 @@ async function getInvalidationHash(invalidations, options) {
         hashes += invalidation.key + ':' + (options.env[invalidation.key] || '');
         break;
       case 'option':
-        hashes += invalidation.key + ':' + (0, _utils2.hashFromOption)(options[invalidation.key]);
+        hashes +=
+        // @ts-expect-error TS7053
+        invalidation.key + ':' + (0, _utils2.hashFromOption)(options[invalidation.key]);
         break;
       default:
+        // @ts-expect-error TS2339
         throw new Error('Unknown invalidation type: ' + invalidation.type);
     }
   }

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -19,23 +19,36 @@ function _diagnostic() {
   };
   return data;
 }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class AtlaspackV3 {
-  constructor(atlaspack_napi) {
+  constructor(atlaspack_napi, napiWorkerPool, isDefaultNapiWorkerPool) {
     this._atlaspack_napi = atlaspack_napi;
+    this._napiWorkerPool = napiWorkerPool;
+    this._isDefaultNapiWorkerPool = isDefaultNapiWorkerPool;
   }
   static async create({
     fs,
     packageManager,
     threads,
     lmdb,
-    napiWorkerPool = new _NapiWorkerPool.NapiWorkerPool(),
+    napiWorkerPool,
     ...options
   }) {
+    // @ts-expect-error TS2339
     options.logLevel = options.logLevel || 'error';
+    // @ts-expect-error TS2339
     options.defaultTargetOptions = options.defaultTargetOptions || {};
-    // $FlowFixMe "engines" are readonly
-    options.defaultTargetOptions.engines = options.defaultTargetOptions.engines || {};
+    // @ts-expect-error TS2339
+    options.defaultTargetOptions.engines =
+    // @ts-expect-error TS2339
+    options.defaultTargetOptions.engines || {};
+    let isDefaultNapiWorkerPool = false;
+    if (!napiWorkerPool) {
+      napiWorkerPool = new _NapiWorkerPool.NapiWorkerPool();
+      isDefaultNapiWorkerPool = true;
+    }
+
+    // @ts-expect-error TS2488
     const [internal, error] = await (0, _rust().atlaspackNapiCreate)({
       fs,
       packageManager,
@@ -48,19 +61,49 @@ class AtlaspackV3 {
         diagnostic: error
       });
     }
-    return new AtlaspackV3(internal);
+    return new AtlaspackV3(internal, napiWorkerPool, isDefaultNapiWorkerPool);
   }
-  async buildAssetGraph() {
-    let [graph, error] = await (0, _rust().atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
-    if (error !== null) {
-      throw new (_diagnostic().default)({
-        diagnostic: error
-      });
+  end() {
+    // If the worker pool was provided to us, don't shut it down, it's up to the provider.
+    if (this._isDefaultNapiWorkerPool) {
+      this._napiWorkerPool.shutdown();
+    }
+  }
+  buildAssetGraph(progressCallback) {
+    return (0, _rust().atlaspackNapiBuildAssetGraph)(this._atlaspack_napi, progressCallback);
+  }
+  buildBundleGraph(progressCallback) {
+    return (0, _rust().atlaspackNapiBuildBundleGraph)(this._atlaspack_napi, progressCallback);
+  }
+  build(progressCallback) {
+    return (0, _rust().atlaspackNapiBuild)(this._atlaspack_napi, progressCallback);
+  }
+  loadBundleGraph(bundleGraph) {
+    const {
+      nodesJson,
+      edges,
+      publicIdByAssetId,
+      environmentsJson
+    } = bundleGraph.serializeForNative();
+    return (0, _rust().atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
+  }
+  updateBundleGraph(bundleGraph, changedAssetIds) {
+    const nodesJson = bundleGraph.serializeAssetNodesForNative(changedAssetIds);
+    return (0, _rust().atlaspackNapiUpdateBundleGraph)(this._atlaspack_napi, nodesJson);
+  }
+  package(bundleId, options) {
+    return (0, _rust().atlaspackNapiPackage)(this._atlaspack_napi, bundleId, options);
+  }
+  async respondToFsEvents(events) {
+    // @ts-expect-error TS2488
+    let [needsRebuild, error] = await (0, _rust().atlaspackNapiRespondToFsEvents)(this._atlaspack_napi, events);
+    if (error) {
+      throw new Error(error);
     }
-    return graph;
+    return needsRebuild;
   }
-  respondToFsEvents(events) {
-    return (0, _rust().atlaspackNapiRespondToFsEvents)(this._atlaspack_napi, events);
+  async completeCacheSession() {
+    return await (0, _rust().atlaspackNapiCompleteSession)(this._atlaspack_napi);
   }
 }
 exports.AtlaspackV3 = AtlaspackV3;

package/lib/atlaspack-v3/NapiWorkerPool.js

@@ -32,7 +32,16 @@ function _rust() {
   };
   return data;
 }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// @ts-expect-error TS2724
+
 const WORKER_PATH = _path().default.join(__dirname, 'worker', 'index.js');
 const ATLASPACK_NAPI_WORKERS = _process().default.env.ATLASPACK_NAPI_WORKERS && parseInt(_process().default.env.ATLASPACK_NAPI_WORKERS, 10);
 class NapiWorkerPool {
@@ -44,7 +53,11 @@ class NapiWorkerPool {
   } = {
     workerCount: undefined
   }) {
-    this.#workerCount = workerCount ?? ATLASPACK_NAPI_WORKERS ?? (0, _rust().getAvailableThreads)();
+    // @ts-expect-error TS2322
+    this.#workerCount = workerCount ?? ATLASPACK_NAPI_WORKERS ??
+    // Default to a maximum of 4 workers as performance worsens beyond that
+    // point in most cases
+    Math.min((0, _rust().getAvailableThreads)(), 4);
     if (!this.#workerCount) {
       // TODO use main thread if workerCount is 0
     }
@@ -54,8 +67,56 @@ class NapiWorkerPool {
       let worker = new (_worker_threads().Worker)(WORKER_PATH);
       this.#workers.push(worker);
       this.#napiWorkers.push(new Promise(res => worker.once('message', res)));
+
+      // Re-emit log events from the worker thread into the main-thread logger
+      // so they reach reporters and are subject to log-level filtering.
+      worker.on('message', message => {
+        if (message != null && typeof message === 'object' && message.type === 'logEvent') {
+          const event = message.event;
+          switch (event.level) {
+            case 'verbose':
+              _logger().default.verbose(event.diagnostics);
+              break;
+            case 'info':
+              _logger().default.info(event.diagnostics);
+              break;
+            case 'warn':
+              _logger().default.warn(event.diagnostics);
+              break;
+            case 'error':
+              _logger().default.error(event.diagnostics);
+              break;
+            case 'progress':
+              _logger().default.progress(event.message);
+              break;
+          }
+        }
+      });
     }
   }
+  clearAllWorkerState() {
+    return Promise.all(this.#workers.map(worker => new Promise(res => {
+      worker.postMessage('clearState');
+
+      // Set up a message handler that only resolves on 'stateCleared'
+      // and ignores all other messages (like the initial napiWorker Transferable)
+      const messageHandler = message => {
+        if (message === 'stateCleared') {
+          worker.removeListener('message', messageHandler);
+          res();
+        } else if (message != null && typeof message === 'object' && message.type === 'logEvent') {
+          // logEvent messages are forwarded asynchronously from the worker
+          // logger bridge and are expected at any time; ignore them here.
+        } else {
+          // Log unexpected messages for debugging
+          // eslint-disable-next-line no-console
+          console.warn(`[NapiWorkerPool] Received unexpected message during clearAllWorkerState: ${JSON.stringify(message)} (type: ${typeof message})`);
+          // Keep listening for 'stateCleared' - don't remove the listener
+        }
+      };
+      worker.on('message', messageHandler);
+    })));
+  }
   workerCount() {
     return this.#workerCount;
   }

package/lib/atlaspack-v3/fs.js

@@ -5,6 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.FileSystemV3 = void 0;
 var _jsCallable = require("./jsCallable");
+// @ts-expect-error TS2305
+
+// @ts-expect-error TS2420
 class FileSystemV3 {
   #fs;
   constructor(fs) {
@@ -29,11 +32,11 @@ class FileSystemV3 {
   };
   readFile = (0, _jsCallable.jsCallable)((path, encoding) => {
     if (!encoding) {
-      // $FlowFixMe
       return [...this.#fs.readFileSync(path)];
     } else {
       return this.#fs.readFileSync(path, encoding);
     }
   });
+  writeFile = (0, _jsCallable.jsCallable)((path, contents) => this.#fs.writeFile(path, Buffer.from(contents)));
 }
 exports.FileSystemV3 = FileSystemV3;

package/lib/atlaspack-v3/index.js

@@ -3,6 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  FileSystemV3: true,
+  AtlaspackV3: true,
+  NapiWorkerPool: true
+};
 Object.defineProperty(exports, "AtlaspackV3", {
   enumerable: true,
   get: function () {
@@ -23,4 +28,26 @@ Object.defineProperty(exports, "NapiWorkerPool", {
 });
 var _fs = require("./fs");
 var _AtlaspackV = require("./AtlaspackV3");
-var _NapiWorkerPool = require("./NapiWorkerPool");
+Object.keys(_AtlaspackV).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _AtlaspackV[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _AtlaspackV[key];
+    }
+  });
+});
+var _NapiWorkerPool = require("./NapiWorkerPool");
+Object.keys(_NapiWorkerPool).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _NapiWorkerPool[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _NapiWorkerPool[key];
+    }
+  });
+});

package/lib/atlaspack-v3/jsCallable.js

@@ -7,10 +7,8 @@ exports.jsCallable = jsCallable;
 function jsCallable(fn) {
   return async (...args) => {
     try {
-      // $FlowFixMe "await" is needed to log the error from
       // Promises and is safe to use on non-promises
       return await fn(...args);
-      // $FlowFixMe
     } catch (error) {
       // eslint-disable-next-line no-console
       console.error(error);

package/lib/atlaspack-v3/worker/compat/asset-symbols.js

@@ -54,7 +54,7 @@ class MutableDependencySymbols {
   }
 
   /*::  @@iterator(): Iterator<[Symbol, DependencyAssetSymbol]> { return ({}: any); } */
-  // $FlowFixMe Flow can't do computed properties
+  // @ts-expect-error TS2416
   [Symbol.iterator]() {
     return this.#symbols.values();
   }
@@ -102,7 +102,7 @@ class AssetSymbols {
   }
 
   /*::  @@iterator(): Iterator<[Symbol, AssetSymbol]> { return ({}: any); } */
-  // $FlowFixMe Flow can't do computed properties
+  // @ts-expect-error TS2416
   [Symbol.iterator]() {
     return this.#symbols.values();
   }
@@ -122,10 +122,12 @@ class MutableAssetSymbols {
       loc,
       local,
       isEsmExport,
-      selfReferenced
+      selfReferenced,
+      isStaticBindingSafe
     } of inner || []) {
       this.set(exported, local, loc, {
         isEsm: isEsmExport,
+        isStaticBindingSafe,
         selfReferenced
       });
     }
@@ -152,6 +154,7 @@ class MutableAssetSymbols {
           }
         } : undefined,
         isEsmExport: Boolean(meta === null || meta === void 0 ? void 0 : meta.isEsm),
+        isStaticBindingSafe: Boolean(meta === null || meta === void 0 ? void 0 : meta.isStaticBindingSafe),
         isWeak: false,
         selfReferenced: Boolean(meta === null || meta === void 0 ? void 0 : meta.selfReferenced)
       });
@@ -189,7 +192,7 @@ class MutableAssetSymbols {
   }
 
   /*::  @@iterator(): Iterator<[Symbol, AssetSymbol]> { return ({}: any); } */
-  // $FlowFixMe Flow can't do computed properties
+  // @ts-expect-error TS2416
   [Symbol.iterator]() {
     return this.#symbols.values();
   }

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

@@ -6,18 +6,18 @@ Object.defineProperty(exports, "__esModule", {
 exports.specifierTypeMap = exports.packageConditionsMap = exports.dependencyPriorityMap = exports.bundleBehaviorMap = exports.BitFlags = void 0;
 /// BitFlags is used to map number/string types from napi types
 class BitFlags {
+  // @ts-expect-error TS2344
   #kv;
   #vk;
+
+  // @ts-expect-error TS2344
   constructor(source) {
     this.#kv = source;
-    this.#vk = Object.fromEntries(
-    // $FlowFixMe
-    Object.entries(source).map(a => a.reverse()));
+    this.#vk = Object.fromEntries(Object.entries(source).map(a => a.reverse()));
   }
   into(key) {
     const found = this.#kv[key];
     if (found === undefined) {
-      // $FlowFixMe
       throw new Error(`Invalid BundleBehavior(${key})`);
     }
     return found;
@@ -28,13 +28,9 @@ class BitFlags {
     }
     return this.into(key);
   }
-  intoArray(keys) {
-    return keys.map(key => this.into(key));
-  }
   from(key) {
     const found = this.#vk[key];
     if (found === undefined) {
-      // $FlowFixMe
       throw new Error(`Invalid BundleBehavior(${key})`);
     }
     return found;
@@ -45,14 +41,21 @@ class BitFlags {
     }
     return this.from(key);
   }
-  fromArray(keys) {
-    return keys.map(key => this.from(key));
+  toArray(keys) {
+    let values = [];
+    for (let [key, value] of Object.entries(this.#kv)) {
+      if ((keys & value) !== 0) {
+        values.push(key);
+      }
+    }
+    return values;
   }
 }
 exports.BitFlags = BitFlags;
 const bundleBehaviorMap = exports.bundleBehaviorMap = new BitFlags({
   inline: 0,
-  isolated: 1
+  isolated: 1,
+  inlineIsolated: 2
 });
 const dependencyPriorityMap = exports.dependencyPriorityMap = new BitFlags({
   sync: 0,
@@ -60,21 +63,24 @@ const dependencyPriorityMap = exports.dependencyPriorityMap = new BitFlags({
   lazy: 2,
   conditional: 3
 });
+
+// Note: The bitflags must match the bitflags in the Rust code.
+// crates/atlaspack_core/src/types/package_json.rs
 const packageConditionsMap = exports.packageConditionsMap = new BitFlags({
-  import: 0,
-  require: 1,
-  module: 2,
-  node: 3,
-  browser: 4,
-  worker: 5,
-  worklet: 6,
-  electron: 7,
-  development: 8,
-  production: 9,
-  types: 10,
-  default: 11,
-  style: 12,
-  sass: 13
+  import: 1 << 0,
+  require: 1 << 1,
+  module: 1 << 2,
+  node: 1 << 3,
+  browser: 1 << 4,
+  worker: 1 << 5,
+  worklet: 1 << 6,
+  electron: 1 << 7,
+  development: 1 << 8,
+  production: 1 << 9,
+  types: 1 << 10,
+  default: 1 << 11,
+  style: 1 << 12,
+  sass: 1 << 13
 });
 const specifierTypeMap = exports.specifierTypeMap = new BitFlags({
   esm: 0,

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

@@ -7,6 +7,8 @@ exports.Dependency = void 0;
 var _target = require("./target");
 var _assetSymbols = require("./asset-symbols");
 var _bitflags = require("./bitflags");
+// @ts-expect-error TS2305
+
 class Dependency {
   get id() {
     throw new Error('Dependency.id');
@@ -24,6 +26,7 @@ class Dependency {
       this.bundleBehavior = _bitflags.bundleBehaviorMap.from(inner.bundleBehavior);
     }
     this.bundleBehavior = undefined;
+    // @ts-expect-error TS2322
     this.symbols = new _assetSymbols.MutableDependencySymbols(inner.symbols || []);
     this.specifier = inner.specifier;
     this.specifierType = _bitflags.specifierTypeMap.from(inner.specifierType);
@@ -32,7 +35,7 @@ class Dependency {
     this.isOptional = inner.isOptional;
     this.isEntry = inner.isEntry;
     this.loc = inner.loc;
-    this.packageConditions = _bitflags.packageConditionsMap.fromArray(inner.packageConditions || []);
+    this.packageConditions = _bitflags.packageConditionsMap.toArray(inner.packageConditions || []);
     this.sourceAssetId = inner.sourceAssetId;
     this.sourcePath = inner.sourcePath;
     this.sourceAssetType = inner.sourceAssetType;