mcp-deploy 0.1.0

package/.next/standalone/node_modules/next/dist/server/app-render/react-large-shell-error.js

@@ -0,0 +1,17 @@
+// TODO: isWellKnownError -> isNextInternalError
+// isReactLargeShellError -> isWarning
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isReactLargeShellError", {
+    enumerable: true,
+    get: function() {
+        return isReactLargeShellError;
+    }
+});
+function isReactLargeShellError(error) {
+    return typeof error === 'object' && error !== null && 'message' in error && typeof error.message === 'string' && error.message.startsWith('This rendered a large document (>');
+}
+
+//# sourceMappingURL=react-large-shell-error.js.map

package/.next/standalone/node_modules/next/dist/server/app-render/react-server.node.js

@@ -0,0 +1,39 @@
+// This file should be opted into the react-server layer
+// eslint-disable-next-line import/no-extraneous-dependencies
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createTemporaryReferenceSet: null,
+    decodeAction: null,
+    decodeFormState: null,
+    decodeReply: null,
+    decodeReplyFromBusboy: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createTemporaryReferenceSet: function() {
+        return _servernode.createTemporaryReferenceSet;
+    },
+    decodeAction: function() {
+        return _servernode.decodeAction;
+    },
+    decodeFormState: function() {
+        return _servernode.decodeFormState;
+    },
+    decodeReply: function() {
+        return _servernode.decodeReply;
+    },
+    decodeReplyFromBusboy: function() {
+        return _servernode.decodeReplyFromBusboy;
+    }
+});
+const _servernode = require("react-server-dom-webpack/server.node");
+
+//# sourceMappingURL=react-server.node.js.map

package/.next/standalone/node_modules/next/dist/server/app-render/render-css-resource.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderCssResource", {
+    enumerable: true,
+    get: function() {
+        return renderCssResource;
+    }
+});
+const _encodeuripath = require("../../shared/lib/encode-uri-path");
+const _getassetquerystring = require("./get-asset-query-string");
+function renderCssResource(entryCssFiles, ctx, preloadCallbacks) {
+    const { componentMod: { createElement } } = ctx;
+    return entryCssFiles.map((entryCssFile, index)=>{
+        // `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_' + entryCssFile.path : 'next';
+        // In dev, Safari and Firefox will cache the resource during HMR:
+        // - https://github.com/vercel/next.js/issues/5860
+        // - https://bugs.webkit.org/show_bug.cgi?id=187726
+        // Because of this, we add a `?v=` query to bypass the cache during
+        // development. We need to also make sure that the number is always
+        // increasing.
+        const fullHref = `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(entryCssFile.path)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`;
+        if (entryCssFile.inlined && !ctx.parsedRequestHeaders.isRSCRequest) {
+            return createElement('style', {
+                key: index,
+                nonce: ctx.nonce,
+                precedence: precedence,
+                href: fullHref
+            }, entryCssFile.content);
+        }
+        preloadCallbacks == null ? void 0 : preloadCallbacks.push(()=>{
+            ctx.componentMod.preloadStyle(fullHref, ctx.renderOpts.crossOrigin, ctx.nonce);
+        });
+        return createElement('link', {
+            key: index,
+            rel: 'stylesheet',
+            href: fullHref,
+            precedence: precedence,
+            crossOrigin: ctx.renderOpts.crossOrigin,
+            nonce: ctx.nonce
+        });
+    });
+}
+
+//# sourceMappingURL=render-css-resource.js.map

