@atlaspack/core 2.16.2-canary.33 → 2.16.2-canary.330

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;
   };
@@ -20,10 +20,14 @@ function _stream() {
 }
 var _bitflags = require("./bitflags");
 var _assetSymbols = require("./asset-symbols");
-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 }; }
+// @ts-expect-error TS2694
+
 class MutableAsset {
+  // @ts-expect-error TS2564
+
+  // @ts-expect-error TS2416
+
   #astDirty;
   #ast;
   #contents;
@@ -34,6 +38,8 @@ class MutableAsset {
   get astGenerator() {
     throw new Error('get MutableAsset.astGenerator');
   }
+
+  // @ts-expect-error TS1051
   set astGenerator(value) {
     throw new Error('set MutableAsset.astGenerator');
   }
@@ -106,7 +112,6 @@ class MutableAsset {
     // Only create the source map if it is requested
     if (!this.#sourceMap && this.#map && typeof this.#map === 'string') {
       let sourceMap = new (_sourceMap().default)(this.#projectRoot);
-      // $FlowFixMe Flow is dumb
       sourceMap.addVLQMap(JSON.parse(this.#map));
       this.#sourceMap = sourceMap;
     }
@@ -126,32 +131,32 @@ class MutableAsset {
   }
 
   // eslint-disable-next-line no-unused-vars
-  addDependency() {
+  addDependency(options) {
     throw new Error('MutableAsset.addDependency()');
   }
 
   // eslint-disable-next-line no-unused-vars
-  addURLDependency() {
+  addURLDependency(url, opts) {
     throw new Error('MutableAsset.addURLDependency()');
   }
 
   // eslint-disable-next-line no-unused-vars
-  setEnvironment() {
+  setEnvironment(opts) {
     throw new Error('MutableAsset.setEnvironment()');
   }
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileChange() {
+  invalidateOnFileChange(invalidation) {
     // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileCreate() {
+  invalidateOnFileCreate(invalidation) {
     // TODO: Forward invalidations to Rust
   }
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnEnvChange() {
+  invalidateOnEnvChange(invalidation) {
     // TODO: Forward invalidations to Rust
   }
   invalidateOnStartup() {

package/lib/atlaspack-v3/worker/compat/plugin-config.js

@@ -7,6 +7,7 @@ exports.PluginConfig = void 0;
 var _Config = _interopRequireDefault(require("../../../public/Config"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class PluginConfig {
+  // @ts-expect-error TS2564
   #projectRoot;
   #inner;
   constructor({
@@ -21,17 +22,14 @@ class PluginConfig {
     this.isSource = isSource;
     this.searchPath = searchPath;
     this.#inner = new _Config.default(
-    // $FlowFixMe
+    // @ts-expect-error TS2345
     {
       invalidateOnConfigKeyChange: [],
       invalidateOnFileCreate: [],
       invalidateOnFileChange: new Set(),
       devDeps: [],
-      // $FlowFixMe
       searchPath: searchPath.replace(projectRoot + '/', '')
-    },
-    // $FlowFixMe
-    {
+    }, {
       projectRoot,
       inputFS: fs,
       outputFS: fs,
@@ -40,21 +38,21 @@ class PluginConfig {
   }
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileChange() {}
+  invalidateOnFileChange(filePath) {}
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileCreate() {}
+  invalidateOnFileCreate(invalidations) {}
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnEnvChange() {}
+  invalidateOnEnvChange(invalidation) {}
   invalidateOnStartup() {}
   invalidateOnBuild() {}
 
   // eslint-disable-next-line no-unused-vars
-  addDevDependency() {}
+  addDevDependency(options) {}
 
   // eslint-disable-next-line no-unused-vars
-  setCacheKey() {}
+  setCacheKey(key) {}
   getConfig(
   // eslint-disable-next-line no-unused-vars
   filePaths,

package/lib/atlaspack-v3/worker/compat/plugin-options.js

@@ -107,6 +107,7 @@ class PluginOptions {
     return this.#options.featureFlags;
   }
   constructor(options) {
+    // @ts-expect-error TS2322
     this.#options = options;
   }
 }

package/lib/atlaspack-v3/worker/compat/plugin-tracer.js

@@ -5,6 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PluginTracer = void 0;
 class PluginTracer {
+  // @ts-expect-error TS2564
+
+  // @ts-expect-error TS2416
   createMeasurement() {
     throw new Error('PluginTracer.createMeasurement');
   }

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

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Target = void 0;
+// @ts-expect-error TS2305
+
 class Target {
   constructor(inner, env) {
     this.distDir = inner.distDir;

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

@@ -1,3 +1,6 @@
 "use strict";
 
+if (process.env.ATLASPACK_SOURCES === 'true' || process.env.ATLASPACK_BUILD_ENV === 'test' || process.env.ATLASPACK_SELF_BUILD) {
+  require('@atlaspack/babel-register');
+}
 require('./worker');

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

@@ -51,33 +51,54 @@ 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 }; }
+// @ts-expect-error TS2305
+
 const CONFIG = Symbol.for('parcel-plugin-config');
 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,
     specifier,
-    resolveFrom
+    resolveFrom,
+    featureFlags
   }) => {
-    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}`);
     }
+    // Set feature flags in the worker process
+    // if (featureFlags) {
+    // Set feature flags in the worker process
+    let featureFlagsModule = await this.#packageManager.require('@atlaspack/feature-flags', __filename, {
+      shouldAutoInstall: false
+    });
+    featureFlagsModule.setFeatureFlags(featureFlags);
+    // const {setFeatureFlags} = await import('@atlaspack/feature-flags');
+    // setFeatureFlags(featureFlags);
+    // }
+
     switch (kind) {
       case 'resolver':
         this.#resolvers.set(specifier, {
@@ -122,6 +143,7 @@ class AtlaspackWorker {
     };
     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,
@@ -134,6 +156,8 @@ class AtlaspackWorker {
         ...defaultOptions
       }));
     }
+
+    // @ts-expect-error TS2345
     const result = await state.resolver.resolve({
       specifier,
       dependency,
@@ -149,13 +173,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,
@@ -187,7 +219,9 @@ class AtlaspackWorker {
       return Promise.resolve(resolvedPath);
     };
     const env = new _compat.Environment(napiEnv);
-    const mutableAsset = new _compat.MutableAsset(innerAsset, contents, env, this.#fs, map, options.projectRoot);
+    const mutableAsset = new _compat.MutableAsset(innerAsset,
+    // @ts-expect-error TS2345
+    contents, env, this.#fs, map, options.projectRoot);
     const defaultOptions = {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
@@ -199,6 +233,8 @@ class AtlaspackWorker {
         outputFS: this.#fs
       })
     };
+
+    // @ts-expect-error TS2345
     const config = await ((_transformer$loadConf = transformer.loadConfig) === null || _transformer$loadConf === void 0 ? void 0 : _transformer$loadConf.call(transformer, {
       config: new _compat.PluginConfig({
         env,
@@ -212,6 +248,7 @@ class AtlaspackWorker {
     }));
     if (transformer.parse) {
       const ast = await transformer.parse({
+        // @ts-expect-error TS2322
         asset: mutableAsset,
         config,
         resolve: resolveFunc,
@@ -222,6 +259,7 @@ class AtlaspackWorker {
       }
     }
     const result = await state.transformer.transform({
+      // @ts-expect-error TS2322
       asset: mutableAsset,
       config,
       resolve: resolveFunc,
@@ -230,8 +268,8 @@ class AtlaspackWorker {
     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 +279,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) {
@@ -250,6 +289,13 @@ 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;
+    }
     return [{
       id: mutableAsset.id,
       bundleBehavior: _compat.bundleBehaviorMap.intoNullable(mutableAsset.bundleBehavior),
@@ -265,10 +311,10 @@ 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
+    // @ts-expect-error TS2533
     JSON.stringify((await mutableAsset.getMap()).toVLQ()) : ''];
   });
 }
@@ -277,4 +323,6 @@ class AtlaspackWorker {
 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);
+
+// @ts-expect-error TS2694

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) {

package/lib/index.js

@@ -4,13 +4,25 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
+  EnvironmentManager: true,
   Atlaspack: true,
   Parcel: true,
   BuildError: true,
   createWorkerFarm: true,
   INTERNAL_RESOLVE: true,
-  INTERNAL_TRANSFORM: true
+  INTERNAL_TRANSFORM: true,
+  WORKER_PATH: true,
+  ATLASPACK_VERSION: true,
+  resolveOptions: true,
+  createEnvironment: true,
+  Environment: true
 };
+Object.defineProperty(exports, "ATLASPACK_VERSION", {
+  enumerable: true,
+  get: function () {
+    return _constants.ATLASPACK_VERSION;
+  }
+});
 Object.defineProperty(exports, "Atlaspack", {
   enumerable: true,
   get: function () {
@@ -23,6 +35,13 @@ Object.defineProperty(exports, "BuildError", {
     return _Atlaspack.BuildError;
   }
 });
+Object.defineProperty(exports, "Environment", {
+  enumerable: true,
+  get: function () {
+    return _Environment2.default;
+  }
+});
+exports.EnvironmentManager = void 0;
 Object.defineProperty(exports, "INTERNAL_RESOLVE", {
   enumerable: true,
   get: function () {
@@ -41,6 +60,18 @@ Object.defineProperty(exports, "Parcel", {
     return _Atlaspack.default;
   }
 });
+Object.defineProperty(exports, "WORKER_PATH", {
+  enumerable: true,
+  get: function () {
+    return _Atlaspack.WORKER_PATH;
+  }
+});
+Object.defineProperty(exports, "createEnvironment", {
+  enumerable: true,
+  get: function () {
+    return _Environment.createEnvironment;
+  }
+});
 Object.defineProperty(exports, "createWorkerFarm", {
   enumerable: true,
   get: function () {
@@ -53,7 +84,19 @@ Object.defineProperty(exports, "default", {
     return _Atlaspack.default;
   }
 });
+Object.defineProperty(exports, "resolveOptions", {
+  enumerable: true,
+  get: function () {
+    return _resolveOptions.default;
+  }
+});
+var EnvironmentManager = _interopRequireWildcard(require("./EnvironmentManager"));
+exports.EnvironmentManager = EnvironmentManager;
 var _Atlaspack = _interopRequireWildcard(require("./Atlaspack"));
+var _constants = require("./constants");
+var _resolveOptions = _interopRequireDefault(require("./resolveOptions"));
+var _Environment = require("./Environment");
+var _Environment2 = _interopRequireDefault(require("./public/Environment"));
 var _atlaspackV = require("./atlaspack-v3");
 Object.keys(_atlaspackV).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -66,5 +109,6 @@ Object.keys(_atlaspackV).forEach(function (key) {
     }
   });
 });
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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; }