@atlaspack/core 2.26.3-dev-compiled-hash-e5f8a1735.0 → 2.28.0

package/dist/requests/AssetGraphRequestRust.js

@@ -14,16 +14,26 @@ const RequestTracker_1 = require("../RequestTracker");
 const SymbolPropagation_1 = require("../SymbolPropagation");
 const EnvironmentManager_1 = require("../EnvironmentManager");
 const Environment_1 = require("../Environment");
+const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
+const assert_2 = __importDefault(require("assert"));
 function createAssetGraphRequestRust(rustAtlaspack) {
     return (input) => ({
         type: RequestTracker_1.requestTypes.asset_graph_request,
         id: input.name,
         run: async (input) => {
             let options = input.options;
-            let serializedAssetGraph = await rustAtlaspack.buildAssetGraph();
-            // @ts-expect-error TS7006
+            let serializedAssetGraph = (await rustAtlaspack.buildAssetGraph());
+            // Newly created nodes
             serializedAssetGraph.nodes = serializedAssetGraph.nodes.map((node) => JSON.parse(node));
-            let { assetGraph, changedAssets } = (0, logger_1.instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph));
+            // Updated existing nodes
+            serializedAssetGraph.updates = serializedAssetGraph.updates.map((node) => JSON.parse(node));
+            // Don't reuse a previous asset graph result if Rust didn't have one too
+            let prevResult = null;
+            if (serializedAssetGraph.hadPreviousGraph) {
+                prevResult =
+                    await input.api.getPreviousResult();
+            }
+            let { assetGraph, changedAssets } = (0, logger_1.instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph, prevResult?.assetGraph));
             let changedAssetsPropagation = new Set(changedAssets.keys());
             let errors = (0, SymbolPropagation_1.propagateSymbols)({
                 options,
@@ -39,7 +49,8 @@ function createAssetGraphRequestRust(rustAtlaspack) {
                     diagnostic: [...errors.values()][0],
                 });
             }
-            return {
+            await (0, dumpGraphToGraphViz_1.default)(assetGraph, 'AssetGraphV3');
+            let result = {
                 assetGraph,
                 assetRequests: [],
                 assetGroupsWithRemovedParents: new Set(),
@@ -47,17 +58,57 @@ function createAssetGraphRequestRust(rustAtlaspack) {
                 changedAssetsPropagation,
                 previousSymbolPropagationErrors: undefined,
             };
+            await input.api.storeResult(result);
+            input.api.invalidateOnBuild();
+            return result;
         },
         input,
     });
 }
