@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AtlaspackWorker = void 0;
+var _sideEffectDetector = require("./side-effect-detector");
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
   _assert = function () {
@@ -51,33 +52,73 @@ var _compat = require("./compat");
 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 }; }
+/* eslint-disable import/first */
+
+// Install side effect detection patches BEFORE importing any modules that use fs
+const sideEffectDetector = new _sideEffectDetector.SideEffectDetector();
+sideEffectDetector.install();
+
+// @ts-expect-error TS2305
+
 const CONFIG = Symbol.for('parcel-plugin-config');
 class AtlaspackWorker {
   #resolvers;
   #transformers;
   #fs;
+  #packageManager;
+  #options;
+  #sideEffectDetector;
   constructor() {
     this.#resolvers = new Map();
     this.#transformers = new Map();
     this.#fs = new (_fs().NodeFS)();
+    this.#packageManager = new (_packageManager().NodePackageManager)(this.#fs, '/');
+    this.#sideEffectDetector = sideEffectDetector; // Use the global detector that was installed before imports
+  }
+
+  clearState() {
+    this.#resolvers.clear();
+    this.#transformers.clear();
+    this.#options = undefined;
   }
   loadPlugin = (0, _jsCallable.jsCallable)(async ({
     kind,
     specifier,
-    resolveFrom
+    resolveFrom,
+    options
   }) => {
-    let customRequire = _module().createRequire(resolveFrom);
-    let resolvedPath = customRequire.resolve(specifier);
-    // $FlowFixMe
-    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}`);
     }
+    if (this.#options == null) {
+      this.#options = {
+        ...options,
+        inputFS: this.#fs,
+        outputFS: this.#fs,
+        packageManager: this.#packageManager,
+        shouldAutoInstall: false
+      };
+    }
+
+    // Set feature flags in the worker process
+    let featureFlagsModule = await this.#packageManager.require('@atlaspack/feature-flags', __filename, {
+      shouldAutoInstall: false
+    });
+    featureFlagsModule.setFeatureFlags(options.featureFlags);
     switch (kind) {
       case 'resolver':
         this.#resolvers.set(specifier, {
@@ -85,55 +126,43 @@ class AtlaspackWorker {
         });
         break;
       case 'transformer':
-        this.#transformers.set(specifier, {
-          transformer: instance
-        });
-        break;
+        {
+          return this.initializeTransformer(instance, specifier);
+        }
     }
   });
   runResolverResolve = (0, _jsCallable.jsCallable)(async ({
     key,
     dependency: napiDependency,
     specifier,
-    pipeline,
-    pluginOptions
+    pipeline
   }) => {
     const state = this.#resolvers.get(key);
     if (!state) {
       throw new Error(`Resolver not found: ${key}`);
     }
-    let packageManager = state.packageManager;
-    if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, pluginOptions.projectRoot);
-      state.packageManager = packageManager;
-    }
     const env = new _compat.Environment(napiDependency.env);
     const dependency = new _compat.Dependency(napiDependency, env);
     const defaultOptions = {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
-      options: new _compat.PluginOptions({
-        ...pluginOptions,
-        packageManager,
-        shouldAutoInstall: false,
-        inputFS: this.#fs,
-        outputFS: this.#fs
-      })
+      options: new _compat.PluginOptions(this.options)
     };
     if (!('config' in state)) {
       var _state$resolver$loadC, _state$resolver;
+      // @ts-expect-error TS2345
       state.config = await ((_state$resolver$loadC = (_state$resolver = state.resolver).loadConfig) === null || _state$resolver$loadC === void 0 ? void 0 : _state$resolver$loadC.call(_state$resolver, {
         config: new _compat.PluginConfig({
-          env,
+          env: napiDependency.env,
+          plugin: key,
           isSource: true,
-          searchPath: specifier,
-          projectRoot: pluginOptions.projectRoot,
-          fs: this.#fs,
-          packageManager
-        }),
+          searchPath: 'index'
+        }, this.options),
         ...defaultOptions
       }));
     }
+
+    // @ts-expect-error TS2345
     const result = await state.resolver.resolve({
       specifier,
       dependency,
@@ -149,13 +178,21 @@ class AtlaspackWorker {
         }
       };
     }
+    if (result.isExcluded) {
+      return {
+        invalidations: [],
+        resolution: {
+          type: 'excluded'
+        }
+      };
+    }
     return {
       invalidations: [],
       resolution: {
         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,
@@ -166,52 +203,58 @@ class AtlaspackWorker {
   });
   runTransformerTransform = (0, _jsCallable.jsCallable)(async ({
     key,
-    env: napiEnv,
-    options,
     asset: innerAsset
   }, contents, map) => {
-    var _transformer$loadConf;
-    const state = this.#transformers.get(key);
-    if (!state) {
+    const instance = this.#transformers.get(key);
+    if (!instance) {
       throw new Error(`Transformer not found: ${key}`);
     }
-    let packageManager = state.packageManager;
-    if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, options.projectRoot);
-      state.packageManager = packageManager;
-    }
-    const transformer = state.transformer;
+    let {
+      transformer,
+      config,
+      allowedEnv = new Set()
+    } = instance;
+    let cacheBailouts = [];
     const resolveFunc = (from, to) => {
       let customRequire = _module().createRequire(from);
       let resolvedPath = customRequire.resolve(to);
+      // Tranformer not cacheable due to use of the resolve function
+
+      cacheBailouts.push(`resolve(${from}, ${to})`);
       return Promise.resolve(resolvedPath);
     };
-    const env = new _compat.Environment(napiEnv);
-    const mutableAsset = new _compat.MutableAsset(innerAsset, contents, env, this.#fs, map, options.projectRoot);
+    const env = new _compat.Environment(innerAsset.env);
+    let mutableAsset = new _compat.MutableAsset(innerAsset,
+    // @ts-expect-error TS2345
+    contents, env, this.#fs, map, this.options.projectRoot);
+    const pluginOptions = new _compat.PluginOptions(this.options);
     const defaultOptions = {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
-      options: new _compat.PluginOptions({
-        ...options,
-        packageManager,
-        shouldAutoInstall: false,
-        inputFS: this.#fs,
-        outputFS: this.#fs
-      })
+      options: pluginOptions
     };
-    const config = await ((_transformer$loadConf = transformer.loadConfig) === null || _transformer$loadConf === void 0 ? void 0 : _transformer$loadConf.call(transformer, {
-      config: new _compat.PluginConfig({
-        env,
-        isSource: true,
-        searchPath: innerAsset.filePath,
-        projectRoot: options.projectRoot,
-        fs: this.#fs,
-        packageManager
-      }),
-      ...defaultOptions
-    }));
+    if (transformer.loadConfig) {
+      if (config != null) {
+        throw new Error(`Transformer (${key}) should not implement 'setup' and 'loadConfig'`);
+      }
+      // @ts-expect-error TS2345
+      config = await transformer.loadConfig({
+        config: new _compat.PluginConfig({
+          plugin: key,
+          isSource: innerAsset.isSource,
+          searchPath: innerAsset.filePath,
+          env
+        }, this.options),
+        ...defaultOptions
+      });
+
+      // Transformer uses the deprecated loadConfig API, so mark as not
+      // cachable
+      cacheBailouts.push(`Transformer.loadConfig`);
+    }
     if (transformer.parse) {
       const ast = await transformer.parse({
+        // @ts-expect-error TS2322
         asset: mutableAsset,
         config,
         resolve: resolveFunc,
@@ -220,18 +263,37 @@ class AtlaspackWorker {
       if (ast) {
         mutableAsset.setAST(ast);
       }
+      cacheBailouts.push(`Transformer.parse`);
     }
-    const result = await state.transformer.transform({
+    const [result, sideEffects] = await this.#sideEffectDetector.monitorSideEffects(key, () => transformer.transform({
+      // @ts-expect-error TS2322
       asset: mutableAsset,
       config,
       resolve: resolveFunc,
       ...defaultOptions
-    });
+    }));
+    if (sideEffects.envUsage.didEnumerate) {
+      cacheBailouts.push(`Env access: enumeration of process.env`);
+    }
+    for (let variable of sideEffects.envUsage.vars) {
+      if (variable in allowedEnv) {
+        continue;
+      }
+      cacheBailouts.push(`Env access: ${variable}`);
+    }
+    for (let {
+      method,
+      path
+    } of sideEffects.fsUsage) {
+      cacheBailouts.push(`FS usage: ${method}(${path})`);
+    }
+    (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
+    (0, _assert().default)(result[0] === mutableAsset, '[V3] Unimplemented: New asset returned from Node transformer');
     if (transformer.generate) {
       const ast = await mutableAsset.getAST();
       if (ast) {
-        // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
         const output = await transformer.generate({
+          // @ts-expect-error TS2322
           asset: mutableAsset,
           ast,
           ...defaultOptions
@@ -241,6 +303,7 @@ class AtlaspackWorker {
         } else if (output.content instanceof Buffer) {
           mutableAsset.setBuffer(output.content);
         } else {
+          // @ts-expect-error TS2345
           mutableAsset.setStream(output.content);
         }
         if (output.map) {
@@ -248,8 +311,17 @@ class AtlaspackWorker {
         }
       }
     }
-    (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
-    (0, _assert().default)(result[0] === mutableAsset, '[V3] Unimplemented: New asset returned from Node transformer');
+    let assetBuffer = await mutableAsset.getBuffer();
+
+    // If the asset has no code, we set the buffer to null, which we can
+    // detect in Rust, to avoid passing back an empty buffer, which we can't.
+    if (assetBuffer.length === 0) {
+      assetBuffer = null;
+    }
+    if (pluginOptions.used) {
+      // Plugin options accessed, so not cachable
+      cacheBailouts.push(`Plugin options accessed`);
+    }
     return [{
       id: mutableAsset.id,
       bundleBehavior: _compat.bundleBehaviorMap.intoNullable(mutableAsset.bundleBehavior),
@@ -265,16 +337,72 @@ class AtlaspackWorker {
       symbols: mutableAsset.symbols.intoNapi(),
       type: mutableAsset.type,
       uniqueKey: mutableAsset.uniqueKey
-    }, await mutableAsset.getBuffer(),
+    }, assetBuffer,
     // Only send back the map if it has changed
     mutableAsset.isMapDirty ?
-    // $FlowFixMe A dirty map means this will be valid
-    JSON.stringify((await mutableAsset.getMap()).toVLQ()) : ''];
+    // @ts-expect-error TS2533
+    JSON.stringify((await mutableAsset.getMap()).toVLQ()) : '',
+    // Limit to first 10 bailouts
+    cacheBailouts.slice(0, 10)];
   });
+  get options() {
+    if (this.#options == null) {
+      throw new Error('Plugin options have not been initialized');
+    }
+    return this.#options;
+  }
+  async initializeTransformer(instance, specifier) {
+    let transformer = instance;
+    let setup, config, allowedEnv;
+    let packageManager = new (_packageManager().NodePackageManager)(this.#fs, this.options.projectRoot);
+    if (transformer.setup) {
+      var _setupResult$env;
+      let setupResult = await transformer.setup({
+        logger: new _compat.PluginLogger(),
+        options: new _compat.PluginOptions({
+          ...this.options,
+          shouldAutoInstall: false,
+          inputFS: this.#fs,
+          outputFS: this.#fs,
+          packageManager
+        }),
+        config: new _compat.PluginConfig({
+          plugin: specifier,
+          searchPath: 'index',
+          // Consider project setup config as source
+          isSource: true
+        }, this.options)
+      });
+      config = setupResult === null || setupResult === void 0 ? void 0 : setupResult.config;
+      allowedEnv = Object.fromEntries((setupResult === null || setupResult === void 0 || (_setupResult$env = setupResult.env) === null || _setupResult$env === void 0 ? void 0 : _setupResult$env.map(env => [env, process.env[env]])) || []);
+
+      // Always add the following env vars to the cache key
+      allowedEnv['NODE_ENV'] = process.env['NODE_ENV'];
+      setup = {
+        conditions: setupResult === null || setupResult === void 0 ? void 0 : setupResult.conditions,
+        config,
+        env: allowedEnv
+      };
+    }
+    this.#transformers.set(specifier, {
+      transformer,
+      config,
+      packageManager,
+      allowedEnv
+    });
+    return setup;
+  }
 }
 
 // Create napi worker and send it back to main thread
 exports.AtlaspackWorker = AtlaspackWorker;
 const worker = new AtlaspackWorker();
 const napiWorker = napi().newNodejsWorker(worker);
-_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage(napiWorker);
+_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage(napiWorker);
+_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.setMaxListeners(_worker_threads().parentPort.getMaxListeners() + 1);
+_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.addListener('message', message => {
+  if (message === 'clearState') {
+    worker.clearState();
+    _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage('stateCleared');
+  }
+});

package/lib/constants.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.VALID = exports.STARTUP = exports.OPTION_CHANGE = exports.INITIAL_BUILD = exports.HASH_REF_REGEX = exports.HASH_REF_PREFIX = exports.HASH_REF_HASH_LEN = exports.FILE_UPDATE = exports.FILE_DELETE = exports.FILE_CREATE = exports.ERROR = exports.ENV_CHANGE = exports.ATLASPACK_VERSION = void 0;
 var _package = require("../package.json");
-// $FlowFixMe
 const ATLASPACK_VERSION = exports.ATLASPACK_VERSION = _package.version;
 const HASH_REF_PREFIX = exports.HASH_REF_PREFIX = 'HASH_REF_';
 const HASH_REF_HASH_LEN = exports.HASH_REF_HASH_LEN = 16;

package/lib/dumpGraphToGraphViz.js

@@ -4,8 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = dumpGraphToGraphViz;
-var _BundleGraph = require("./BundleGraph");
-var _RequestTracker = require("./RequestTracker");
 function _path() {
   const data = _interopRequireDefault(require("path"));
   _path = function () {
@@ -47,13 +45,13 @@ const TYPE_COLORS = {
 };
 async function dumpGraphToGraphViz(graph, name, edgeTypes) {
   var _globalThis$ATLASPACK;
-  if ("production" === 'production' && !process.env.ATLASPACK_BUILD_REPL) {
+  if (process.env.ATLASPACK_BUILD_ENV === 'production' && !process.env.ATLASPACK_BUILD_REPL) {
     return;
   }
-  let mode = process.env.ATLASPACK_BUILD_REPL ? // $FlowFixMe
+  let mode = process.env.ATLASPACK_BUILD_REPL ? // @ts-expect-error TS7017
   (_globalThis$ATLASPACK = globalThis.ATLASPACK_DUMP_GRAPHVIZ) === null || _globalThis$ATLASPACK === void 0 ? void 0 : _globalThis$ATLASPACK.mode : process.env.ATLASPACK_DUMP_GRAPHVIZ;
 
-  // $FlowFixMe[invalid-compare]
+  // @ts-expect-error TS2367
   if (mode == null || mode == false) {
     return;
   }
@@ -61,38 +59,57 @@ async function dumpGraphToGraphViz(graph, name, edgeTypes) {
   let GraphVizGraph = require('graphviz/lib/deps/graph').Graph;
   let g = new GraphVizGraph(null, 'G');
   g.type = 'digraph';
-  // $FlowFixMe
   for (let [id, node] of graph.nodes.entries()) {
     if (node == null) continue;
     let n = g.addNode(nodeId(id));
-    // $FlowFixMe default is fine. Not every type needs to be in the map.
+    // @ts-expect-error TS7053
     n.set('color', COLORS[node.type || 'default']);
     n.set('shape', 'box');
     n.set('style', 'filled');
     let label;
     if (typeof node === 'string') {
       label = node;
+      // @ts-expect-error TS2339
     } else if (node.assets) {
+      // @ts-expect-error TS2339
       label = `(${nodeId(id)}), (assetIds: ${[...node.assets].map(a => {
         let arr = a.filePath.split('/');
         return arr[arr.length - 1];
-      }).join(', ')}) (sourceBundles: ${[...node.sourceBundles].join(', ')}) (bb ${node.bundleBehavior ?? 'none'})`;
+      })
+      // @ts-expect-error TS2339
+      .join(', ')}) (sourceBundles: ${[...node.sourceBundles].join(', '
+      // @ts-expect-error TS2339
+      )}) (bb ${node.bundleBehavior ?? 'none'})`;
+      // @ts-expect-error TS2339
     } else if (node.type) {
+      // @ts-expect-error TS2339
       label = `[${(0, _graph().fromNodeId)(id)}] ${node.type || 'No Type'}: [${node.id}]: `;
+      // @ts-expect-error TS2339
       if (node.type === 'dependency') {
+        // @ts-expect-error TS2339
         label += node.value.specifier;
         let parts = [];
+        // @ts-expect-error TS2339
         if (node.value.priority !== _types.Priority.sync) {
           var _Object$entries$find;
-          parts.push((_Object$entries$find = Object.entries(_types.Priority).find(([, v]) => v === node.value.priority)) === null || _Object$entries$find === void 0 ? void 0 : _Object$entries$find[0]);
+          parts.push((_Object$entries$find = Object.entries(_types.Priority).find(
+          // @ts-expect-error TS2339
+          ([, v]) => v === node.value.priority)) === null || _Object$entries$find === void 0 ? void 0 : _Object$entries$find[0]);
         }
+        // @ts-expect-error TS2339
         if (node.value.isOptional) parts.push('optional');
+        // @ts-expect-error TS2339
         if (node.value.specifierType === _types.SpecifierType.url) parts.push('url');
+        // @ts-expect-error TS2339
         if (node.hasDeferred) parts.push('deferred');
+        // @ts-expect-error TS2339
         if (node.deferred) parts.push('deferred');
+        // @ts-expect-error TS2339
         if (node.excluded) parts.push('excluded');
         if (parts.length) label += ' (' + parts.join(', ') + ')';
+        // @ts-expect-error TS2339
         if (node.value.env) label += ` (${getEnvDescription(node.value.env)})`;
+        // @ts-expect-error TS2339
         let depSymbols = node.value.symbols;
         if (detailedSymbols) {
           if (depSymbols) {
@@ -107,11 +124,17 @@ async function dumpGraphToGraphViz(graph, name, edgeTypes) {
             if (weakSymbols.length) {
               label += '\\nweakSymbols: ' + weakSymbols.join(',');
             }
+            // @ts-expect-error TS2339
             if (node.usedSymbolsUp.size > 0) {
-              label += '\\nusedSymbolsUp: ' + [...node.usedSymbolsUp].map(([s, sAsset]) => sAsset ? `${s}(${sAsset.asset}.${sAsset.symbol ?? ''})` : sAsset === null ? `${s}(external)` : `${s}(ambiguous)`).join(',');
+              label += '\\nusedSymbolsUp: ' +
+              // @ts-expect-error TS2339
+              [...node.usedSymbolsUp].map(([s, sAsset]) => sAsset ? `${s}(${sAsset.asset}.${sAsset.symbol ?? ''})` : sAsset === null ? `${s}(external)` : `${s}(ambiguous)`).join(',');
             }
+            // @ts-expect-error TS2339
             if (node.usedSymbolsDown.size > 0) {
-              label += '\\nusedSymbolsDown: ' + [...node.usedSymbolsDown].join(',');
+              label +=
+              // @ts-expect-error TS2339
+              '\\nusedSymbolsDown: ' + [...node.usedSymbolsDown].join(',');
             }
             // if (node.usedSymbolsDownDirty) label += '\\nusedSymbolsDownDirty';
             // if (node.usedSymbolsUpDirtyDown)
@@ -121,17 +144,28 @@ async function dumpGraphToGraphViz(graph, name, edgeTypes) {
             label += '\\nsymbols: cleared';
           }
         }
+        // @ts-expect-error TS2339
       } else if (node.type === 'asset') {
-        label += _path().default.basename((0, _projectPath.fromProjectPathRelative)(node.value.filePath)) + '#' + node.value.type;
+        label +=
+        // @ts-expect-error TS2339
+        _path().default.basename((0, _projectPath.fromProjectPathRelative)(node.value.filePath)) + '#' +
+        // @ts-expect-error TS2339
+        node.value.type;
         if (detailedSymbols) {
+          // @ts-expect-error TS2339
           if (!node.value.symbols) {
             label += '\\nsymbols: cleared';
+            // @ts-expect-error TS2339
           } else if (node.value.symbols.size) {
-            label += '\\nsymbols: ' + [...node.value.symbols].map(([e, {
+            label += '\\nsymbols: ' +
+            // @ts-expect-error TS2339
+            [...node.value.symbols].map(([e, {
               local
             }]) => [e, local]).join(';');
           }
+          // @ts-expect-error TS2339
           if (node.usedSymbols.size) {
+            // @ts-expect-error TS2339
             label += '\\nusedSymbols: ' + [...node.usedSymbols].join(',');
           }
           // if (node.usedSymbolsDownDirty) label += '\\nusedSymbolsDownDirty';
@@ -139,21 +173,38 @@ async function dumpGraphToGraphViz(graph, name, edgeTypes) {
         } else {
           label += '\\nsymbols: cleared';
         }
+        // @ts-expect-error TS2339
       } else if (node.type === 'asset_group') {
+        // @ts-expect-error TS2339
         if (node.deferred) label += '(deferred)';
+        // @ts-expect-error TS2339
       } else if (node.type === 'file') {
+        // @ts-expect-error TS2339
         label += _path().default.basename(node.id);
+        // @ts-expect-error TS2339
       } else if (node.type === 'transformer_request') {
-        label += _path().default.basename(node.value.filePath) + ` (${getEnvDescription(node.value.env)})`;
+        label +=
+        // @ts-expect-error TS2339
+        _path().default.basename(node.value.filePath) +
+        // @ts-expect-error TS2339
+        ` (${getEnvDescription(node.value.env)})`;
+        // @ts-expect-error TS2339
       } else if (node.type === 'bundle') {
         let parts = [];
+        // @ts-expect-error TS2339
         if (node.value.needsStableName) parts.push('stable name');
+        // @ts-expect-error TS2339
         parts.push(node.value.name);
+        // @ts-expect-error TS2339
         parts.push('bb:' + (node.value.bundleBehavior ?? 'null'));
+        // @ts-expect-error TS2339
         if (node.value.isPlaceholder) parts.push('placeholder');
         if (parts.length) label += ' (' + parts.join(', ') + ')';
+        // @ts-expect-error TS2339
         if (node.value.env) label += ` (${getEnvDescription(node.value.env)})`;
+        // @ts-expect-error TS2339
       } else if (node.type === 'request') {
+        // @ts-expect-error TS2339
         label = node.requestType + ':' + node.id;
       }
     }
@@ -163,10 +214,13 @@ async function dumpGraphToGraphViz(graph, name, edgeTypes) {
   if (edgeTypes) {
     edgeNames = Object.fromEntries(Object.entries(edgeTypes).map(([k, v]) => [v, k]));
   }
+
+  // @ts-expect-error TS2488
   for (let edge of graph.getAllEdges()) {
     let gEdge = g.addEdge(nodeId(edge.from), nodeId(edge.to));
     let color = null;
     if (edge.type != 1 && edgeNames) {
+      // @ts-expect-error TS7053
       color = TYPE_COLORS[edgeNames[edge.type]];
     }
     if (color != null) {
@@ -175,7 +229,7 @@ async function dumpGraphToGraphViz(graph, name, edgeTypes) {
   }
   if (process.env.ATLASPACK_BUILD_REPL) {
     var _globalThis$ATLASPACK2;
-    // $FlowFixMe
+    // @ts-expect-error TS7017
     (_globalThis$ATLASPACK2 = globalThis.ATLASPACK_DUMP_GRAPHVIZ) === null || _globalThis$ATLASPACK2 === void 0 || _globalThis$ATLASPACK2.call(globalThis, name, g.to_dot());
   } else {
     const tempy = require('tempy');
@@ -187,8 +241,9 @@ async function dumpGraphToGraphViz(graph, name, edgeTypes) {
     console.log('Dumped', tmp);
   }
 }
+
+// @ts-expect-error TS2552
 function nodeId(id) {
-  // $FlowFixMe
   return `node${id}`;
 }
 function getEnvDescription(env) {