@semiont/frontend 0.3.2 → 0.3.4

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

@@ -33,8 +33,10 @@ const _tracer = require("../lib/trace/tracer");
 const _constants = require("../lib/trace/constants");
 const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
 const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
+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'
@@ -49,7 +51,7 @@ function errorMissingDefaultExport(pagePath, convention) {
     });
 }
 const cacheNodeKey = 'c';
-async function createComponentTreeInternal({ loaderTree: tree, parentParams, rootLayoutIncluded, injectedCSS, injectedJS, injectedFontPreloadTags, ctx, missingSlots, preloadCallbacks, authInterrupts, MetadataOutlet }, isRoot) {
+async function createComponentTreeInternal({ loaderTree: tree, parentParams, parentOptionalCatchAllParamName, parentRuntimePrefetchable, 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;
@@ -109,8 +111,9 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
         injectedCSS: injectedCSSWithCurrentLayout,
         injectedJS: injectedJSWithCurrentLayout
     }) : [];
-    const prefetchConfig = layoutOrPageMod ? layoutOrPageMod.unstable_prefetch : undefined;
-    /** Whether this segment should use a runtime prefetch instead of a static prefetch. */ const hasRuntimePrefetch = (prefetchConfig == null ? void 0 : prefetchConfig.mode) === 'runtime';
+    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],
@@ -189,7 +192,9 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
                 case 'cache':
                 case 'private-cache':
                 case 'prerender-client':
+                case 'validation-client':
                 case 'unstable-cache':
+                case 'generate-static-params':
                     break;
                 default:
                     workUnitStore;
@@ -201,12 +206,46 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
             const dynamicUsageDescription = `revalidate: 0 configured ${segment}`;
             workStore.dynamicUsageDescription = dynamicUsageDescription;
             throw Object.defineProperty(new DynamicServerError(dynamicUsageDescription), "__NEXT_ERROR_CODE", {
-                value: "E394",
+                value: "E1005",
                 enumerable: false,
                 configurable: true
             });
         }
     }
+    // Read unstable_dynamicStaleTime from page modules (not layouts) and track it on
+    // the store's stale field. This affects the segment cache stale time via
+    // the StaleTimeIterable.
+    if (isPage && typeof (layoutOrPageMod == null ? void 0 : layoutOrPageMod.unstable_dynamicStaleTime) === 'number') {
+        const pageStaleTime = layoutOrPageMod.unstable_dynamicStaleTime;
+        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+        if (workUnitStore) {
+            switch(workUnitStore.type){
+                case 'prerender':
+                case 'prerender-runtime':
+                case 'prerender-legacy':
+                case 'prerender-ppr':
+                    if (workUnitStore.stale > pageStaleTime) {
+                        workUnitStore.stale = pageStaleTime;
+                    }
+                    break;
+                case 'request':
+                    if (workUnitStore.stale === undefined || workUnitStore.stale > pageStaleTime) {
+                        workUnitStore.stale = pageStaleTime;
+                    }
+                    break;
+                // createComponentTree is not called for these stores:
+                case 'cache':
+                case 'private-cache':
+                case 'prerender-client':
+                case 'validation-client':
+                case 'unstable-cache':
+                case 'generate-static-params':
+                    break;
+                default:
+                    workUnitStore;
+            }
+        }
+    }
     const isStaticGeneration = workStore.isStaticGeneration;
     // Assume the segment we're rendering contains only partial data if PPR is
     // enabled and this is a statically generated response. This is used by the
@@ -248,7 +287,7 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
         }
     }
     // Handle dynamic segment params.
-    const segmentParam = getDynamicParamFromSegment(segment);
+    const segmentParam = getDynamicParamFromSegment(tree);
     // Create object holding the parent params and current params
     let currentParams = parentParams;
     if (segmentParam && segmentParam.value !== null) {
@@ -257,8 +296,16 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
             [segmentParam.param]: segmentParam.value
         };
     }
+    // Track optional catch-all params with no value (e.g., [[...slug]] at /).
+    // These params won't exist as properties on the params object, so vary
+    // params tracking needs to use a Proxy to detect access. We propagate this
+    // through the tree so that child segments (like __PAGE__) also know about
+    // the missing param. In practice, this only gets passed down one level —
+    // from the optional catch-all layout segment to the page segment — so it's
+    // always very close to the leaf of the tree.
+    const optionalCatchAllParamName = (segmentParam == null ? void 0 : segmentParam.type) === 'oc' && segmentParam.value === null ? segmentParam.param : parentOptionalCatchAllParamName;
     // Resolve the segment param
