db-json-cli 2.0.1 → 2.0.2

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createComponentStylesAndScripts", {
+    enumerable: true,
+    get: function() {
+        return createComponentStylesAndScripts;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _interopdefault = require("./interop-default");
+const _getcssinlinedlinktags = require("./get-css-inlined-link-tags");
+const _getassetquerystring = require("./get-asset-query-string");
+const _encodeuripath = require("../../shared/lib/encode-uri-path");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function createComponentStylesAndScripts({ filePath, getComponent, injectedCSS, injectedJS, ctx }) {
+    const { styles: cssHrefs, scripts: jsHrefs } = (0, _getcssinlinedlinktags.getLinkAndScriptTags)(ctx.clientReferenceManifest, filePath, injectedCSS, injectedJS);
+    const styles = cssHrefs ? cssHrefs.map((href, index)=>{
+        const fullHref = `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(href)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`;
+        // `Precedence` is an opt-in signal for React to handle resource
+        // loading and deduplication, etc. It's also used as the key to sort
+        // resources so they will be injected in the correct order.
+        // During HMR, it's critical to use different `precedence` values
+        // for different stylesheets, so their order will be kept.
+        // https://github.com/facebook/react/pull/25060
+        const precedence = process.env.NODE_ENV === "development" ? "next_" + href : "next";
+        return /*#__PURE__*/ (0, _jsxruntime.jsx)("link", {
+            rel: "stylesheet",
+            href: fullHref,
+            // @ts-ignore
+            precedence: precedence,
+            crossOrigin: ctx.renderOpts.crossOrigin
+        }, index);
+    }) : null;
+    const scripts = jsHrefs ? jsHrefs.map((href)=>/*#__PURE__*/ (0, _jsxruntime.jsx)("script", {
+            src: `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(href)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`,
+            async: true
+        })) : null;
+    const Comp = (0, _interopdefault.interopDefault)(await getComponent());
+    return [
+        Comp,
+        styles,
+        scripts
+    ];
+}
+
+//# sourceMappingURL=create-component-styles-and-scripts.js.map

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

@@ -0,0 +1,455 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createComponentTree", {
+    enumerable: true,
+    get: function() {
+        return createComponentTree;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _clientreference = require("../../lib/client-reference");
+const _appdirmodule = require("../lib/app-dir-module");
+const _interopdefault = require("./interop-default");
+const _parseloadertree = require("./parse-loader-tree");
+const _createcomponentstylesandscripts = require("./create-component-styles-and-scripts");
+const _getlayerassets = require("./get-layer-assets");
+const _hasloadingcomponentintree = require("./has-loading-component-in-tree");
+const _patchfetch = require("../lib/patch-fetch");
+const _parallelroutedefault = require("../../client/components/parallel-route-default");
+const _tracer = require("../lib/trace/tracer");
+const _constants = require("../lib/trace/constants");
+const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function createComponentTree(props) {
+    return (0, _tracer.getTracer)().trace(_constants.NextNodeServerSpan.createComponentTree, {
+        spanName: "build component tree"
+    }, ()=>createComponentTreeInternal(props));
+}
+async function createComponentTreeInternal({ createSegmentPath, loaderTree: tree, parentParams, firstItem, rootLayoutIncluded, injectedCSS, injectedJS, injectedFontPreloadTags, asNotFound, metadataOutlet, ctx, missingSlots }) {
+    const { renderOpts: { nextConfigOutput, experimental }, staticGenerationStore, componentMod: { NotFoundBoundary, LayoutRouter, RenderFromTemplateContext, ClientPageRoot, createUntrackedSearchParams, createDynamicallyTrackedSearchParams, serverHooks: { DynamicServerError }, Postpone }, pagePath, getDynamicParamFromSegment, isPrefetch, query } = ctx;
+    const { page, layoutOrPagePath, segment, components, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    const { layout, template, error, loading, "not-found": notFound } = components;
+    const injectedCSSWithCurrentLayout = new Set(injectedCSS);
+    const injectedJSWithCurrentLayout = new Set(injectedJS);
+    const injectedFontPreloadTagsWithCurrentLayout = new Set(injectedFontPreloadTags);
+    const layerAssets = (0, _getlayerassets.getLayerAssets)({
+        ctx,
+        layoutOrPagePath,
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout,
+        injectedFontPreloadTags: injectedFontPreloadTagsWithCurrentLayout
+    });
+    const [Template, templateStyles, templateScripts] = template ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: template[1],
+        getComponent: template[0],
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout
+    }) : [
+        _react.default.Fragment
+    ];
+    const [ErrorComponent, errorStyles, errorScripts] = error ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: error[1],
+        getComponent: error[0],
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout
+    }) : [];
+    const [Loading, loadingStyles, loadingScripts] = loading ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: loading[1],
+        getComponent: loading[0],
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout
+    }) : [];
+    const isLayout = typeof layout !== "undefined";
+    const isPage = typeof page !== "undefined";
+    const [layoutOrPageMod] = await (0, _tracer.getTracer)().trace(_constants.NextNodeServerSpan.getLayoutOrPageModule, {
+        hideSpan: !(isLayout || isPage),
+        spanName: "resolve segment modules",
+        attributes: {
+            "next.segment": segment
+        }
+    }, ()=>(0, _appdirmodule.getLayoutOrPageModule)(tree));
+    /**
+   * Checks if the current segment is a root layout.
+   */ const rootLayoutAtThisLevel = isLayout && !rootLayoutIncluded;
+    /**
+   * Checks if the current segment or any level above it has a root layout.
+   */ const rootLayoutIncludedAtThisLevelOrAbove = rootLayoutIncluded || rootLayoutAtThisLevel;
+    const [NotFound, notFoundStyles] = notFound ? await (0, _createcomponentstylesandscripts.createComponentStylesAndScripts)({
+        ctx,
+        filePath: notFound[1],
+        getComponent: notFound[0],
+        injectedCSS: injectedCSSWithCurrentLayout,
+        injectedJS: injectedJSWithCurrentLayout
+    }) : [];
+    let dynamic = layoutOrPageMod == null ? void 0 : layoutOrPageMod.dynamic;
+    if (nextConfigOutput === "export") {
+        if (!dynamic || dynamic === "auto") {
+            dynamic = "error";
+        } else if (dynamic === "force-dynamic") {
+            // force-dynamic is always incompatible with 'export'. We must interrupt the build
+            throw new _staticgenerationbailout.StaticGenBailoutError(`Page with \`dynamic = "force-dynamic"\` couldn't be exported. \`output: "export"\` requires all pages be renderable statically because there is not runtime server to dynamic render routes in this output format. Learn more: https://nextjs.org/docs/app/building-your-application/deploying/static-exports`);
+        }
+    }
+    if (typeof dynamic === "string") {
+        // the nested most config wins so we only force-static
+        // if it's configured above any parent that configured
+        // otherwise
+        if (dynamic === "error") {
+            staticGenerationStore.dynamicShouldError = true;
+        } else if (dynamic === "force-dynamic") {
+            staticGenerationStore.forceDynamic = true;
+            // TODO: (PPR) remove this bailout once PPR is the default
+            if (staticGenerationStore.isStaticGeneration && !staticGenerationStore.prerenderState) {
+                // If the postpone API isn't available, we can't postpone the render and
+                // therefore we can't use the dynamic API.
+                const err = new DynamicServerError(`Page with \`dynamic = "force-dynamic"\` won't be rendered statically.`);
+                staticGenerationStore.dynamicUsageDescription = err.message;
+                staticGenerationStore.dynamicUsageStack = err.stack;
+                throw err;
+            }
+        } else {
+            staticGenerationStore.dynamicShouldError = false;
+            staticGenerationStore.forceStatic = dynamic === "force-static";
+        }
+    }
+    if (typeof (layoutOrPageMod == null ? void 0 : layoutOrPageMod.fetchCache) === "string") {
+        staticGenerationStore.fetchCache = layoutOrPageMod == null ? void 0 : layoutOrPageMod.fetchCache;
+    }
+    if (typeof (layoutOrPageMod == null ? void 0 : layoutOrPageMod.revalidate) !== "undefined") {
+        (0, _patchfetch.validateRevalidate)(layoutOrPageMod == null ? void 0 : layoutOrPageMod.revalidate, staticGenerationStore.urlPathname);
+    }
+    if (typeof (layoutOrPageMod == null ? void 0 : layoutOrPageMod.revalidate) === "number") {
+        ctx.defaultRevalidate = layoutOrPageMod.revalidate;
+        if (typeof staticGenerationStore.revalidate === "undefined" || typeof staticGenerationStore.revalidate === "number" && staticGenerationStore.revalidate > ctx.defaultRevalidate) {
+            staticGenerationStore.revalidate = ctx.defaultRevalidate;
+        }
+        if (!staticGenerationStore.forceStatic && staticGenerationStore.isStaticGeneration && ctx.defaultRevalidate === 0 && // If the postpone API isn't available, we can't postpone the render and
+        // therefore we can't use the dynamic API.
+        !staticGenerationStore.prerenderState) {
+            const dynamicUsageDescription = `revalidate: 0 configured ${segment}`;
+            staticGenerationStore.dynamicUsageDescription = dynamicUsageDescription;
+            throw new DynamicServerError(dynamicUsageDescription);
+        }
+    }
+    // If there's a dynamic usage error attached to the store, throw it.
+    if (staticGenerationStore.dynamicUsageErr) {
+        throw staticGenerationStore.dynamicUsageErr;
+    }
+    const LayoutOrPage = layoutOrPageMod ? await (0, _interopdefault.interopDefault)(layoutOrPageMod) : undefined;
+    /**
+   * The React Component to render.
+   */ let Component = LayoutOrPage;
+    const parallelKeys = Object.keys(parallelRoutes);
+    const hasSlotKey = parallelKeys.length > 1;
+    // TODO-APP: This is a hack to support unmatched parallel routes, which will throw `notFound()`.
+    // This ensures that a `NotFoundBoundary` is available for when that happens,
+    // but it's not ideal, as it needlessly invokes the `NotFound` component and renders the `RootLayout` twice.
+    // We should instead look into handling the fallback behavior differently in development mode so that it doesn't
+    // rely on the `NotFound` behavior.
+    if (hasSlotKey && rootLayoutAtThisLevel && LayoutOrPage) {
+        Component = (componentProps)=>{
+            const NotFoundComponent = NotFound;
+            const RootLayoutComponent = LayoutOrPage;
+            return /*#__PURE__*/ (0, _jsxruntime.jsx)(NotFoundBoundary, {
+                notFound: NotFoundComponent ? /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                    children: [
+                        layerAssets,
+                        /*#__PURE__*/ (0, _jsxruntime.jsxs)(RootLayoutComponent, {
+                            params: componentProps.params,
+                            children: [
+                                notFoundStyles,
+                                /*#__PURE__*/ (0, _jsxruntime.jsx)(NotFoundComponent, {})
+                            ]
+                        })
+                    ]
+                }) : undefined,
+                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(RootLayoutComponent, {
+                    ...componentProps
+                })
+            });
+        };
+    }
+    if (process.env.NODE_ENV === "development") {
+        const { isValidElementType } = require("next/dist/compiled/react-is");
+        if ((isPage || typeof Component !== "undefined") && !isValidElementType(Component)) {
+            throw new Error(`The default export is not a React Component in page: "${pagePath}"`);
+        }
+        if (typeof ErrorComponent !== "undefined" && !isValidElementType(ErrorComponent)) {
+            throw new Error(`The default export of error is not a React Component in page: ${segment}`);
+        }
+        if (typeof Loading !== "undefined" && !isValidElementType(Loading)) {
+            throw new Error(`The default export of loading is not a React Component in ${segment}`);
+        }
+        if (typeof NotFound !== "undefined" && !isValidElementType(NotFound)) {
+            throw new Error(`The default export of notFound is not a React Component in ${segment}`);
+        }
+    }
+    // Handle dynamic segment params.
+    const segmentParam = getDynamicParamFromSegment(segment);
+    /**
+   * Create object holding the parent params and current params
+   */ const currentParams = // Handle null case where dynamic param is optional
+    segmentParam && segmentParam.value !== null ? {
+        ...parentParams,
+        [segmentParam.param]: segmentParam.value
+    } : parentParams;
+    // Resolve the segment param
+    const actualSegment = segmentParam ? segmentParam.treeSegment : segment;
+    //
+    // TODO: Combine this `map` traversal with the loop below that turns the array
+    // into an object.
+    const parallelRouteMap = await Promise.all(Object.keys(parallelRoutes).map(async (parallelRouteKey)=>{
+        const isChildrenRouteKey = parallelRouteKey === "children";
+        const currentSegmentPath = firstItem ? [
+            parallelRouteKey
+        ] : [
+            actualSegment,
+            parallelRouteKey
+        ];
+        const parallelRoute = parallelRoutes[parallelRouteKey];
+        const notFoundComponent = NotFound && isChildrenRouteKey ? /*#__PURE__*/ (0, _jsxruntime.jsx)(NotFound, {}) : undefined;
+        // if we're prefetching and that there's a Loading component, we bail out
+        // otherwise we keep rendering for the prefetch.
+        // We also want to bail out if there's no Loading component in the tree.
+        let childCacheNodeSeedData = null;
+        if (// Before PPR, the way instant navigations work in Next.js is we
+        // prefetch everything up to the first route segment that defines a
+        // loading.tsx boundary. (We do the same if there's no loading
+        // boundary in the entire tree, because we don't want to prefetch too
+        // much) The rest of the tree is defered until the actual navigation.
+        // It does not take into account whether the data is dynamic — even if
+        // the tree is completely static, it will still defer everything
+        // inside the loading boundary.
+        //
+        // This behavior predates PPR and is only relevant if the
+        // PPR flag is not enabled.
+        isPrefetch && (Loading || !(0, _hasloadingcomponentintree.hasLoadingComponentInTree)(parallelRoute)) && // The approach with PPR is different — loading.tsx behaves like a
+        // regular Suspense boundary and has no special behavior.
+        //
+        // With PPR, we prefetch as deeply as possible, and only defer when
+        // dynamic data is accessed. If so, we only defer the nearest parent
+        // Suspense boundary of the dynamic data access, regardless of whether
+        // the boundary is defined by loading.tsx or a normal <Suspense>
+        // component in userspace.
+        //
+        // NOTE: In practice this usually means we'll end up prefetching more
+        // than we were before PPR, which may or may not be considered a
+        // performance regression by some apps. The plan is to address this
+        // before General Availability of PPR by introducing granular
+        // per-segment fetching, so we can reuse as much of the tree as
+        // possible during both prefetches and dynamic navigations. But during
+        // the beta period, we should be clear about this trade off in our
+        // communications.
+        !experimental.ppr) {
+        // Don't prefetch this child. This will trigger a lazy fetch by the
+        // client router.
+        } else {
+            // Create the child component
+            if (process.env.NODE_ENV === "development" && missingSlots) {
+                var _parsedTree_layoutOrPagePath;
+                // When we detect the default fallback (which triggers a 404), we collect the missing slots
+                // to provide more helpful debug information during development mode.
+                const parsedTree = (0, _parseloadertree.parseLoaderTree)(parallelRoute);
+                if ((_parsedTree_layoutOrPagePath = parsedTree.layoutOrPagePath) == null ? void 0 : _parsedTree_layoutOrPagePath.endsWith(_parallelroutedefault.PARALLEL_ROUTE_DEFAULT_PATH)) {
+                    missingSlots.add(parallelRouteKey);
+                }
+            }
+            const seedData = await createComponentTreeInternal({
+                createSegmentPath: (child)=>{
+                    return createSegmentPath([
+                        ...currentSegmentPath,
+                        ...child
+                    ]);
+                },
+                loaderTree: parallelRoute,
+                parentParams: currentParams,
+                rootLayoutIncluded: rootLayoutIncludedAtThisLevelOrAbove,
+                injectedCSS: injectedCSSWithCurrentLayout,
+                injectedJS: injectedJSWithCurrentLayout,
+                injectedFontPreloadTags: injectedFontPreloadTagsWithCurrentLayout,
+                asNotFound,
+                metadataOutlet: isChildrenRouteKey ? metadataOutlet : undefined,
+                ctx,
+                missingSlots
+            });
+            childCacheNodeSeedData = seedData;
+        }
+        // This is turned back into an object below.
+        return [
+            parallelRouteKey,
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(LayoutRouter, {
+                parallelRouterKey: parallelRouteKey,
+                segmentPath: createSegmentPath(currentSegmentPath),
+                // TODO-APP: Add test for loading returning `undefined`. This currently can't be tested as the `webdriver()` tab will wait for the full page to load before returning.
+                error: ErrorComponent,
+                errorStyles: errorStyles,
+                errorScripts: errorScripts,
+                template: /*#__PURE__*/ (0, _jsxruntime.jsx)(Template, {
+                    children: /*#__PURE__*/ (0, _jsxruntime.jsx)(RenderFromTemplateContext, {})
+                }),
+                templateStyles: templateStyles,
+                templateScripts: templateScripts,
+                notFound: notFoundComponent,
+                notFoundStyles: notFoundStyles
+            }),
+            childCacheNodeSeedData
+        ];
+    }));
+    // Convert the parallel route map into an object after all promises have been resolved.
+    let parallelRouteProps = {};
+    let parallelRouteCacheNodeSeedData = {};
+    for (const parallelRoute of parallelRouteMap){
+        const [parallelRouteKey, parallelRouteProp, flightData] = parallelRoute;
+        parallelRouteProps[parallelRouteKey] = parallelRouteProp;
+        parallelRouteCacheNodeSeedData[parallelRouteKey] = flightData;
+    }
+    const loadingData = Loading ? [
+        /*#__PURE__*/ (0, _jsxruntime.jsx)(Loading, {}),
+        loadingStyles,
+        loadingScripts
+    ] : 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 (!Component) {
+        return [
+            actualSegment,
+            parallelRouteCacheNodeSeedData,
+            // TODO: I don't think the extra fragment is necessary. React treats top
+            // level fragments as transparent, i.e. the runtime behavior should be
+            // identical even without it. But maybe there's some findDOMNode-related
+            // reason that I'm not aware of, so I'm leaving it as-is out of extreme
+            // caution, for now.
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                children: [
+                    layerAssets,
+                    parallelRouteProps.children
+                ]
+            }),
+            loadingData
+        ];
+    }
+    // If force-dynamic is used and the current render supports postponing, we
+    // replace it with a node that will postpone the render. This ensures that the
+    // postpone is invoked during the react render phase and not during the next
+    // render phase.
+    // @TODO this does not actually do what it seems like it would or should do. The idea is that
+    // if we are rendering in a force-dynamic mode and we can postpone we should only make the segments
+    // that ask for force-dynamic to be dynamic, allowing other segments to still prerender. However
+    // because this comes after the children traversal and the static generation store is mutated every segment
+    // along the parent path of a force-dynamic segment will hit this condition effectively making the entire
+    // render force-dynamic. We should refactor this function so that we can correctly track which segments
+    // need to be dynamic
+    if (staticGenerationStore.forceDynamic && staticGenerationStore.prerenderState) {
+        return [
+            actualSegment,
+            parallelRouteCacheNodeSeedData,
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                children: [
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(Postpone, {
+                        prerenderState: staticGenerationStore.prerenderState,
+                        reason: 'dynamic = "force-dynamic" was used',
+                        pathname: staticGenerationStore.urlPathname
+                    }),
+                    layerAssets
+                ]
+            }),
+            loadingData
+        ];
+    }
+    const isClientComponent = (0, _clientreference.isClientReference)(layoutOrPageMod);
+    // We avoid cloning this object because it gets consumed here exclusively.
+    const props = parallelRouteProps;
+    // If it's a not found route, and we don't have any matched parallel
+    // routes, we try to render the not found component if it exists.
+    if (NotFound && asNotFound && // In development, it could hit the parallel-route-default not found, so we only need to check the segment.
+    // Or if there's no parallel routes means it reaches the end.
+    !parallelRouteMap.length) {
+        props.children = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+            children: [
+                /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+                    name: "robots",
+                    content: "noindex"
+                }),
+                process.env.NODE_ENV === "development" && /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
+                    name: "next-error",
+                    content: "not-found"
+                }),
+                notFoundStyles,
+                /*#__PURE__*/ (0, _jsxruntime.jsx)(NotFound, {})
+            ]
+        });
+    }
+    // Assign params to props
+    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}`);
+    }
+    props.params = currentParams;
+    let segmentElement;
+    if (isPage) {
+        // Assign searchParams to props if this is a page
+        if (isClientComponent) {
+            // When we are passing searchParams to a client component Page we don't want to track the dynamic access
+            // here in the RSC layer because the serialization will trigger a dynamic API usage.
+            // Instead we pass the searchParams untracked but we wrap the Page in a root client component
+            // which can among other things adds the dynamic tracking before rendering the page.
+            // @TODO make the root wrapper part of next-app-loader so we don't need the extra client component
+            props.searchParams = createUntrackedSearchParams(query);
+            segmentElement = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                children: [
+                    metadataOutlet,
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(ClientPageRoot, {
+                        props: props,
+                        Component: Component
+                    }),
+                    layerAssets
+                ]
+            });
+        } else {
+            // 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.
+            props.searchParams = createDynamicallyTrackedSearchParams(query);
+            segmentElement = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+                children: [
+                    metadataOutlet,
+                    /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
+                        ...props
+                    }),
+                    layerAssets
+                ]
+            });
+        }
+    } else {
+        // For layouts we just render the component
+        segmentElement = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+            children: [
+                layerAssets,
+                /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
+                    ...props
+                })
+            ]
+        });
+    }
+    return [
+        actualSegment,
+        parallelRouteCacheNodeSeedData,
+        /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
+            children: [
+                segmentElement,
+                null
+            ]
+        }),
+        loadingData
+    ];
+}
+
+//# sourceMappingURL=create-component-tree.js.map

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ErrorHandlerSource: null,
+    createErrorHandler: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ErrorHandlerSource: function() {
+        return ErrorHandlerSource;
+    },
+    createErrorHandler: function() {
+        return createErrorHandler;
+    }
+});
+const _stringhash = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/string-hash"));
+const _formatservererror = require("../../lib/format-server-error");
+const _tracer = require("../lib/trace/tracer");
+const _pipereadable = require("../pipe-readable");
+const _isdynamicusageerror = require("../../export/helpers/is-dynamic-usage-error");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const ErrorHandlerSource = {
+    serverComponents: "serverComponents",
+    flightData: "flightData",
+    html: "html"
+};
+function createErrorHandler({ /**
+   * Used for debugging
+   */ source, dev, isNextExport, errorLogger, digestErrorsMap, allCapturedErrors, silenceLogger }) {
+    return (err, errorInfo)=>{
+        var _err_message;
+        // 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) {
+            // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
+            err.digest = (0, _stringhash.default)(err.message + ((errorInfo == null ? void 0 : errorInfo.stack) || err.stack || "")).toString();
+        }
+        const digest = err.digest;
+        if (allCapturedErrors) allCapturedErrors.push(err);
+        // These errors are expected. We return the digest
+        // so that they can be properly handled.
+        if ((0, _isdynamicusageerror.isDynamicUsageError)(err)) return err.digest;
+        // If the response was closed, we don't need to log the error.
+        if ((0, _pipereadable.isAbortError)(err)) return;
+        if (!digestErrorsMap.has(digest)) {
+            digestErrorsMap.set(digest, err);
+        } else if (source === ErrorHandlerSource.html) {
+            // For SSR errors, if we have the existing digest in errors map,
+            // we should use the existing error object to avoid duplicate error logs.
+            err = digestErrorsMap.get(digest);
+        }
+        // Format server errors in development to add more helpful error messages
+        if (dev) {
+            (0, _formatservererror.formatServerError)(err);
+        }
+        // Used for debugging error source
+        // console.error(source, 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.")))) {
+            // Record exception in an active span, if available.
+            const span = (0, _tracer.getTracer)().getActiveScopeSpan();
+            if (span) {
+                span.recordException(err);
+                span.setStatus({
+                    code: _tracer.SpanStatusCode.ERROR,
+                    message: err.message
+                });
+            }
+            if (!silenceLogger) {
+                if (errorLogger) {
+                    errorLogger(err).catch(()=>{});
+                } else {
+                    // The error logger is currently not provided in the edge runtime.
+                    // Use the exposed `__next_log_error__` instead.
+                    // This will trace error traces to the original source code.
+                    if (typeof __next_log_error__ === "function") {
+                        __next_log_error__(err);
+                    } else {
+                        console.error(err);
+                    }
+                }
+            }
+        }
+        return err.digest;
+    };
+}
+
+//# sourceMappingURL=create-error-handler.js.map

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    addSearchParamsIfPageSegment: null,
+    createFlightRouterStateFromLoaderTree: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    addSearchParamsIfPageSegment: function() {
+        return addSearchParamsIfPageSegment;
+    },
+    createFlightRouterStateFromLoaderTree: function() {
+        return createFlightRouterStateFromLoaderTree;
+    }
+});
+const _segment = require("../../shared/lib/segment");
+function addSearchParamsIfPageSegment(segment, searchParams) {
+    const isPageSegment = segment === _segment.PAGE_SEGMENT_KEY;
+    if (isPageSegment) {
+        const stringifiedQuery = JSON.stringify(searchParams);
+        return stringifiedQuery !== "{}" ? segment + "?" + stringifiedQuery : segment;
+    }
+    return segment;
+}
+function createFlightRouterStateFromLoaderTree([segment, parallelRoutes, { layout }], getDynamicParamFromSegment, searchParams, rootLayoutIncluded = false) {
+    const dynamicParam = getDynamicParamFromSegment(segment);
+    const treeSegment = dynamicParam ? dynamicParam.treeSegment : segment;
+    const segmentTree = [
+        addSearchParamsIfPageSegment(treeSegment, searchParams),
+        {}
+    ];
+    if (!rootLayoutIncluded && typeof layout !== "undefined") {
+        rootLayoutIncluded = true;
+        segmentTree[4] = true;
+    }
+    segmentTree[1] = Object.keys(parallelRoutes).reduce((existingValue, currentValue)=>{
+        existingValue[currentValue] = createFlightRouterStateFromLoaderTree(parallelRoutes[currentValue], getDynamicParamFromSegment, searchParams, rootLayoutIncluded);
+        return existingValue;
+    }, {});
+    return segmentTree;
+}
+
+//# sourceMappingURL=create-flight-router-state-from-loader-tree.js.map