@aeolus-fleet/console 0.35.0 → 0.36.1

package/.next/standalone/node_modules/next/dist/lib/metadata/resolve-metadata-parallel.js

@@ -0,0 +1,632 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    resolveMetadataForBranch: null,
+    resolveMetadataResolution: null,
+    resolveViewportForBranch: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    resolveMetadataForBranch: function() {
+        return resolveMetadataForBranch;
+    },
+    resolveMetadataResolution: function() {
+        return resolveMetadataResolution;
+    },
+    resolveViewportForBranch: function() {
+        return resolveViewportForBranch;
+    }
+});
+require("server-only");
+const _defaultmetadata = require("./default-metadata");
+const _getsegmentparam = require("../../shared/lib/router/utils/get-segment-param");
+const _appdirmodule = require("../../server/lib/app-dir-module");
+const _params = require("../../server/request/params");
+const _segment = require("../../shared/lib/segment");
+const _default = require("../../client/components/builtin/default");
+const _defaultnull = require("../../client/components/builtin/default-null");
+const _workasyncstorageexternal = require("../../server/app-render/work-async-storage.external");
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
+const _clientandserverreferences = require("../client-and-server-references");
+const _lazyresult = require("../../server/lib/lazy-result");
+const _httpaccessfallback = require("../../client/components/http-access-fallback/http-access-fallback");
+const _redirecterror = require("../../client/components/redirect-error");
+const _metadataresolutionprimitives = require("./metadata-resolution-primitives");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const METADATA = 1;
+const VIEWPORT = 2;
+const METADATA_AND_VIEWPORT = 3;
+async function collectMetadataAndViewport({ tree, props, route, errorConvention, resolutionTarget }) {
+    const shouldResolveMetadata = Boolean(resolutionTarget & METADATA);
+    const shouldResolveViewport = Boolean(resolutionTarget & VIEWPORT);
+    const moduleResultPromise = errorConvention ? (0, _appdirmodule.getComponentTypeModule)(tree, 'layout').then((mod)=>({
+            mod,
+            modType: errorConvention
+        })) : (0, _appdirmodule.getLayoutOrPageModule)(tree);
+    const staticFilesMetadata = shouldResolveMetadata ? (0, _metadataresolutionprimitives.resolveStaticMetadata)(tree[2], props) : Promise.resolve(null);
+    // Static metadata is resolved eagerly, but its rejection belongs to this
+    // branch and will be replayed through the branch's metadata outlet.
+    staticFilesMetadata.catch(()=>null);
+    const moduleResult = await moduleResultPromise;
+    const hasStaticFilesMetadata = shouldResolveMetadata && hasStaticMetadataFiles(tree);
+    if (moduleResult.modType) {
+        route += `/${moduleResult.modType}`;
+    }
+    const metadata = shouldResolveMetadata && moduleResult.mod ? (0, _metadataresolutionprimitives.getDefinedMetadata)(moduleResult.mod, props, {
+        route
+    }) : null;
+    const viewport = shouldResolveViewport && moduleResult.mod ? (0, _metadataresolutionprimitives.getDefinedViewport)(moduleResult.mod, props, {
+        route
+    }) : null;
+    let errorLayer = null;
+    if (errorConvention && tree[2][errorConvention]) {
+        const errorMod = await (0, _appdirmodule.getComponentTypeModule)(tree, errorConvention);
+        errorLayer = {
+            metadata: shouldResolveMetadata && errorMod ? (0, _metadataresolutionprimitives.getDefinedMetadata)(errorMod, props, {
+                route
+            }) : null,
+            viewport: shouldResolveViewport && errorMod ? (0, _metadataresolutionprimitives.getDefinedViewport)(errorMod, props, {
+                route
+            }) : null,
+            staticFilesMetadata,
+            hasStaticFilesMetadata
+        };
+    }
+    return {
+        metadata,
+        viewport,
+        staticFilesMetadata,
+        hasStaticFilesMetadata,
+        errorLayer
+    };
+}
+function callResolver(resolver) {
+    let result;
+    try {
+        result = resolver();
+    } catch (error) {
+        result = Promise.reject(error);
+    }
+    if (result instanceof Promise) {
+        // Generators are eagerly executed, so attach a rejection handler before
+        // an earlier layer can suspend or fail.
+        result.catch(()=>null);
+    }
+    return result;
+}
+function getResult(exportForResult) {
+    if (typeof exportForResult === 'function') {
+        // If the function is a 'use cache' function that uses the parent data as
+        // the second argument, we don't want to eagerly execute it during
+        // metadata/viewport pre-rendering, as the parent data might also be
+        // computed from another 'use cache' function. To ensure that the hanging
+        // input abort signal handling works in this case (i.e. the depending
+        // function waits for the cached input to resolve while encoding its args),
+        // they must be called sequentially. This can be accomplished by wrapping
+        // the call in a lazy promise, so that the original function is only called
+        // when the result is actually awaited.
+        const useCacheFunctionInfo = (0, _clientandserverreferences.getUseCacheFunctionInfo)(exportForResult.$$original);
+        if (useCacheFunctionInfo && !useCacheFunctionInfo.usedArgs[1]) {
+            return {
+                resolveParent: null,
+                result: callResolver(()=>{
+                    // @ts-expect-error We intentionally omit the parent argument, because
+                    // we know this 'use cache' function does not use it.
+                    return exportForResult();
+                })
+            };
+        }
+        let resolveParent;
+        const parent = new Promise((resolve)=>{
+            resolveParent = resolve;
+        });
+        return {
+            resolveParent: resolveParent,
+            result: useCacheFunctionInfo ? (0, _lazyresult.createLazyResult)(()=>exportForResult(parent)) : callResolver(()=>exportForResult(parent))
+        };
+    }
+    return {
+        resolveParent: null,
+        result: typeof exportForResult === 'object' ? exportForResult : null
+    };
+}
+function resolveParentResult(parentResult, resolveParent) {
+    if (process.env.NODE_ENV === 'development') {
+        parentResult = require('../../shared/lib/deep-freeze').deepFreeze(structuredClone(parentResult));
+    }
+    resolveParent(parentResult);
+}
+function cloneStaticMetadata(metadata) {
+    if (!metadata) return null;
+    return {
+        ...metadata,
+        icon: metadata.icon ? [
+            ...metadata.icon
+        ] : undefined,
+        apple: metadata.apple ? [
+            ...metadata.apple
+        ] : undefined,
+        openGraph: metadata.openGraph ? [
+            ...metadata.openGraph
+        ] : undefined,
+        twitter: metadata.twitter ? [
+            ...metadata.twitter
+        ] : undefined
+    };
+}
+function createMetadataAccumulator() {
+    return {
+        metadata: (0, _defaultmetadata.createDefaultMetadata)(),
+        titleTemplates: {
+            title: null,
+            twitter: null,
+            openGraph: null
+        },
+        favicon: null,
+        leafSegmentStaticIcons: {
+            icon: [],
+            apple: []
+        },
+        buildState: {
+            warnings: new Set()
+        }
+    };
+}
+function cloneMetadataAccumulator(accumulator) {
+    return {
+        metadata: structuredClone(accumulator.metadata),
+        titleTemplates: {
+            ...accumulator.titleTemplates
+        },
+        favicon: accumulator.favicon ? structuredClone(accumulator.favicon) : null,
+        leafSegmentStaticIcons: {
+            icon: structuredClone(accumulator.leafSegmentStaticIcons.icon),
+            apple: structuredClone(accumulator.leafSegmentStaticIcons.apple)
+        },
+        buildState: {
+            warnings: new Set(accumulator.buildState.warnings)
+        }
+    };
+}
+function cloneViewportAccumulator(accumulator) {
+    return {
+        viewport: structuredClone(accumulator.viewport)
+    };
+}
+async function accumulateMetadataLayer(parent, prerendered, staticMetadata, route, layerIndex, pathname, metadataContext) {
+    var _staticFilesMetadata_icon;
+    const accumulator = await parent;
+    const staticFilesMetadata = cloneStaticMetadata(await staticMetadata);
+    // Treat favicon as a special case. It should be the first icon in the list.
+    // layerIndex <= 1 represents the root layout and a page at the root.
+    if (layerIndex <= 1 && (0, _metadataresolutionprimitives.isFavicon)(staticFilesMetadata == null ? void 0 : (_staticFilesMetadata_icon = staticFilesMetadata.icon) == null ? void 0 : _staticFilesMetadata_icon[0])) {
+        var _staticFilesMetadata_icon1;
+        const icon = staticFilesMetadata == null ? void 0 : (_staticFilesMetadata_icon1 = staticFilesMetadata.icon) == null ? void 0 : _staticFilesMetadata_icon1.shift();
+        if (layerIndex === 0 && icon) {
+            accumulator.favicon = (0, _metadataresolutionprimitives.convertUrlsToStrings)(icon);
+        }
+    }
+    if (prerendered.resolveParent) {
+        resolveParentResult(accumulator.metadata, prerendered.resolveParent);
+    }
+    let metadata;
+    if (isPromiseLike(prerendered.result)) {
+        metadata = await prerendered.result;
+    } else {
+        metadata = prerendered.result;
+    }
+    await (0, _metadataresolutionprimitives.mergeMetadata)(route, pathname, {
+        metadata,
+        resolvedMetadata: accumulator.metadata,
+        staticFilesMetadata,
+        titleTemplates: accumulator.titleTemplates,
+        metadataContext,
+        buildState: accumulator.buildState,
+        leafSegmentStaticIcons: accumulator.leafSegmentStaticIcons,
+        cloneResolvedMetadata: false
+    });
+    return accumulator;
+}
+async function accumulateViewportLayer(parent, prerendered) {
+    const accumulator = await parent;
+    if (prerendered.resolveParent) {
+        resolveParentResult(accumulator.viewport, prerendered.resolveParent);
+    }
+    let viewport;
+    if (isPromiseLike(prerendered.result)) {
+        viewport = await prerendered.result;
+    } else {
+        viewport = prerendered.result;
+    }
+    (0, _metadataresolutionprimitives.mergeViewport)({
+        resolvedViewport: accumulator.viewport,
+        viewport,
+        cloneResolvedViewport: false
+    });
+    return accumulator;
+}
+function prepareMetadataAccumulatorForChild(parent, clone, childIsPage, errorConvention) {
+    return parent.then((parentAccumulator)=>{
+        const accumulator = clone ? cloneMetadataAccumulator(parentAccumulator) : parentAccumulator;
+        // A title template applies to a descendant segment, but not to a page in
+        // the same segment. Error convention metadata is an additional terminal
+        // layer, so the leaf layout's template does apply to it.
+        if (!childIsPage || errorConvention) {
+            var _accumulator_metadata_title, _accumulator_metadata_openGraph, _accumulator_metadata_twitter;
+            accumulator.titleTemplates = {
+                title: ((_accumulator_metadata_title = accumulator.metadata.title) == null ? void 0 : _accumulator_metadata_title.template) || null,
+                openGraph: ((_accumulator_metadata_openGraph = accumulator.metadata.openGraph) == null ? void 0 : _accumulator_metadata_openGraph.title.template) || null,
+                twitter: ((_accumulator_metadata_twitter = accumulator.metadata.twitter) == null ? void 0 : _accumulator_metadata_twitter.title.template) || null
+            };
+        }
+        return accumulator;
+    });
+}
+function prepareViewportAccumulatorForChild(parent, clone) {
+    return clone ? parent.then(cloneViewportAccumulator) : parent;
+}
+function completeMetadataAccumulator(accumulator, metadataContext) {
+    const { leafSegmentStaticIcons, metadata } = accumulator;
+    if ((leafSegmentStaticIcons.icon.length > 0 || leafSegmentStaticIcons.apple.length > 0) && !metadata.icons) {
+        metadata.icons = {
+            icon: [],
+            apple: []
+        };
+        if (leafSegmentStaticIcons.icon.length > 0) {
+            metadata.icons.icon.unshift(...(0, _metadataresolutionprimitives.convertUrlsToStrings)(leafSegmentStaticIcons.icon));
+        }
+        if (leafSegmentStaticIcons.apple.length > 0) {
+            metadata.icons.apple.unshift(...(0, _metadataresolutionprimitives.convertUrlsToStrings)(leafSegmentStaticIcons.apple));
+        }
+    }
+    return (0, _metadataresolutionprimitives.postProcessMetadata)(metadata, accumulator.favicon, accumulator.titleTemplates, metadataContext);
+}
+function getResolutionStatus(reason) {
+    if ((0, _httpaccessfallback.isHTTPAccessFallbackError)(reason)) {
+        return (0, _httpaccessfallback.getAccessFallbackErrorTypeByStatus)((0, _httpaccessfallback.getAccessFallbackHTTPStatus)(reason)) || 'error';
+    }
+    if ((0, _redirecterror.isRedirectError)(reason)) {
+        return 'redirect';
+    }
+    return 'error';
+}
+function createRejectedOutcome(reason) {
+    return {
+        status: getResolutionStatus(reason),
+        reason
+    };
+}
+function createMetadataBranchOutcome(pendingAccumulator, metadataContext) {
+    const completed = pendingAccumulator.then((accumulator)=>({
+            value: (0, _metadataresolutionprimitives.createSelectedMetadata)(completeMetadataAccumulator(accumulator, metadataContext)),
+            warnings: accumulator.buildState.warnings
+        }));
+    return completed.then(({ value, warnings })=>({
+            status: 'resolved',
+            value,
+            warnings
+        }), createRejectedOutcome);
+}
+function createViewportBranchOutcome(pendingAccumulator) {
+    return pendingAccumulator.then((accumulator)=>({
+            status: 'resolved',
+            value: accumulator.viewport
+        }), createRejectedOutcome);
+}
+function createOutletPromise(metadataOutcome, viewportOutcome) {
+    let pendingOutcomes = 2;
+    const outlet = new Promise((resolve, reject)=>{
+        function settle(outcome) {
+            if (outcome.status !== 'resolved') {
+                reject(outcome.reason);
+            } else if (--pendingOutcomes === 0) {
+                resolve(null);
+            }
+        }
+        metadataOutcome.then(settle, reject);
+        viewportOutcome.then(settle, reject);
+    });
+    // Outlet promises can reject before React renders the corresponding slot.
+    // Observe the rejection immediately while preserving it for React to replay.
+    outlet.catch(()=>null);
+    return outlet;
+}
+function appendTreeRoute(parentRoute, segment) {
+    if (segment === _segment.PAGE_SEGMENT_KEY) return parentRoute;
+    if (parentRoute === null) return segment;
+    return `${parentRoute}/${segment}`;
+}
+function isPageTree(tree) {
+    const { layout, page, defaultPage } = tree[2];
+    return layout === undefined && (page !== undefined || defaultPage !== undefined && tree[0] === _segment.DEFAULT_SEGMENT_KEY);
+}
+function isBuiltinFallback(tree) {
+    const { defaultPage } = tree[2];
+    return (defaultPage == null ? void 0 : defaultPage[1].endsWith(_default.PARALLEL_ROUTE_DEFAULT_PATH)) === true || (defaultPage == null ? void 0 : defaultPage[1].endsWith(_defaultnull.PARALLEL_ROUTE_DEFAULT_NULL_PATH)) === true;
+}
+function hasHeadDefinition(layer) {
+    if (layer === null) return false;
+    return layer.metadata !== null || layer.viewport !== null || layer.hasStaticFilesMetadata;
+}
+function hasStaticMetadataFiles(tree) {
+    var _metadata_icon, _metadata_apple, _metadata_openGraph, _metadata_twitter;
+    const metadata = tree[2].metadata;
+    return Boolean(metadata && ((((_metadata_icon = metadata.icon) == null ? void 0 : _metadata_icon.length) ?? 0) > 0 || (((_metadata_apple = metadata.apple) == null ? void 0 : _metadata_apple.length) ?? 0) > 0 || (((_metadata_openGraph = metadata.openGraph) == null ? void 0 : _metadata_openGraph.length) ?? 0) > 0 || (((_metadata_twitter = metadata.twitter) == null ? void 0 : _metadata_twitter.length) ?? 0) > 0 || metadata.manifest !== undefined));
+}
+function selectDefaultMetadataBranch(branches, forkDepth) {
+    if (branches.length === 0) {
+        throw new _invarianterror.InvariantError('Expected at least one metadata branch');
+    }
+    let selected = branches[0];
+    for(let i = 1; i < branches.length; i++){
+        const candidate = branches[i];
+        if (selected.branch.isBuiltinFallback !== candidate.branch.isBuiltinFallback) {
+            if (!candidate.branch.isBuiltinFallback) {
+                selected = candidate;
+            }
+            continue;
+        }
+        const selectedIsChildren = selected.key === 'children';
+        const candidateIsChildren = candidate.key === 'children';
+        if (selectedIsChildren !== candidateIsChildren) {
+            const childrenBranch = selectedIsChildren ? selected : candidate;
+            const namedBranch = selectedIsChildren ? candidate : selected;
+            const childrenDefinesHead = childrenBranch.branch.definitionDepth > forkDepth;
+            const namedDefinesHead = namedBranch.branch.definitionDepth > forkDepth;
+            // Prefer children when it contributes to the head. Otherwise, allow a
+            // named slot with its own definition to provide the selected metadata.
+            selected = childrenDefinesHead || !namedDefinesHead ? childrenBranch : namedBranch;
+            continue;
+        }
+        if (candidate.branch.definitionDepth > selected.branch.definitionDepth) {
+            selected = candidate;
+            continue;
+        }
+        if (candidate.branch.definitionDepth < selected.branch.definitionDepth) {
+            continue;
+        }
+        const selectedDepth = selected.branch.keyPath.length;
+        const candidateDepth = candidate.branch.keyPath.length;
+        if (candidateDepth > selectedDepth) {
+            selected = candidate;
+            continue;
+        }
+        if (candidateDepth === selectedDepth && candidate.key < selected.key) {
+            selected = candidate;
+        }
+    }
+    return selected.branch;
+}
+async function walkMetadataTree(context, state) {
+    const [segment, parallelRoutes, { page }] = state.tree;
+    const treeRoute = appendTreeRoute(state.treeRoute, segment);
+    const isPage = page !== undefined;
+    const depth = state.keyPath.length;
+    const shouldResolveMetadata = Boolean(context.resolutionTarget & METADATA);
+    const shouldResolveViewport = Boolean(context.resolutionTarget & VIEWPORT);
+    let currentParams = state.parentParams;
+    const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment);
+    if (segmentParam) {
+        const value = context.interpolatedParams[segmentParam.paramName];
+        if (value !== null && value !== undefined) {
+            currentParams = {
+                ...state.parentParams,
+                [segmentParam.paramName]: value
+            };
+        }
+    }
+    const optionalCatchAllParamName = (segmentParam == null ? void 0 : segmentParam.paramType) === 'optional-catchall' && (context.interpolatedParams[segmentParam.paramName] === null || context.interpolatedParams[segmentParam.paramName] === undefined) ? segmentParam.paramName : state.parentOptionalCatchAllParamName;
+    const params = (0, _params.createServerParamsForMetadata)(currentParams, optionalCatchAllParamName);
+    const props = isPage ? {
+        params,
+        searchParams: context.searchParams
+    } : {
+        params
+    };
+    const layer = await collectMetadataAndViewport({
+        tree: state.tree,
+        props,
+        route: treeRoute ?? '',
+        errorConvention: context.errorConvention,
+        resolutionTarget: context.resolutionTarget
+    });
+    let definitionDepth = hasHeadDefinition(layer) ? depth : state.definitionDepth;
+    // Invoke each active generator as soon as this layer is discovered. Its
+    // parent promise is resolved later when the preceding accumulator is ready.
+    let metadata = state.metadataParent;
+    if (shouldResolveMetadata) {
+        const prerenderedMetadata = getResult(layer.metadata);
+        metadata = accumulateMetadataLayer(metadata, prerenderedMetadata, layer.staticFilesMetadata, context.route, depth, context.pathname, context.metadataContext);
+    }
+    let viewport = state.viewportParent;
+    if (shouldResolveViewport) {
+        const prerenderedViewport = getResult(layer.viewport);
+        viewport = accumulateViewportLayer(viewport, prerenderedViewport);
+    }
+    const errorLayer = layer.errorLayer || state.errorLayer;
+    let parallelRouteKeys = Object.keys(parallelRoutes);
+    if (context.selectedKeyPath !== null) {
+        const selectedKey = context.selectedKeyPath[depth];
+        if (parallelRouteKeys.length === 0) {
+            if (selectedKey !== undefined) {
+                throw new _invarianterror.InvariantError('Expected selected metadata branch to end at a leaf');
+            }
+        } else {
+            if (selectedKey === undefined || !parallelRoutes[selectedKey]) {
+                throw new _invarianterror.InvariantError('Expected selected metadata branch to match loader tree');
+            }
+            parallelRouteKeys = [
+                selectedKey
+            ];
+        }
+    }
+    if (parallelRouteKeys.length === 0) {
+        if (context.errorConvention) {
+            if (hasHeadDefinition(errorLayer)) {
+                definitionDepth = depth + 1;
+            }
+            if (shouldResolveMetadata) {
+                const errorMetadata = getResult((errorLayer == null ? void 0 : errorLayer.metadata) || null);
+                metadata = accumulateMetadataLayer(metadata, errorMetadata, (errorLayer == null ? void 0 : errorLayer.staticFilesMetadata) || Promise.resolve(null), context.route, depth + 1, context.pathname, context.metadataContext);
+            }
+            if (shouldResolveViewport) {
+                const errorViewport = getResult((errorLayer == null ? void 0 : errorLayer.viewport) || null);
+                viewport = accumulateViewportLayer(viewport, errorViewport);
+            }
+        }
+        const metadataOutcome = createMetadataBranchOutcome(metadata, context.metadataContext);
+        const viewportOutcome = createViewportBranchOutcome(viewport);
+        context.outlets.set(state.tree, createOutletPromise(metadataOutcome, viewportOutcome));
+        return {
+            metadata: metadataOutcome,
+            viewport: viewportOutcome,
+            keyPath: state.keyPath,
+            definitionDepth,
+            isBuiltinFallback: isBuiltinFallback(state.tree)
+        };
+    }
+    const cloneAtFork = parallelRouteKeys.length > 1;
+    const pendingChildBranches = [];
+    for (const parallelRouteKey of parallelRouteKeys){
+        const childTree = parallelRoutes[parallelRouteKey];
+        const childKeyPath = [
+            ...state.keyPath,
+            parallelRouteKey
+        ];
+        const branch = walkMetadataTree(context, {
+            tree: childTree,
+            treeRoute,
+            parentParams: currentParams,
+            parentOptionalCatchAllParamName: optionalCatchAllParamName,
+            metadataParent: prepareMetadataAccumulatorForChild(metadata, cloneAtFork && shouldResolveMetadata, isPageTree(childTree), context.errorConvention),
+            viewportParent: prepareViewportAccumulatorForChild(viewport, cloneAtFork && shouldResolveViewport),
+            errorLayer,
+            definitionDepth,
+            keyPath: childKeyPath
+        });
+        // Child walks start eagerly, but are awaited in order below. Observe each
+        // rejection now so a failure in one branch cannot leave a later sibling's
+        // rejection unhandled.
+        branch.catch(()=>null);
+        pendingChildBranches.push({
+            key: parallelRouteKey,
+            branch
+        });
+    }
+    const childBranches = [];
+    for (const pendingChildBranch of pendingChildBranches){
+        childBranches.push({
+            key: pendingChildBranch.key,
+            branch: await pendingChildBranch.branch
+        });
+    }
+    return selectDefaultMetadataBranch(childBranches, depth);
+}
+async function resolveMetadataTree(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext, selectedKeyPath, resolutionTarget) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw new _invarianterror.InvariantError('Expected workStore to be initialized');
+    }
+    const outlets = new Map();
+    const selectedBranch = await walkMetadataTree({
+        pathname,
+        searchParams,
+        errorConvention,
+        interpolatedParams,
+        metadataContext,
+        route: workStore.route,
+        selectedKeyPath,
+        resolutionTarget,
+        outlets
+    }, {
+        tree,
+        treeRoute: null,
+        parentParams: {},
+        parentOptionalCatchAllParamName: null,
+        metadataParent: Promise.resolve(createMetadataAccumulator()),
+        viewportParent: Promise.resolve({
+            viewport: (0, _defaultmetadata.createDefaultViewport)()
+        }),
+        errorLayer: null,
+        definitionDepth: -1,
+        keyPath: []
+    });
+    const selected = selectedBranch.metadata.then((outcome)=>{
+        if (outcome.status === 'resolved') {
+            for (const warning of outcome.warnings){
+                _log.warn(warning);
+            }
+        }
+        return outcome;
+    });
+    return {
+        selectedKeyPath: selectedBranch.keyPath,
+        selectedMetadata: selected,
+        selectedViewport: selectedBranch.viewport,
+        outlets
+    };
+}
+function resolveMetadataResolution(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext) {
+    return resolveMetadataTree(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext, null, METADATA_AND_VIEWPORT);
+}
+async function resolveMetadataForBranch(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext, selectedKeyPath) {
+    const resolution = await resolveMetadataTree(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext, selectedKeyPath, METADATA);
+    return resolution.selectedMetadata;
+}
+async function resolveViewportForBranch(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext, selectedKeyPath) {
+    const resolution = await resolveMetadataTree(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext, selectedKeyPath, VIEWPORT);
+    return resolution.selectedViewport;
+}
+function isPromiseLike(value) {
+    return typeof value === 'object' && value !== null && typeof value.then === 'function';
+}
+
+//# sourceMappingURL=resolve-metadata-parallel.js.map