@atlaspack/core 2.12.1-dev.3450 → 2.12.1-dev.3460

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

@@ -48,16 +48,17 @@ function _module() {
 }
 var _compat = require("./compat");
 var _jsCallable = require("../jsCallable");
-var _Environment = _interopRequireDefault(require("../../public/Environment"));
 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 }; }
 const CONFIG = Symbol.for('parcel-plugin-config');
 class AtlaspackWorker {
   #resolvers;
+  #transformers;
   #fs;
   constructor() {
     this.#resolvers = new Map();
+    this.#transformers = new Map();
     this.#fs = new (_fs().NodeFS)();
   }
   loadPlugin = (0, _jsCallable.jsCallable)(async ({
@@ -83,11 +84,16 @@ class AtlaspackWorker {
           resolver: instance
         });
         break;
+      case 'transformer':
+        this.#transformers.set(specifier, {
+          transformer: instance
+        });
+        break;
     }
   });
   runResolverResolve = (0, _jsCallable.jsCallable)(async ({
     key,
-    dependency,
+    dependency: napiDependency,
     specifier,
     pipeline,
     projectRoot
@@ -101,80 +107,27 @@ class AtlaspackWorker {
       packageManager = new (_packageManager().NodePackageManager)(this.#fs, projectRoot);
       state.packageManager = packageManager;
     }
+    const env = new _compat.Environment(napiDependency.env);
+    const dependency = new _compat.Dependency(napiDependency, env);
     const defaultOptions = {
-      get logger() {
-        // $FlowFixMe
-        return globalThis.console;
-      },
-      tracer: {
-        enabled: false,
-        createMeasurement: () => null
-      },
-      options: {
-        get mode() {
-          throw new Error('Resolver.resolve.options.mode');
-        },
-        parcelVersion: 'TODO',
+      logger: new _compat.PluginLogger(),
+      tracer: new _compat.PluginTracer(),
+      options: new _compat.PluginOptions({
         packageManager,
-        env: process.env,
-        get hmrOptions() {
-          throw new Error('Resolver.resolve.options.hmrOptions');
-        },
-        get serveOptions() {
-          throw new Error('Resolver.resolve.options.serveOptions');
-        },
-        get shouldBuildLazily() {
-          throw new Error('Resolver.resolve.options.shouldBuildLazily');
-        },
         shouldAutoInstall: false,
-        get logLevel() {
-          throw new Error('Resolver.resolve.options.logLevel');
-        },
         projectRoot,
-        get cacheDir() {
-          throw new Error('Resolver.resolve.options.cacheDir');
-        },
         inputFS: this.#fs,
-        outputFS: this.#fs,
-        get instanceId() {
-          throw new Error('Resolver.resolve.options.instanceId');
-        },
-        get detailedReport() {
-          throw new Error('Resolver.resolve.options.detailedReport');
-        },
-        get featureFlags() {
-          throw new Error('Resolver.resolve.options.featureFlags');
-        }
-      }
+        outputFS: this.#fs
+      })
     };
     if (!('config' in state)) {
       var _state$resolver$loadC, _state$resolver;
       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: {
+        config: new _compat.PluginConfig({
+          env,
           isSource: true,
-          searchPath: '',
-          // $FlowFixMe This isn't correct to flow but is enough to satisfy the runtime checks
-          env: new _Environment.default(dependency.env, {
-            projectRoot,
-            hmrOptions: undefined
-          }),
-          invalidateOnFileChange() {},
-          invalidateOnFileCreate() {},
-          invalidateOnEnvChange() {},
-          invalidateOnStartup() {},
-          invalidateOnBuild() {},
-          addDevDependency() {},
-          setCacheKey() {},
-          getConfig() {
-            throw new Error('Resolver.loadConfig.config.getConfig');
-          },
-          getConfigFrom() {
-            throw new Error('Resolver.loadConfig.config.getConfigFrom');
-          },
-          getPackage() {
-            throw new Error('Resolver.loadConfig.config.getPackage');
-          }
-        },
+          searchPath: ''
+        }),
         ...defaultOptions
       }));
     }
@@ -203,74 +156,109 @@ class AtlaspackWorker {
         code: result.code || undefined,
         meta: result.meta || undefined,
         pipeline: result.pipeline || undefined,
-        priority: result.priority && PriorityMap[result.priority],
+        priority: _compat.dependencyPriorityMap.intoNullable(result.priority),
         query: result.query && result.query.toString()
       }
     };
   });
