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

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

@@ -18,6 +18,20 @@ function napi() {
   };
   return data;
 }
+function _fs() {
+  const data = require("@atlaspack/fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _packageManager() {
+  const data = require("@atlaspack/package-manager");
+  _packageManager = function () {
+    return data;
+  };
+  return data;
+}
 function _worker_threads() {
   const data = require("worker_threads");
   _worker_threads = function () {
@@ -40,8 +54,12 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 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 ({
     kind,
@@ -55,44 +73,70 @@ class AtlaspackWorker {
     let instance = undefined;
     if (resolvedModule.default && resolvedModule.default[CONFIG]) {
       instance = resolvedModule.default[CONFIG];
-    } else if (resolvedModule.default && resolvedModule.default.default[CONFIG]) {
+    } else if (resolvedModule.default && resolvedModule.default.default && resolvedModule.default.default[CONFIG]) {
       instance = resolvedModule.default.default[CONFIG];
     } else {
       throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
     }
     switch (kind) {
       case 'resolver':
-        this.#resolvers.set(specifier, instance);
+        this.#resolvers.set(specifier, {
+          resolver: instance
+        });
+        break;
+      case 'transformer':
+        this.#transformers.set(specifier, {
+          transformer: instance
+        });
         break;
     }
   });
   runResolverResolve = (0, _jsCallable.jsCallable)(async ({
     key,
-    dependency,
-    specifier
+    dependency: napiDependency,
+    specifier,
+    pipeline,
+    projectRoot
   }) => {
-    const resolver = this.#resolvers.get(key);
-    if (!resolver) {
+    const state = this.#resolvers.get(key);
+    if (!state) {
       throw new Error(`Resolver not found: ${key}`);
     }
-    const result = await resolver.resolve({
+    let packageManager = state.packageManager;
+    if (!packageManager) {
+      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 = {
+      logger: new _compat.PluginLogger(),
+      tracer: new _compat.PluginTracer(),
+      options: new _compat.PluginOptions({
+        packageManager,
+        shouldAutoInstall: false,
+        projectRoot,
+        inputFS: this.#fs,
+        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: new _compat.PluginConfig({
+          env,
+          isSource: true,
+          searchPath: ''
+        }),
+        ...defaultOptions
+      }));
+    }
+    const result = await state.resolver.resolve({
       specifier,
       dependency,
-      get options() {
-        throw new Error('TODO: Resolver.resolve.options');
-      },
-      get logger() {
-        throw new Error('TODO: Resolver.resolve.logger');
-      },
-      get tracer() {
-        throw new Error('TODO: Resolver.resolve.tracer');
-      },
-      get pipeline() {
-        throw new Error('TODO: Resolver.resolve.pipeline');
-      },
-      get config() {
-        throw new Error('TODO: Resolver.resolve.config');
-      }
+      pipeline,
+      config: state.config,
+      ...defaultOptions
     });
     if (!result) {
       return {
@@ -112,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.3443+d1170cfc7",
+  "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.3443+d1170cfc7",
-    "@atlaspack/diagnostic": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/events": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/feature-flags": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/fs": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/graph": "3.2.1-dev.3443+d1170cfc7",
-    "@atlaspack/logger": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/package-manager": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/plugin": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/profiler": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/rust": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/types": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/utils": "2.12.1-dev.3443+d1170cfc7",
-    "@atlaspack/workers": "2.12.1-dev.3443+d1170cfc7",
+    "@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": "d1170cfc79beb290b2a066f472f68f71f7d7cb23"
+  "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'),
   });
 }