@nilsr0711/drydock 0.1.0 → 0.1.1

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/server/request/params.js

@@ -1,527 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    createParamsFromClient: null,
-    createPrerenderParamsForClientSegment: null,
-    createServerParamsForMetadata: null,
-    createServerParamsForRoute: null,
-    createServerParamsForServerSegment: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createParamsFromClient: function() {
-        return createParamsFromClient;
-    },
-    createPrerenderParamsForClientSegment: function() {
-        return createPrerenderParamsForClientSegment;
-    },
-    createServerParamsForMetadata: function() {
-        return createServerParamsForMetadata;
-    },
-    createServerParamsForRoute: function() {
-        return createServerParamsForRoute;
-    },
-    createServerParamsForServerSegment: function() {
-        return createServerParamsForServerSegment;
-    }
-});
-const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
-const _varyparams = require("../app-render/vary-params");
-const _reflect = require("../web/spec-extension/adapters/reflect");
-const _dynamicrendering = require("../app-render/dynamic-rendering");
-const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
-const _invarianterror = require("../../shared/lib/invariant-error");
-const _reflectutils = require("../../shared/lib/utils/reflect-utils");
-const _dynamicrenderingutils = require("../dynamic-rendering-utils");
-const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-callsite-server-error-logger");
-const _dynamicaccessasyncstorageexternal = require("../app-render/dynamic-access-async-storage.external");
-const _stagedrendering = require("../app-render/staged-rendering");
-function createParamsFromClient(underlyingParams) {
-    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-    if (!workStore) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
-            value: "E1068",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender':
-            case 'prerender-client':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-                // Client params don't need additional vary tracking because by the
-                // time they reach the client, the access would have already been
-                // tracked by the server.
-                const varyParamsAccumulator = null;
-                return createStaticPrerenderParams(underlyingParams, null, workStore, workUnitStore, varyParamsAccumulator);
-            case 'validation-client':
-                return createClientParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples);
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E736",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-runtime':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
-                    value: "E770",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'generate-static-params':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
-                    value: "E1122",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'request':
-                if (process.env.NODE_ENV === 'development') {
-                    // Semantically we only need the dev tracking when running in `next dev`
-                    // but since you would never use next dev with production NODE_ENV we use this
-                    // as a proxy so we can statically exclude this code from production builds.
-                    const fallbackParams = workUnitStore.fallbackParams;
-                    // Client params are not runtime prefetchable
-                    const isRuntimePrefetchable = false;
-                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
-                } else if (workUnitStore.validationSamples) {
-                    return createClientParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples);
-                } else {
-                    return createRenderParamsInProd(underlyingParams);
-                }
-            default:
-                workUnitStore;
-        }
-    }
-    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
-}
-function createServerParamsForMetadata(underlyingParams, optionalCatchAllParamName, isRuntimePrefetchable) {
-    const metadataVaryParamsAccumulator = (0, _varyparams.getMetadataVaryParamsAccumulator)();
-    return createServerParamsForServerSegment(underlyingParams, optionalCatchAllParamName, metadataVaryParamsAccumulator, isRuntimePrefetchable);
-}
-function createServerParamsForRoute(underlyingParams, varyParamsAccumulator = null) {
-    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-    if (!workStore) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
-            value: "E1068",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-                return createStaticPrerenderParams(underlyingParams, null, workStore, workUnitStore, varyParamsAccumulator);
-            case 'prerender-client':
-            case 'validation-client':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called in client contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E1064",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E738",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'generate-static-params':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
-                    value: "E1131",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-runtime':
-                {
-                    // Route params are not runtime prefetchable
-                    const isRuntimePrefetchable = false;
-                    return createRuntimePrerenderParams(underlyingParams, null, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
-                }
-            case 'request':
-                if (process.env.NODE_ENV === 'development') {
-                    // Semantically we only need the dev tracking when running in `next dev`
-                    // but since you would never use next dev with production NODE_ENV we use this
-                    // as a proxy so we can statically exclude this code from production builds.
-                    const fallbackParams = workUnitStore.fallbackParams;
-                    // Route params are not runtime prefetchable
-                    const isRuntimePrefetchable = false;
-                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
-                } else {
-                    return createRenderParamsInProd(underlyingParams);
-                }
-            default:
-                workUnitStore;
-        }
-    }
-    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
-}
-function createServerParamsForServerSegment(underlyingParams, optionalCatchAllParamName, varyParamsAccumulator, isRuntimePrefetchable) {
-    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-    if (!workStore) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
-            value: "E1068",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender':
-            case 'prerender-client':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-                return createStaticPrerenderParams(underlyingParams, optionalCatchAllParamName, workStore, workUnitStore, varyParamsAccumulator);
-            case 'validation-client':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForServerSegment should not be called in client contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E1101",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForServerSegment should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E743",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'generate-static-params':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForServerSegment should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
-                    value: "E1120",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-runtime':
-                return createRuntimePrerenderParams(underlyingParams, optionalCatchAllParamName, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
-            case 'request':
-                if (process.env.NODE_ENV === 'development') {
-                    // Semantically we only need the dev tracking when running in `next dev`
-                    // but since you would never use next dev with production NODE_ENV we use this
-                    // as a proxy so we can statically exclude this code from production builds.
-                    const fallbackParams = workUnitStore.fallbackParams;
-                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
-                } else if (workUnitStore.asyncApiPromises && workUnitStore.validationSamples) {
-                    return createServerParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples, workUnitStore.asyncApiPromises, isRuntimePrefetchable);
-                } else if (workUnitStore.asyncApiPromises && hasFallbackRouteParams(underlyingParams, workUnitStore.fallbackParams)) {
-                    return (isRuntimePrefetchable ? workUnitStore.asyncApiPromises.earlySharedParamsParent : workUnitStore.asyncApiPromises.sharedParamsParent).then(()=>underlyingParams);
-                } else {
-                    return createRenderParamsInProd(underlyingParams);
-                }
-            default:
-                workUnitStore;
-        }
-    }
-    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
-}
-function createPrerenderParamsForClientSegment(underlyingParams) {
-    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-    if (!workStore) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Missing workStore in createPrerenderParamsForClientSegment'), "__NEXT_ERROR_CODE", {
-            value: "E773",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender':
-            case 'prerender-client':
-                const fallbackParams = workUnitStore.fallbackRouteParams;
-                if (fallbackParams) {
-                    for(let key in underlyingParams){
-                        if (fallbackParams.has(key)) {
-                            // This params object has one or more fallback params, so we need
-                            // to consider the awaiting of this params object "dynamic". Since
-                            // we are in cacheComponents mode we encode this as a promise that never
-                            // resolves.
-                            return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`params`');
-                        }
-                    }
-                }
-                break;
-            case 'validation-client':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderParamsForClientSegment should not be called in validation contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E1099",
-                    enumerable: false,
-                    configurable: true
-                });
-                break;
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderParamsForClientSegment should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E734",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'generate-static-params':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderParamsForClientSegment should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
-                    value: "E1126",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-            case 'prerender-runtime':
-            case 'request':
-                break;
-            default:
-                workUnitStore;
-        }
-    }
-    // We're prerendering in a mode that does not abort. We resolve the promise without
-    // any tracking because we're just transporting a value from server to client where the tracking
-    // will be applied.
-    return Promise.resolve(underlyingParams);
-}
-function createStaticPrerenderParams(underlyingParams, optionalCatchAllParamName, workStore, prerenderStore, varyParamsAccumulator) {
-    const underlyingParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName) : underlyingParams;
-    switch(prerenderStore.type){
-        case 'prerender':
-        case 'prerender-client':
-            {
-                const fallbackParams = prerenderStore.fallbackRouteParams;
-                if (fallbackParams) {
-                    for(const key in underlyingParams){
-                        if (fallbackParams.has(key)) {
-                            // This params object has one or more fallback params, so we need
-                            // to consider the awaiting of this params object "dynamic". Since
-                            // we are in cacheComponents mode we encode this as a promise that never
-                            // resolves.
-                            return makeHangingParams(underlyingParamsWithVarying, workStore, prerenderStore);
-                        }
-                    }
-                }
-                break;
-            }
-        case 'prerender-ppr':
-            {
-                const fallbackParams = prerenderStore.fallbackRouteParams;
-                if (fallbackParams) {
-                    for(const key in underlyingParams){
-                        if (fallbackParams.has(key)) {
-                            return makeErroringParams(underlyingParamsWithVarying, fallbackParams, workStore, prerenderStore);
-                        }
-                    }
-                }
-                break;
-            }
-        case 'prerender-legacy':
-            break;
-        default:
-            prerenderStore;
-    }
-    return makeUntrackedParams(underlyingParamsWithVarying);
-}
-function createRuntimePrerenderParams(underlyingParams, optionalCatchAllParamName, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable) {
-    const underlyingParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName) : underlyingParams;
-    const result = makeUntrackedParams(underlyingParamsWithVarying);
-    const { stagedRendering } = workUnitStore;
-    if (!stagedRendering) {
-        return result;
-    }
-    const stage = isRuntimePrefetchable ? _stagedrendering.RenderStage.EarlyRuntime : _stagedrendering.RenderStage.Runtime;
-    return stagedRendering.waitForStage(stage).then(()=>result);
-}
-function hasFallbackRouteParams(underlyingParams, fallbackParams) {
-    if (fallbackParams) {
-        for(let key in underlyingParams){
-            if (fallbackParams.has(key)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function createServerParamsInInstantValidation(underlyingParams, workStore, validationSamples, asyncApiPromises, isRuntimePrefetchable) {
-    const { createExhaustiveParamsProxy } = require('../app-render/instant-validation/instant-samples');
-    const declaredParams = new Set(Object.keys(validationSamples.params ?? {}));
-    const proxiedUnderlying = createExhaustiveParamsProxy(underlyingParams, declaredParams, workStore.route);
-    return (isRuntimePrefetchable ? asyncApiPromises.earlySharedParamsParent : asyncApiPromises.sharedParamsParent).then(()=>proxiedUnderlying);
-}
-function createClientParamsInInstantValidation(underlyingParams, workStore, validationSamples) {
-    const { createExhaustiveParamsProxy } = require('../app-render/instant-validation/instant-samples');
-    const declaredParams = new Set(Object.keys((validationSamples == null ? void 0 : validationSamples.params) ?? {}));
-    const proxiedUnderlying = createExhaustiveParamsProxy(underlyingParams, declaredParams, workStore.route);
-    return Promise.resolve(proxiedUnderlying);
-}
-function createRenderParamsInProd(underlyingParams) {
-    return makeUntrackedParams(underlyingParams);
-}
-function createRenderParamsInDev(underlyingParams, fallbackParams, workStore, requestStore, isRuntimePrefetchable) {
-    return makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackRouteParams(underlyingParams, fallbackParams), workStore, requestStore, isRuntimePrefetchable);
-}
-const CachedParams = new WeakMap();
-const fallbackParamsProxyHandler = {
-    get: function get(target, prop, receiver) {
-        if (prop === 'then' || prop === 'catch' || prop === 'finally') {
-            const originalMethod = _reflect.ReflectAdapter.get(target, prop, receiver);
-            return ({
-                [prop]: (...args)=>{
-                    const store = _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.getStore();
-                    if (store) {
-                        store.abortController.abort(Object.defineProperty(new Error(`Accessed fallback \`params\` during prerendering.`), "__NEXT_ERROR_CODE", {
-                            value: "E691",
-                            enumerable: false,
-                            configurable: true
-                        }));
-                    }
-                    return new Proxy(originalMethod.apply(target, args), fallbackParamsProxyHandler);
-                }
-            })[prop];
-        }
-        return _reflect.ReflectAdapter.get(target, prop, receiver);
-    }
-};
-function makeHangingParams(underlyingParams, workStore, prerenderStore) {
-    const cachedParams = CachedParams.get(underlyingParams);
-    if (cachedParams) {
-        return cachedParams;
-    }
-    const promise = new Proxy((0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`params`'), fallbackParamsProxyHandler);
-    CachedParams.set(underlyingParams, promise);
-    return promise;
-}
-function makeErroringParams(underlyingParams, fallbackParams, workStore, prerenderStore) {
-    const cachedParams = CachedParams.get(underlyingParams);
-    if (cachedParams) {
-        return cachedParams;
-    }
-    const augmentedUnderlying = {
-        ...underlyingParams
-    };
-    // We don't use makeResolvedReactPromise here because params
-    // supports copying with spread and we don't want to unnecessarily
-    // instrument the promise with spreadable properties of ReactPromise.
-    const promise = Promise.resolve(augmentedUnderlying);
-    CachedParams.set(underlyingParams, promise);
-    Object.keys(underlyingParams).forEach((prop)=>{
-        if (_reflectutils.wellKnownProperties.has(prop)) {
-        // These properties cannot be shadowed because they need to be the
-        // true underlying value for Promises to work correctly at runtime
-        } else {
-            if (fallbackParams.has(prop)) {
-                Object.defineProperty(augmentedUnderlying, prop, {
-                    get () {
-                        const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
-                        // In most dynamic APIs we also throw if `dynamic = "error"` however
-                        // for params is only dynamic when we're generating a fallback shell
-                        // and even when `dynamic = "error"` we still support generating dynamic
-                        // fallback shells
-                        // TODO remove this comment when cacheComponents is the default since there
-                        // will be no `dynamic = "error"`
-                        if (prerenderStore.type === 'prerender-ppr') {
-                            // PPR Prerender (no cacheComponents)
-                            (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
-                        } else {
-                            // Legacy Prerender
-                            (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
-                        }
-                    },
-                    enumerable: true
-                });
-            }
-        }
-    });
-    return promise;
-}
-function makeUntrackedParams(underlyingParams) {
-    const cachedParams = CachedParams.get(underlyingParams);
-    if (cachedParams) {
-        return cachedParams;
-    }
-    const promise = Promise.resolve(underlyingParams);
-    CachedParams.set(underlyingParams, promise);
-    return promise;
-}
-function makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackParams, workStore, requestStore, isRuntimePrefetchable) {
-    if (requestStore.asyncApiPromises && hasFallbackParams) {
-        // We wrap each instance of params in a `new Promise()`, because deduping
-        // them across requests doesn't work anyway and this let us show each
-        // await a different set of values. This is important when all awaits
-        // are in third party which would otherwise track all the way to the
-        // internal params.
-        const sharedParamsParent = isRuntimePrefetchable ? requestStore.asyncApiPromises.earlySharedParamsParent : requestStore.asyncApiPromises.sharedParamsParent;
-        const promise = new Promise((resolve, reject)=>{
-            sharedParamsParent.then(()=>resolve(underlyingParams), reject);
-        });
-        // @ts-expect-error
-        promise.displayName = 'params';
-        return instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
-    }
-    const cachedParams = CachedParams.get(underlyingParams);
-    if (cachedParams) {
-        return cachedParams;
-    }
-    // We don't use makeResolvedReactPromise here because params
-    // supports copying with spread and we don't want to unnecessarily
-    // instrument the promise with spreadable properties of ReactPromise.
-    const promise = hasFallbackParams ? (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingParams, requestStore, _stagedrendering.RenderStage.Runtime) : Promise.resolve(underlyingParams);
-    const proxiedPromise = instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
-    CachedParams.set(underlyingParams, proxiedPromise);
-    return proxiedPromise;
-}
-function instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore) {
-    // Track which properties we should warn for.
-    const proxiedProperties = new Set();
-    Object.keys(underlyingParams).forEach((prop)=>{
-        if (_reflectutils.wellKnownProperties.has(prop)) {
-        // These properties cannot be shadowed because they need to be the
-        // true underlying value for Promises to work correctly at runtime
-        } else {
-            proxiedProperties.add(prop);
-        }
-    });
-    return new Proxy(promise, {
-        get (target, prop, receiver) {
-            if (typeof prop === 'string') {
-                if (// We are accessing a property that was proxied to the promise instance
-                proxiedProperties.has(prop)) {
-                    const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
-                    warnForSyncAccess(workStore.route, expression);
-                }
-            }
-            return _reflect.ReflectAdapter.get(target, prop, receiver);
-        },
-        set (target, prop, value, receiver) {
-            if (typeof prop === 'string') {
-                proxiedProperties.delete(prop);
-            }
-            return _reflect.ReflectAdapter.set(target, prop, value, receiver);
-        },
-        ownKeys (target) {
-            const expression = '`...params` or similar expression';
-            warnForSyncAccess(workStore.route, expression);
-            return Reflect.ownKeys(target);
-        }
-    });
-}
-const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createParamsAccessError);
-function createParamsAccessError(route, expression) {
-    const prefix = route ? `Route "${route}" ` : 'This route ';
-    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`params\` is a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
-        value: "E834",
-        enumerable: false,
-        configurable: true
-    });
-}
-
-//# sourceMappingURL=params.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/server/request/pathname.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "createServerPathnameForMetadata", {
-    enumerable: true,
-    get: function() {
-        return createServerPathnameForMetadata;
-    }
-});
-const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
-const _dynamicrendering = require("../app-render/dynamic-rendering");
-const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
-const _dynamicrenderingutils = require("../dynamic-rendering-utils");
-const _invarianterror = require("../../shared/lib/invariant-error");
-function createServerPathnameForMetadata(underlyingPathname) {
-    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-    if (!workStore) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
-            value: "E1068",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-                {
-                    return createPrerenderPathname(underlyingPathname, workStore, workUnitStore);
-                }
-            case 'prerender-client':
-            case 'validation-client':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerPathnameForMetadata should not be called in client contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E1065",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerPathnameForMetadata should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E740",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'generate-static-params':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerPathnameForMetadata should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
-                    value: "E1129",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-runtime':
-                return (0, _dynamicrenderingutils.delayUntilRuntimeStage)(workUnitStore, createRenderPathname(underlyingPathname));
-            case 'request':
-                return createRenderPathname(underlyingPathname);
-            default:
-                workUnitStore;
-        }
-    }
-    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
-}
-function createPrerenderPathname(underlyingPathname, workStore, prerenderStore) {
-    switch(prerenderStore.type){
-        case 'prerender':
-            {
-                const fallbackParams = prerenderStore.fallbackRouteParams;
-                if (fallbackParams && fallbackParams.size > 0) {
-                    return (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`pathname`');
-                }
-                break;
-            }
-        case 'prerender-ppr':
-            {
-                const fallbackParams = prerenderStore.fallbackRouteParams;
-                if (fallbackParams && fallbackParams.size > 0) {
-                    return makeErroringPathname(workStore, prerenderStore.dynamicTracking);
-                }
-                break;
-            }
-        case 'prerender-legacy':
-            break;
-        default:
-            prerenderStore;
-    }
-    // We don't have any fallback params so we have an entirely static safe params object
-    return Promise.resolve(underlyingPathname);
-}
-function makeErroringPathname(workStore, dynamicTracking) {
-    let reject = null;
-    const promise = new Promise((_, re)=>{
-        reject = re;
-    });
-    const originalThen = promise.then.bind(promise);
-    // We instrument .then so that we can generate a tracking event only if you actually
-    // await this promise, not just that it is created.
-    promise.then = (onfulfilled, onrejected)=>{
-        if (reject) {
-            try {
-                (0, _dynamicrendering.postponeWithTracking)(workStore.route, 'metadata relative url resolving', dynamicTracking);
-            } catch (error) {
-                reject(error);
-                reject = null;
-            }
-        }
-        return originalThen(onfulfilled, onrejected);
-    };
-    // We wrap in a noop proxy to trick the runtime into thinking it
-    // isn't a native promise (it's not really). This is so that awaiting
-    // the promise will call the `then` property triggering the lazy postpone
-    return new Proxy(promise, {});
-}
-function createRenderPathname(underlyingPathname) {
-    return Promise.resolve(underlyingPathname);
-}
-
-//# sourceMappingURL=pathname.js.map