-  ping() {
-    // console.log('Hi');
-  }
-  async runTransformer({
-    resolveFrom,
-    specifier,
-    options,
-    asset
-  }) {
-    const customRequire = _module().createRequire(resolveFrom);
-    const resolvedPath = customRequire.resolve(specifier);
-    // $FlowFixMe
-    const transformerModule = await import(resolvedPath);
-    const transformer = transformerModule.default.default[CONFIG];
-    let assetCompat = new _compat.AssetCompat(asset, options);
-    try {
-      if (transformer.parse) {
-        // $FlowFixMe
-        const ast = await transformer.parse({
-          asset: assetCompat
-        }); // missing "config"
-        // $FlowFixMe
-        assetCompat.setAST(ast);
+  runTransformerTransform = (0, _jsCallable.jsCallable)(async ({
+    key,
+    env: napiEnv,
+    projectRoot,
+    asset: innerAsset
+  }) => {
+    var _transformer$loadConf;
+    const state = this.#transformers.get(key);
+    if (!state) {
+      throw new Error(`Transformer not found: ${key}`);
+    }
+    let packageManager = state.packageManager;
+    if (!packageManager) {
+      packageManager = new (_packageManager().NodePackageManager)(this.#fs, projectRoot);
+      state.packageManager = packageManager;
+    }
+    const transformer = state.transformer;
+    const env = new _compat.Environment(napiEnv);
+    const mutableAsset = new _compat.MutableAsset(innerAsset, this.#fs, env);
+    const defaultOptions = {
+      logger: new _compat.PluginLogger(),
+      tracer: new _compat.PluginTracer(),
+      options: new _compat.PluginOptions({
+        packageManager,
+        shouldAutoInstall: false,
+        projectRoot,
+        inputFS: this.#fs,
+        outputFS: this.#fs
+      })
+    };
+    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: ''
+      }),
+      ...defaultOptions
+    }));
+    if (transformer.parse) {
+      const ast = await transformer.parse({
+        asset: mutableAsset,
+        config,
+        get resolve() {
+          throw new Error('Transformer.parse.resolve()');
+        },
+        ...defaultOptions
+      });
+      if (ast) {
+        mutableAsset.setAST(ast);
       }
-
-      // $FlowFixMe
-      const result = await transformer.transform({
-        // $FlowFixMe
-        asset: assetCompat,
-        options,
-        config: null
+    }
+    const result = await state.transformer.transform({
+      asset: mutableAsset,
+      config,
+      get resolve() {
+        throw new Error('Transformer.transform.resolve()');
+      },
+      ...defaultOptions
+    });
+    if (transformer.generate) {
+      const ast = await mutableAsset.getAST();
+      if (!ast) {
+        throw new Error('Transformer.generate.ast');
+      }
+      // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
+      const output = await transformer.generate({
+        asset: mutableAsset,
+        ast,
+        ...defaultOptions
       });
-      if (transformer.generate) {
-        // $FlowFixMe
-        let output = await transformer.generate({
-          // $FlowFixMe
-          asset: assetCompat,
-          // $FlowFixMe
-          ast: assetCompat.getAST()
-        });
-        // $FlowFixMe
-        assetCompat.setCode(output.content);
+      if (typeof output.content === 'string') {
+        mutableAsset.setCode(output.content);
+      } else if (output.content instanceof Buffer) {
+        mutableAsset.setBuffer(output.content);
+      } else {
+        mutableAsset.setStream(output.content);
       }
-      (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
-      (0, _assert().default)(result[0] === assetCompat, '[V3] Unimplemented: New asset returned from Node transformer');
-      return {
-        asset,
-        dependencies: assetCompat._dependencies
-      };
-    } catch (e) {
-      // TODO: Improve error logging from JS plugins. Without this you currently
-      // only see the error message, no stack trace.
-      // eslint-disable-next-line no-console
-      console.error(e);
-      throw e;
     }
-  }
+    (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');
+    return {
+      asset: {
+        id: mutableAsset.id,
+        bundleBehavior: _compat.bundleBehaviorMap.intoNullable(mutableAsset.bundleBehavior),
+        filePath: mutableAsset.filePath,
+        type: mutableAsset.type,
+        code: Array.from(await mutableAsset.getBuffer()),
+        meta: mutableAsset.meta,
+        pipeline: mutableAsset.pipeline,
+        query: mutableAsset.query.toString(),
+        symbols: mutableAsset.symbols.intoNapi(),
+        uniqueKey: mutableAsset.uniqueKey,
+        sideEffects: mutableAsset.sideEffects,
+        isBundleSplittable: mutableAsset.isBundleSplittable,
+        isSource: mutableAsset.isSource
+      }
+    };
+  });
 }
 exports.AtlaspackWorker = AtlaspackWorker;
-napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorker());
-const PriorityMap = {
-  sync: 0,
-  parallel: 1,
-  lazy: 2,
-  conditional: 3
-};
+napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorker());

package/lib/projectPath.js

@@ -27,14 +27,22 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * A path that's relative to the project root.
  */
 function toProjectPath_(projectRoot, p) {
+  // If the file path is not provided, then treat it as though it is already from the project root
   if (p == null) {
     return p;
   }
 
-  // If the file is outside the project root, store an absolute path rather
-  // than a relative one. This way if the project root is moved, the file
-  // references still work. Accessing files outside the project root is not
-  // portable anyway.
+  // If the file path is already relative and it does not begin with . then treat the path as if it
+  // is already from the project root. This prevents relative paths from being processed twice,
+  // most often within `toInternalSourceLocation` when handling loc types from symbols and asset
+  // dependencies.
+  if (p[0] !== '.' && !_path().default.isAbsolute(p)) {
+    return p;
+  }
+
+  // If the file is outside the project root, store an absolute path rather than a relative one.
+  // This way if the project root is moved, the file references still work. Accessing files outside
+  // the project root is not portable anyway.
   let relative = (0, _utils().relativePath)(projectRoot, p, false);
   if (relative.startsWith('..')) {
     return process.platform === 'win32' ? (0, _utils().normalizeSeparators)(p) : p;

package/lib/requests/ConfigRequest.js

@@ -15,7 +15,7 @@ function _utils() {
   };
   return data;
 }
-var _serializer = require("../serializer.js");
+var _serializer = require("../serializer");
 function _logger() {
   const data = require("@atlaspack/logger");
   _logger = function () {

package/lib/requests/WriteBundleRequest.js

@@ -4,14 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = createWriteBundleRequest;
-exports.replaceStream = replaceStream;
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
 var _constants = require("../constants");
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
@@ -135,8 +127,16 @@ async function run({
   let writeOptions = publicBundle.env.isBrowser() || !mainEntry ? undefined : {
     mode: (await inputFS.stat(mainEntry.filePath)).mode
   };
-  const contents = await options.cache.getBlob(cacheKeys.content);
-  const size = contents.byteLength;
+  let contentStream;
+  if (info.isLargeBlob) {
+    contentStream = options.cache.getStream(cacheKeys.content);
+  } else {
+    contentStream = (0, _utils().blobToStream)(await options.cache.getBlob(cacheKeys.content));
+  }
+  let size = 0;
+  contentStream = contentStream.pipe(new (_utils().TapStream)(buf => {
+    size += buf.length;
+  }));
   let configResult = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
   let config = (0, _AtlaspackConfigRequest.getCachedAtlaspackConfig)(configResult, options);
   let {
@@ -144,9 +144,9 @@ async function run({
     invalidDevDeps
   } = await (0, _DevDepRequest.getDevDepRequests)(api);
   (0, _DevDepRequest.invalidateDevDeps)(invalidDevDeps, options, config);
-  await writeFiles(contents, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
+  await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
   if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline && (await options.cache.has(mapKey))) {
-    await writeFiles(await options.cache.getBlob(mapKey), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
+    await writeFiles((0, _utils().blobToStream)(await options.cache.getBlob(mapKey)), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
   }
   let res = {
     filePath,
@@ -159,13 +159,13 @@ async function run({
   api.storeResult(res);
   return res;
 }
-async function writeFiles(contents, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api) {
+async function writeFiles(inputStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api) {
   let compressors = await config.getCompressors((0, _projectPath.fromProjectPathRelative)(filePath));
   let fullPath = (0, _projectPath.fromProjectPath)(options.projectRoot, filePath);
-  const stream = info.hashReferences.length ? (0, _rust().replaceHashReferences)(contents, Object.fromEntries(hashRefToNameHash.entries())) : contents;
+  let stream = info.hashReferences.length ? inputStream.pipe(replaceStream(hashRefToNameHash)) : inputStream;
   let promises = [];
   for (let compressor of compressors) {
-    promises.push(runCompressor(compressor, (0, _utils().blobToStream)(stream), options, outputFS, fullPath, writeOptions, devDeps, api));
+    promises.push(runCompressor(compressor, cloneStream(stream), options, outputFS, fullPath, writeOptions, devDeps, api));
   }
   await Promise.all(promises);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-dev.3450+58845ef87",
+  "version": "2.12.1-dev.3460+340817991",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/diagnostic": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/events": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/feature-flags": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/fs": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/graph": "3.2.1-dev.3450+58845ef87",
-    "@atlaspack/logger": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/package-manager": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/plugin": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/profiler": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/rust": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/types": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/utils": "2.12.1-dev.3450+58845ef87",
-    "@atlaspack/workers": "2.12.1-dev.3450+58845ef87",
+    "@atlaspack/cache": "2.12.1-dev.3460+340817991",
+    "@atlaspack/diagnostic": "2.12.1-dev.3460+340817991",
+    "@atlaspack/events": "2.12.1-dev.3460+340817991",
+    "@atlaspack/feature-flags": "2.12.1-dev.3460+340817991",
+    "@atlaspack/fs": "2.12.1-dev.3460+340817991",
+    "@atlaspack/graph": "3.2.1-dev.3460+340817991",
+    "@atlaspack/logger": "2.12.1-dev.3460+340817991",
+    "@atlaspack/package-manager": "2.12.1-dev.3460+340817991",
+    "@atlaspack/plugin": "2.12.1-dev.3460+340817991",
+    "@atlaspack/profiler": "2.12.1-dev.3460+340817991",
+    "@atlaspack/rust": "2.12.1-dev.3460+340817991",
+    "@atlaspack/types": "2.12.1-dev.3460+340817991",
+    "@atlaspack/utils": "2.12.1-dev.3460+340817991",
+    "@atlaspack/workers": "2.12.1-dev.3460+340817991",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -54,8 +54,15 @@
     "rfdc": "1",
     "tempy": "^0.2.1"
   },
+  "exports": {
+    ".": "./lib/index.js",
+    "./worker": {
+      "development": "./src/worker.js",
+      "default": "./lib/worker.js"
+    }
+  },
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "58845ef87446fcedb7d7d8876440c64184645cbb"
+  "gitHead": "3408179911d6c67e2bdad99e545dd7a0a9a6782c"
 }

package/src/AssetGraph.js

@@ -168,13 +168,15 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         nodes.push(node);
       }
     } else if (assetGroups) {
-      nodes.push(
-        ...assetGroups.map(assetGroup => nodeFromAssetGroup(assetGroup)),
-      );
+      for (const assetGroup of assetGroups) {
+        // Adding nodes individually ensures we do not encounter a range stack size exceeded error
+        // when there are >100000 asset groups
+        nodes.push(nodeFromAssetGroup(assetGroup));
+      }
     }
     this.replaceNodeIdsConnectedTo(
       nullthrows(this.rootNodeId),
-      nodes.map(node => this.addNode(node)),
+      nodes.map((node) => this.addNode(node)),
     );
   }
 
@@ -213,7 +215,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
     this.replaceNodeIdsConnectedTo(
       entrySpecifierNodeId,
-      resolved.map(file => this.addNode(nodeFromEntryFile(file))),
+      resolved.map((file) => this.addNode(nodeFromEntryFile(file))),
     );
   }
 
@@ -222,7 +224,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
     targets: Array<Target>,
     correspondingRequest: string,
   ) {
-    let depNodes = targets.map(target => {
+    let depNodes = targets.map((target) => {
       let node = nodeFromDep(
         // The passed project path is ignored in this case, because there is no `loc`
         createDependency('', {
@@ -254,7 +256,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
     this.replaceNodeIdsConnectedTo(
       entryNodeId,
-      depNodes.map(node => this.addNode(node)),
+      depNodes.map((node) => this.addNode(node)),
     );
   }
 
@@ -340,7 +342,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
       let traversedNode = nullthrows(this.getNode(traversedNodeId));
       if (traversedNode.type === 'asset') {
         let hasDeferred = this.getNodeIdsConnectedFrom(traversedNodeId).some(
-          childNodeId => {
+          (childNodeId) => {
             let childNode = nullthrows(this.getNode(childNodeId));
             return childNode.hasDeferred == null
               ? false
@@ -417,7 +419,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
     let deps = this.getIncomingDependencies(resolvedAsset);
 
-    return deps.every(d => {
+    return deps.every((d) => {
       // If this dependency has already been through this process, and we
       // know it's not deferrable, then there's no need to re-check
       if (this.undeferredDependencies.has(d)) {
@@ -428,7 +430,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         d.symbols &&
         !(d.env.isLibrary && d.isEntry) &&
         !d.symbols.has('*') &&
-        ![...d.symbols.keys()].some(symbol => {
+        ![...d.symbols.keys()].some((symbol) => {
           let assetSymbol = resolvedAsset.symbols?.get(symbol)?.local;
           return assetSymbol != null && symbols.has(assetSymbol);
         });
@@ -532,7 +534,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         };
       }
       let dependentAsset = dependentAssets.find(
-        a => a.uniqueKey === dep.specifier,
+        (a) => a.uniqueKey === dep.specifier,
       );
       if (dependentAsset) {
         depNode.complete = true;
@@ -593,7 +595,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
     startNodeId: ?NodeId,
   ): ?TContext {
     return this.filteredTraverse(
-      nodeId => {
+      (nodeId) => {
         let node = nullthrows(this.getNode(nodeId));
         return node.type === 'asset' ? node.value : null;
       },
@@ -631,7 +633,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
 
     let hash = new Hash();
     // TODO: sort??
-    this.traverse(nodeId => {
+    this.traverse((nodeId) => {
       let node = nullthrows(this.getNode(nodeId));
       if (node.type === 'asset') {
         hash.writeString(nullthrows(node.value.outputHash));

package/src/Atlaspack.js

@@ -1,5 +1,4 @@
 // @flow strict-local
-
 import type {
   Asset,
   AsyncSubscription,
@@ -58,7 +57,7 @@ import {
 } from './projectPath';
 import {tracer} from '@atlaspack/profiler';
 import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
-import {AtlaspackV3, toFileSystemV3} from './atlaspack-v3';
+import {AtlaspackV3, FileSystemV3} from './atlaspack-v3';
 
 registerCoreWithSerializer();
 
@@ -144,7 +143,7 @@ export default class Atlaspack {
           ? undefined
           : [entries],
         env: resolvedOptions.env,
-        fs: inputFS && toFileSystemV3(inputFS),
+        fs: inputFS && new FileSystemV3(inputFS),
         defaultTargetOptions: {
           // $FlowFixMe projectPath is just a string
           distDir: resolvedOptions.defaultTargetOptions.distDir,
@@ -401,7 +400,7 @@ export default class Atlaspack {
           options,
         ),
         buildTime: Date.now() - startTime,
-        requestBundle: async bundle => {
+        requestBundle: async (bundle) => {
           let bundleNode = bundleGraph._graph.getNodeByContentKey(bundle.id);
           invariant(bundleNode?.type === 'bundle', 'Bundle does not exist');
 
@@ -580,7 +579,7 @@ export default class Atlaspack {
     let res = await this.#requestTracker.runRequest(request, {
       force: true,
     });
-    return res.map(asset =>
+    return res.map((asset) =>
       assetFromValue(asset, nullthrows(this.#resolvedOptions)),
     );
   }
@@ -648,7 +647,7 @@ export function createWorkerFarm(
     ...options,
     // $FlowFixMe
     workerPath: process.browser
-      ? '@atlaspack/core/src/worker.js'
+      ? '@atlaspack/core/worker'
       : require.resolve('./worker'),
   });
 }