@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/client/dev/debug-channel.js

@@ -35,216 +35,6 @@ const pairs = new Map();
  * together), so a few dozen leaves ample headroom even for the segment-heavy
  * bursts the Instant Navs DevTools capture can produce.
  */ const MAX_DEBUG_CHANNEL_PAIRS = 64;
-const DB_NAME = '__next_debug_channel';
-const STORE_NAME = 'channels';
-const CREATED_AT_INDEX = 'createdAt';
-/**
- * Upper bound on persisted document debug channels in IndexedDB (one per
- * document, kept for HTTP-cache restore), evicted oldest-first.
- */ const MAX_PERSISTED_DOCUMENT_CHANNELS = 10;
-function openDebugChannelDB() {
-    return new Promise((resolve, reject)=>{
-        const openRequest = indexedDB.open(DB_NAME, 1);
-        openRequest.onupgradeneeded = ()=>{
-            const store = openRequest.result.createObjectStore(STORE_NAME, {
-                keyPath: 'requestId'
-            });
-            store.createIndex(CREATED_AT_INDEX, 'createdAt');
-        };
-        openRequest.onsuccess = ()=>resolve(openRequest.result);
-        openRequest.onerror = ()=>reject(openRequest.error);
-        openRequest.onblocked = ()=>reject(openRequest.error);
-    });
-}
-/**
- * Resolves on the next idle period via `requestIdleCallback`, falling back to a
- * `setTimeout` where `requestIdleCallback` is unavailable.
- */ function whenIdle() {
-    return new Promise((resolve)=>{
-        if (typeof requestIdleCallback === 'function') {
-            requestIdleCallback(()=>resolve());
-        } else {
-            setTimeout(resolve, 0);
-        }
-    });
-}
-async function persistDebugChannelToIndexedDB(requestId, chunks) {
-    let db;
-    try {
-        db = await openDebugChannelDB();
-    } catch (error) {
-        console.debug('Failed to open debug channel IndexedDB for write', error);
-        return;
-    }
-    try {
-        await new Promise((resolve, reject)=>{
-            const transaction = db.transaction(STORE_NAME, 'readwrite');
-            const store = transaction.objectStore(STORE_NAME);
-            store.put({
-                requestId,
-                createdAt: Date.now(),
-                chunks
-            });
-            // Prune oldest entries beyond the cap to bound storage growth across tabs
-            // and/or page loads. The createdAt index gives ordered traversal without
-            // scanning, and the cursor deletes commit atomically with the put above.
-            const countReq = store.count();
-            countReq.onsuccess = ()=>{
-                let entriesToDelete = countReq.result - MAX_PERSISTED_DOCUMENT_CHANNELS;
-                if (entriesToDelete <= 0) {
-                    return;
-                }
-                const cursorReq = store.index(CREATED_AT_INDEX).openCursor();
-                cursorReq.onsuccess = ()=>{
-                    const cursor = cursorReq.result;
-                    if (!cursor || entriesToDelete === 0) {
-                        return;
-                    }
-                    cursor.delete();
-                    entriesToDelete--;
-                    cursor.continue();
-                };
-            };
-            transaction.oncomplete = ()=>{
-                if (process.env.__NEXT_TEST_MODE) {
-                    // Test-only flag, set once this document's debug channel entry is
-                    // durably committed. Persistence is deferred to an idle callback and
-                    // the IndexedDB write is async, so this flag lets e2e tests await
-                    // persistence deterministically — coupling only to "an entry was
-                    // persisted" and not to how or where it is stored. It resets
-                    // naturally on each navigation since every document gets a fresh
-                    // window. The local cast keeps the augmentation out of the shipped
-                    // declaration files.
-                    ;
-                    self.__NEXT_DEBUG_CHANNEL_PERSISTED = true;
-                }
-                resolve();
-            };
-            transaction.onerror = ()=>reject(transaction.error);
-            transaction.onabort = ()=>reject(transaction.error);
-        });
-    } catch (error) {
-        // Best-effort: if persistence fails (quota, transaction abort, etc.), an
-        // HTTP cache restore will fall back to location.reload() since no entry
-        // will be found.
-        console.debug('Failed to write debug channel entry to IndexedDB', error);
-    } finally{
-        db.close();
-    }
-}
-function restoreDebugChannelFromIndexedDB(requestId) {
-    return new ReadableStream({
-        async start (controller) {
-            let entry;
-            try {
-                const db = await openDebugChannelDB();
-                try {
-                    entry = await new Promise((resolve, reject)=>{
-                        const tx = db.transaction(STORE_NAME, 'readonly');
-                        const store = tx.objectStore(STORE_NAME);
-                        const getReq = store.get(requestId);
-                        getReq.onsuccess = ()=>resolve(getReq.result);
-                        getReq.onerror = ()=>reject(getReq.error);
-                    });
-                } finally{
-                    db.close();
-                }
-            } catch (error) {
-                // Treat any IDB failure as "no entry" and fall through to reload.
-                console.debug('Failed to read debug channel entry from IndexedDB', error);
-            }
-            if (!entry) {
-                // Debug channel can't be restored — missing debug chunks would block
-                // hydration. Force a fresh page load from the server. Leave the stream
-                // parked (no enqueue, no close) so the Flight client stays put until
-                // the reload tears the document down, instead of synchronously erroring
-                // with "Connection closed.".
-                location.reload();
-                return;
-            }
-            for (const chunk of entry.chunks){
-                controller.enqueue(chunk);
-            }
-            controller.close();
-        }
-    });
-}
-/**
- * Decide at script-execution time whether the document was served from the
- * browser's cache or freshly fetched from the server. `type === 'back_forward'`
- * alone isn't enough: a back/forward navigation can also be a fresh server
- * re-fetch when the HTTP cache entry was evicted (long-lived tab, storage
- * pressure, manual cache clear), and treating that as a cache restore would
- * trigger an unnecessary `location.reload()` when no persisted chunks are
- * found.
- */ function wasServedFromCacheKnownAtExec(entry) {
-    if (!entry) {
-        return 1;
-    }
-    // Safari tab-duplication cache restore: type='navigate' paired with
-    // responseStart=0 (no first-body-byte over the network) and a non-zero
-    // responseEnd. Fresh navigations always have responseStart > 0.
-    if (entry.type === 'navigate' && entry.responseStart === 0 && entry.responseEnd > 0) {
-        return 0;
-    }
-    // Every remaining cache-restore signal requires a back/forward navigation.
-    // (bfcache restores don't re-execute scripts and never reach this code.)
-    if (entry.type !== 'back_forward') {
-        return 1;
-    }
-    // Chrome ≥109 and Safari ≥17 populate `deliveryType` at exec time even when
-    // the size fields aren't filled in yet. This is the only exec-time fast path
-    // for real Safari ≥17 cache restores (Safari leaves encodedBodySize at 0 at
-    // exec).
-    if (entry.deliveryType === 'cache') {
-        return 0;
-    }
-    // Chrome and Firefox publish an HTTP cache restore as transferSize=0 (no
-    // bytes over the wire) plus a non-zero cached body size at exec time.
-    if (entry.transferSize === 0 && entry.encodedBodySize > 0) {
-        return 0;
-    }
-    // No body bytes measured yet. Either the response is still streaming, or
-    // WebKit is reporting transferSize=0 and encodedBodySize=0 at exec time
-    // regardless of whether the document was cached or re-fetched. Defer to
-    // `pageshow` where the two cases become distinguishable.
-    if (entry.encodedBodySize === 0) {
-        return 2;
-    }
-    // Body bytes already measured at exec time with no other cache signal: a
-    // re-fetched back-nav whose response happened to complete before our script
-    // ran. The deferred branch above would have caught the same case if the
-    // response had still been streaming.
-    return 1;
-}
-/**
- * Re-check the cache-restore decision at `pageshow`, when every browser has
- * populated the navigation-entry size fields. Only called when
- * `wasServedFromCacheKnownAtExec` returned `ExecTimeCacheDecision.Undecided`.
- */ function wasServedFromCacheAtPageshow(entry) {
-    if (!entry) {
-        return false;
-    }
-    // Safari tab-duplication signature; see the matching branch in
-    // `wasServedFromCacheKnownAtExec`.
-    if (entry.type === 'navigate' && entry.responseStart === 0 && entry.responseEnd > 0) {
-        return true;
-    }
-    // A back/forward navigation where at least one of the size fields is zero
-    // means the body didn't come over the wire. Browsers signal a cache restore
-    // differently — Chrome/Firefox zero `transferSize` and keep a non-zero cached
-    // `encodedBodySize`; Safari does the inverse with a small `transferSize`
-    // (header overhead) and `encodedBodySize=0`; WebKit under Playwright zeros
-    // both. A fresh re-fetch populates both with the response size.
-    return entry.type === 'back_forward' && (entry.transferSize === 0 || entry.encodedBodySize === 0);
-}
-function getNavigationEntry() {
-    try {
-        return performance.getEntriesByType('navigation')[0];
-    } catch  {
-        return undefined;
-    }
-}
 /**
  * Reclaim the least-recently-used debug-channel pairs once the map exceeds
  * `MAX_DEBUG_CHANNEL_PAIRS`. The map is iterated in insertion order and we
@@ -273,19 +63,7 @@ function getOrCreateDebugChannelReadableWriterPair(requestId) {
         pairs.set(requestId, existingPair);
         return existingPair;
     }
-    // Buffer chunks only for the initial document's debug channel, not for
-    // client-side navigation requests. Persisted to IndexedDB once complete so it
-    // can be restored when the browser serves the page from HTTP cache
-    // (back-forward navigation, tab duplication, etc.).
-    const chunks = requestId === self.__next_r ? [] : null;
-    const { readable, writable } = new TransformStream({
-        transform (chunk, controller) {
-            if (chunks) {
-                chunks.push(chunk.slice());
-            }
-            controller.enqueue(chunk);
-        }
-    });
+    const { readable, writable } = new TransformStream();
     const pair = {
         readable,
         writer: writable.getWriter()
@@ -294,27 +72,10 @@ function getOrCreateDebugChannelReadableWriterPair(requestId) {
     // Retain the pair past its stream's close (see MAX_DEBUG_CHANNEL_PAIRS) and
     // bound the map by reclaiming the least-recently-used.
     evictExcessDebugChannelPairs();
-    pair.writer.closed.then(async ()=>{
-        if (!chunks) {
-            return;
-        }
-        // The initial document's debug stream closes while hydration is still
-        // running, so persisting here would steal main-thread time from it. Wait
-        // for genuine idle (no timeout): persistence is best-effort, so if the
-        // page never idles before navigation we skip it and a later restore falls
-        // back to a reload, rather than forcing a blocking write.
-        await whenIdle();
-        await persistDebugChannelToIndexedDB(requestId, chunks);
-    }).catch((error)=>{
-        // writer.closed rejected (e.g., stream aborted), nothing to persist.
+    // An errored stream rejects `writer.closed`. Observe the rejection so that it
+    // does not surface as an unhandled rejection.
+    pair.writer.closed.catch((error)=>{
         console.debug('Debug channel writer closed with error', error);
-    }).finally(()=>{
-        // Keep the now-closed pair in the map so late decodes of this request
-        // still resolve against its buffered stream; it's reclaimed later by LRU
-        // eviction. Release the IndexedDB staging buffer now that it's persisted.
-        if (chunks) {
-            chunks.length = 0;
-        }
     });
     return pair;
 }
@@ -323,40 +84,12 @@ function createDebugChannel(requestHeaders) {
     if (requestHeaders) {
         requestId = requestHeaders[_approuterheaders.NEXT_REQUEST_ID_HEADER] ?? undefined;
         if (!requestId) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected a ${JSON.stringify(_approuterheaders.NEXT_REQUEST_ID_HEADER)} request header.`), "__NEXT_ERROR_CODE", {
-                value: "E854",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Expected a ${JSON.stringify(_approuterheaders.NEXT_REQUEST_ID_HEADER)} request header.`);
         }
     } else {
         requestId = self.__next_r;
         if (!requestId) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected a request ID to be defined for the document via self.__next_r.`), "__NEXT_ERROR_CODE", {
-                value: "E806",
-                enumerable: false,
-                configurable: true
-            });
-        }
-    }
-    // Only attempt to restore the IndexedDB debug channel entry for the
-    // initial document load (no request headers). Client-side navigations pass
-    // request headers and should always use the WebSocket-backed debug channel.
-    if (!requestHeaders) {
-        switch(wasServedFromCacheKnownAtExec(getNavigationEntry())){
-            case 0:
-                return {
-                    readable: restoreDebugChannelOrReload(requestId)
-                };
-            case 2:
-                // Body bytes haven't been measured on the navigation entry yet. Suspend
-                // the stream until pageshow, re-check there, then source from the
-                // persisted chunks or the WebSocket-backed pair accordingly.
-                return {
-                    readable: createDeferredDebugChannelReadable(requestId)
-                };
-            case 1:
-                break;
+            throw new _invarianterror.InvariantError(`Expected a request ID to be defined for the document via self.__next_r.`);
         }
     }
     const pair = getOrCreateDebugChannelReadableWriterPair(requestId);
@@ -368,56 +101,6 @@ function createDebugChannel(requestHeaders) {
         readable: branch
     };
 }
-/**
- * Try to restore the debug channel from the persisted chunks. If none are
- * found, force a fresh page load.
- */ function restoreDebugChannelOrReload(requestId) {
-    const readable = restoreDebugChannelFromIndexedDB(requestId);
-    if (readable) {
-        return readable;
-    }
-    // No persisted entry. Typically this happens when the HTTP cache held the
-    // HTML but the persisted entry was never written, or was overwritten by a
-    // newer document in this tab.
-    location.reload();
-    // Never-closing stream. Keeps the Flight client suspended until the reload
-    // tears the document down, instead of letting it synchronously error with
-    // "Connection closed.".
-    return new ReadableStream();
-}
-/**
- * Used when `wasServedFromCacheKnownAtExec` returns
- * `ExecTimeCacheDecision.Undecided`. Waits for `pageshow`, re-runs the check,
- * and forwards data from either the persisted chunks or the WebSocket.
- */ function createDeferredDebugChannelReadable(requestId) {
-    return new ReadableStream({
-        async start (controller) {
-            // By `pageshow` every browser has populated the navigation-entry size
-            // fields, so the re-check below is unambiguous.
-            await new Promise((resolve)=>{
-                window.addEventListener('pageshow', ()=>resolve(), {
-                    once: true
-                });
-            });
-            const source = wasServedFromCacheAtPageshow(getNavigationEntry()) ? restoreDebugChannelOrReload(requestId) : getOrCreateDebugChannelReadableWriterPair(requestId).readable;
-            const reader = source.getReader();
-            try {
-                while(true){
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        controller.close();
-                        return;
-                    }
-                    controller.enqueue(value);
-                }
-            } catch (error) {
-                controller.error(error);
-            } finally{
-                reader.releaseLock();
-            }
-        }
-    });
-}
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });

package/app/node_modules/next/dist/client/dev/hot-reloader/app/hot-reloader-app.js

@@ -38,9 +38,9 @@ const _shared = require("../shared");
 const _nextdevtools = require("next/dist/compiled/next-devtools");
 const _replayssronlyerrors = require("../../../../next-devtools/userspace/app/errors/replay-ssr-only-errors");
 const _appdevoverlayerrorboundary = require("../../../../next-devtools/userspace/app/app-dev-overlay-error-boundary");
-const _useerrorhandler = require("../../../../next-devtools/userspace/app/errors/use-error-handler");
 const _runtimeerrorhandler = require("../../runtime-error-handler");
 const _websocket = require("./web-socket");
+const _useerrorhandler = require("../../../../next-devtools/userspace/app/errors/use-error-handler");
 const _hotreloadertypes = require("../../../../server/dev/hot-reloader-types");
 const _navigationuntracked = require("../../../components/navigation-untracked");
 const _reporthmrlatency = /*#__PURE__*/ _interop_require_default._(require("../../report-hmr-latency"));
@@ -204,6 +204,12 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
                 hmrUpdate.hasUpdates);
             }
             _nextdevtools.dispatcher.onBuildOk();
+            // A successful build can be a no-op after recovering from an error, so
+            // there may be no server component change to resolve the test callback.
+            if (process.env.__NEXT_TEST_MODE && self.__NEXT_HMR_CB) {
+                self.__NEXT_HMR_CB();
+                self.__NEXT_HMR_CB = null;
+            }
         } else {
             tryApplyUpdatesWebpack(sendMessage);
         }