-    const isSegmentViewEnabled = !!ctx.renderOpts.dev;
+    const isSegmentViewEnabled = !!process.env.__NEXT_DEV_SERVER;
     const dir = (process.env.NEXT_RUNTIME === 'edge' ? process.env.__NEXT_EDGE_PROJECT_DIR : ctx.renderOpts.dir) || '';
     const [notFoundElement, notFoundFilePath] = await createBoundaryConventionElement({
         ctx,
@@ -338,6 +385,8 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
             const seedData = await createComponentTreeInternal({
                 loaderTree: parallelRoute,
                 parentParams: currentParams,
+                parentOptionalCatchAllParamName: optionalCatchAllParamName,
+                parentRuntimePrefetchable: isRuntimePrefetchable,
                 rootLayoutIncluded: rootLayoutIncludedAtThisLevelOrAbove,
                 injectedCSS: injectedCSSWithCurrentLayout,
                 injectedJS: injectedJSWithCurrentLayout,
@@ -429,15 +478,11 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
     ] : null;
     // When the segment does not have a layout or page we still have to add the layout router to ensure the path holds the loading component
     if (!MaybeComponent) {
-        return [
-            createElement(Fragment, {
-                key: cacheNodeKey
-            }, layerAssets, parallelRouteProps.children),
-            parallelRouteCacheNodeSeedData,
-            loadingData,
-            isPossiblyPartialResponse,
-            hasRuntimePrefetch
-        ];
+        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
+        // pre-resolved empty tracker.
+        _varyparams.emptyVaryParamsAccumulator);
     }
     const Component = MaybeComponent;
     // If force-dynamic is used and the current render supports postponing, we
@@ -452,20 +497,18 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
     // render force-dynamic. We should refactor this function so that we can correctly track which segments
     // need to be dynamic
     if (workStore.isStaticGeneration && workStore.forceDynamic && experimental.isRoutePPREnabled) {
-        return [
-            createElement(Fragment, {
-                key: cacheNodeKey
-            }, createElement(Postpone, {
-                reason: 'dynamic = "force-dynamic" was used',
-                route: workStore.route
-            }), layerAssets),
-            parallelRouteCacheNodeSeedData,
-            loadingData,
-            true,
-            hasRuntimePrefetch
-        ];
+        return createSeedData(ctx, createElement(Fragment, {
+            key: cacheNodeKey
+        }, 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
+        // are accessed. The vary params are empty.
+        _varyparams.emptyVaryParamsAccumulator);
     }
     const isClientComponent = (0, _clientandserverreferences.isClientReference)(layoutOrPageMod);
+    const varyParamsAccumulator = isClientComponent && cacheComponents ? // from the server, so they have an empty vary params set.
+    _varyparams.emptyVaryParamsAccumulator : (0, _varyparams.createVaryParamsAccumulator)();
     if (process.env.NODE_ENV === 'development' && 'params' in parallelRouteProps) {
         // @TODO consider making this an error and running the check in build as well
         console.error(`"params" is a reserved prop in Layouts and Pages and cannot be used as the name of a parallel route in ${segment}`);
@@ -483,7 +526,7 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
                 });
             } else if (isStaticGeneration) {
                 const promiseOfParams = createPrerenderParamsForClientSegment(currentParams);
-                const promiseOfSearchParams = createPrerenderSearchParamsForClientPage(workStore);
+                const promiseOfSearchParams = createPrerenderSearchParamsForClientPage();
                 pageElement = createElement(ClientPageRoot, {
                     Component: PageComponent,
                     serverProvidedParams: {
@@ -508,11 +551,11 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
         } 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, workStore);
+            const params = createServerParamsForServerSegment(currentParams, optionalCatchAllParamName, varyParamsAccumulator, isRuntimePrefetchable);
             // 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, workStore);
+            let searchParams = createServerSearchParamsForServerPage(query, varyParamsAccumulator, isRuntimePrefetchable);
             if ((0, _clientandserverreferences.isUseCacheFunction)(PageComponent)) {
                 const UseCachePageComponent = PageComponent;
                 pageElement = createElement(UseCachePageComponent, {
@@ -535,15 +578,9 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
             type: segmentType,
             pagePath: pageFilePath
         }, pageElement) : pageElement;
-        return [
-            createElement(Fragment, {
-                key: cacheNodeKey
-            }, wrappedPageElement, layerAssets, MetadataOutlet ? createElement(MetadataOutlet, null) : null),
-            parallelRouteCacheNodeSeedData,
-            loadingData,
-            isPossiblyPartialResponse,
-            hasRuntimePrefetch
-        ];
+        return createSeedData(ctx, createElement(Fragment, {
+            key: cacheNodeKey
+        }, wrappedPageElement, layerAssets, MetadataOutlet ? createElement(MetadataOutlet, null) : null), parallelRouteCacheNodeSeedData, loadingData, isPossiblyPartialResponse, isRuntimePrefetchable, varyParamsAccumulator);
     } else {
         const SegmentComponent = Component;
         const isRootLayoutWithChildrenSlotAndAtLeastOneMoreSlot = rootLayoutAtThisLevel && 'children' in parallelRoutes && Object.keys(parallelRoutes).length > 1;
@@ -633,7 +670,7 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
                 }, layerAssets, clientSegment);
             }
         } else {
-            const params = createServerParamsForServerSegment(currentParams, workStore);
+            const params = createServerParamsForServerSegment(currentParams, optionalCatchAllParamName, varyParamsAccumulator, isRuntimePrefetchable);
             let serverSegment;
             if ((0, _clientandserverreferences.isUseCacheFunction)(SegmentComponent)) {
                 const UseCacheLayoutComponent = SegmentComponent;
@@ -677,13 +714,7 @@ async function createComponentTreeInternal({ loaderTree: tree, parentParams, roo
             pagePath: layoutFilePath
         }, segmentNode) : segmentNode;
         // For layouts we just render the component
-        return [
-            wrappedSegmentNode,
-            parallelRouteCacheNodeSeedData,
-            loadingData,
-            isPossiblyPartialResponse,
-            hasRuntimePrefetch
-        ];
+        return createSeedData(ctx, wrappedSegmentNode, parallelRouteCacheNodeSeedData, loadingData, isPossiblyPartialResponse, isRuntimePrefetchable, varyParamsAccumulator);
     }
 }
 function createErrorBoundaryClientSegmentRoot({ ctx, ErrorBoundaryComponent, errorElement, ClientSegmentRoot, layerAssets, SegmentComponent, currentParams }) {
@@ -704,8 +735,8 @@ function getRootParams(loaderTree, getDynamicParamFromSegment) {
     return getRootParamsImpl({}, loaderTree, getDynamicParamFromSegment);
 }
 function getRootParamsImpl(parentParams, loaderTree, getDynamicParamFromSegment) {
-    const { segment, modules: { layout }, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(loaderTree);
-    const segmentParam = getDynamicParamFromSegment(segment);
+    const { modules: { layout }, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(loaderTree);
+    const segmentParam = getDynamicParamFromSegment(loaderTree);
     let currentParams = parentParams;
     if (segmentParam && segmentParam.value !== null) {
         currentParams = {
@@ -733,7 +764,7 @@ function getRootParamsImpl(parentParams, loaderTree, getDynamicParamFromSegment)
 }
 async function createBoundaryConventionElement({ ctx, conventionName, Component, styles, tree }) {
     const { componentMod: { createElement, Fragment } } = ctx;
-    const isSegmentViewEnabled = !!ctx.renderOpts.dev;
+    const isSegmentViewEnabled = !!process.env.__NEXT_DEV_SERVER;
     const dir = (process.env.NEXT_RUNTIME === 'edge' ? process.env.__NEXT_EDGE_PROJECT_DIR : ctx.renderOpts.dir) || '';
     const { SegmentViewNode } = ctx.componentMod;
     const element = Component ? createElement(Fragment, null, createElement(Component, null), styles) : undefined;
@@ -750,5 +781,60 @@ async function createBoundaryConventionElement({ ctx, conventionName, Component,
         pagePath
     ];
 }
+function createSeedData(ctx, rsc, parallelRoutes, loading, isPossiblyPartialResponse, isRuntimePrefetchable, 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
+        // set of children.
+        // NOTE: The reason this is a separate wrapper from LayoutRouter is because
+        // not all segments render a LayoutRouter component, e.g. the root segment.
+        const LoadingBoundaryProvider = ctx.componentMod.LoadingBoundaryProvider;
+        rsc = createElement(LoadingBoundaryProvider, {
+            loading: loading,
+            children: rsc
+        });
+    }
+    return [
+        rsc,
+        parallelRoutes,
+        null,
+        isPossiblyPartialResponse,
+        varyParamsAccumulator ? (0, _varyparams.getVaryParamsThenable)(varyParamsAccumulator) : null
+    ];
+}
 
 //# sourceMappingURL=create-component-tree.js.map

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

@@ -39,6 +39,7 @@ const _dynamicrendering = require("./dynamic-rendering");
 const _iserror = require("../../lib/is-error");
 const _errortelemetryutils = require("../../lib/error-telemetry-utils");
 const _reactlargeshellerror = require("./react-large-shell-error");
+const _instantvalidationerror = require("./instant-validation/instant-validation-error");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -56,9 +57,10 @@ function getDigestForWellKnownError(error) {
     if ((0, _hooksservercontext.isDynamicServerError)(error)) return error.digest;
     // If this is a prerender interrupted error, we don't need to log the error.
     if ((0, _dynamicrendering.isPrerenderInterruptedError)(error)) return error.digest;
+    if ((0, _instantvalidationerror.isInstantValidationError)(error)) return error.digest;
     return undefined;
 }
-function createReactServerErrorHandler(shouldFormatError, isNextExport, reactServerErrors, onReactServerRenderError, spanToRecordOn) {
+function createReactServerErrorHandler(shouldFormatError, isBuildTimePrerendering, reactServerErrors, onReactServerRenderError, spanToRecordOn) {
     return (thrownValue)=>{
         var _err_message;
         if (typeof thrownValue === 'string') {
@@ -108,7 +110,7 @@ function createReactServerErrorHandler(shouldFormatError, isNextExport, reactSer
             (0, _formatservererror.formatServerError)(err);
         }
         // Don't log the suppressed error during export
-        if (!(isNextExport && (err == null ? void 0 : (_err_message = err.message) == null ? void 0 : _err_message.includes('The specific message is omitted in production builds to avoid leaking sensitive details.')))) {
+        if (!(isBuildTimePrerendering && (err == null ? void 0 : (_err_message = err.message) == null ? void 0 : _err_message.includes('The specific message is omitted in production builds to avoid leaking sensitive details.')))) {
             // Record exception on the provided span if available, otherwise try active span.
             const span = spanToRecordOn ?? (0, _tracer.getTracer)().getActiveScopeSpan();
             if (span) {
@@ -124,7 +126,7 @@ function createReactServerErrorHandler(shouldFormatError, isNextExport, reactSer
         return err.digest;
     };
 }
-function createHTMLErrorHandler(shouldFormatError, isNextExport, reactServerErrors, allCapturedErrors, onHTMLRenderSSRError, spanToRecordOn) {
+function createHTMLErrorHandler(shouldFormatError, isBuildTimePrerendering, reactServerErrors, allCapturedErrors, onHTMLRenderSSRError, spanToRecordOn) {
     return (thrownValue, errorInfo)=>{
         var _err_message;
         if ((0, _reactlargeshellerror.isReactLargeShellError)(thrownValue)) {
@@ -161,7 +163,7 @@ function createHTMLErrorHandler(shouldFormatError, isNextExport, reactServerErro
             (0, _formatservererror.formatServerError)(err);
         }
         // Don't log the suppressed error during export
-        if (!(isNextExport && (err == null ? void 0 : (_err_message = err.message) == null ? void 0 : _err_message.includes('The specific message is omitted in production builds to avoid leaking sensitive details.')))) {
+        if (!(isBuildTimePrerendering && (err == null ? void 0 : (_err_message = err.message) == null ? void 0 : _err_message.includes('The specific message is omitted in production builds to avoid leaking sensitive details.')))) {
             // HTML errors contain RSC errors as well, filter them out before reporting
             if (isSSRError) {
                 // Record exception on the provided span if available, otherwise try active span.

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

@@ -22,55 +22,81 @@ _export(exports, {
 });
 const _approutertypes = require("../../shared/lib/app-router-types");
 const _segment = require("../../shared/lib/segment");
-function createFlightRouterStateFromLoaderTreeImpl([segment, parallelRoutes, { layout, loading }], getDynamicParamFromSegment, searchParams, includeHasLoadingBoundary, didFindRootLayout) {
-    const dynamicParam = getDynamicParamFromSegment(segment);
+async function createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, getDynamicParamFromSegment, searchParams, didFindRootLayout) {
+    const [segment, parallelRoutes, { layout, loading, page }] = loaderTree;
+    const dynamicParam = getDynamicParamFromSegment(loaderTree);
     const treeSegment = dynamicParam ? dynamicParam.treeSegment : segment;
     const segmentTree = [
         (0, _segment.addSearchParamsIfPageSegment)(treeSegment, searchParams),
         {}
     ];
+    // Load the layout or page module to check for unstable_instant config
+    const mod = layout ? await layout[0]() : page ? await page[0]() : undefined;
+    const instantConfig = mod ? mod.unstable_instant : 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
+    // if prefetch-hints.json was not generated), we fall through and still
+    // 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,
+    // 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;
+    }
     // Mark the first segment that has a layout as the "root" layout
     if (!didFindRootLayout && typeof layout !== 'undefined') {
         didFindRootLayout = true;
-        segmentTree[4] = true;
+        prefetchHints |= _approutertypes.PrefetchHint.IsRootLayout;
+    }
+    if (instantConfig && typeof instantConfig === 'object') {
+        prefetchHints |= _approutertypes.PrefetchHint.SubtreeHasInstant;
+        if (instantConfig.prefetch === 'runtime') {
+            prefetchHints |= _approutertypes.PrefetchHint.HasRuntimePrefetch;
+        }
+    }
+    // Check if this segment has a loading boundary
+    if (loading) {
+        prefetchHints |= _approutertypes.PrefetchHint.SegmentHasLoadingBoundary;
     }
-    let childHasLoadingBoundary = false;
     const children = {};
-    Object.keys(parallelRoutes).forEach((parallelRouteKey)=>{
-        const child = createFlightRouterStateFromLoaderTreeImpl(parallelRoutes[parallelRouteKey], getDynamicParamFromSegment, searchParams, includeHasLoadingBoundary, didFindRootLayout);
-        if (includeHasLoadingBoundary && child[5] !== _approutertypes.HasLoadingBoundary.SubtreeHasNoLoadingBoundary) {
-            childHasLoadingBoundary = true;
+    for(const parallelRouteKey in parallelRoutes){
+        var _hintTree_slots;
+        // 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);
+        // 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;
+            }
         }
         children[parallelRouteKey] = child;
-    });
+    }
     segmentTree[1] = children;
-    if (includeHasLoadingBoundary) {
-        // During a route tree prefetch, the FlightRouterState includes whether a
-        // tree has a loading boundary. The client uses this to determine if it can
-        // skip the data prefetch request — if `hasLoadingBoundary` is `false`, the
-        // data prefetch response will be empty, so there's no reason to request it.
-        // NOTE: It would be better to accumulate this while building the loader
-        // tree so we don't have to keep re-deriving it, but since this won't be
-        // once PPR is enabled everywhere, it's not that important.
-        segmentTree[5] = loading ? _approutertypes.HasLoadingBoundary.SegmentHasLoadingBoundary : childHasLoadingBoundary ? _approutertypes.HasLoadingBoundary.SubtreeHasLoadingBoundary : _approutertypes.HasLoadingBoundary.SubtreeHasNoLoadingBoundary;
+    if (prefetchHints !== 0) {
+        segmentTree[4] = prefetchHints;
     }
     return segmentTree;
 }
-function createFlightRouterStateFromLoaderTree(loaderTree, getDynamicParamFromSegment, searchParams) {
-    const includeHasLoadingBoundary = false;
+async function createFlightRouterStateFromLoaderTree(loaderTree, hintTree, getDynamicParamFromSegment, searchParams) {
     const didFindRootLayout = false;
-    return createFlightRouterStateFromLoaderTreeImpl(loaderTree, getDynamicParamFromSegment, searchParams, includeHasLoadingBoundary, didFindRootLayout);
+    return createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, getDynamicParamFromSegment, searchParams, didFindRootLayout);
 }
-function createRouteTreePrefetch(loaderTree, getDynamicParamFromSegment) {
+async function createRouteTreePrefetch(loaderTree, hintTree, getDynamicParamFromSegment) {
     // 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 = {};
-    // During a route tree prefetch, we include `hasLoadingBoundary` in
-    // the response.
-    const includeHasLoadingBoundary = true;
     const didFindRootLayout = false;
-    return createFlightRouterStateFromLoaderTreeImpl(loaderTree, getDynamicParamFromSegment, searchParams, includeHasLoadingBoundary, didFindRootLayout);
+    return createFlightRouterStateFromLoaderTreeImpl(loaderTree, hintTree, getDynamicParamFromSegment, searchParams, didFindRootLayout);
 }
 
 //# sourceMappingURL=create-flight-router-state-from-loader-tree.js.map

package/standalone/node_modules/next/dist/server/app-render/csrf-protection.js

@@ -14,8 +14,12 @@ Object.defineProperty(exports, "isCsrfOriginAllowed", {
     }
 });
 function matchWildcardDomain(domain, pattern) {
-    const domainParts = domain.split('.');
-    const patternParts = pattern.split('.');
+    // DNS names are case-insensitive per RFC 1035
+    // Use ASCII-only toLowerCase to avoid unicode issues
+    const normalizedDomain = domain.replace(/[A-Z]/g, (c)=>c.toLowerCase());
+    const normalizedPattern = pattern.replace(/[A-Z]/g, (c)=>c.toLowerCase());
+    const domainParts = normalizedDomain.split('.');
+    const patternParts = normalizedPattern.split('.');
     if (patternParts.length < 1) {
         // pattern is empty and therefore invalid to match against
         return false;
@@ -69,7 +73,14 @@ function matchWildcardDomain(domain, pattern) {
     return domainParts.length === 0;
 }
 const isCsrfOriginAllowed = (originDomain, allowedOrigins = [])=>{
-    return allowedOrigins.some((allowedOrigin)=>allowedOrigin && (allowedOrigin === originDomain || matchWildcardDomain(originDomain, allowedOrigin)));
+    // DNS names are case-insensitive per RFC 1035
+    // Use ASCII-only toLowerCase to avoid unicode issues
+    const normalizedOrigin = originDomain.replace(/[A-Z]/g, (c)=>c.toLowerCase());
+    return allowedOrigins.some((allowedOrigin)=>{
+        if (!allowedOrigin) return false;
+        const normalizedAllowed = allowedOrigin.replace(/[A-Z]/g, (c)=>c.toLowerCase());
+        return normalizedAllowed === normalizedOrigin || matchWildcardDomain(originDomain, allowedOrigin);
+    });
 };
 
 //# sourceMappingURL=csrf-protection.js.map

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

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createDebugChannel: null,
+    toNodeDebugChannel: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createDebugChannel: function() {
+        return _debugchannelserverweb.createDebugChannel;
+    },
+    toNodeDebugChannel: function() {
+        return _debugchannelserverweb.toNodeDebugChannel;
+    }
+});
+const _debugchannelserverweb = require("./debug-channel-server.web");
+
+//# sourceMappingURL=debug-channel-server.js.map

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

@@ -0,0 +1,71 @@
+/**
+ * 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";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createDebugChannel: null,
+    createWebDebugChannel: null,
+    toNodeDebugChannel: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createDebugChannel: function() {
+        return createDebugChannel;
+    },
+    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({
+        start (controller) {
+            readableController = controller;
+        }
+    });
+    return {
+        serverSide: {
+            writable: new WritableStream({
+                write (chunk) {
+                    readableController == null ? void 0 : readableController.enqueue(chunk);
+                },
+                close () {
+                    readableController == null ? void 0 : readableController.close();
+                },
+                abort (err) {
+                    readableController == null ? void 0 : readableController.error(err);
+                }
+            })
+        },
+        clientSide: {
+            readable: clientSideReadable
+        }
+    };
+}
+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",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=debug-channel-server.web.js.map