@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/server/app-render/create-component-styles-and-scripts.js

@@ -17,16 +17,21 @@ async function createComponentStylesAndScripts({ filePath, getComponent, injecte
     const { componentMod: { createElement } } = ctx;
     const { styles: entryCssFiles, scripts: jsHrefs } = (0, _getcssinlinedlinktags.getLinkAndScriptTags)(filePath, injectedCSS, injectedJS);
     const styles = (0, _rendercssresource.renderCssResource)(entryCssFiles, ctx);
-    const scripts = jsHrefs ? jsHrefs.map((href, index)=>createElement('script', {
+    const scripts = [];
+    let scriptIndex = 0;
+    for (const href of jsHrefs){
+        scripts.push(createElement('script', {
             src: `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(href)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`,
             async: true,
-            key: `script-${index}`
-        })) : null;
+            key: `script-${scriptIndex}`
+        }));
+        scriptIndex++;
+    }
     const Comp = (0, _interopdefault.interopDefault)(await getComponent());
     return [
         Comp,
         styles,
-        scripts
+        scripts.length ? scripts : null
     ];
 }
 

package/dist/node_modules/next/dist/server/app-render/create-component-tree.js

@@ -36,7 +36,6 @@ const _workunitasyncstorageexternal = require("./work-unit-async-storage.externa
 const _varyparams = require("./vary-params");
 const _segment = require("../../shared/lib/segment");
 const _segmentexplorerpath = require("./segment-explorer-path");
-const _stagedrendering = require("./staged-rendering");
 function createComponentTree(props) {
     return (0, _tracer.getTracer)().trace(_constants.NextNodeServerSpan.createComponentTree, {
         spanName: 'build component tree'
@@ -51,7 +50,7 @@ function errorMissingDefaultExport(pagePath, convention) {
     });
 }
 const cacheNodeKey = 'c';
-async function createComponentTreeInternal({ loaderTree: tree, parentParams, parentOptionalCatchAllParamName, parentRuntimePrefetchable, rootLayoutIncluded, injectedCSS, injectedJS, injectedFontPreloadTags, ctx, missingSlots, preloadCallbacks, authInterrupts, MetadataOutlet, prerenderHTTPError }, isRoot) {
+async function createComponentTreeInternal({ loaderTree: tree, parentParams, parentOptionalCatchAllParamName, rootLayoutIncluded, injectedCSS, injectedJS, injectedFontPreloadTags, ctx, missingSlots, preloadCallbacks, authInterrupts, MetadataOutlet }, isRoot) {
     const { renderOpts: { nextConfigOutput, experimental, cacheComponents }, workStore, componentMod: { createElement, Fragment, SegmentViewNode, HTTPAccessFallbackBoundary, LayoutRouter, RenderFromTemplateContext, ClientPageRoot, ClientSegmentRoot, createServerSearchParamsForServerPage, createPrerenderSearchParamsForClientPage, createServerParamsForServerSegment, createPrerenderParamsForClientSegment, serverHooks: { DynamicServerError }, Postpone }, pagePath, getDynamicParamFromSegment, isPrefetch, query } = ctx;
     const { page, conventionPath, segment, modules, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
     const { layout, template, error, loading, 'not-found': notFound, forbidden, unauthorized } = modules;
@@ -111,9 +110,6 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, par
         injectedCSS: injectedCSSWithCurrentLayout,
         injectedJS: injectedJSWithCurrentLayout
     }) : [];
-    const instantConfig = layoutOrPageMod ? layoutOrPageMod.unstable_instant : undefined;
-    const hasRuntimePrefetch = instantConfig && typeof instantConfig === 'object' ? instantConfig.prefetch === 'runtime' : false;
-    const isRuntimePrefetchable = hasRuntimePrefetch || parentRuntimePrefetchable;
     const [Forbidden, forbiddenStyles] = authInterrupts && forbidden ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
         ctx,
         filePath: forbidden[1],
@@ -382,39 +378,11 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, par
                     missingSlots.add(parallelRouteKey);
                 }
             }
-            // The outer prerender catch already found the deepest segment whose
-            // HTTP fallback should replace the throwing page. When we reach that
-            // segment's `children` slot, render the fallback directly instead of
-            // descending back into the subtree that threw during deserialization.
-            // Like the other segment-level boundary props below, HTTP access
-            // fallbacks are attached to the default `children` slot, not to named
-            // parallel routes.
-            const shouldRenderPrerenderHTTPFallback = (prerenderHTTPError == null ? void 0 : prerenderHTTPError.boundaryTree) === tree && isChildrenRouteKey;
-            if (shouldRenderPrerenderHTTPFallback) {
-                let fallbackElement;
-                switch(prerenderHTTPError.triggeredStatus){
-                    case 404:
-                        fallbackElement = notFoundElement;
-                        break;
-                    case 403:
-                        fallbackElement = forbiddenElement;
-                        break;
-                    case 401:
-                        fallbackElement = unauthorizedElement;
-                        break;
-                    default:
-                        break;
-                }
-                if (fallbackElement) {
-                    childCacheNodeSeedData = createSeedData(ctx, fallbackElement, {}, null, isPossiblyPartialResponse, false, _varyparams.emptyVaryParamsAccumulator);
-                }
-            }
             if (childCacheNodeSeedData === null) {
                 const seedData = await createComponentTreeInternal({
                     loaderTree: parallelRoute,
                     parentParams: currentParams,
                     parentOptionalCatchAllParamName: optionalCatchAllParamName,
-                    parentRuntimePrefetchable: isRuntimePrefetchable,
                     rootLayoutIncluded: rootLayoutIncludedAtThisLevelOrAbove,
                     injectedCSS: injectedCSSWithCurrentLayout,
                     injectedJS: injectedJSWithCurrentLayout,
@@ -425,8 +393,7 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, par
                     authInterrupts,
                     // `StreamingMetadataOutlet` is used to conditionally throw. In the case of parallel routes we will have more than one page
                     // but we only want to throw on the first one.
-                    MetadataOutlet: isChildrenRouteKey ? MetadataOutlet : null,
-                    prerenderHTTPError
+                    MetadataOutlet: isChildrenRouteKey ? MetadataOutlet : null
                 }, false);
                 childCacheNodeSeedData = seedData;
             }
@@ -510,7 +477,7 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, par
     if (!MaybeComponent) {
         return createSeedData(ctx, createElement(Fragment, {
             key: cacheNodeKey
-        }, layerAssets, parallelRouteProps.children), parallelRouteCacheNodeSeedData, loadingData, isPossiblyPartialResponse, isRuntimePrefetchable, // No user-provided component, so no params will be accessed. Use the
+        }, layerAssets, parallelRouteProps.children), parallelRouteCacheNodeSeedData, loadingData, isPossiblyPartialResponse, // No user-provided component, so no params will be accessed. Use the
         // pre-resolved empty tracker.
         _varyparams.emptyVaryParamsAccumulator);
     }