-function getAssetGraph(serializedGraph) {
-    let graph = new AssetGraph_1.default({
-        _contentKeyToNodeId: new Map(),
-        _nodeIdToContentKey: new Map(),
-        initialCapacity: serializedGraph.edges.length,
-    });
-    graph.safeToIncrementallyBundle = false;
+function getAssetGraph(serializedGraph, prevAssetGraph) {
+    let graph;
+    let reuseEdges = false;
+    if (prevAssetGraph && serializedGraph.safeToSkipBundling) {
+        graph = new AssetGraph_1.default({
+            _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+            _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+            nodes: prevAssetGraph.nodes,
+            rootNodeId: prevAssetGraph.rootNodeId,
+            adjacencyList: prevAssetGraph.adjacencyList,
+        });
+        reuseEdges = true;
+    }
+    else if (prevAssetGraph &&
+        (serializedGraph.updates.length > 0 || serializedGraph.nodes.length > 0)) {
+        graph = new AssetGraph_1.default({
+            _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+            _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+            nodes: prevAssetGraph.nodes,
+            initialCapacity: serializedGraph.edges.length,
+            // Accomodate the root node
+            initialNodeCapacity: prevAssetGraph.nodes.length + 1,
+            rootNodeId: prevAssetGraph.rootNodeId,
+        });
+        graph.safeToIncrementallyBundle = false;
+    }
+    else {
+        graph = new AssetGraph_1.default({
+            _contentKeyToNodeId: new Map(),
+            _nodeIdToContentKey: new Map(),
+            initialCapacity: serializedGraph.edges.length,
+            // Accomodate the root node
+            initialNodeCapacity: serializedGraph.nodes.length + 1,
+        });
+        let rootNodeId = graph.addNodeByContentKey('@@root', {
+            id: '@@root',
+            type: 'root',
+            value: null,
+        });
+        graph.setRootNodeId(rootNodeId);
+        graph.safeToIncrementallyBundle = false;
+    }
+    (0, assert_1.default)(graph, 'Asset graph not initialized');
+    (0, assert_1.default)(graph.rootNodeId != null, 'Asset graph has no root node');
     // @ts-expect-error TS7031
     function mapSymbols({ exported, ...symbol }) {
         let jsSymbol = {
@@ -95,21 +146,29 @@ function getAssetGraph(serializedGraph) {
         ].join(':');
         let envId = envs.get(envKey);
         if (envId == null) {
-            envId = `${envs.size}`;
+            envId = envs.size.toString();
             envs.set(envKey, envId);
         }
         return envId;
     };
-    for (let node of serializedGraph.nodes) {
-        if (node.type === 'root') {
-            let index = graph.addNodeByContentKey('@@root', {
-                id: '@@root',
-                type: 'root',
-                value: null,
-            });
-            graph.setRootNodeId(index);
+    function updateNode(newNode, isUpdateNode) {
+        if (isUpdateNode) {
+            let existingNode = graph.getNodeByContentKey(newNode.id);
+            (0, assert_2.default)(existingNode && existingNode.type === newNode.type);
+            Object.assign(existingNode, newNode);
         }
-        else if (node.type === 'entry') {
+        else {
+            graph.addNodeByContentKey(newNode.id, newNode);
+        }
+    }
+    let nodeTypeSwitchoverIndex = serializedGraph.nodes.length;
+    let nodesCount = serializedGraph.nodes.length + serializedGraph.updates.length;
+    for (let index = 0; index < nodesCount; index++) {
+        let isUpdateNode = index >= nodeTypeSwitchoverIndex;
+        let node = isUpdateNode
+            ? serializedGraph.updates[index - nodeTypeSwitchoverIndex]
+            : serializedGraph.nodes[index];
+        if (node.type === 'entry') {
             let id = 'entry:' + ++entry;
             graph.addNodeByContentKey(id, {
                 id: id,
@@ -137,14 +196,15 @@ function getAssetGraph(serializedGraph) {
                 asset.symbols = new Map(asset.symbols.map(mapSymbols));
             }
             changedAssets.set(id, asset);
-            graph.addNodeByContentKey(id, {
+            let assetNode = {
                 id,
                 type: 'asset',
                 usedSymbols: new Set(),
                 usedSymbolsDownDirty: true,
                 usedSymbolsUpDirty: true,
                 value: asset,
-            });
+            };
+            updateNode(assetNode, isUpdateNode);
         }
         else if (node.type === 'dependency') {
             let { dependency, id } = node.value;
@@ -163,7 +223,7 @@ function getAssetGraph(serializedGraph) {
                 usedSymbolsDown.add('*');
                 usedSymbolsUp.set('*', undefined);
             }
-            graph.addNodeByContentKey(id, {
+            let depNode = {
                 id,
                 type: 'dependency',
                 deferred: false,
@@ -176,21 +236,24 @@ function getAssetGraph(serializedGraph) {
                 usedSymbolsUpDirtyDown: true,
                 usedSymbolsUpDirtyUp: true,
                 value: dependency,
-            });
+            };
+            updateNode(depNode, isUpdateNode);
         }
     }
-    for (let i = 0; i < serializedGraph.edges.length; i += 2) {
-        let from = serializedGraph.edges[i];
-        let to = serializedGraph.edges[i + 1];
-        let fromNode = graph.getNode(from);
-        let toNode = graph.getNode(to);
-        if (fromNode?.type === 'dependency') {
-            (0, assert_1.default)(toNode?.type === 'asset');
-        }
-        if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
-            fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+    if (!reuseEdges) {
+        for (let i = 0; i < serializedGraph.edges.length; i += 2) {
+            let from = serializedGraph.edges[i];
+            let to = serializedGraph.edges[i + 1];
+            let fromNode = graph.getNode(from);
+            let toNode = graph.getNode(to);
+            if (fromNode?.type === 'dependency') {
+                (0, assert_1.default)(toNode?.type === 'asset');
+            }
+            if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
+                fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+            }
+            graph.addEdge(from, to);
         }
-        graph.addEdge(from, to);
     }
     return {
         assetGraph: graph,

package/dist/requests/AtlaspackConfigRequest.js

@@ -141,27 +141,16 @@ async function resolveAtlaspackConfig(options) {
     }
     let { config, extendedFiles } = await parseAndProcessConfig(configPath, contents, options);
     if (options.additionalReporters.length > 0) {
-        if (options.featureFlags.deduplicateReporters) {
-            const reporterMap = new Map();
-            options.additionalReporters.forEach(({ packageName, resolveFrom }) => {
-                reporterMap.set(packageName, { packageName, resolveFrom });
-            });
-            config.reporters?.forEach((reporter) => {
-                if (!reporterMap.has(reporter.packageName)) {
-                    reporterMap.set(reporter.packageName, reporter);
-                }
-            });
-            config.reporters = Array.from(reporterMap.values());
-        }
-        else {
-            config.reporters = [
-                ...options.additionalReporters.map(({ packageName, resolveFrom }) => ({
-                    packageName,
-                    resolveFrom,
-                })),
-                ...(config.reporters ?? []),
-            ];
-        }
+        const reporterMap = new Map();
+        options.additionalReporters.forEach(({ packageName, resolveFrom }) => {
+            reporterMap.set(packageName, { packageName, resolveFrom });
+        });
+        config.reporters?.forEach((reporter) => {
+            if (!reporterMap.has(reporter.packageName)) {
+                reporterMap.set(reporter.packageName, reporter);
+            }
+        });
+        config.reporters = Array.from(reporterMap.values());
     }
     return { config, extendedFiles, usedDefault };
 }

package/dist/requests/BundleGraphRequest.js

@@ -116,9 +116,11 @@ function createBundleGraphRequest(input) {
                 lazyExcludes: options.lazyExcludes,
                 requestedAssetIds,
             });
-            let { assetGraph, changedAssets, assetRequests } = await api.runRequest(request, {
-                force: Boolean(input.rustAtlaspack) ||
-                    (options.shouldBuildLazily && requestedAssetIds.size > 0),
+            let { assetGraph, changedAssets, assetRequests } = await (0, logger_1.instrumentAsync)('asset-graph-request', () => {
+                return api.runRequest(request, {
+                    force: Boolean(input.rustAtlaspack) ||
+                        (options.shouldBuildLazily && requestedAssetIds.size > 0),
+                });
             });
             if (input.options.featureFlags?.loadableSideEffects) {
                 applySideEffectsForLoadableImports(assetGraph);

package/dist/resolveOptions.js

@@ -190,6 +190,7 @@ async function resolveOptions(initialOptions) {
             : false,
         shouldDisableCache: initialOptions.shouldDisableCache ?? false,
         shouldProfile: initialOptions.shouldProfile ?? false,
+        nativeProfiler: initialOptions.nativeProfiler,
         shouldTrace: initialOptions.shouldTrace ?? false,
         cacheDir,
         watchDir,

package/dist/worker.js

@@ -21,7 +21,7 @@ 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("@parcel/source-map");
+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"));

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;
   };
@@ -410,6 +410,10 @@ class Atlaspack {
       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.

package/lib/BundleGraph.js

@@ -914,6 +914,113 @@ class BundleGraph {
       return isReferenced;
     });
   }
+
+  // New method: Fast checks only (no caching of results)
+  isAssetReferencedFastCheck(bundle, asset) {
+    // Fast Check #1: If asset is in multiple bundles in same target, it's referenced
+    let bundlesWithAsset = this.getBundlesWithAsset(asset).filter(b => b.target.name === bundle.target.name && b.target.distDir === bundle.target.distDir);
+    if (bundlesWithAsset.length > 1) {
+      return true;
+    }
+
+    // Fast Check #2: If asset is referenced by any async/conditional dependency, it's referenced
+    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.priority === _types.Priority.conditional) && node.value.specifierType !== _types.SpecifierType.url)) {
+      return true;
+    }
+
+    // Fast checks failed - return null to indicate expensive computation needed
+    return null;
+  }
+  getReferencedAssets(bundle) {
+    let referencedAssets = new Set();
+
+    // Build a map of all assets in this bundle with their dependencies
+    // This allows us to check all assets in a single traversal
+    let assetDependenciesMap = new Map();
+    this.traverseAssets(bundle, asset => {
+      // Always do fast checks (no caching)
+      let fastCheckResult = this.isAssetReferencedFastCheck(bundle, asset);
+      if (fastCheckResult === true) {
+        referencedAssets.add(asset);
+        return;
+      }
+
+      // Fast checks failed (fastCheckResult === null), need expensive computation
+      // Check if it's actually referenced via traversal
+
+      // Store dependencies for later batch checking
+      let dependencies = this._graph.getNodeIdsConnectedTo((0, _nullthrows().default)(this._graph.getNodeIdByContentKey(asset.id))).map(id => (0, _nullthrows().default)(this._graph.getNode(id))).filter(node => node.type === 'dependency').map(node => {
+        (0, _assert().default)(node.type === 'dependency');
+        return node.value;
+      });
+      if (dependencies.length > 0) {
+        assetDependenciesMap.set(asset, dependencies);
+      }
+    });
+
+    // If no assets need the expensive check, return early
+    if (assetDependenciesMap.size === 0) {
+      return referencedAssets;
+    }
+
+    // Get the assets we need to check once
+    let assetsToCheck = Array.from(assetDependenciesMap.keys());
+
+    // Helper function to check if all assets from assetDependenciesMap are in referencedAssets
+    const allAssetsReferenced = () => assetsToCheck.length <= referencedAssets.size && assetsToCheck.every(asset => referencedAssets.has(asset));
+
+    // Do ONE traversal to check all remaining assets
+    // We can share visitedBundles across all assets because we check every asset
+    // against every visited bundle, which matches the original per-asset behavior
+    let siblingBundles = new Set(this.getBundleGroupsContainingBundle(bundle).flatMap(bundleGroup => this.getBundlesInBundleGroup(bundleGroup, {
+      includeInline: true
+    })));
+    let visitedBundles = new Set();
+
+    // Single traversal from all referencers
+    for (let referencer of siblingBundles) {
+      this.traverseBundles((descendant, _, actions) => {
+        if (descendant.id === bundle.id) {
+          return;
+        }
+        if (visitedBundles.has(descendant)) {
+          actions.skipChildren();
+          return;
+        }
+        visitedBundles.add(descendant);
+        if (descendant.type !== bundle.type || (0, _EnvironmentManager.fromEnvironmentId)(descendant.env).context !== (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context) {
+          // Don't skip children - they might be the right type!
+          return;
+        }
+
+        // Check ALL assets at once in this descendant bundle
+        for (let [asset, dependencies] of assetDependenciesMap) {
+          // Skip if already marked as referenced
+          if (referencedAssets.has(asset)) {
+            continue;
+          }
+
+          // Check if this descendant bundle references the asset
+          if (!this.bundleHasAsset(descendant, asset) && dependencies.some(dependency => this.bundleHasDependency(descendant, dependency))) {
+            referencedAssets.add(asset);
+          }
+        }
+
+        // If all assets from assetDependenciesMap are now marked as referenced, we can stop early
+        if (allAssetsReferenced()) {
+          actions.stop();
+          return;
+        }
+      }, referencer);
+
+      // If all assets from assetDependenciesMap are referenced, no need to check more sibling bundles
+      if (allAssetsReferenced()) {
+        break;
+      }
+    }
+    return referencedAssets;
+  }
   hasParentBundleOfType(bundle, type) {
     let parents = this.getParentBundles(bundle);
     return parents.length > 0 && parents.every(parent => parent.type === type);

package/lib/CommittedAsset.js

@@ -26,7 +26,7 @@ function _utils() {
   return data;
 }
 function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/source-map"));
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
   _sourceMap = function () {
     return data;
   };

package/lib/Transformation.js

@@ -72,6 +72,13 @@ function _profiler() {
   };
   return data;
 }
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
 function _featureFlags() {
   const data = require("@atlaspack/feature-flags");
   _featureFlags = function () {
@@ -343,10 +350,9 @@ class Transformation {
     // generate all assets in a large bundle during packaging.
     await Promise.all(resultingAssets.filter(asset => asset.ast != null && !(this.options.mode === 'production' && asset.value.type === 'css' && asset.value.symbols)).map(async asset => {
       if (asset.isASTDirty && asset.generate) {
-        var _output$map;
         let output = await asset.generate();
         asset.content = output.content;
-        asset.mapBuffer = (_output$map = output.map) === null || _output$map === void 0 ? void 0 : _output$map.toBuffer();
+        asset.mapBuffer = _sourceMap().default.safeToBuffer(output.map);
       }
       asset.clearAST();
     }));
@@ -453,10 +459,9 @@ class Transformation {
       logger,
       tracer
     })) && asset.generate) {
-      var _output$map2;
       let output = await asset.generate();
       asset.content = output.content;
-      asset.mapBuffer = (_output$map2 = output.map) === null || _output$map2 === void 0 ? void 0 : _output$map2.toBuffer();
+      asset.mapBuffer = _sourceMap().default.safeToBuffer(output.map);
     }
 
     // Load config for the transformer.

package/lib/UncommittedAsset.js

@@ -19,7 +19,7 @@ function _stream() {
   return data;
 }
 function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/source-map"));
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
   _sourceMap = function () {
     return data;
   };
@@ -218,7 +218,7 @@ class UncommittedAsset {
     });
     if (map) {
       this.map = map;
-      this.mapBuffer = map.toBuffer();
+      this.mapBuffer = _sourceMap().default.safeToBuffer(map);
       this.setCode(code.replace(_utils().SOURCEMAP_RE, ''));
     }
     return this.map;
@@ -349,7 +349,7 @@ class UncommittedAsset {
       content,
       ast: result.ast,
       isASTDirty: result.ast === this.ast ? this.isASTDirty : true,
-      mapBuffer: result.map ? result.map.toBuffer() : null,
+      mapBuffer: _sourceMap().default.safeToBuffer(result.map),
       code: this.code,
       invalidations: this.invalidations
     });

package/lib/assetUtils.js

@@ -65,6 +65,13 @@ function _profiler() {
 }
 var _IdentifierRegistry = require("./IdentifierRegistry");
 var _EnvironmentManager = require("./EnvironmentManager");
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAssetIdFromOptions(options) {
   const data = {
@@ -150,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 {

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

@@ -8,7 +8,6 @@ exports.specifierTypeMap = exports.packageConditionsMap = exports.dependencyPrio
 class BitFlags {
   // @ts-expect-error TS2344
   #kv;
-  // @ts-expect-error TS2344
   #vk;
 
   // @ts-expect-error TS2344
@@ -29,9 +28,6 @@ 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) {
@@ -45,8 +41,14 @@ 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;
@@ -61,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

@@ -35,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;

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

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.MutableAsset = void 0;
 function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/source-map"));
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
   _sourceMap = function () {
     return data;
   };

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

@@ -58,10 +58,12 @@ class AtlaspackWorker {
   #resolvers;
   #transformers;
   #fs;
+  #packageManager;
   constructor() {
     this.#resolvers = new Map();
     this.#transformers = new Map();
     this.#fs = new (_fs().NodeFS)();
+    this.#packageManager = new (_packageManager().NodePackageManager)(this.#fs, '/');
   }
   loadPlugin = (0, _jsCallable.jsCallable)(async ({
     kind,
@@ -69,13 +71,19 @@ class AtlaspackWorker {
     resolveFrom,
     featureFlags
   }) => {
-    let customRequire = _module().createRequire(resolveFrom);
-    let resolvedPath = customRequire.resolve(specifier);
-    let resolvedModule = await import(resolvedPath);
+    // Use packageManager.require() instead of dynamic import() to support TypeScript plugins
+    let resolvedModule = await this.#packageManager.require(specifier, resolveFrom, {
+      shouldAutoInstall: false
+    });
     let instance = undefined;
-    if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+    // Check for CommonJS export (module.exports = new Plugin(...))
+    if (resolvedModule[CONFIG]) {
+      instance = resolvedModule[CONFIG];
+    } else if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+      // ESM default export
       instance = resolvedModule.default[CONFIG];
     } else if (resolvedModule.default && resolvedModule.default.default && resolvedModule.default.default[CONFIG]) {
+      // Double-wrapped default export
       instance = resolvedModule.default.default[CONFIG];
     } else {
       throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
@@ -175,7 +183,7 @@ class AtlaspackWorker {
         type: 'resolved',
         filePath: result.filePath || '',
         canDefer: result.canDefer || false,
-        sideEffects: result.sideEffects || false,
+        sideEffects: result.sideEffects ?? true,
         code: result.code || undefined,
         meta: result.meta || undefined,
         pipeline: result.pipeline || undefined,