@claudeye/linux-arm64 1.0.6-beta.2 → 1.0.6-beta.4

package/assets/standalone/node_modules/next/dist/server/node-environment-extensions/process-error-handlers.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "installProcessErrorHandlers", {
+    enumerable: true,
+    get: function() {
+        return installProcessErrorHandlers;
+    }
+});
+const _ispostpone = require("../lib/router-utils/is-postpone");
+let _global = globalThis;
+function installProcessErrorHandlers(shouldRemoveUncaughtErrorAndRejectionListeners) {
+    if (_global.nextInitializedProcessErrorHandlers) return;
+    _global.nextInitializedProcessErrorHandlers = true;
+    // The conventional wisdom of Node.js and other runtimes is to treat
+    // unhandled errors as fatal and exit the process.
+    //
+    // But Next.js is not a generic JS runtime — it's a specialized runtime for
+    // React Server Components.
+    //
+    // Many unhandled rejections are due to the late-awaiting pattern for
+    // prefetching data. In Next.js it's OK to call an async function without
+    // immediately awaiting it, to start the request as soon as possible
+    // without blocking unncessarily on the result. These can end up
+    // triggering an "unhandledRejection" if it later turns out that the
+    // data is not needed to render the page. Example:
+    //
+    //     const promise = fetchData()
+    //     const shouldShow = await checkCondition()
+    //     if (shouldShow) {
+    //       return <Component promise={promise} />
+    //     }
+    //
+    // In this example, `fetchData` is called immediately to start the request
+    // as soon as possible, but if `shouldShow` is false, then it will be
+    // discarded without unwrapping its result. If it errors, it will trigger
+    // an "unhandledRejection" event.
+    //
+    // Ideally, we would suppress these rejections completely without warning,
+    // because we don't consider them real errors. (TODO: Currently we do warn.)
+    //
+    // But regardless of whether we do or don't warn, we definitely shouldn't
+    // crash the entire process.
+    //
+    // Even a "legit" unhandled error unrelated to prefetching shouldn't
+    // prevent the rest of the page from rendering.
+    //
+    // So, we're going to intentionally override the default error handling
+    // behavior of the outer JS runtime to be more forgiving
+    // Remove any existing "unhandledRejection" and "uncaughtException" handlers.
+    // This is gated behind an experimental flag until we've considered the impact
+    // in various deployment environments. It's possible this may always need to
+    // be configurable.
+    if (shouldRemoveUncaughtErrorAndRejectionListeners) {
+        process.removeAllListeners('uncaughtException');
+        process.removeAllListeners('unhandledRejection');
+    }
+    // Install a new handler to prevent the process from crashing.
+    process.on('unhandledRejection', (reason)=>{
+        if ((0, _ispostpone.isPostpone)(reason)) {
+            // React postpones that are unhandled might end up logged here but they're
+            // not really errors. They're just part of rendering.
+            return;
+        }
+        // Immediately log the error.
+        // TODO: Ideally, if we knew that this error was triggered by application
+        // code, we would suppress it entirely without logging. We can't reliably
+        // detect all of these, but when cacheComponents is enabled, we could suppress
+        // at least some of them by waiting to log the error until after all in-
+        // progress renders have completed. Then, only log errors for which there
+        // was not a corresponding "rejectionHandled" event.
+        console.error(reason);
+    });
+    process.on('rejectionHandled', ()=>{
+    // TODO: See note in the unhandledRejection handler above. In the future,
+    // we may use the "rejectionHandled" event to de-queue an error from
+    // being logged.
+    });
+    // Unhandled exceptions are errors triggered by non-async functions, so this
+    // is unrelated to the late-awaiting pattern. However, for similar reasons,
+    // we still shouldn't crash the process. Just log it.
+    process.on('uncaughtException', (reason)=>{
+        if ((0, _ispostpone.isPostpone)(reason)) {
+            return;
+        }
+        console.error(reason);
+    });
+}
+
+//# sourceMappingURL=process-error-handlers.js.map

package/assets/standalone/node_modules/next/dist/server/node-environment-extensions/random.js