@@ -532,7 +499,7 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, par
         }, createElement(Postpone, {
             reason: 'dynamic = "force-dynamic" was used',
             route: workStore.route
-        }), layerAssets), parallelRouteCacheNodeSeedData, loadingData, true, isRuntimePrefetchable, // force-dynamic postpones without rendering the component, so no params
+        }), layerAssets), parallelRouteCacheNodeSeedData, loadingData, true, // force-dynamic postpones without rendering the component, so no params
         // are accessed. The vary params are empty.
         _varyparams.emptyVaryParamsAccumulator);
     }
@@ -581,11 +548,11 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, par
         } else {
             // If we are passing params to a server component Page we need to track
             // their usage in case the current render mode tracks dynamic API usage.
-            const params = createServerParamsForServerSegment(currentParams, optionalCatchAllParamName, varyParamsAccumulator, isRuntimePrefetchable);
+            const params = createServerParamsForServerSegment(currentParams, optionalCatchAllParamName, varyParamsAccumulator);
             // If we are passing searchParams to a server component Page we need to
             // track their usage in case the current render mode tracks dynamic API
             // usage.
-            let searchParams = createServerSearchParamsForServerPage(query, varyParamsAccumulator, isRuntimePrefetchable);
+            let searchParams = createServerSearchParamsForServerPage(query, varyParamsAccumulator);
             if ((0, _clientandserverreferences.isUseCacheFunction)(PageComponent)) {
                 const UseCachePageComponent = PageComponent;
                 pageElement = createElement(UseCachePageComponent, {
@@ -610,7 +577,7 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, par
         }, pageElement) : pageElement;
         return createSeedData(ctx, createElement(Fragment, {
             key: cacheNodeKey
-        }, wrappedPageElement, layerAssets, MetadataOutlet ? createElement(MetadataOutlet, null) : null), parallelRouteCacheNodeSeedData, loadingData, isPossiblyPartialResponse, isRuntimePrefetchable, varyParamsAccumulator);
+        }, wrappedPageElement, layerAssets, MetadataOutlet ? createElement(MetadataOutlet, null) : null), parallelRouteCacheNodeSeedData, loadingData, isPossiblyPartialResponse, varyParamsAccumulator);
     } else {
         const SegmentComponent = Component;
         const isRootLayoutWithChildrenSlotAndAtLeastOneMoreSlot = rootLayoutAtThisLevel && 'children' in parallelRoutes && Object.keys(parallelRoutes).length > 1;
@@ -700,7 +667,7 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, par
                 }, layerAssets, clientSegment);
             }
         } else {
-            const params = createServerParamsForServerSegment(currentParams, optionalCatchAllParamName, varyParamsAccumulator, isRuntimePrefetchable);
+            const params = createServerParamsForServerSegment(currentParams, optionalCatchAllParamName, varyParamsAccumulator);
             let serverSegment;
             if ((0, _clientandserverreferences.isUseCacheFunction)(SegmentComponent)) {
                 const UseCacheLayoutComponent = SegmentComponent;
@@ -744,7 +711,7 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, par
             pagePath: layoutFilePath
         }, segmentNode) : segmentNode;
         // For layouts we just render the component
