turn things off

packages/next/src/build/webpack-build/impl.ts

@@ -104,6 +104,7 @@ export async function webpackBuildImpl(
       })
     )
 
+  console.log(entrypoints);
   const commonWebpackOptions = {
     isServer: false,
     buildId: NextBuildContext.buildId!,

packages/next/src/build/webpack-config.ts

@@ -363,6 +363,7 @@ export default async function getBaseWebpackConfig(
     ? '-experimental'
     : ''
 
+
   const babelConfigFile = getBabelConfigFile(dir)
 
   if (!dev && hasCustomExportOutput(config)) {
@@ -1229,12 +1230,12 @@ export default async function getBaseWebpackConfig(
       rules: [
         // Alias server-only and client-only to proper exports based on bundling layers
         {
-          issuerLayer: {
+          // issuerLayer: {
-            or: [
+          //   or: [
-              ...WEBPACK_LAYERS.GROUP.serverOnly,
+          //     ...WEBPACK_LAYERS.GROUP.serverOnly,
-              ...WEBPACK_LAYERS.GROUP.neutralTarget,
+          //     ...WEBPACK_LAYERS.GROUP.neutralTarget,
-            ],
+          //   ],
-          },
+          // },
           resolve: {
             // Error on client-only but allow server-only
             alias: createServerOnlyClientOnlyAliases(true),

packages/next/src/build/webpack/loaders/next-client-pages-loader.ts

@@ -7,16 +7,9 @@ export type ClientPagesLoaderOptions = {
 
 // this parameter: https://www.typescriptlang.org/docs/handbook/functions.html#this-parameters
 function nextClientPagesLoader(this: any) {
-  const pagesLoaderSpan = this.currentTraceSpan.traceChild(
-    'next-client-pages-loader'
-  )
-
-  return pagesLoaderSpan.traceFn(() => {
     const { absolutePagePath, page } =
       this.getOptions() as ClientPagesLoaderOptions
 
-    pagesLoaderSpan.setAttribute('absolutePagePath', absolutePagePath)
-
     const stringifiedPageRequest = stringifyRequest(this, absolutePagePath)
     const stringifiedPage = JSON.stringify(page)
 
@@ -33,7 +26,6 @@ function nextClientPagesLoader(this: any) {
       });
     }
   `
-  })
 }
 
 export default nextClientPagesLoader

packages/next/src/build/webpack/plugins/react-loadable-plugin.ts

@@ -169,20 +169,21 @@ export class ReactLoadablePlugin {
     const projectSrcDir = this.pagesOrAppDir
       ? path.dirname(this.pagesOrAppDir)
       : undefined
-    const manifest = buildManifest(
-      compiler,
-      compilation,
-      projectSrcDir,
-      this.dev
-    )
 
-    assets[this.filename] = new sources.RawSource(
+    // const manifest = buildManifest(
-      JSON.stringify(manifest, null, 2)
+    //   compiler,
-    )
+    //   compilation,
+    //   projectSrcDir,
+    //   this.dev
+    // )
+    //
+    // assets[this.filename] = new sources.RawSource(
+    //   JSON.stringify(manifest, null, 2)
+    // )
     if (this.runtimeAsset) {
       assets[this.runtimeAsset] = new sources.RawSource(
         `self.__REACT_LOADABLE_MANIFEST=${JSON.stringify(
-          JSON.stringify(manifest)
+          JSON.stringify({  })
         )}`
       )
     }

packages/next/src/bundles/webpack/packages/webpack.js

@@ -1,6 +1,113 @@
 exports.__esModule = true
 
 exports.default = undefined
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("../util/Hash")} Hash */
+
+/**
+ * StringXor class provides methods for performing
+ * [XOR operations](https://en.wikipedia.org/wiki/Exclusive_or) on strings. In this context
+ * we operating on the character codes of two strings, which are represented as
+ * [Buffer](https://nodejs.org/api/buffer.html) objects.
+ *
+ * We use [StringXor in webpack](https://github.com/webpack/webpack/commit/41a8e2ea483a544c4ccd3e6217bdfb80daffca39)
+ * to create a hash of the current state of the compilation. By XOR'ing the Module hashes, it
+ * doesn't matter if the Module hashes are sorted or not. This is useful because it allows us to avoid sorting the
+ * Module hashes.
+ *
+ * @example
+ * ```js
+ * const xor = new StringXor();
+ * xor.add('hello');
+ * xor.add('world');
+ * console.log(xor.toString());
+ * ```
+ *
+ * @example
+ * ```js
+ * const xor = new StringXor();
+ * xor.add('foo');
+ * xor.add('bar');
+ * const hash = createHash('sha256');
+ * hash.update(xor.toString());
+ * console.log(hash.digest('hex'));
+ * ```
+ */
+class StringXor {
+  constructor() {
+    /** @type {Buffer|undefined} */
+    this._value = undefined;
+  }
+
+  /**
+   * Adds a string to the current StringXor object.
+   *
+   * @param {string} str string
+   * @returns {void}
+   */
+  add(str) {
+    const len = str.length;
+    const value = this._value;
+    if (value === undefined) {
+      /**
+       * We are choosing to use Buffer.allocUnsafe() because it is often faster than Buffer.alloc() because
+       * it allocates a new buffer of the specified size without initializing the memory.
+       */
+      const newValue = (this._value = Buffer.allocUnsafe(len));
+      for (let i = 0; i < len; i++) {
+        newValue[i] = str.charCodeAt(i);
+      }
+      return;
+    }
+    const valueLen = value.length;
+    if (valueLen < len) {
+      const newValue = (this._value = Buffer.allocUnsafe(len));
+      let i;
+      for (i = 0; i < valueLen; i++) {
+        newValue[i] = value[i] ^ str.charCodeAt(i);
+      }
+      for (; i < len; i++) {
+        newValue[i] = str.charCodeAt(i);
+      }
+    } else {
+      for (let i = 0; i < len; i++) {
+        value[i] = value[i] ^ str.charCodeAt(i);
+      }
+    }
+  }
+
+  /**
+   * Returns a string that represents the current state of the StringXor object. We chose to use "latin1" encoding
+   * here because "latin1" encoding is a single-byte encoding that can represent all characters in the
+   * [ISO-8859-1 character set](https://en.wikipedia.org/wiki/ISO/IEC_8859-1). This is useful when working
+   * with binary data that needs to be represented as a string.
+   *
+   * @returns {string} Returns a string that represents the current state of the StringXor object.
+   */
+  toString() {
+    const value = this._value;
+    return value === undefined ? "" : value.toString("latin1");
+  }
+
+  /**
+   * Updates the hash with the current state of the StringXor object.
+   *
+   * @param {Hash} hash Hash instance
+   */
+  updateHash(hash) {
+    const value = this._value;
+    if (value !== undefined) hash.update(value);
+  }
+}
+
+module.exports = StringXor;
+
 
 exports.init = function () {
   if (process.env.NEXT_PRIVATE_LOCAL_WEBPACK) {
@@ -12,7 +119,7 @@ exports.init = function () {
       // eslint-disable-next-line import/no-extraneous-dependencies
       NodeTargetPlugin: require('webpack/lib/node/NodeTargetPlugin'),
       // eslint-disable-next-line import/no-extraneous-dependencies
-      StringXor: require('webpack/lib/util/StringXor'),
+      StringXor,
       // eslint-disable-next-line import/no-extraneous-dependencies
       NormalModule: require('webpack/lib/NormalModule'),
       // eslint-disable-next-line import/no-extraneous-dependencies

packages/next/src/server/dev/hot-reloader-webpack.ts

@@ -7,6 +7,7 @@ import type { UrlObject } from 'url'
 import type { RouteDefinition } from '../route-definitions/route-definition'
 
 import { webpack, StringXor } from 'next/dist/compiled/webpack/webpack'
+import {util} from "@rspack/core"
 import { getOverlayMiddleware } from '../../client/components/react-dev-overlay/server/middleware'
 import { WebpackHotMiddleware } from './hot-middleware'
 import { join, relative, isAbsolute, posix } from 'path'
@@ -768,7 +769,6 @@ export default class HotReloaderWebpack implements NextJsHotReloaderInterface {
           Object.keys(entries).map(async (entryKey) => {
             const entryData = entries[entryKey]
             const { bundlePath, dispose } = entryData
-
             const result =
               /^(client|server|edge-server)@(app|pages|root)@(.*)/g.exec(
                 entryKey
@@ -1130,8 +1130,8 @@ export default class HotReloaderWebpack implements NextJsHotReloaderInterface {
                     stats.chunkGraph.getChunkModulesIterable(chunk)
 
                   let hasCSSModuleChanges = false
-                  let chunksHash = new StringXor()
+                  let chunksHash =  util.createHash('md4')
-                  let chunksHashServerLayer = new StringXor()
+                  let chunksHashServerLayer =  util.createHash('md4');
 
                   modsIterable.forEach((mod: any) => {
                     if (