@parcel/workers 2.10.2 → 2.11.0

package/lib/Worker.js

@@ -42,13 +42,16 @@ class Worker extends _events().default {
     this.options = options;
   }
   async fork(forkModule) {
-    let filteredArgs = process.execArgv.filter(v => !/^--(debug|inspect|no-opt|max-old-space-size=)/.test(v));
-    for (let i = 0; i < filteredArgs.length; i++) {
-      let arg = filteredArgs[i];
-      let isArgWithParam = (arg === '-r' || arg === '--require') && filteredArgs[i + 1] === '@parcel/register' || arg === '--title';
-      if (isArgWithParam) {
-        filteredArgs.splice(i, 2);
-        i--;
+    let filteredArgs = [];
+    if (process.execArgv) {
+      filteredArgs = process.execArgv.filter(v => !/^--(debug|inspect|no-opt|max-old-space-size=|max-semi-space-size=|expose-gc)/.test(v));
+      for (let i = 0; i < filteredArgs.length; i++) {
+        let arg = filteredArgs[i];
+        let isArgWithParam = (arg === '-r' || arg === '--require') && filteredArgs[i + 1] === '@parcel/register' || arg === '--title';
+        if (isArgWithParam) {
+          filteredArgs.splice(i, 2);
+          i--;
+        }
       }
     }
 
@@ -74,13 +77,16 @@ class Worker extends _events().default {
         }
       }
     }
-    let WorkerBackend = (0, _backend.getWorkerBackend)(this.options.backend);
-    this.worker = new WorkerBackend(filteredArgs, data => this.receive(data), err => {
-      this.emit('error', err);
-    }, code => {
+    let onMessage = data => this.receive(data);
+    let onExit = code => {
       this.exitCode = code;
       this.emit('exit', code);
-    });
+    };
+    let onError = err => {
+      this.emit('error', err);
+    };
+    let WorkerBackend = (0, _backend.getWorkerBackend)(this.options.backend);
+    this.worker = new WorkerBackend(filteredArgs, onMessage, onError, onExit);
     await this.worker.start();
     await new Promise((resolve, reject) => {
       this.call({

package/lib/WorkerFarm.js

@@ -10,6 +10,8 @@ Object.defineProperty(exports, "Handle", {
   }
 });
 exports.default = void 0;
+var coreWorker = _interopRequireWildcard(require("./core-worker"));
+var bus = _interopRequireWildcard(require("./bus"));
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
   _assert = function () {
@@ -71,9 +73,9 @@ function _logger() {
   };
   return data;
 }
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 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; }
 let referenceId = 1;
 const DEFAULT_MAX_CONCURRENT_CALLS = 30;
 
@@ -85,12 +87,14 @@ class WorkerFarm extends _events().default {
   callQueue = [];
   ending = false;
   warmWorkers = 0;
+  readyWorkers = 0;
   workers = new Map();
   handles = new Map();
   sharedReferences = new Map();
   sharedReferencesByValue = new Map();
   serializedSharedReferences = new Map();
   constructor(farmOptions = {}) {
+    var _process$stdout;
     super();
     this.options = {
       maxConcurrentWorkers: WorkerFarm.getNumWorkers(),
@@ -106,8 +110,17 @@ class WorkerFarm extends _events().default {
       throw new Error('Please provide a worker path!');
     }
 
-    // $FlowFixMe this must be dynamic
-    this.localWorker = require(this.options.workerPath);
+    // $FlowFixMe
+    if (process.browser) {
+      if (this.options.workerPath === '@parcel/core/src/worker.js') {
+        this.localWorker = coreWorker;
+      } else {
+        throw new Error('No dynamic require possible: ' + this.options.workerPath);
+      }
+    } else {
+      // $FlowFixMe this must be dynamic
+      this.localWorker = require(this.options.workerPath);
+    }
     this.localWorkerInit = this.localWorker.childInit != null ? this.localWorker.childInit() : null;
     this.run = this.createHandle('run');
 
@@ -119,7 +132,7 @@ class WorkerFarm extends _events().default {
     // Note this can't be fixed easily where other things pipe into stdout -  even after starting > 10 worker
     // threads `process.stdout.getMaxListeners()` will still return 10, however adding another pipe into `stdout`
     // will give the warning with `<worker count + 1>` as the number of listeners.
-    process.stdout.setMaxListeners(Math.max(process.stdout.getMaxListeners(), WorkerFarm.getNumWorkers() + 1));
+    (_process$stdout = process.stdout) === null || _process$stdout === void 0 || _process$stdout.setMaxListeners(Math.max(process.stdout.getMaxListeners(), WorkerFarm.getNumWorkers() + 1));
     this.startMaxWorkers();
   }
   workerApi = {
@@ -215,7 +228,13 @@ class WorkerFarm extends _events().default {
     });
     worker.fork((0, _nullthrows().default)(this.options.workerPath));
     worker.on('request', data => this.processRequest(data, worker));
-    worker.on('ready', () => this.processQueue());
+    worker.on('ready', () => {
+      this.readyWorkers++;
+      if (this.readyWorkers === this.options.maxConcurrentWorkers) {
+        this.emit('ready');
+      }
+      this.processQueue();
+    });
     worker.on('response', () => this.processQueue());
     worker.on('error', err => this.onError(err, worker));
     worker.once('exit', () => this.stopWorker(worker));
@@ -278,8 +297,17 @@ class WorkerFarm extends _events().default {
       var _this$handles$get;
       mod = (0, _nullthrows().default)((_this$handles$get = this.handles.get(handleId)) === null || _this$handles$get === void 0 ? void 0 : _this$handles$get.fn);
     } else if (location) {
-      // $FlowFixMe this must be dynamic
-      mod = require(location);
+      // $FlowFixMe
+      if (process.browser) {
+        if (location === '@parcel/workers/src/bus.js') {
+          mod = bus;
+        } else {
+          throw new Error('No dynamic require possible: ' + location);
+        }
+      } else {
+        // $FlowFixMe this must be dynamic
+        mod = require(location);
+      }
     } else {
       throw new Error('Unknown request');
     }

package/lib/backend.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.detectBackend = detectBackend;
 exports.getWorkerBackend = getWorkerBackend;
 function detectBackend() {
+  // $FlowFixMe
+  if (process.browser) return 'web';
   switch (process.env.PARCEL_WORKER_BACKEND) {
     case 'threads':
     case 'process':
@@ -24,6 +26,8 @@ function getWorkerBackend(backend) {
       return require('./threads/ThreadsWorker').default;
     case 'process':
       return require('./process/ProcessWorker').default;
+    case 'web':
+      return require('./web/WebWorker').default;
     default:
       throw new Error(`Invalid backend: ${backend}`);
   }

package/lib/bus.js

@@ -17,7 +17,8 @@ class Bus extends _events().default {
   emit(event, ...args) {
     if (_childState.child) {
       _childState.child.workerApi.callMaster({
-        location: __filename,
+        // $FlowFixMe
+        location: process.browser ? '@parcel/workers/src/bus.js' : __filename,
         method: 'emit',
         args: [event, ...args]
       }, false);
@@ -27,5 +28,4 @@ class Bus extends _events().default {
     }
   }
 }
-var _default = new Bus();
-exports.default = _default;
+var _default = exports.default = new Bus();

package/lib/child.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Child = void 0;
+var coreWorker = _interopRequireWildcard(require("./core-worker"));
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
   _assert = function () {
@@ -48,9 +49,9 @@ function _profiler() {
   return data;
 }
 var _Handle2 = _interopRequireDefault(require("./Handle"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 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; }
 // The import of './Handle' should really be imported eagerly (with @babel/plugin-transform-modules-commonjs's lazy mode).
 const Handle = _Handle2.default;
 class Child {
@@ -97,8 +98,17 @@ class Child {
     this.child.send(data);
   }
   async childInit(module, childId) {
-    // $FlowFixMe this must be dynamic
-    this.module = require(module);
+    // $FlowFixMe
+    if (process.browser) {
+      if (module === '@parcel/core/src/worker.js') {
+        this.module = coreWorker;
+      } else {
+        throw new Error('No dynamic require possible: ' + module);
+      }
+    } else {
+      // $FlowFixMe this must be dynamic
+      this.module = require(module);
+    }
     this.childId = childId;
     if (this.module.childInit != null) {
       await this.module.childInit();

package/lib/childState.js

@@ -8,8 +8,7 @@ exports.setChild = setChild;
 // This file is imported by both the WorkerFarm and child implementation.
 // When a worker is inited, it sets the state in this file.
 // This way, WorkerFarm can access the state without directly importing the child code.
-let child = null;
-exports.child = child;
+let child = exports.child = null;
 function setChild(c) {
   exports.child = child = c;
 }

package/lib/core-worker.browser.js

@@ -0,0 +1,4 @@
+"use strict";
+
+// eslint-disable-next-line monorepo/no-internal-import
+module.exports = require('@parcel/core/src/worker.js');

package/lib/core-worker.js

@@ -0,0 +1,4 @@
+"use strict";
+
+// This is used only in browser builds
+module.exports = {};

package/lib/cpuCount.js

@@ -56,11 +56,19 @@ function getCores(bypassCache = false) {
   if (cores && !bypassCache) {
     return cores;
   }
-  try {
-    cores = detectRealCores();
-  } catch (e) {
-    // Guess the amount of real cores
-    cores = _os().default.cpus().filter((cpu, index) => !cpu.model.includes('Intel') || index % 2 === 1).length;
+
+  // $FlowFixMe
+  if (process.browser) {
+    // eslint-disable-next-line no-undef
+    cores = navigator.hardwareConcurrency / 2;
+  }
+  if (!cores) {
+    try {
+      cores = detectRealCores();
+    } catch (e) {
+      // Guess the amount of real cores
+      cores = _os().default.cpus().filter((cpu, index) => !cpu.model.includes('Intel') || index % 2 === 1).length;
+    }
   }
 
   // Another fallback

package/lib/index.js

@@ -39,8 +39,8 @@ function _profiler() {
   };
   return data;
 }
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+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 }; }
 if (!_WorkerFarm.default.isWorker()) {
   // Forward all logger events originating from workers into the main process
@@ -72,5 +72,4 @@ if (!_WorkerFarm.default.isWorker()) {
     _profiler().tracer.trace(e);
   });
 }
-var _default = _WorkerFarm.default;
-exports.default = _default;
+var _default = exports.default = _WorkerFarm.default;

package/lib/web/WebChild.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _childState = require("../childState");
+var _child = require("../child");
+function _core() {
+  const data = require("@parcel/core");
+  _core = function () {
+    return data;
+  };
+  return data;
+}
+/* eslint-env worker*/
+class WebChild {
+  constructor(onMessage, onExit) {
+    if (!(typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)) {
+      throw new Error('Only create WebChild instances in a worker!');
+    }
+    this.onMessage = onMessage;
+    this.onExit = onExit;
+    self.addEventListener('message', ({
+      data
+    }) => {
+      if (data === 'stop') {
+        this.onExit(0);
+        self.postMessage('stopped');
+      }
+      // $FlowFixMe assume WorkerMessage as data
+      this.handleMessage(data);
+    });
+    self.postMessage('online');
+  }
+  handleMessage(data) {
+    this.onMessage((0, _core().restoreDeserializedObject)(data));
+  }
+  send(data) {
+    self.postMessage((0, _core().prepareForSerialization)(data));
+  }
+}
+exports.default = WebChild;
+(0, _childState.setChild)(new _child.Child(WebChild));

package/lib/web/WebWorker.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _core() {
+  const data = require("@parcel/core");
+  _core = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@parcel/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+let id = 0;
+class WebWorker {
+  constructor(execArgv, onMessage, onError, onExit) {
+    this.execArgv = execArgv;
+    this.onMessage = onMessage;
+    this.onError = onError;
+    this.onExit = onExit;
+  }
+  start() {
+    // $FlowFixMe[incompatible-call]
+    this.worker = new Worker(new URL('./WebChild.js', import.meta.url), {
+      name: `Parcel Worker ${id++}`,
+      type: 'module'
+    });
+    let {
+      deferred,
+      promise
+    } = (0, _utils().makeDeferredWithPromise)();
+    this.worker.onmessage = ({
+      data
+    }) => {
+      if (data === 'online') {
+        deferred.resolve();
+        return;
+      }
+
+      // $FlowFixMe assume WorkerMessage as data
+      this.handleMessage(data);
+    };
+    this.worker.onerror = this.onError;
+    // Web workers can't crash or intentionally stop on their own, apart from stop() below
+    // this.worker.on('exit', this.onExit);
+
+    return promise;
+  }
+  stop() {
+    if (!this.stopping) {
+      this.stopping = (async () => {
+        this.worker.postMessage('stop');
+        let {
+          deferred,
+          promise
+        } = (0, _utils().makeDeferredWithPromise)();
+        this.worker.addEventListener('message', ({
+          data
+        }) => {
+          if (data === 'stopped') {
+            deferred.resolve();
+          }
+        });
+        await promise;
+        this.worker.terminate();
+        this.onExit(0);
+      })();
+    }
+    return this.stopping;
+  }
+  handleMessage(data) {
+    this.onMessage((0, _core().restoreDeserializedObject)(data));
+  }
+  send(data) {
+    this.worker.postMessage((0, _core().prepareForSerialization)(data));
+  }
+}
+exports.default = WebWorker;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/workers",
-  "version": "2.10.2",
+  "version": "2.11.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
@@ -21,20 +21,20 @@
     "node": ">= 12.0.0"
   },
   "dependencies": {
-    "@parcel/diagnostic": "2.10.2",
-    "@parcel/logger": "2.10.2",
-    "@parcel/profiler": "2.10.2",
-    "@parcel/types": "2.10.2",
-    "@parcel/utils": "2.10.2",
+    "@parcel/diagnostic": "2.11.0",
+    "@parcel/logger": "2.11.0",
+    "@parcel/profiler": "2.11.0",
+    "@parcel/types": "2.11.0",
+    "@parcel/utils": "2.11.0",
     "nullthrows": "^1.1.1"
   },
   "peerDependencies": {
-    "@parcel/core": "^2.10.2"
+    "@parcel/core": "^2.11.0"
   },
   "browser": {
-    "./src/cpuCount.js": false,
     "./src/process/ProcessWorker.js": false,
-    "./src/threads/ThreadsWorker.js": false
+    "./src/threads/ThreadsWorker.js": false,
+    "./src/core-worker.js": "./src/core-worker.browser.js"
   },
-  "gitHead": "a1391ed8a719fc2f976dbadb528ca2dcffa7da12"
+  "gitHead": "f8076f1644cabc944695b5ec82602c8ae32bcf21"
 }

package/src/Worker.js

@@ -48,19 +48,25 @@ export default class Worker extends EventEmitter {
   }
 
   async fork(forkModule: FilePath) {
-    let filteredArgs = process.execArgv.filter(
-      v => !/^--(debug|inspect|no-opt|max-old-space-size=)/.test(v),
-    );
-
-    for (let i = 0; i < filteredArgs.length; i++) {
-      let arg = filteredArgs[i];
-      let isArgWithParam =
-        ((arg === '-r' || arg === '--require') &&
-          filteredArgs[i + 1] === '@parcel/register') ||
-        arg === '--title';
-      if (isArgWithParam) {
-        filteredArgs.splice(i, 2);
-        i--;
+    let filteredArgs = [];
+    if (process.execArgv) {
+      filteredArgs = process.execArgv.filter(
+        v =>
+          !/^--(debug|inspect|no-opt|max-old-space-size=|max-semi-space-size=|expose-gc)/.test(
+            v,
+          ),
+      );
+
+      for (let i = 0; i < filteredArgs.length; i++) {
+        let arg = filteredArgs[i];
+        let isArgWithParam =
+          ((arg === '-r' || arg === '--require') &&
+            filteredArgs[i + 1] === '@parcel/register') ||
+          arg === '--title';
+        if (isArgWithParam) {
+          filteredArgs.splice(i, 2);
+          i--;
+        }
       }
     }
 

package/src/WorkerFarm.js

@@ -11,6 +11,8 @@ import type {
 } from './types';
 import type {HandleFunction} from './Handle';
 
+import * as coreWorker from './core-worker';
+import * as bus from './bus';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
 import EventEmitter from 'events';
@@ -46,9 +48,10 @@ export type FarmOptions = {|
   shouldTrace?: boolean,
 |};
 
-type WorkerModule = {|
+type WorkerModule = {
   +[string]: (...args: Array<mixed>) => Promise<mixed>,
-|};
+  ...
+};
 
 export type WorkerApi = {|
   callMaster(CallRequest, ?boolean): Promise<mixed>,
@@ -74,6 +77,7 @@ export default class WorkerFarm extends EventEmitter {
   options: FarmOptions;
   run: HandleFunction;
   warmWorkers: number = 0;
+  readyWorkers: number = 0;
   workers: Map<number, Worker> = new Map();
   handles: Map<number, Handle> = new Map();
   sharedReferences: Map<SharedReference, mixed> = new Map();
@@ -99,10 +103,23 @@ export default class WorkerFarm extends EventEmitter {
       throw new Error('Please provide a worker path!');
     }
 
-    // $FlowFixMe this must be dynamic
-    this.localWorker = require(this.options.workerPath);
+    // $FlowFixMe
+    if (process.browser) {
+      if (this.options.workerPath === '@parcel/core/src/worker.js') {
+        this.localWorker = coreWorker;
+      } else {
+        throw new Error(
+          'No dynamic require possible: ' + this.options.workerPath,
+        );
+      }
+    } else {
+      // $FlowFixMe this must be dynamic
+      this.localWorker = require(this.options.workerPath);
+    }
+
     this.localWorkerInit =
       this.localWorker.childInit != null ? this.localWorker.childInit() : null;
+
     this.run = this.createHandle('run');
 
     // Worker thread stdout is by default piped into the process stdout, if there are enough worker
@@ -113,7 +130,7 @@ export default class WorkerFarm extends EventEmitter {
     // Note this can't be fixed easily where other things pipe into stdout -  even after starting > 10 worker
     // threads `process.stdout.getMaxListeners()` will still return 10, however adding another pipe into `stdout`
     // will give the warning with `<worker count + 1>` as the number of listeners.
-    process.stdout.setMaxListeners(
+    process.stdout?.setMaxListeners(
       Math.max(
         process.stdout.getMaxListeners(),
         WorkerFarm.getNumWorkers() + 1,
@@ -251,7 +268,13 @@ export default class WorkerFarm extends EventEmitter {
 
     worker.on('request', data => this.processRequest(data, worker));
 
-    worker.on('ready', () => this.processQueue());
+    worker.on('ready', () => {
+      this.readyWorkers++;
+      if (this.readyWorkers === this.options.maxConcurrentWorkers) {
+        this.emit('ready');
+      }
+      this.processQueue();
+    });
     worker.on('response', () => this.processQueue());
 
     worker.on('error', err => this.onError(err, worker));
@@ -332,8 +355,17 @@ export default class WorkerFarm extends EventEmitter {
     if (handleId != null) {
       mod = nullthrows(this.handles.get(handleId)?.fn);
     } else if (location) {
-      // $FlowFixMe this must be dynamic
-      mod = require(location);
+      // $FlowFixMe
+      if (process.browser) {
+        if (location === '@parcel/workers/src/bus.js') {
+          mod = (bus: any);
+        } else {
+          throw new Error('No dynamic require possible: ' + location);
+        }
+      } else {
+        // $FlowFixMe this must be dynamic
+        mod = require(location);
+      }
     } else {
       throw new Error('Unknown request');
     }

package/src/backend.js

@@ -2,6 +2,9 @@
 import type {BackendType, WorkerImpl} from './types';
 
 export function detectBackend(): BackendType {
+  // $FlowFixMe
+  if (process.browser) return 'web';
+
   switch (process.env.PARCEL_WORKER_BACKEND) {
     case 'threads':
     case 'process':
@@ -22,6 +25,8 @@ export function getWorkerBackend(backend: BackendType): Class<WorkerImpl> {
       return require('./threads/ThreadsWorker').default;
     case 'process':
       return require('./process/ProcessWorker').default;
+    case 'web':
+      return require('./web/WebWorker').default;
     default:
       throw new Error(`Invalid backend: ${backend}`);
   }

package/src/bus.js

@@ -7,7 +7,8 @@ class Bus extends EventEmitter {
     if (child) {
       child.workerApi.callMaster(
         {
-          location: __filename,
+          // $FlowFixMe
+          location: process.browser ? '@parcel/workers/src/bus.js' : __filename,
           method: 'emit',
           args: [event, ...args],
         },

package/src/child.js

@@ -12,6 +12,7 @@ import type {
 import type {Async, IDisposable} from '@parcel/types';
 import type {SharedReference} from './WorkerFarm';
 
+import * as coreWorker from './core-worker';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
 import Logger, {patchConsole, unpatchConsole} from '@parcel/logger';
@@ -100,8 +101,17 @@ export class Child {
   }
 
   async childInit(module: string, childId: number): Promise<void> {
-    // $FlowFixMe this must be dynamic
-    this.module = require(module);
+    // $FlowFixMe
+    if (process.browser) {
+      if (module === '@parcel/core/src/worker.js') {
+        this.module = coreWorker;
+      } else {
+        throw new Error('No dynamic require possible: ' + module);
+      }
+    } else {
+      // $FlowFixMe this must be dynamic
+      this.module = require(module);
+    }
     this.childId = childId;
 
     if (this.module.childInit != null) {

package/src/core-worker.browser.js

@@ -0,0 +1,3 @@
+// @flow
+// eslint-disable-next-line monorepo/no-internal-import
+module.exports = require('@parcel/core/src/worker.js');

package/src/core-worker.js

@@ -0,0 +1,2 @@
+// This is used only in browser builds
+module.exports = {};

package/src/cpuCount.js

@@ -47,15 +47,23 @@ export default function getCores(bypassCache?: boolean = false): number {
     return cores;
   }
 
-  try {
-    cores = detectRealCores();
-  } catch (e) {
-    // Guess the amount of real cores
-    cores = os
-      .cpus()
-      .filter(
-        (cpu, index) => !cpu.model.includes('Intel') || index % 2 === 1,
-      ).length;
+  // $FlowFixMe
+  if (process.browser) {
+    // eslint-disable-next-line no-undef
+    cores = navigator.hardwareConcurrency / 2;
+  }
+
+  if (!cores) {
+    try {
+      cores = detectRealCores();
+    } catch (e) {
+      // Guess the amount of real cores
+      cores = os
+        .cpus()
+        .filter(
+          (cpu, index) => !cpu.model.includes('Intel') || index % 2 === 1,
+        ).length;
+    }
   }
 
   // Another fallback

package/src/types.js

@@ -65,4 +65,4 @@ export interface ChildImpl {
   send(data: WorkerMessage): void;
 }
 
-export type BackendType = 'threads' | 'process';
+export type BackendType = 'threads' | 'process' | 'web';

package/src/web/WebChild.js

@@ -0,0 +1,50 @@
+// @flow
+/* eslint-env worker*/
+
+import type {
+  ChildImpl,
+  MessageHandler,
+  ExitHandler,
+  WorkerMessage,
+} from '../types';
+import {setChild} from '../childState';
+import {Child} from '../child';
+import {prepareForSerialization, restoreDeserializedObject} from '@parcel/core';
+
+export default class WebChild implements ChildImpl {
+  onMessage: MessageHandler;
+  onExit: ExitHandler;
+
+  constructor(onMessage: MessageHandler, onExit: ExitHandler) {
+    if (
+      !(
+        typeof WorkerGlobalScope !== 'undefined' &&
+        self instanceof WorkerGlobalScope
+      )
+    ) {
+      throw new Error('Only create WebChild instances in a worker!');
+    }
+
+    this.onMessage = onMessage;
+    this.onExit = onExit;
+    self.addEventListener('message', ({data}: MessageEvent) => {
+      if (data === 'stop') {
+        this.onExit(0);
+        self.postMessage('stopped');
+      }
+      // $FlowFixMe assume WorkerMessage as data
+      this.handleMessage(data);
+    });
+    self.postMessage('online');
+  }
+
+  handleMessage(data: WorkerMessage) {
+    this.onMessage(restoreDeserializedObject(data));
+  }
+
+  send(data: WorkerMessage) {
+    self.postMessage(prepareForSerialization(data));
+  }
+}
+
+setChild(new Child(WebChild));

package/src/web/WebWorker.js

@@ -0,0 +1,85 @@
+// @flow
+
+import type {
+  WorkerImpl,
+  MessageHandler,
+  ErrorHandler,
+  ExitHandler,
+  WorkerMessage,
+} from '../types';
+import {prepareForSerialization, restoreDeserializedObject} from '@parcel/core';
+import {makeDeferredWithPromise} from '@parcel/utils';
+
+let id = 0;
+
+export default class WebWorker implements WorkerImpl {
+  execArgv: Object;
+  onMessage: MessageHandler;
+  onError: ErrorHandler;
+  onExit: ExitHandler;
+  worker: Worker;
+  stopping: ?Promise<void>;
+
+  constructor(
+    execArgv: Object,
+    onMessage: MessageHandler,
+    onError: ErrorHandler,
+    onExit: ExitHandler,
+  ) {
+    this.execArgv = execArgv;
+    this.onMessage = onMessage;
+    this.onError = onError;
+    this.onExit = onExit;
+  }
+
+  start(): Promise<void> {
+    // $FlowFixMe[incompatible-call]
+    this.worker = new Worker(new URL('./WebChild.js', import.meta.url), {
+      name: `Parcel Worker ${id++}`,
+      type: 'module',
+    });
+
+    let {deferred, promise} = makeDeferredWithPromise();
+
+    this.worker.onmessage = ({data}) => {
+      if (data === 'online') {
+        deferred.resolve();
+        return;
+      }
+
+      // $FlowFixMe assume WorkerMessage as data
+      this.handleMessage(data);
+    };
+    this.worker.onerror = this.onError;
+    // Web workers can't crash or intentionally stop on their own, apart from stop() below
+    // this.worker.on('exit', this.onExit);
+
+    return promise;
+  }
+
+  stop(): Promise<void> {
+    if (!this.stopping) {
+      this.stopping = (async () => {
+        this.worker.postMessage('stop');
+        let {deferred, promise} = makeDeferredWithPromise();
+        this.worker.addEventListener('message', ({data}: MessageEvent) => {
+          if (data === 'stopped') {
+            deferred.resolve();
+          }
+        });
+        await promise;
+        this.worker.terminate();
+        this.onExit(0);
+      })();
+    }
+    return this.stopping;
+  }
+
+  handleMessage(data: WorkerMessage) {
+    this.onMessage(restoreDeserializedObject(data));
+  }
+
+  send(data: WorkerMessage) {
+    this.worker.postMessage(prepareForSerialization(data));
+  }
+}