@@ -8,12 +8,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _utils = require("./utils");
+const _ioutils = require("./io-utils");
 const expression = '`Math.random()`';
 try {
     const _random = Math.random;
     Math.random = (function random() {
-        (0, _utils.io)(expression, 'random');
+        (0, _ioutils.io)(expression, 'random');
         return _random.apply(null, arguments);
     // We bind here to alter the `toString` printing to match `Math.random`'s native `toString`.
     // eslint-disable-next-line no-extra-bind

package/assets/standalone/node_modules/next/dist/server/node-environment-extensions/{unhandled-rejection.js → unhandled-rejection.external.js}

@@ -89,6 +89,11 @@ const warnUninstalledOnce = warn ? function warnUninstalledOnce(...args) {
         warn(...args);
     }
 } : undefined;
+// We use a global symbol to detect if the filter has already been installed.
+// If two instances of this module are loaded, each captures the other's handler
+// as an underlying listener, creating mutual recursion that overflows the stack.
+// We error defensively rather than silently degrading.
+const FILTER_INSTALLED_KEY = Symbol.for('next.unhandledRejectionFilter');
 let filterInstalled = false;
 // We store the proxied listeners for unhandled rejections here.
 let underlyingListeners = [];
@@ -143,8 +148,10 @@ const MACGUFFIN_EVENT = 'Next.UnhandledRejectionFilter.MacguffinEvent';
  *
  * This should be called once during server startup to install the global filter.
  */ function installUnhandledRejectionFilter() {
-    if (filterInstalled) {
-        warnWithTrace == null ? void 0 : warnWithTrace('Unexpected subsequent filter installation. This is a bug in Next.js');
+    if (globalThis[FILTER_INSTALLED_KEY] || filterInstalled) {
+        // Already installed by another evaluation of this module in the same
+        // process (e.g., Jest's module system re-evaluating an already-loaded
+        // module). Safe to skip since the filter is already active.
         return;
     }
     debug == null ? void 0 : debug('Installing Filter');
@@ -384,6 +391,7 @@ You can debug event listener operations by running Next.js with \`NEXT_UNHANDLED
         return originalProcessListeners.call(process, event);
     });
     filterInstalled = true;
+    globalThis[FILTER_INSTALLED_KEY] = true;
 }
 /**
  * Uninstalls the unhandled rejection filter and restores original process methods.
@@ -422,13 +430,20 @@ You can debug event listener operations by running Next.js with \`NEXT_UNHANDLED
 }
 /**
  * The filtering handler that decides whether to suppress or delegate unhandled rejections.
- */ function filteringUnhandledRejectionHandler(reason, promise) {
+ */ let handlingRejection = false;
+function filteringUnhandledRejectionHandler(reason, promise) {
+    if (handlingRejection) {
+        // An underlying listener synchronously re-emitted 'unhandledRejection'.
+        // Re-entering the listener loop would overflow the stack.
+        return;
+    }
     const capturedListenerMetadata = Array.from(listenerMetadata);
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     if (workUnitStore) {
         switch(workUnitStore.type){
             case 'prerender':
             case 'prerender-client':
+            case 'validation-client':
             case 'prerender-runtime':
                 {
                     const signal = workUnitStore.renderSignal;
@@ -445,6 +460,7 @@ You can debug event listener operations by running Next.js with \`NEXT_UNHANDLED
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
+            case 'generate-static-params':
                 break;
             default:
                 workUnitStore;
@@ -460,6 +476,7 @@ You can debug event listener operations by running Next.js with \`NEXT_UNHANDLED
         // do not automatically terminate the process.
         console.error('Unhandled Rejection:', reason);
     } else {
+        handlingRejection = true;
         try {
             for (const meta of capturedListenerMetadata){
                 if (meta.once) {
@@ -478,6 +495,8 @@ You can debug event listener operations by running Next.js with \`NEXT_UNHANDLED
             setImmediate(()=>{
                 throw error;
             });
+        } finally{
+            handlingRejection = false;
         }
     }
 }
@@ -486,4 +505,4 @@ if (ENABLE_UHR_FILTER) {
     installUnhandledRejectionFilter();
 }
 
-//# sourceMappingURL=unhandled-rejection.js.map
+//# sourceMappingURL=unhandled-rejection.external.js.map

package/assets/standalone/node_modules/next/dist/server/node-environment-extensions/web-crypto.js

@@ -9,7 +9,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _utils = require("./utils");
+const _ioutils = require("./io-utils");
 let webCrypto;
 if (process.env.NEXT_RUNTIME === 'edge') {
     webCrypto = crypto;
@@ -25,7 +25,7 @@ const getRandomValuesExpression = '`crypto.getRandomValues()`';
 try {
     const _getRandomValues = webCrypto.getRandomValues;
     webCrypto.getRandomValues = function getRandomValues() {
-        (0, _utils.io)(getRandomValuesExpression, 'crypto');
+        (0, _ioutils.io)(getRandomValuesExpression, 'crypto');
         return _getRandomValues.apply(webCrypto, arguments);
     };
 } catch  {
@@ -35,7 +35,7 @@ const randomUUIDExpression = '`crypto.randomUUID()`';
 try {
     const _randomUUID = webCrypto.randomUUID;
     webCrypto.randomUUID = function randomUUID() {
-        (0, _utils.io)(randomUUIDExpression, 'crypto');
+        (0, _ioutils.io)(randomUUIDExpression, 'crypto');
         return _randomUUID.apply(webCrypto, arguments);
     };
 } catch  {

package/assets/standalone/node_modules/next/dist/server/node-environment.js

@@ -9,7 +9,7 @@ require("./node-environment-extensions/error-inspect");
 require("./node-environment-extensions/console-file");
 require("./node-environment-extensions/console-exit");
 require("./node-environment-extensions/console-dim.external");
-require("./node-environment-extensions/unhandled-rejection");
+require("./node-environment-extensions/unhandled-rejection.external");
 require("./node-environment-extensions/random");
 require("./node-environment-extensions/date");
 require("./node-environment-extensions/web-crypto");

package/assets/standalone/node_modules/next/dist/server/normalizers/request/segment-prefix-rsc.js

@@ -9,7 +9,8 @@ Object.defineProperty(exports, "SegmentPrefixRSCPathnameNormalizer", {
     }
 });
 const _constants = require("../../../lib/constants");
-const PATTERN = new RegExp(`^(/.*)${_constants.RSC_SEGMENTS_DIR_SUFFIX}(/.*)${_constants.RSC_SEGMENT_SUFFIX}$`);
+const _escaperegexp = require("../../../shared/lib/escape-regexp");
+const PATTERN = new RegExp(`^(/.*)${(0, _escaperegexp.escapeStringRegexp)(_constants.RSC_SEGMENTS_DIR_SUFFIX)}(/.*)${(0, _escaperegexp.escapeStringRegexp)(_constants.RSC_SEGMENT_SUFFIX)}$`);
 class SegmentPrefixRSCPathnameNormalizer {
     match(pathname) {
         return PATTERN.test(pathname);

package/assets/standalone/node_modules/next/dist/server/patch-error-inspect.js

@@ -5,7 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     patchErrorInspectEdgeLite: null,
     patchErrorInspectNodeJS: null,
-    setBundlerFindSourceMapImplementation: null
+    setBundlerFindSourceMapImplementation: null,
+    setCodeFrameRenderer: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -22,6 +23,9 @@ _export(exports, {
     },
     setBundlerFindSourceMapImplementation: function() {
         return setBundlerFindSourceMapImplementation;
+    },
+    setCodeFrameRenderer: function() {
+        return setCodeFrameRenderer;
     }
 });
 const _module = require("module");
@@ -30,7 +34,6 @@ const _url = /*#__PURE__*/ _interop_require_wildcard(require("url"));
 const _sourcemap = require("next/dist/compiled/source-map");
 const _sourcemaps = require("./lib/source-maps");
 const _parsestack = require("./lib/parse-stack");
-const _shared = require("../next-devtools/server/shared");
 const _workunitasyncstorageexternal = require("./app-render/work-unit-async-storage.external");
 const _picocolors = require("../lib/picocolors");
 function _getRequireWildcardCache(nodeInterop) {
@@ -82,6 +85,17 @@ let bundlerFindSourceMapPayload = ()=>undefined;
 function setBundlerFindSourceMapImplementation(findSourceMapImplementation) {
     bundlerFindSourceMapPayload = findSourceMapImplementation;
 }
+let codeFrameRenderer;
+function setCodeFrameRenderer(renderer) {
+    codeFrameRenderer = renderer;
+}
+function getOriginalCodeFrame(frame, source, colors = process.stdout.isTTY) {
+    if (!codeFrameRenderer) {
+        // No renderer available - gracefully degrade
+        return null;
+    }
+    return codeFrameRenderer(frame, source, colors);
+}
 function frameToString(methodName, sourceURL, line1, column1) {
     let sourceLocation = line1 !== null ? `:${line1}` : '';
     if (column1 !== null && sourceLocation !== '') {
@@ -189,11 +203,15 @@ function ignoreListAnonymousStackFramesIfSandwiched(sourceMappedFrames) {
         sourceMapPayload = maybeSourceMapPayload;
         try {
             // Pass the source map URL as the second parameter so that the consumer
-            // can resolve relative paths in the source map's `sources` array.
-            // This is a guess!  Turbopack places .map files as siblings to the chunks so this is sufficient to compute
-            // relative paths but is actually wrong (the chunk and sourcemap have different content hashes).
-            // We are using the node API to read the sourcemap and it doesn't give us access to the URI.
-            const sourceMapURL = sourceURL + '.map';
+            // can resolve relative paths in the source map's `sources` array. This is
+            // a guess! Turbopack places .map files as siblings to the chunks so this
+            // is sufficient to compute relative paths but is actually wrong (the
+            // chunk and sourcemap have different content hashes). We are using the
+            // node API to read the sourcemap and it doesn't give us access to the
+            // URI. Devirtualize `about://React/Server/file:///path/to/chunk.js?4` to
+            // `file:///path/to/chunk.js` so that relative `sources` in the source map
+            // resolve against the real chunk URL, not the virtual one.
+            const sourceMapURL = (0, _sourcemaps.devirtualizeReactServerURL)(sourceURL) + '.map';
             sourceMapConsumer = new _sourcemap.SourceMapConsumer(sourceMapPayload, // @ts-expect-error: our typings don't include this parameter but it is here.
             sourceMapURL);
         } catch (cause) {
@@ -267,19 +285,17 @@ function ignoreListAnonymousStackFramesIfSandwiched(sourceMappedFrames) {
         arguments: [],
         ignored
     };
-    /** undefined = not yet computed*/ let codeFrame;
-    return Object.defineProperty({
+    /** undefined = not yet computed */ let codeFrame;
+    return {
         stack: originalFrame,
-        code: null
-    }, 'code', {
-        get: ()=>{
+        get code () {
             if (codeFrame === undefined) {
                 const sourceContent = sourceMapConsumer.sourceContentFor(sourcePosition.source, /* returnNullOnMissing */ true) ?? null;
-                codeFrame = (0, _shared.getOriginalCodeFrame)(originalFrame, sourceContent, inspectOptions.colors);
+                codeFrame = getOriginalCodeFrame(originalFrame, sourceContent, inspectOptions.colors);
             }
             return codeFrame;
         }
-    });
+    };
 }
 function parseAndSourceMap(error, inspectOptions) {
     const showIgnoreListed = process.env.__NEXT_SHOW_IGNORE_LISTED === 'true';
@@ -355,15 +371,17 @@ function parseAndSourceMap(error, inspectOptions) {
     return errorName + ': ' + error.message + sourceMappedStack + (sourceFrame !== null ? '\n' + sourceFrame : '');
 }
 function sourceMapError(error, inspectOptions) {
+    // Setting an undefined `cause` would print `[cause]: undefined`
+    const options = error.cause !== undefined ? {
+        cause: error.cause
+    } : undefined;
     // Create a new Error object with the source mapping applied and then use native
     // Node.js formatting on the result.
-    const newError = error.cause !== undefined ? Object.defineProperty(new Error(error.message, {
-        cause: error.cause
-    }), "__NEXT_ERROR_CODE", {
+    const newError = error instanceof AggregateError ? Object.defineProperty(new AggregateError(error.errors, error.message, options), "__NEXT_ERROR_CODE", {
         value: "E394",
         enumerable: false,
         configurable: true
-    }) : Object.defineProperty(new Error(error.message), "__NEXT_ERROR_CODE", {
+    }) : Object.defineProperty(new Error(error.message, options), "__NEXT_ERROR_CODE", {
         value: "E394",
         enumerable: false,
         configurable: true
@@ -398,8 +416,7 @@ function patchErrorInspectNodeJS(errorConstructor) {
             try {
                 return inspect(newError, {
                     ...inspectOptions,
-                    depth: (inspectOptions.depth ?? // Default in Node.js
-                    2) - depth
+                    depth
                 });
             } finally{
                 ;

package/assets/standalone/node_modules/next/dist/server/render-result.js

@@ -122,6 +122,15 @@ class RenderResult {
         }
     }
     /**
+   * Pipes the response through a transform stream. This converts the response
+   * to a single readable stream (chaining if needed) and pipes it through the
+   * provided transform.
+   *
+   * @param transform The transform stream to pipe through
+   */ pipeThrough(transform) {
+        this.response = this.readable.pipeThrough(transform);
+    }
+    /**
    * Unshifts a new stream to the response. This will convert the response to an
    * array of streams if it is not already one and will add the new stream to
    * the start of the array. When this response is piped, all of the streams

package/assets/standalone/node_modules/next/dist/server/render.js

@@ -80,7 +80,7 @@ if (process.env.NEXT_RUNTIME !== 'edge') {
 function noRouter() {
     const message = 'No router instance found. you should only use "next/router" inside the client side of your app. https://nextjs.org/docs/messages/no-router-instance';
     throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-        value: "E394",
+        value: "E1027",
         enumerable: false,
         configurable: true
     });
@@ -209,9 +209,8 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
     (0, _apiutils.setLazyProp)({
         req: req
     }, 'cookies', (0, _getcookieparser.getCookieParser)(req.headers));
-    const metadata = {};
-    metadata.assetQueryString = renderOpts.dev && renderOpts.assetQueryString || '';
-    if (renderOpts.dev && !metadata.assetQueryString) {
+    let baseAssetQueryString = process.env.__NEXT_DEV_SERVER && renderOpts.assetQueryString || '';
+    if (process.env.__NEXT_DEV_SERVER && !baseAssetQueryString) {
         const userAgent = (req.headers['user-agent'] || '').toLowerCase();
         if (userAgent.includes('safari') && !userAgent.includes('chrome')) {
             // In dev we invalidate the cache by appending a timestamp to the resource URL.
@@ -219,18 +218,19 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             // TODO: remove this workaround when https://bugs.webkit.org/show_bug.cgi?id=187726 is fixed.
             // Note: The workaround breaks breakpoints on reload since the script url always changes,
             // so we only apply it to Safari.
-            metadata.assetQueryString = `?ts=${Date.now()}`;
+            baseAssetQueryString = `?ts=${Date.now()}`;
         }
     }
-    // if deploymentId is provided we append it to all asset requests
-    if (sharedContext.deploymentId) {
-        metadata.assetQueryString += `${metadata.assetQueryString ? '&' : '?'}dpl=${sharedContext.deploymentId}`;
-    }
+    const mutableAssetQueryString = baseAssetQueryString + (sharedContext.deploymentId ? `${baseAssetQueryString ? '&' : '?'}dpl=${sharedContext.deploymentId}` : '');
+    const assetQueryString = baseAssetQueryString + (sharedContext.clientAssetToken ? `${baseAssetQueryString ? '&' : '?'}dpl=${sharedContext.clientAssetToken}` : '');
+    const metadata = {
+        assetQueryString,
+        mutableAssetQueryString
+    };
     // don't modify original query object
     query = Object.assign({}, query);
-    const { err, dev = false, pageConfig = {}, buildManifest, reactLoadableManifest, ErrorDebug, getStaticProps, getStaticPaths, getServerSideProps, isNextDataRequest, params, previewProps, basePath, images, runtime: globalRuntime, isExperimentalCompile, expireTime } = renderOpts;
+    const { err, pageConfig = {}, buildManifest, reactLoadableManifest, ErrorDebug, getStaticProps, getStaticPaths, getServerSideProps, isNextDataRequest, params, previewProps, basePath, images, runtime: globalRuntime, isExperimentalCompile, expireTime } = renderOpts;
     const { App } = extra;
-    const assetQueryString = metadata.assetQueryString;
     let Document = extra.Document;
     let Component = renderOpts.Component;
     const OriginComponent = Component;
@@ -239,13 +239,13 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
     // next internal queries should be stripped out
     (0, _internalutils.stripInternalQueries)(query);
     const isSSG = !!getStaticProps;
-    const isBuildTimeSSG = isSSG && renderOpts.nextExport;
+    const isBuildTimeSSG = isSSG && renderOpts.isBuildTimePrerendering;
     const defaultAppGetInitialProps = App.getInitialProps === App.origGetInitialProps;
     const hasPageGetInitialProps = !!(Component == null ? void 0 : Component.getInitialProps);
     const hasPageScripts = Component == null ? void 0 : Component.unstable_scriptLoader;
     const pageIsDynamic = (0, _isdynamic.isDynamicRoute)(pathname);
     const defaultErrorGetInitialProps = pathname === '/_error' && Component.getInitialProps === Component.origGetInitialProps;
-    if (renderOpts.nextExport && hasPageGetInitialProps && !defaultErrorGetInitialProps) {
+    if (renderOpts.isBuildTimePrerendering && hasPageGetInitialProps && !defaultErrorGetInitialProps) {
         warn(`Detected getInitialProps on page '${pathname}'` + ` while running export. It's recommended to use getStaticProps` + ` which has a more correct behavior for static exporting.` + `\nRead more: https://nextjs.org/docs/messages/get-initial-props-export`);
     }
     let isAutoExport = !hasPageGetInitialProps && defaultAppGetInitialProps && !isSSG && !getServerSideProps;
@@ -253,7 +253,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
     // would normally be automatically statically optimized
     // ensure we set cache header so it's not rendered on-demand
     // every request
-    if (isAutoExport && !dev && isExperimentalCompile) {
+    if (isAutoExport && !process.env.__NEXT_DEV_SERVER && isExperimentalCompile) {
         res.setHeader('Cache-Control', (0, _cachecontrol.getCacheControlHeader)({
             revalidate: false,
             expire: expireTime
@@ -310,7 +310,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
         });
     }
     let asPath = renderOpts.resolvedAsPath || req.url;
-    if (dev) {
+    if (process.env.__NEXT_DEV_SERVER) {
         const { isValidElementType } = require('next/dist/compiled/react-is');
         if (!isValidElementType(Component)) {
             throw Object.defineProperty(new Error(`The default export is not a React Component in page: "${pathname}"`), "__NEXT_ERROR_CODE", {
@@ -498,7 +498,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
         }
     };
     let props;
-    const nextExport = !isSSG && (renderOpts.nextExport || dev && (isAutoExport || isFallback));
+    const nextExport = !isSSG && (renderOpts.isBuildTimePrerendering || process.env.__NEXT_DEV_SERVER && (isAutoExport || isFallback));
     const styledJsxInsertedHTML = ()=>{
         const styles = jsxStyleRegistry.styles();
         jsxStyleRegistry.flush();
@@ -611,7 +611,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             }
             metadata.isRedirect = true;
         }
-        if ((dev || isBuildTimeSSG) && !metadata.isNotFound && !(0, _isserializableprops.isSerializableProps)(pathname, 'getStaticProps', data.props)) {
+        if ((process.env.__NEXT_DEV_SERVER || isBuildTimeSSG) && !metadata.isNotFound && !(0, _isserializableprops.isSerializableProps)(pathname, 'getStaticProps', data.props)) {
             // this fn should throw an error instead of ever returning `false`
             throw Object.defineProperty(new Error('invariant: getStaticProps did not return valid props. Please report this.'), "__NEXT_ERROR_CODE", {
                 value: "E129",
@@ -697,7 +697,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
                         const message = `You should not access 'res' after getServerSideProps resolves.` + `\nRead more: https://nextjs.org/docs/messages/gssp-no-mutating-res`;
                         if (deferredContent) {
                             throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-                                value: "E394",
+                                value: "E1028",
                                 enumerable: false,
                                 configurable: true
                             });
@@ -815,7 +815,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             ;
             data.props = await data.props;
         }
-        if ((dev || isBuildTimeSSG) && !(0, _isserializableprops.isSerializableProps)(pathname, 'getServerSideProps', data.props)) {
+        if ((process.env.__NEXT_DEV_SERVER || isBuildTimeSSG) && !(0, _isserializableprops.isSerializableProps)(pathname, 'getServerSideProps', data.props)) {
             // this fn should throw an error instead of ever returning `false`
             throw Object.defineProperty(new Error('invariant: getServerSideProps did not return valid props. Please report this.'), "__NEXT_ERROR_CODE", {
                 value: "E31",
@@ -906,7 +906,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
                         head
                     };
                 }
-                if (dev && (props.router || props.Component)) {
+                if (process.env.__NEXT_DEV_SERVER && (props.router || props.Component)) {
                     throw Object.defineProperty(new Error(`'router' and 'Component' can not be returned in getInitialProps from _app.js https://nextjs.org/docs/messages/cant-override-next-props`), "__NEXT_ERROR_CODE", {
                         value: "E230",
                         enumerable: false,
@@ -932,7 +932,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             if (!docProps || typeof docProps.html !== 'string') {
                 const message = `"${(0, _utils.getDisplayName)(Document)}.getInitialProps()" should resolve to an object with a "html" prop set with a valid html string`;
                 throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-                    value: "E394",
+                    value: "E1039",
                     enumerable: false,
                     configurable: true
                 });
@@ -1054,7 +1054,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             isFallback,
             isExperimentalCompile,
             dynamicIds: dynamicImportsIds.size === 0 ? undefined : Array.from(dynamicImportsIds),
-            err: renderOpts.err ? serializeError(dev, renderOpts.err) : undefined,
+            err: renderOpts.err ? serializeError(!!process.env.__NEXT_DEV_SERVER, renderOpts.err) : undefined,
             gsp: !!getStaticProps ? true : undefined,
             gssp: !!getServerSideProps ? true : undefined,
             customServer: sharedContext.customServer,
@@ -1065,20 +1065,22 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             defaultLocale,
             domainLocales,
             isPreview: isPreview === true ? true : undefined,
-            notFoundSrcPage: notFoundSrcPage && dev ? notFoundSrcPage : undefined
+            notFoundSrcPage: notFoundSrcPage && process.env.__NEXT_DEV_SERVER ? notFoundSrcPage : undefined
         },
         nonce,
         buildManifest: filteredBuildManifest,
         docComponentsRendered,
         dangerousAsPath: router.asPath,
-        isDevelopment: !!dev,
+        isDevelopment: !!process.env.__NEXT_DEV_SERVER,
+        deploymentId: sharedContext.deploymentId,
         dynamicImports: Array.from(dynamicImports),
         dynamicCssManifest: new Set(renderOpts.dynamicCssManifest || []),
         assetPrefix,
         // Only enabled in production as development mode has features relying on HMR (style injection for example)
         unstable_runtimeJS: process.env.NODE_ENV === 'production' ? pageConfig.unstable_runtimeJS : undefined,
         unstable_JsPreload: pageConfig.unstable_JsPreload,
-        assetQueryString,
+        assetQueryString: assetQueryString || '',
+        mutableAssetQueryString: mutableAssetQueryString || '',
         scriptLoader,
         locale,
         disableOptimizedLoading,

package/assets/standalone/node_modules/next/dist/server/request/connection.js

@@ -15,6 +15,7 @@ const _staticgenerationbailout = require("../../client/components/static-generat
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
 const _utils = require("./utils");
 const _stagedrendering = require("../app-render/staged-rendering");
+const _invarianterror = require("../../shared/lib/invariant-error");
 function connection() {
     const callingExpression = 'connection';
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
@@ -72,12 +73,29 @@ function connection() {
                         enumerable: false,
                         configurable: true
                     });
+                case 'generate-static-params':
+                    throw Object.defineProperty(new Error(`Route ${workStore.route} used \`connection()\` inside \`generateStaticParams\`. This is not supported because \`generateStaticParams\` runs at build time without an HTTP request. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
+                        value: "E1125",
+                        enumerable: false,
+                        configurable: true
+                    });
                 case 'prerender':
                 case 'prerender-client':
                 case 'prerender-runtime':
                     // We return a promise that never resolves to allow the prerender to
                     // stall at this point.
                     return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`connection()`');
+                case 'validation-client':
+                    {
+                        // TODO(NAR-789): make this consistent with the actual browser behavior when we change it.
+                        // Until then, erroring is fine.
+                        const exportName = '`connection`';
+                        throw Object.defineProperty(new _invarianterror.InvariantError(`${exportName} must not be used within a Client Component. Next.js should be preventing ${exportName} from being included in Client Components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                            value: "E1063",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
                 case 'prerender-ppr':
                     // We use React's postpone API to interrupt rendering here to create a
                     // dynamic hole
@@ -96,6 +114,8 @@ function connection() {
                             return workUnitStore.asyncApiPromises.connection;
                         }
                         return (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(undefined, workUnitStore, _stagedrendering.RenderStage.Dynamic);
+                    } else if (workUnitStore.asyncApiPromises) {
+                        return workUnitStore.asyncApiPromises.connection;
                     } else {
                         return Promise.resolve(undefined);
                     }
@@ -105,6 +125,8 @@ function connection() {
         }
     }
     // If we end up here, there was no work store or work unit store present.
+    // TODO(NAR-789): connection() is not currently statically prevented from being imported in client components,
+    // so we always error about a missing work unit store.
     (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
 }