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

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @atlaspack/core
 
+## 2.27.0
+
+### Minor Changes
+
+- [#869](https://github.com/atlassian-labs/atlaspack/pull/869) [`cfb4707`](https://github.com/atlassian-labs/atlaspack/commit/cfb4707087498e4fa4dcf10753fe984a248d196b) Thanks [@benjervis](https://github.com/benjervis)! - Adds a feature to the V3 devloop that will minimise the amount of work done if the change is only a content change.
+
+### Patch Changes
+
+- [#873](https://github.com/atlassian-labs/atlaspack/pull/873) [`ec3abe4`](https://github.com/atlassian-labs/atlaspack/commit/ec3abe4dffc98560a850fd2f71fb566577e6c99c) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - cleanup deduplicateReporters flag
+
+- [#870](https://github.com/atlassian-labs/atlaspack/pull/870) [`33d4c26`](https://github.com/atlassian-labs/atlaspack/commit/33d4c261ceb8d585d56b0a446ed6e28cf7f1126d) Thanks [@matt-koko](https://github.com/matt-koko)! - Support Loading TypeScript Plugin Files in v3
+
+- [#856](https://github.com/atlassian-labs/atlaspack/pull/856) [`f31b041`](https://github.com/atlassian-labs/atlaspack/commit/f31b04107e9077c9946aadb99f6f91bb69703bb7) Thanks [@matt-koko](https://github.com/matt-koko)! - Handle Directory Entry Points in v3
+
+- [#859](https://github.com/atlassian-labs/atlaspack/pull/859) [`8180981`](https://github.com/atlassian-labs/atlaspack/commit/8180981be14c00f9570adb70d3f350bd91d6ec0a) Thanks [@benjervis](https://github.com/benjervis)! - Re-use asset graphs when building in Native, if we have one left over from a previous incremental build
+
+- [#883](https://github.com/atlassian-labs/atlaspack/pull/883) [`119210b`](https://github.com/atlassian-labs/atlaspack/commit/119210b597eb993c50445df87a36b70bd49cd414) Thanks [@matt-koko](https://github.com/matt-koko)! - Fix bitflags rust/js interop
+
+- Updated dependencies [[`ec3abe4`](https://github.com/atlassian-labs/atlaspack/commit/ec3abe4dffc98560a850fd2f71fb566577e6c99c), [`c7fe3f7`](https://github.com/atlassian-labs/atlaspack/commit/c7fe3f76f247e9e20299e205e2df0a16c418eaf2), [`cfb4707`](https://github.com/atlassian-labs/atlaspack/commit/cfb4707087498e4fa4dcf10753fe984a248d196b), [`1468695`](https://github.com/atlassian-labs/atlaspack/commit/1468695fc0c9d06f060a6da9e9b0e154f11dff34), [`f31b041`](https://github.com/atlassian-labs/atlaspack/commit/f31b04107e9077c9946aadb99f6f91bb69703bb7), [`8180981`](https://github.com/atlassian-labs/atlaspack/commit/8180981be14c00f9570adb70d3f350bd91d6ec0a), [`ae77e74`](https://github.com/atlassian-labs/atlaspack/commit/ae77e7452a466b43b3fa5bed24d4ba26345ed765), [`f0a496f`](https://github.com/atlassian-labs/atlaspack/commit/f0a496f70fc8652e090cf1b3f6260e8cfbb796e2), [`7d7a55d`](https://github.com/atlassian-labs/atlaspack/commit/7d7a55dd6395ec391a2e4c33b3dec0d1ea477d4c), [`540f253`](https://github.com/atlassian-labs/atlaspack/commit/540f253dfdcd1a5caebbdc0b197319d439404aae)]:
+  - @atlaspack/feature-flags@2.26.2
+  - @atlaspack/rust@3.10.0
+  - @atlaspack/graph@3.6.0
+  - @atlaspack/utils@3.1.2
+  - @atlaspack/cache@3.2.33
+  - @atlaspack/fs@2.15.33
+  - @atlaspack/logger@2.14.30
+  - @atlaspack/package-manager@2.14.38
+  - @atlaspack/workers@2.14.38
+  - @atlaspack/plugin@2.14.38
+  - @atlaspack/profiler@2.14.35
+  - @atlaspack/types@2.15.28
+
 ## 2.26.2
 
 ### Patch Changes

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

@@ -19,7 +19,6 @@ class BitFlags {
     constructor(source) {
         // @ts-expect-error TS2344
         _BitFlags_kv.set(this, void 0);
-        // @ts-expect-error TS2344
         _BitFlags_vk.set(this, void 0);
         __classPrivateFieldSet(this, _BitFlags_kv, source, "f");
         __classPrivateFieldSet(this, _BitFlags_vk, Object.fromEntries(Object.entries(source).map((a) => a.reverse())), "f");
@@ -37,9 +36,6 @@ class BitFlags {
         }
         return this.into(key);
     }
-    intoArray(keys) {
-        return keys.map((key) => this.into(key));
-    }
     from(key) {
         const found = __classPrivateFieldGet(this, _BitFlags_vk, "f")[key];
         if (found === undefined) {
@@ -53,8 +49,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(__classPrivateFieldGet(this, _BitFlags_kv, "f"))) {
+            if ((keys & value) !== 0) {
+                values.push(key);
+            }
+        }
+        return values;
     }
 }
 exports.BitFlags = BitFlags;
@@ -70,21 +72,23 @@ 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
 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,
 });
 exports.specifierTypeMap = new BitFlags({
     esm: 0,

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

@@ -31,7 +31,7 @@ class Dependency {
         this.isOptional = inner.isOptional;
         this.isEntry = inner.isEntry;
         this.loc = inner.loc;
-        this.packageConditions = bitflags_1.packageConditionsMap.fromArray(inner.packageConditions || []);
+        this.packageConditions = bitflags_1.packageConditionsMap.toArray(inner.packageConditions || []);
         this.sourceAssetId = inner.sourceAssetId;
         this.sourcePath = inner.sourcePath;
         this.sourceAssetType = inner.sourceAssetType;

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

@@ -46,7 +46,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _AtlaspackWorker_resolvers, _AtlaspackWorker_transformers, _AtlaspackWorker_fs;
+var _AtlaspackWorker_resolvers, _AtlaspackWorker_transformers, _AtlaspackWorker_fs, _AtlaspackWorker_packageManager;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AtlaspackWorker = void 0;
 const assert_1 = __importDefault(require("assert"));
@@ -63,17 +63,23 @@ class AtlaspackWorker {
         _AtlaspackWorker_resolvers.set(this, void 0);
         _AtlaspackWorker_transformers.set(this, void 0);
         _AtlaspackWorker_fs.set(this, void 0);
+        _AtlaspackWorker_packageManager.set(this, void 0);
         this.loadPlugin = (0, jsCallable_1.jsCallable)(async ({ kind, specifier, 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 __classPrivateFieldGet(this, _AtlaspackWorker_packageManager, "f").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 {
@@ -287,10 +293,11 @@ class AtlaspackWorker {
         __classPrivateFieldSet(this, _AtlaspackWorker_resolvers, new Map(), "f");
         __classPrivateFieldSet(this, _AtlaspackWorker_transformers, new Map(), "f");
         __classPrivateFieldSet(this, _AtlaspackWorker_fs, new fs_1.NodeFS(), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_packageManager, new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), '/'), "f");
     }
 }
 exports.AtlaspackWorker = AtlaspackWorker;
-_AtlaspackWorker_resolvers = new WeakMap(), _AtlaspackWorker_transformers = new WeakMap(), _AtlaspackWorker_fs = new WeakMap();
+_AtlaspackWorker_resolvers = new WeakMap(), _AtlaspackWorker_transformers = new WeakMap(), _AtlaspackWorker_fs = new WeakMap(), _AtlaspackWorker_packageManager = new WeakMap();
 // Create napi worker and send it back to main thread
 const worker = new AtlaspackWorker();
 const napiWorker = napi.newNodejsWorker(worker);

package/dist/requests/AssetGraphRequest.js

@@ -30,7 +30,7 @@ function createAssetGraphRequest(requestInput) {
         run: async (input) => {
             let prevResult = await input.api.getPreviousResult();
             let builder = new AssetGraphBuilder(input, prevResult);
-            let assetGraphRequest = await await builder.build();
+            let assetGraphRequest = await builder.build();
             // early break for incremental bundling if production or flag is off;
             assetGraphRequest.assetGraph.setDisableIncrementalBundling(!input.options.shouldBundleIncrementally ||
                 input.options.mode === 'production');

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/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/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}`);

package/lib/requests/AssetGraphRequest.js

@@ -73,7 +73,7 @@ function createAssetGraphRequest(requestInput) {
     run: async input => {
       let prevResult = await input.api.getPreviousResult();
       let builder = new AssetGraphBuilder(input, prevResult);
-      let assetGraphRequest = await await builder.build();
+      let assetGraphRequest = await builder.build();
 
       // early break for incremental bundling if production or flag is off;
       assetGraphRequest.assetGraph.setDisableIncrementalBundling(!input.options.shouldBundleIncrementally || input.options.mode === 'production');