@@ -234,6 +240,11 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
                 }
                 break;
             }
+        case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.VULNERABILITY_INSIGHT:
+            {
+                _nextdevtools.dispatcher.onVulnerabilityInsight(message.hasVulnerabilityInsight);
+                break;
+            }
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.BUILT:
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SYNC:
             {
@@ -244,6 +255,9 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
                 const { errors, warnings } = message;
                 // Is undefined when it's a 'built' event
                 if ('versionInfo' in message) _nextdevtools.dispatcher.onVersionInfo(message.versionInfo);
+                if ('hasVulnerabilityInsight' in message) {
+                    _nextdevtools.dispatcher.onVulnerabilityInsight(message.hasVulnerabilityInsight);
+                }
                 if ('debug' in message && message.debug) _nextdevtools.dispatcher.onDebugInfo(message.debug);
                 if ('devIndicator' in message) _nextdevtools.dispatcher.onDevIndicator(message.devIndicator);
                 if ('devToolsConfig' in message) _nextdevtools.dispatcher.onDevToolsConfig(message.devToolsConfig);
@@ -294,7 +308,8 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
                 processTurbopackMessage({
                     type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.TURBOPACK_CONNECTED,
                     data: {
-                        sessionId: message.data.sessionId
+                        sessionId: message.data.sessionId,
+                        hmrVersion: message.data.hmrVersion
                     }
                 });
                 break;
@@ -305,7 +320,8 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
                 _nextdevtools.dispatcher.onBeforeRefresh();
                 processTurbopackMessage({
                     type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.TURBOPACK_MESSAGE,
-                    data: message.data
+                    data: message.data,
+                    hmrVersion: message.hmrVersion
                 });
                 if (_runtimeerrorhandler.RuntimeErrorHandler.hadRuntimeError) {
                     console.warn(_shared.REACT_REFRESH_FULL_RELOAD_FROM_ERROR);
@@ -317,6 +333,10 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
         // TODO-APP: make server component change more granular
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES:
             {
+                processTurbopackMessage({
+                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES,
+                    hmrVersion: message.hmrVersion
+                });
                 turbopackHmr?.onServerComponentChanges();
                 sendMessage(JSON.stringify({
                     event: 'server-component-reload-page',
@@ -342,9 +362,9 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.STATIC_PARAMS_CHANGED:
             {
                 // Re-fetch the current router tree so the render picks up the new set of
-                // statically-known params (and thus the fresh `fallbackParams`). Unlike
-                // `SERVER_COMPONENT_CHANGES` this does not store an HMR refresh hash, so
-                // it doesn't invalidate `"use cache"` entries.
+                // statically-known params (and thus the fresh `stagedFallbackParams`).
+                // Unlike `SERVER_COMPONENT_CHANGES` this does not store an HMR refresh
+                // hash, so it doesn't invalidate `"use cache"` entries.
                 if (_runtimeerrorhandler.RuntimeErrorHandler.hadRuntimeError || document.documentElement.id === '__next_error__') {
                     if (reloading) return;
                     reloading = true;
@@ -379,11 +399,7 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
                 const { errorJSON } = message;
                 if (errorJSON) {
                     const errorObject = JSON.parse(errorJSON);
-                    const error = Object.defineProperty(new Error(errorObject.message), "__NEXT_ERROR_CODE", {
-                        value: "E394",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    const error = new Error(errorObject.message);
                     error.stack = errorObject.stack;
                     handleErrors([
                         error
@@ -421,6 +437,11 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
                 }
                 return;
             }
+        case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.RUNTIME_ERRORS:
+            {
+                // Runtime error state is consumed by external HMR observers.
+                return;
+            }
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REQUEST_CURRENT_ERROR_STATE:
             {
                 const errorState = (0, _nextdevtools.getSerializedOverlayState)();
@@ -459,16 +480,8 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
                     }
                 }), {
                     findSourceMapURL: _appfindsourcemapurl.findSourceMapURL
-                }).then(({ errors, errorCodes })=>{
+                }).then(({ errors })=>{
                     for (const error of errors){
-                        const code = errorCodes.get(error);
-                        if (code !== undefined) {
-                            Object.defineProperty(error, '__NEXT_ERROR_CODE', {
-                                value: code,
-                                enumerable: false,
-                                configurable: true
-                            });
-                        }
                         // These errors originated on the server and were already logged
                         // there. Mark them so the browser-to-terminal log forwarding
                         // doesn't replay them back to the CLI as duplicates.
@@ -476,12 +489,8 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
                         console.error(error);
                     }
                 }, (err)=>{
-                    console.error(Object.defineProperty(new Error('Failed to deserialize errors.', {
+                    console.error(new Error('Failed to deserialize errors.', {
                         cause: err
-                    }), "__NEXT_ERROR_CODE", {
-                        value: "E946",
-                        enumerable: false,
-                        configurable: true
                     }));
                 });
                 return;
@@ -497,22 +506,31 @@ function processMessage(message, sendMessage, processTurbopackMessage, staticInd
     }
 }
 function HotReload({ children, globalError, webSocket, staticIndicatorState }) {
-    (0, _useerrorhandler.useErrorHandler)(_nextdevtools.dispatcher.onUnhandledError, _nextdevtools.dispatcher.onUnhandledRejection);
     (0, _websocket.useWebSocketPing)(webSocket);
     // We don't want access of the pathname for the dev tools to trigger a dynamic
     // access (as the dev overlay will never be present in production).
     const pathname = (0, _navigationuntracked.useUntrackedPathname)();
+    if (process.env.__NEXT_EXPOSE_RUNTIME_ERRORS_TO_HMR) {
+        // Republish after navigation commits so HMR observers receive the current
+        // pathname even when the captured errors haven't changed.
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        (0, _react.useEffect)(()=>{
+            const { reportCurrentRuntimeErrorState } = require('../runtime-error-state');
+            reportCurrentRuntimeErrorState();
+        }, [
+            pathname
+        ]);
+    } else {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        (0, _useerrorhandler.useErrorHandler)(_nextdevtools.dispatcher.onUnhandledError, _nextdevtools.dispatcher.onUnhandledRejection);
+    }
     if (process.env.__NEXT_DEV_INDICATOR) {
         // this conditional is only for dead-code elimination which
         // isn't a runtime conditional only build-time so ignore hooks rule
         // eslint-disable-next-line react-hooks/rules-of-hooks
         (0, _react.useEffect)(()=>{
             if (!staticIndicatorState) {
-                throw Object.defineProperty(new _invarianterror.InvariantError('Expected staticIndicatorState to be defined in dev mode.'), "__NEXT_ERROR_CODE", {
-                    value: "E786",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('Expected staticIndicatorState to be defined in dev mode.');
             }
             staticIndicatorState.pathname = pathname;
             if (staticIndicatorState.appIsrManifest) {

package/app/node_modules/next/dist/client/dev/hot-reloader/app/web-socket.js

@@ -39,11 +39,7 @@ let serverSessionId = null;
 let mostRecentCompilationHash = null;
 function createWebSocket(assetPrefix, staticIndicatorState) {
     if (!self.__next_r) {
-        throw Object.defineProperty(new _invarianterror.InvariantError(`Expected a request ID to be defined for the document via self.__next_r.`), "__NEXT_ERROR_CODE", {
-            value: "E806",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`Expected a request ID to be defined for the document via self.__next_r.`);
     }
     let webSocket;
     let timer;
@@ -52,6 +48,13 @@ function createWebSocket(assetPrefix, staticIndicatorState) {
             webSocket.send(data);
         }
     };
+    let runtimeErrorStateReporter;
+    if (process.env.__NEXT_EXPOSE_RUNTIME_ERRORS_TO_HMR) {
+        const { createRuntimeErrorStateReporter } = require('../runtime-error-state');
+        runtimeErrorStateReporter = createRuntimeErrorStateReporter(sendMessage);
+    } else {
+        runtimeErrorStateReporter = null;
+    }
     const processTurbopackMessage = createProcessTurbopackMessage(sendMessage);
     function init() {
         if (webSocket) {
@@ -61,6 +64,7 @@ function createWebSocket(assetPrefix, staticIndicatorState) {
         newWebSocket.binaryType = 'arraybuffer';
         function handleOnline() {
             _forwardlogs.logQueue.onSocketReady(newWebSocket);
+            runtimeErrorStateReporter?.reportCurrent();
             reconnections = 0;
             window.console.log('[HMR] connected');
         }
@@ -162,7 +166,8 @@ function createProcessTurbopackMessage(sendMessage) {
                 queue.length = 0;
             },
             sendMessage,
-            onUpdateError: (err)=>(0, _hotreloaderapp.performFullReload)(err, sendMessage)
+            onUpdateError: (err)=>(0, _hotreloaderapp.performFullReload)(err, sendMessage),
+            chunkUpdateListenersGlobal: process.env.__NEXT_TURBOPACK_CHUNK_UPDATE_LISTENERS_GLOBAL
         });
     });
     return processTurbopackMessage;
@@ -171,11 +176,7 @@ function useWebSocketPing(webSocket) {
     const { tree } = (0, _react.useContext)(_approutercontextsharedruntime.GlobalLayoutRouterContext);
     (0, _react.useEffect)(()=>{
         if (!webSocket) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('Expected webSocket to be defined in dev mode.'), "__NEXT_ERROR_CODE", {
-                value: "E785",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('Expected webSocket to be defined in dev mode.');
         }
         // Never send pings when using Turbopack as it's not used.
         // Pings were originally used to keep track of active routes in on-demand-entries with webpack.
@@ -227,21 +228,13 @@ function parseBinaryMessage(data) {
             }
         default:
             {
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid binary HMR message of type ${messageType}`), "__NEXT_ERROR_CODE", {
-                    value: "E809",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError(`Invalid binary HMR message of type ${messageType}`);
             }
     }
 }
 function assertByteLength(data, expectedLength) {
     if (data.byteLength < expectedLength) {
-        throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid binary HMR message: insufficient data (expected ${expectedLength} bytes, got ${data.byteLength})`), "__NEXT_ERROR_CODE", {
-            value: "E808",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`Invalid binary HMR message: insufficient data (expected ${expectedLength} bytes, got ${data.byteLength})`);
     }
 }