package/.next/standalone/node_modules/next/dist/server/app-render/required-scripts.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getRequiredScripts", {
+    enumerable: true,
+    get: function() {
+        return getRequiredScripts;
+    }
+});
+const _encodeuripath = require("../../shared/lib/encode-uri-path");
+const _reactdom = /*#__PURE__*/ _interop_require_default(require("react-dom"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getRequiredScripts(buildManifest, assetPrefix, crossOrigin, SRIManifest, qs, nonce, pagePath) {
+    var _buildManifest_rootMainFilesTree;
+    let preinitScripts;
+    let preinitScriptCommands = [];
+    const bootstrapScript = {
+        src: '',
+        crossOrigin
+    };
+    const files = (((_buildManifest_rootMainFilesTree = buildManifest.rootMainFilesTree) == null ? void 0 : _buildManifest_rootMainFilesTree[pagePath]) || buildManifest.rootMainFiles).map(_encodeuripath.encodeURIPath);
+    if (files.length === 0) {
+        throw Object.defineProperty(new Error('Invariant: missing bootstrap script. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
+            value: "E459",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if (SRIManifest) {
+        bootstrapScript.src = `${assetPrefix}/_next/` + files[0] + qs;
+        bootstrapScript.integrity = SRIManifest[files[0]];
+        for(let i = 1; i < files.length; i++){
+            const src = `${assetPrefix}/_next/` + files[i] + qs;
+            const integrity = SRIManifest[files[i]];
+            preinitScriptCommands.push(src, integrity);
+        }
+        preinitScripts = ()=>{
+            // preinitScriptCommands is a double indexed array of src/integrity pairs
+            for(let i = 0; i < preinitScriptCommands.length; i += 2){
+                _reactdom.default.preinit(preinitScriptCommands[i], {
+                    as: 'script',
+                    integrity: preinitScriptCommands[i + 1],
+                    crossOrigin,
+                    nonce
+                });
+            }
+        };
+    } else {
+        bootstrapScript.src = `${assetPrefix}/_next/` + files[0] + qs;
+        for(let i = 1; i < files.length; i++){
+            const src = `${assetPrefix}/_next/` + files[i] + qs;
+            preinitScriptCommands.push(src);
+        }
+        preinitScripts = ()=>{
+            // preinitScriptCommands is a singled indexed array of src values
+            for(let i = 0; i < preinitScriptCommands.length; i++){
+                _reactdom.default.preinit(preinitScriptCommands[i], {
+                    as: 'script',
+                    nonce,
+                    crossOrigin
+                });
+            }
+        };
+    }
+    return [
+        preinitScripts,
+        bootstrapScript
+    ];
+}
+
+//# sourceMappingURL=required-scripts.js.map

package/.next/standalone/node_modules/next/dist/server/app-render/segment-explorer-path.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    BOUNDARY_PREFIX: null,
+    BOUNDARY_SUFFIX: null,
+    BUILTIN_PREFIX: null,
+    getBoundaryOriginFileType: null,
+    getConventionPathByType: null,
+    isBoundaryFile: null,
+    isBuiltinBoundaryFile: null,
+    isNextjsBuiltinFilePath: null,
+    normalizeBoundaryFilename: null,
+    normalizeConventionFilePath: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    BOUNDARY_PREFIX: function() {
+        return BOUNDARY_PREFIX;
+    },
+    BOUNDARY_SUFFIX: function() {
+        return BOUNDARY_SUFFIX;
+    },
+    BUILTIN_PREFIX: function() {
+        return BUILTIN_PREFIX;
+    },
+    getBoundaryOriginFileType: function() {
+        return getBoundaryOriginFileType;
+    },
+    getConventionPathByType: function() {
+        return getConventionPathByType;
+    },
+    isBoundaryFile: function() {
+        return isBoundaryFile;
+    },
+    isBuiltinBoundaryFile: function() {
+        return isBuiltinBoundaryFile;
+    },
+    isNextjsBuiltinFilePath: function() {
+        return isNextjsBuiltinFilePath;
+    },
+    normalizeBoundaryFilename: function() {
+        return normalizeBoundaryFilename;
+    },
+    normalizeConventionFilePath: function() {
+        return normalizeConventionFilePath;
+    }
+});
+const BUILTIN_PREFIX = '__next_builtin__';
+const nextInternalPrefixRegex = /^(.*[\\/])?next[\\/]dist[\\/]client[\\/]components[\\/]builtin[\\/]/;
+function normalizeConventionFilePath(projectDir, conventionPath) {
+    // Turbopack project path is formed as: "<project root>/<cwd>".
+    // When project root is not the working directory, we can extract the relative project root path.
+    // This is mostly used for running Next.js inside a monorepo.
+    const cwd = process.env.NEXT_RUNTIME === 'edge' ? '' : process.cwd();
+    const relativeProjectRoot = projectDir.replace(cwd, '');
+    let relativePath = (conventionPath || '')// remove turbopack [project] prefix
+    .replace(/^\[project\]/, '')// remove turbopack relative project path, everything after [project] and before the working directory.
+    .replace(relativeProjectRoot, '')// remove the project root from the path
+    .replace(projectDir, '')// remove cwd prefix
+    .replace(cwd, '')// remove /(src/)?app/ dir prefix
+    .replace(/^([\\/])*(src[\\/])?app[\\/]/, '');
+    // If it's internal file only keep the filename, strip nextjs internal prefix
+    if (nextInternalPrefixRegex.test(relativePath)) {
+        relativePath = relativePath.replace(nextInternalPrefixRegex, '');
+        // Add a special prefix to let segment explorer know it's a built-in component
+        relativePath = `${BUILTIN_PREFIX}${relativePath}`;
+    }
+    return relativePath.replace(/\\/g, '/');
+}
+const isNextjsBuiltinFilePath = (filePath)=>{
+    return nextInternalPrefixRegex.test(filePath);
+};
+const BOUNDARY_SUFFIX = '@boundary';
+function normalizeBoundaryFilename(filename) {
+    return filename.replace(new RegExp(`^${BUILTIN_PREFIX}`), '').replace(new RegExp(`${BOUNDARY_SUFFIX}$`), '');
+}
+const BOUNDARY_PREFIX = 'boundary:';
+function isBoundaryFile(fileType) {
+    return fileType.startsWith(BOUNDARY_PREFIX);
+}
+function isBuiltinBoundaryFile(fileType) {
+    return fileType.startsWith(BUILTIN_PREFIX);
+}
+function getBoundaryOriginFileType(fileType) {
+    return fileType.replace(BOUNDARY_PREFIX, '');
+}
+function getConventionPathByType(tree, dir, conventionType) {
+    const modules = tree[2];
+    const conventionPath = modules[conventionType] ? modules[conventionType][1] : undefined;
+    if (conventionPath) {
+        return normalizeConventionFilePath(dir, conventionPath);
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=segment-explorer-path.js.map

package/.next/standalone/node_modules/next/dist/server/app-render/server-inserted-html.js

@@ -0,0 +1,77 @@
+/* eslint-disable @next/internal/no-ambiguous-jsx -- whole module is used in React Client */ // Provider for the `useServerInsertedHTML` API to register callbacks to insert
+// elements into the HTML stream.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createServerInsertedHTML", {
+    enumerable: true,
+    get: function() {
+        return createServerInsertedHTML;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _serverinsertedhtmlsharedruntime = require("../../shared/lib/server-inserted-html.shared-runtime");
+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;
+}
+function createServerInsertedHTML() {
+    const serverInsertedHTMLCallbacks = [];
+    const addInsertedHtml = (handler)=>{
+        serverInsertedHTMLCallbacks.push(handler);
+    };
+    return {
+        ServerInsertedHTMLProvider ({ children }) {
+            return /*#__PURE__*/ (0, _jsxruntime.jsx)(_serverinsertedhtmlsharedruntime.ServerInsertedHTMLContext.Provider, {
+                value: addInsertedHtml,
+                children: children
+            });
+        },
+        renderServerInsertedHTML () {
+            return serverInsertedHTMLCallbacks.map((callback, index)=>/*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Fragment, {
+                    children: callback()
+                }, '__next_server_inserted__' + index));
+        }
+    };
+}
+
+//# sourceMappingURL=server-inserted-html.js.map

package/.next/standalone/node_modules/next/dist/server/app-render/staged-rendering.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    RenderStage: null,
+    StagedRenderingController: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    RenderStage: function() {
+        return RenderStage;
+    },
+    StagedRenderingController: function() {
+        return StagedRenderingController;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
+var RenderStage = /*#__PURE__*/ function(RenderStage) {
+    RenderStage[RenderStage["Before"] = 1] = "Before";
+    RenderStage[RenderStage["Static"] = 2] = "Static";
+    RenderStage[RenderStage["Runtime"] = 3] = "Runtime";
+    RenderStage[RenderStage["Dynamic"] = 4] = "Dynamic";
+    RenderStage[RenderStage["Abandoned"] = 5] = "Abandoned";
+    return RenderStage;
+}({});
+class StagedRenderingController {
+    constructor(abortSignal = null, hasRuntimePrefetch){
+        this.abortSignal = abortSignal;
+        this.hasRuntimePrefetch = hasRuntimePrefetch;
+        this.currentStage = 1;
+        this.staticInterruptReason = null;
+        this.runtimeInterruptReason = null;
+        this.staticStageEndTime = Infinity;
+        this.runtimeStageEndTime = Infinity;
+        this.runtimeStageListeners = [];
+        this.dynamicStageListeners = [];
+        this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.mayAbandon = false;
+        if (abortSignal) {
+            abortSignal.addEventListener('abort', ()=>{
+                const { reason } = abortSignal;
+                if (this.currentStage < 3) {
+                    this.runtimeStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
+                    ;
+                    this.runtimeStagePromise.reject(reason);
+                }
+                if (this.currentStage < 4 || this.currentStage === 5) {
+                    this.dynamicStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
+                    ;
+                    this.dynamicStagePromise.reject(reason);
+                }
+            }, {
+                once: true
+            });
+            this.mayAbandon = true;
+        }
+    }
+    onStage(stage, callback) {
+        if (this.currentStage >= stage) {
+            callback();
+        } else if (stage === 3) {
+            this.runtimeStageListeners.push(callback);
+        } else if (stage === 4) {
+            this.dynamicStageListeners.push(callback);
+        } else {
+            // This should never happen
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
+                value: "E881",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    canSyncInterrupt() {
+        // If we haven't started the render yet, it can't be interrupted.
+        if (this.currentStage === 1) {
+            return false;
+        }
+        const boundaryStage = this.hasRuntimePrefetch ? 4 : 3;
+        return this.currentStage < boundaryStage;
+    }
+    syncInterruptCurrentStageWithReason(reason) {
+        if (this.currentStage === 1) {
+            return;
+        }
+        // If Sync IO occurs during the initial (abandonable) render, we'll retry it,
+        // so we want a slightly different flow.
+        // See the implementation of `abandonRenderImpl` for more explanation.
+        if (this.mayAbandon) {
+            return this.abandonRenderImpl();
+        }
+        // If we're in the final render, we cannot abandon it. We need to advance to the Dynamic stage
+        // and capture the interruption reason.
+        switch(this.currentStage){
+            case 2:
+                {
+                    this.staticInterruptReason = reason;
+                    this.advanceStage(4);
+                    return;
+                }
+            case 3:
+                {
+                    // We only error for Sync IO in the runtime stage if the route
+                    // is configured to use runtime prefetching.
+                    // We do this to reflect the fact that during a runtime prefetch,
+                    // Sync IO aborts aborts the render.
+                    // Note that `canSyncInterrupt` should prevent us from getting here at all
+                    // if runtime prefetching isn't enabled.
+                    if (this.hasRuntimePrefetch) {
+                        this.runtimeInterruptReason = reason;
+                        this.advanceStage(4);
+                    }
+                    return;
+                }
+            case 4:
+            case 5:
+            default:
+        }
+    }
+    getStaticInterruptReason() {
+        return this.staticInterruptReason;
+    }
+    getRuntimeInterruptReason() {
+        return this.runtimeInterruptReason;
+    }
+    getStaticStageEndTime() {
+        return this.staticStageEndTime;
+    }
+    getRuntimeStageEndTime() {
+        return this.runtimeStageEndTime;
+    }
+    abandonRender() {
+        if (!this.mayAbandon) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('`abandonRender` called on a stage controller that cannot be abandoned.'), "__NEXT_ERROR_CODE", {
+                value: "E938",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        this.abandonRenderImpl();
+    }
+    abandonRenderImpl() {
+        // In staged rendering, only the initial render is abandonable.
+        // We can abandon the initial render if
+        //   1. We notice a cache miss, and need to wait for caches to fill
+        //   2. A sync IO error occurs, and the render should be interrupted
+        //      (this might be a lazy intitialization of a module,
+        //       so we still want to restart in this case and see if it still occurs)
+        // In either case, we'll be doing another render after this one,
+        // so we only want to unblock the Runtime stage, not Dynamic, because
+        // unblocking the dynamic stage would likely lead to wasted (uncached) IO.
+        const { currentStage } = this;
+        switch(currentStage){
+            case 2:
+                {
+                    this.currentStage = 5;
+                    this.resolveRuntimeStage();
+                    return;
+                }
+            case 3:
+                {
+                    this.currentStage = 5;
+                    return;
+                }
+            case 4:
+            case 1:
+            case 5:
+                break;
+            default:
+                {
+                    currentStage;
+                }
+        }
+    }
+    advanceStage(stage) {
+        // If we're already at the target stage or beyond, do nothing.
+        // (this can happen e.g. if sync IO advanced us to the dynamic stage)
+        if (stage <= this.currentStage) {
+            return;
+        }
+        let currentStage = this.currentStage;
+        this.currentStage = stage;
+        if (currentStage < 3 && stage >= 3) {
+            this.staticStageEndTime = performance.now() + performance.timeOrigin;
+            this.resolveRuntimeStage();
+        }
+        if (currentStage < 4 && stage >= 4) {
+            this.runtimeStageEndTime = performance.now() + performance.timeOrigin;
+            this.resolveDynamicStage();
+            return;
+        }
+    }
+    /** Fire the `onStage` listeners for the runtime stage and unblock any promises waiting for it. */ resolveRuntimeStage() {
+        const runtimeListeners = this.runtimeStageListeners;
+        for(let i = 0; i < runtimeListeners.length; i++){
+            runtimeListeners[i]();
+        }
+        runtimeListeners.length = 0;
+        this.runtimeStagePromise.resolve();
+    }
+    /** Fire the `onStage` listeners for the dynamic stage and unblock any promises waiting for it. */ resolveDynamicStage() {
+        const dynamicListeners = this.dynamicStageListeners;
+        for(let i = 0; i < dynamicListeners.length; i++){
+            dynamicListeners[i]();
+        }
+        dynamicListeners.length = 0;
+        this.dynamicStagePromise.resolve();
+    }
+    getStagePromise(stage) {
+        switch(stage){
+            case 3:
+                {
+                    return this.runtimeStagePromise.promise;
+                }
+            case 4:
+                {
+                    return this.dynamicStagePromise.promise;
+                }
+            default:
+                {
+                    stage;
+                    throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
+                        value: "E881",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+        }
+    }
+    waitForStage(stage) {
+        return this.getStagePromise(stage);
+    }
+    delayUntilStage(stage, displayName, resolvedValue) {
+        const ioTriggerPromise = this.getStagePromise(stage);
+        const promise = makeDevtoolsIOPromiseFromIOTrigger(ioTriggerPromise, displayName, resolvedValue);
+        // Analogously to `makeHangingPromise`, we might reject this promise if the signal is invoked.
+        // (e.g. in the case where we don't want want the render to proceed to the dynamic stage and abort it).
+        // We shouldn't consider this an unhandled rejection, so we attach a noop catch handler here to suppress this warning.
+        if (this.abortSignal) {
+            promise.catch(ignoreReject);
+        }
+        return promise;
+    }
+}
+function ignoreReject() {}
+// TODO(restart-on-cache-miss): the layering of `delayUntilStage`,
+// `makeDevtoolsIOPromiseFromIOTrigger` and and `makeDevtoolsIOAwarePromise`
+// is confusing, we should clean it up.
+function makeDevtoolsIOPromiseFromIOTrigger(ioTrigger, displayName, resolvedValue) {
+    // If we create a `new Promise` and give it a displayName
+    // (with no userspace code above us in the stack)
+    // React Devtools will use it as the IO cause when determining "suspended by".
+    // In particular, it should shadow any inner IO that resolved/rejected the promise
+    // (in case of staged rendering, this will be the `setTimeout` that triggers the relevant stage)
+    const promise = new Promise((resolve, reject)=>{
+        ioTrigger.then(resolve.bind(null, resolvedValue), reject);
+    });
+    if (displayName !== undefined) {
+        // @ts-expect-error
+        promise.displayName = displayName;
+    }
+    return promise;
+}
+
+//# sourceMappingURL=staged-rendering.js.map

package/.next/standalone/node_modules/next/dist/server/app-render/staged-validation.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "anySegmentHasRuntimePrefetchEnabled", {
+    enumerable: true,
+    get: function() {
+        return anySegmentHasRuntimePrefetchEnabled;
+    }
+});
+const _appdirmodule = require("../lib/app-dir-module");
+const _parseloadertree = require("../../shared/lib/router/utils/parse-loader-tree");
+async function anySegmentHasRuntimePrefetchEnabled(tree) {
+    const { mod: layoutOrPageMod } = await (0, _appdirmodule.getLayoutOrPageModule)(tree);
+    // TODO(restart-on-cache-miss): Does this work correctly for client page/layout modules?
+    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';
+    if (hasRuntimePrefetch) {
+        return true;
+    }
+    const { parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+    for(const parallelRouteKey in parallelRoutes){
+        const parallelRoute = parallelRoutes[parallelRouteKey];
+        const hasChildRuntimePrefetch = await anySegmentHasRuntimePrefetchEnabled(parallelRoute);
+        if (hasChildRuntimePrefetch) {
+            return true;
+        }
+    }
+    return false;
+}
+
+//# sourceMappingURL=staged-validation.js.map