-        return createSeedData(ctx, wrappedSegmentNode, parallelRouteCacheNodeSeedData, loadingData, isPossiblyPartialResponse, isRuntimePrefetchable, varyParamsAccumulator);
+        return createSeedData(ctx, wrappedSegmentNode, parallelRouteCacheNodeSeedData, loadingData, isPossiblyPartialResponse, varyParamsAccumulator);
     }
 }
 function createErrorBoundaryClientSegmentRoot({ ctx, ErrorBoundaryComponent, errorElement, ClientSegmentRoot, layerAssets, SegmentComponent, currentParams }) {
@@ -811,41 +778,8 @@ async function createBoundaryConventionElement({ ctx, conventionName, Component,
         pagePath
     ];
 }
-function createSeedData(ctx, rsc, parallelRoutes, loading, isPossiblyPartialResponse, isRuntimePrefetchable, varyParamsAccumulator) {
+function createSeedData(ctx, rsc, parallelRoutes, loading, isPossiblyPartialResponse, varyParamsAccumulator) {
     const createElement = ctx.componentMod.createElement;
-    // When this segment is NOT runtime-prefetchable, delay it until the Static
-    // stage by wrapping the node in a promise. This allows runtime-prefetchable
-    // segments (the lower tree) to render first during EarlyStatic, so their
-    // runtime data resolves in EarlyRuntime where sync IO can be checked.
-    // React will suspend on the thenable and resume when the stage advances.
-    if (!isRuntimePrefetchable) {
-        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-        if (workUnitStore) {
-            let stagedRendering;
-            switch(workUnitStore.type){
-                case 'request':
-                case 'prerender-runtime':
-                    stagedRendering = workUnitStore.stagedRendering;
-                    if (stagedRendering) {
-                        const deferredRsc = rsc;
-                        rsc = stagedRendering.waitForStage(_stagedrendering.RenderStage.Static).then(()=>deferredRsc);
-                    }
-                    break;
-                case 'prerender':
-                case 'prerender-client':
-                case 'validation-client':
-                case 'prerender-ppr':
-                case 'prerender-legacy':
-                case 'cache':
-                case 'private-cache':
-                case 'unstable-cache':
-                case 'generate-static-params':
-                    break;
-                default:
-                    workUnitStore;
-            }
-        }
-    }
     if (loading !== null) {
         // If a loading.tsx boundary is present, wrap the component data in an
         // additional context provider to pass the loading data to the next
@@ -863,7 +797,9 @@ function createSeedData(ctx, rsc, parallelRoutes, loading, isPossiblyPartialResp
         parallelRoutes,
         null,
         isPossiblyPartialResponse,
-        varyParamsAccumulator ? (0, _varyparams.getVaryParamsThenable)(varyParamsAccumulator) : null
+        // The accumulator is itself the AsyncIterable<string> that Flight
+        // serializes into the segment's seed data.
+        varyParamsAccumulator
     ];
 }
 

package/dist/node_modules/next/dist/server/app-render/create-error-handler.js

@@ -63,10 +63,6 @@ function getDigestForWellKnownError(error) {
 function createReactServerErrorHandler(shouldFormatError, isBuildTimePrerendering, reactServerErrors, onReactServerRenderError, spanToRecordOn) {
     return (thrownValue)=>{
         var _err_message;
-        if (typeof thrownValue === 'string') {
-            // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
-            return (0, _stringhash.default)(thrownValue).toString();
-        }
         // If the response was closed, we don't need to log the error.
         if ((0, _pipereadable.isAbortError)(thrownValue)) return;
         const digest = getDigestForWellKnownError(thrownValue);
@@ -83,22 +79,27 @@ function createReactServerErrorHandler(shouldFormatError, isBuildTimePrerenderin
         // If the error already has a digest, respect the original digest,
         // so it won't get re-generated into another new error.
         if (err.digest) {
-            if (process.env.NODE_ENV === 'production' && reactServerErrors.has(err.digest)) {
-                // This error is likely an obfuscated error from another react-server
-                // environment (e.g. 'use cache'). We recover the original error here
-                // for reporting purposes.
-                err = reactServerErrors.get(err.digest);
-                // We don't log it again though, as it was already logged in the
-                // original environment.
-                silenceLog = true;
-            } else {
-            // Either we're in development (where we want to keep the transported
-            // error with environmentName), or the error is not in reactServerErrors
-            // but has a digest from other means. Keep the error as-is.
+            const originalError = reactServerErrors.get(err.digest);
+            if (originalError) {
+                // This error crossed a react-server boundary (e.g. from a `'use cache'`
+                // render). Reaching the handler means it surfaced (it wasn't caught in
+                // userland), so stamp the digest onto the original to mark it surfaced.
+                // If the original was recorded as `invalidDynamicUsageError` without a
+                // digest (a cache that aborted across the boundary), this is what lets
+                // the dev overlay dedup: the separate forwarding checks for that digest
+                // and skips it.
+                originalError.digest ??= err.digest;
+                if (process.env.NODE_ENV === 'production') {
+                    // In production we use the recovered original (de-obfuscated!) error
+                    // for reporting, and don't log it again as it was already logged in
+                    // the original environment.
+                    err = originalError;
+                    silenceLog = true;
+                }
             }
         } else {
-            err.digest = (0, _errortelemetryutils.createDigestWithErrorCode)(err, // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
-            (0, _stringhash.default)(err.message + (err.stack || '')).toString());
+            // TODO-APP: look at using webcrypto instead of string-hash. Requires a promise to be awaited.
+            err.digest = typeof thrownValue === 'string' ? (0, _stringhash.default)(thrownValue).toString() : (0, _errortelemetryutils.createDigestWithErrorCode)(err, (0, _stringhash.default)(err.message + (err.stack || '')).toString());
         }
         // @TODO by putting this here and not at the top it is possible that
         // we don't error the build in places we actually expect to

package/dist/node_modules/next/dist/server/app-render/create-flight-router-state-from-loader-tree.js

@@ -22,7 +22,7 @@ _export(exports, {
 });
 const _approutertypes = require("../../shared/lib/app-router-types");
 const _segment = require("../../shared/lib/segment");
-async function createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, getDynamicParamFromSegment, searchParams, didFindRootLayout) {
+async function createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment, searchParams, didFindRootLayout) {
     const [segment, parallelRoutes, { layout, loading, page }] = loaderTree;
     const dynamicParam = getDynamicParamFromSegment(loaderTree);
     const treeSegment = dynamicParam ? dynamicParam.treeSegment : segment;
@@ -30,9 +30,13 @@ async function createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, g
         (0, _segment.addSearchParamsIfPageSegment)(treeSegment, searchParams),
         {}
     ];
-    // Load the layout or page module to check for unstable_instant config
+    // Load the layout or page module to check its instant and prefetch
+    // configs. When a segment doesn't export prefetch, it defaults to
+    // 'partial' if the app has opted into partial prefetching globally via the
+    // `partialPrefetching` config in next.config.js.
     const mod = layout ? await layout[0]() : page ? await page[0]() : undefined;
-    const instantConfig = mod ? mod.unstable_instant : undefined;
+    const instantConfig = mod ? mod.instant : undefined;
+    const prefetchConfig = (mod ? mod.prefetch : undefined) ?? (partialPrefetching === 'unstable_eager' ? 'unstable_eager' : partialPrefetching ? 'partial' : undefined);
     let prefetchHints = 0;
     // Union in the precomputed build-time hints (e.g. segment inlining
     // decisions) if available. When hints are not available (e.g. dev mode or
@@ -40,24 +44,75 @@ async function createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, g
     // compute the other hints below. In the future this should be a build
     // error, but for now we gracefully degrade.
     //
-    // TODO: Move more of the hints computation (IsRootLayout, instant config,
+    // TODO: Move more of the hints computation (IsRootLayoutOrAbove, instant config,
     // loading boundary detection) into the build-time measurement step in
     // collectPrefetchHints, so this function only needs to union the
     // precomputed bitmask rather than re-derive hints on every render.
     if (hintTree !== null) {
         prefetchHints |= hintTree.hints;
+    } else if (prefetchInliningEnabled) {
+        if (isBuildTimePrerendering) {
+            // Prefetch inlining is enabled but no hint tree was provided during a
+            // build-time prerender. This happens for the initial RSC payload
+            // generated before collectPrefetchHints has run. Mark so the client
+            // can expire the route cache entry and re-fetch the tree with correct
+            // hints.
+            prefetchHints |= _approutertypes.PrefetchHint.InliningHintsStale;
+        } else if (isStaticGeneration) {
+            // TODO(#91407): Temporary mitigation: when hints are missing during
+            // runtime static generation, fall back to treating every segment as
+            // unprefetchable. This currently happens for routes with
+            // `instant = false` at the root segment, which causes the prerender
+            // to run per-request instead of being cached, and the prefetch hints
+            // manifest is not available.
+            //
+            // Once that bug is fixed, this branch should become an error again —
+            // hints should always be available from the manifest during ISR.
+            prefetchHints |= _approutertypes.PrefetchHint.PrefetchDisabled;
+        } else if (cacheComponents) {
+            // At runtime with no hint tree, this is a fully dynamic route with no
+            // manifest entry. Treat every segment as unprefetchable. Do NOT set
+            // InliningHintsStale — that would cause the client to enter an
+            // infinite re-fetch loop trying to get hints that will never exist.
+            prefetchHints |= _approutertypes.PrefetchHint.PrefetchDisabled;
+        } else {
+        // Without cacheComponents, dynamic pages have no static shell so
+        // hints are never computed. Don't disable prefetching — just skip
+        // the inlining hint system and let prefetching proceed normally.
+        }
     }
-    // Mark the first segment that has a layout as the "root" layout
-    if (!didFindRootLayout && typeof layout !== 'undefined') {
-        didFindRootLayout = true;
-        prefetchHints |= _approutertypes.PrefetchHint.IsRootLayout;
-    }
-    if (instantConfig && typeof instantConfig === 'object') {
-        prefetchHints |= _approutertypes.PrefetchHint.SubtreeHasInstant;
-        if (instantConfig.prefetch === 'runtime') {
-            prefetchHints |= _approutertypes.PrefetchHint.HasRuntimePrefetch;
+    // Mark every segment at or above the root layout (i.e. until we descend past
+    // the first segment that has a layout).
+    if (!didFindRootLayout) {
+        prefetchHints |= _approutertypes.PrefetchHint.IsRootLayoutOrAbove;
+        if (typeof layout !== 'undefined') {
+            // This segment is the root layout; its descendants are below it.
+            didFindRootLayout = true;
         }
     }
+    if (instantConfig === false) {
+        // The segment explicitly opts out of Partial Prefetching. We don't change
+        // the prefetch behavior, but we record it so the dev-time
+        // `<Link prefetch={true}>` warning can be suppressed for this route.
+        prefetchHints |= _approutertypes.PrefetchHint.SubtreeHasInstantFalse;
+    }
+    if (prefetchConfig === 'partial') {
+        prefetchHints |= _approutertypes.PrefetchHint.SubtreeHasPartialPrefetching;
+    } else if (prefetchConfig === 'unstable_eager') {
+        // Like 'partial' (uses the PPR fetch strategy) but also marks the segment
+        // as eager, so App Shells keeps prefetching it instead of relying on the
+        // shared app shell.
+        prefetchHints |= _approutertypes.PrefetchHint.SubtreeHasPartialPrefetching | _approutertypes.PrefetchHint.SubtreeHasEagerPrefetch;
+    } else if (prefetchConfig === 'force-disabled') {
+        prefetchHints |= _approutertypes.PrefetchHint.PrefetchDisabled;
+    }
+    // Mark the segment as "eager" unless its effective prefetch strategy is
+    // 'partial'. 'unstable_eager' already set the bit above. Under App Shells,
+    // a subtree with no eager segment skips its Speculative prefetch and relies
+    // on the shared app shell instead.
+    if (prefetchConfig !== 'partial') {
+        prefetchHints |= _approutertypes.PrefetchHint.SubtreeHasEagerPrefetch;
+    }
     // Check if this segment has a loading boundary
     if (loading) {
         prefetchHints |= _approutertypes.PrefetchHint.SegmentHasLoadingBoundary;
@@ -68,15 +123,10 @@ async function createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, g
         // Look up the child hint node by parallel route key, traversing the
         // hint tree in parallel with the loader tree.
         const childHintNode = (hintTree == null ? void 0 : (_hintTree_slots = hintTree.slots) == null ? void 0 : _hintTree_slots[parallelRouteKey]) ?? null;
-        const child = await createFlightRouterStateFromLoaderTreeImpl(parallelRoutes[parallelRouteKey], childHintNode, getDynamicParamFromSegment, searchParams, didFindRootLayout);
+        const child = await createFlightRouterStateFromLoaderTreeImpl(parallelRoutes[parallelRouteKey], childHintNode, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment, searchParams, didFindRootLayout);
         // Propagate subtree flags from children
         if (child[4] !== undefined) {
-            prefetchHints |= child[4] & (_approutertypes.PrefetchHint.SubtreeHasInstant | _approutertypes.PrefetchHint.SubtreeHasLoadingBoundary);
-            // If a child has a loading boundary (either directly or in its subtree),
-            // propagate that as SubtreeHasLoadingBoundary to this segment.
-            if (child[4] & (_approutertypes.PrefetchHint.SegmentHasLoadingBoundary | _approutertypes.PrefetchHint.SubtreeHasLoadingBoundary)) {
-                prefetchHints |= _approutertypes.PrefetchHint.SubtreeHasLoadingBoundary;
-            }
+            prefetchHints = (0, _approutertypes.propagateSubtreeBits)(prefetchHints, child[4]);
         }
         children[parallelRouteKey] = child;
     }
@@ -86,17 +136,19 @@ async function createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, g
     }
     return segmentTree;
 }
-async function createFlightRouterStateFromLoaderTree(loaderTree, hintTree, getDynamicParamFromSegment, searchParams) {
-    const didFindRootLayout = false;
-    return createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, getDynamicParamFromSegment, searchParams, didFindRootLayout);
+async function createFlightRouterStateFromLoaderTree(loaderTree, hintTree, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment, searchParams, // Whether a root layout was already found above this loader tree slice, so a
+// slice that starts below the root layout doesn't mark a sub-layout as the
+// root layout.
+didFindRootLayout = false) {
+    return createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment, searchParams, didFindRootLayout);
 }
-async function createRouteTreePrefetch(loaderTree, hintTree, getDynamicParamFromSegment) {
+async function createRouteTreePrefetch(loaderTree, hintTree, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment, // See note on createFlightRouterStateFromLoaderTree's didFindRootLayout.
+didFindRootLayout = false) {
     // Search params should not be added to page segment's cache key during a
     // route tree prefetch request, because they do not affect the structure of
     // the route. The client cache has its own logic to handle search params.
     const searchParams = {};
-    const didFindRootLayout = false;
-    return createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, getDynamicParamFromSegment, searchParams, didFindRootLayout);
+    return createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, prefetchInliningEnabled, cacheComponents, partialPrefetching, isStaticGeneration, isBuildTimePrerendering, getDynamicParamFromSegment, searchParams, didFindRootLayout);
 }
 
 //# sourceMappingURL=create-flight-router-state-from-loader-tree.js.map

package/dist/node_modules/next/dist/server/app-render/debug-channel-server.js

@@ -1,15 +1,15 @@
 /**
  * Compile-time switcher for debug channel operations.
  *
- * Simple re-export from the web implementation.
- * A future change will add a conditional branch for node streams.
+ * When __NEXT_USE_NODE_STREAMS is true, uses a Node PassThrough-based channel.
+ * Otherwise, uses web WritableStream APIs.
  */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    createDebugChannel: null,
-    toNodeDebugChannel: null
+    createNodeDebugChannel: null,
+    createWebDebugChannel: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -18,13 +18,30 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    createDebugChannel: function() {
-        return _debugchannelserverweb.createDebugChannel;
+    createNodeDebugChannel: function() {
+        return createNodeDebugChannel;
     },
-    toNodeDebugChannel: function() {
-        return _debugchannelserverweb.toNodeDebugChannel;
+    createWebDebugChannel: function() {
+        return createWebDebugChannel;
     }
 });
-const _debugchannelserverweb = require("./debug-channel-server.web");
+let _m;
+if (process.env.__NEXT_USE_NODE_STREAMS) {
+    _m = require('./debug-channel-server.node');
+} else {
+    _m = require('./debug-channel-server.web');
+}
+function createWebDebugChannel() {
+    if (process.env.NODE_ENV === 'production') {
+        return undefined;
+    }
+    return _m.createWebDebugChannel();
+}
+function createNodeDebugChannel() {
+    if (process.env.NODE_ENV === 'production') {
+        return undefined;
+    }
+    return _m.createNodeDebugChannel();
+}
 
 //# sourceMappingURL=debug-channel-server.js.map

package/dist/node_modules/next/dist/server/app-render/debug-channel-server.node.js

@@ -0,0 +1,60 @@
+/**
+ * Node debug channel implementation.
+ * Loaded by debug-channel-server.ts when __NEXT_USE_NODE_STREAMS is enabled.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createNodeDebugChannel: null,
+    createWebDebugChannel: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createNodeDebugChannel: function() {
+        return createNodeDebugChannel;
+    },
+    createWebDebugChannel: function() {
+        return _debugchannelserverweb.createWebDebugChannel;
+    }
+});
+const _nodestream = require("node:stream");
+const _debugchannelserverweb = require("./debug-channel-server.web");
+function createNodeDebugChannel() {
+    // The readable side is a PassThrough that the client reads from. The
+    // server-side write target is a separate, write-only Writable that forwards
+    // into it rather than the PassThrough itself: React's renderToPipeableStream
+    // detects `.read()` on the debug channel and would enter bidirectional mode,
+    // reading its own output back as commands.
+    //
+    // The forwarding must use `passthrough.write()` / `passthrough.end()`, not
+    // `passthrough.push()` / `passthrough.push(null)`. A PassThrough is a Duplex;
+    // pushing `null` ends only its readable half and leaves the writable half
+    // open (`writableEnded` stays false). If the readable is consumed via
+    // `Readable.toWeb()`, that web stream never closes while the PassThrough's
+    // writable half is still open — so the debug channel would never close on the
+    // client. Ending it via `passthrough.end()` closes both halves and the close
+    // propagates.
+    const passthrough = new _nodestream.PassThrough();
+    const writable = new _nodestream.Writable({
+        write (chunk, encoding, callback) {
+            passthrough.write(chunk, encoding, callback);
+        },
+        final (callback) {
+            passthrough.end(callback);
+        }
+    });
+    return {
+        serverSide: writable,
+        clientSide: {
+            readable: passthrough
+        }
+    };
+}
+
+//# sourceMappingURL=debug-channel-server.node.js.map

package/dist/node_modules/next/dist/server/app-render/debug-channel-server.web.js

@@ -1,15 +1,13 @@
 /**
  * Web debug channel implementation.
  * Loaded by debug-channel-server.ts.
- */ // Types defined inline for now; will move to debug-channel-server.node.ts later.
-"use strict";
+ */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    createDebugChannel: null,
-    createWebDebugChannel: null,
-    toNodeDebugChannel: null
+    createNodeDebugChannel: null,
+    createWebDebugChannel: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -18,22 +16,13 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    createDebugChannel: function() {
-        return createDebugChannel;
+    createNodeDebugChannel: function() {
+        return createNodeDebugChannel;
     },
     createWebDebugChannel: function() {
         return createWebDebugChannel;
-    },
-    toNodeDebugChannel: function() {
-        return toNodeDebugChannel;
     }
 });
-function createDebugChannel() {
-    if (process.env.NODE_ENV === 'production') {
-        return undefined;
-    }
-    return createWebDebugChannel();
-}
 function createWebDebugChannel() {
     let readableController;
     const clientSideReadable = new ReadableStream({
@@ -60,9 +49,9 @@ function createWebDebugChannel() {
         }
     };
 }
-function toNodeDebugChannel(_webDebugChannel) {
-    throw Object.defineProperty(new Error('toNodeDebugChannel cannot be used in edge/web runtime, this is a bug in the Next.js codebase'), "__NEXT_ERROR_CODE", {
-        value: "E1071",
+function createNodeDebugChannel() {
+    throw Object.defineProperty(new Error('not implemented'), "__NEXT_ERROR_CODE", {
+        value: "E1154",
         enumerable: false,
         configurable: true
     });

package/dist/node_modules/next/dist/server/app-render/dev-validation-error-delivery.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "serializeValidationErrorsToFlight", {
+    enumerable: true,
+    get: function() {
+        return serializeValidationErrorsToFlight;
+    }
+});
+const _streamops = require("./stream-ops");
+const _manifestssingleton = require("./manifests-singleton");
+const _errortelemetryutils = require("../../lib/error-telemetry-utils");
+const filterStackFrame = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').filterStackFrameDEV : undefined;
+async function serializeValidationErrorsToFlight(componentMod, errors) {
+    const errorCodes = new Map();
+    for (const err of errors){
+        const code = (0, _errortelemetryutils.extractNextErrorCode)(err);
+        if (code !== undefined) {
+            errorCodes.set(err, code);
+        }
+    }
+    const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
+    const stream = (0, _streamops.renderToNodeFlightStream)(componentMod, {
+        errors,
+        errorCodes
+    }, clientModules, {
+        filterStackFrame
+    });
+    const chunks = [];
+    for await (const chunk of stream){
+        chunks.push(chunk);
+    }
+    return chunks;
+}
+
+//# sourceMappingURL=dev-validation-error-delivery.js.map