{"version":3,"sources":["../../../src/server/request/search-params.ts"],"sourcesContent":["import type { WorkStore } from '../app-render/work-async-storage.external'\n\nimport { ReflectAdapter } from '../web/spec-extension/adapters/reflect'\nimport {\n  throwToInterruptStaticGeneration,\n  postponeWithTracking,\n  trackDynamicDataInDynamicRender,\n  annotateDynamicAccess,\n  trackSynchronousRequestDataAccessInDev,\n  delayUntilRuntimeStage,\n} from '../app-render/dynamic-rendering'\n\nimport {\n  workUnitAsyncStorage,\n  type PrerenderStoreLegacy,\n  type PrerenderStorePPR,\n  type PrerenderStoreModern,\n  type PrerenderStoreModernRuntime,\n  type StaticPrerenderStore,\n  throwInvariantForMissingStore,\n} from '../app-render/work-unit-async-storage.external'\nimport { InvariantError } from '../../shared/lib/invariant-error'\nimport {\n  makeDevtoolsIOAwarePromise,\n  makeHangingPromise,\n} from '../dynamic-rendering-utils'\nimport { createDedupedByCallsiteServerErrorLoggerDev } from '../create-deduped-by-callsite-server-error-logger'\nimport {\n  describeStringPropertyAccess,\n  describeHasCheckingStringProperty,\n  wellKnownProperties,\n} from '../../shared/lib/utils/reflect-utils'\nimport {\n  throwWithStaticGenerationBailoutErrorWithDynamicError,\n  throwForSearchParamsAccessInUseCache,\n} from './utils'\n\nexport type SearchParams = { [key: string]: string | string[] | undefined }\n\n/**\n * In this version of Next.js the `params` prop passed to Layouts, Pages, and other Segments is a Promise.\n * However to facilitate migration to this new Promise type you can currently still access params directly on the Promise instance passed to these Segments.\n * The `UnsafeUnwrappedSearchParams` type is available if you need to temporarily access the underlying params without first awaiting or `use`ing the Promise.\n *\n * In a future version of Next.js the `params` prop will be a plain Promise and this type will be removed.\n *\n * Typically instances of `params` can be updated automatically to be treated as a Promise by a codemod published alongside this Next.js version however if you\n * have not yet run the codemod of the codemod cannot detect certain instances of `params` usage you should first try to refactor your code to await `params`.\n *\n * If refactoring is not possible but you still want to be able to access params directly without typescript errors you can cast the params Promise to this type\n *\n * ```tsx\n * type Props = { searchParams: Promise<{ foo: string }> }\n *\n * export default async function Page(props: Props) {\n *  const { searchParams } = (props.searchParams as unknown as UnsafeUnwrappedSearchParams<typeof props.searchParams>)\n *  return ...\n * }\n * ```\n *\n * This type is marked deprecated to help identify it as target for refactoring away.\n *\n * @deprecated\n */\nexport type UnsafeUnwrappedSearchParams<P> =\n  P extends Promise<infer U> ? Omit<U, 'then' | 'status' | 'value'> : never\n\nexport function createSearchParamsFromClient(\n  underlyingSearchParams: SearchParams,\n  workStore: WorkStore\n): Promise<SearchParams> {\n  const workUnitStore = workUnitAsyncStorage.getStore()\n  if (workUnitStore) {\n    switch (workUnitStore.type) {\n      case 'prerender':\n      case 'prerender-client':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n        return createStaticPrerenderSearchParams(workStore, workUnitStore)\n      case 'prerender-runtime':\n        throw new InvariantError(\n          'createSearchParamsFromClient should not be called in a runtime prerender.'\n        )\n      case 'cache':\n      case 'private-cache':\n      case 'unstable-cache':\n        throw new InvariantError(\n          'createSearchParamsFromClient should not be called in cache contexts.'\n        )\n      case 'request':\n        return createRenderSearchParams(underlyingSearchParams, workStore)\n      default:\n        workUnitStore satisfies never\n    }\n  }\n  throwInvariantForMissingStore()\n}\n\n// generateMetadata always runs in RSC context so it is equivalent to a Server Page Component\nexport const createServerSearchParamsForMetadata =\n  createServerSearchParamsForServerPage\n\nexport function createServerSearchParamsForServerPage(\n  underlyingSearchParams: SearchParams,\n  workStore: WorkStore\n): Promise<SearchParams> {\n  const workUnitStore = workUnitAsyncStorage.getStore()\n  if (workUnitStore) {\n    switch (workUnitStore.type) {\n      case 'prerender':\n      case 'prerender-client':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n        return createStaticPrerenderSearchParams(workStore, workUnitStore)\n      case 'cache':\n      case 'private-cache':\n      case 'unstable-cache':\n        throw new InvariantError(\n          'createServerSearchParamsForServerPage should not be called in cache contexts.'\n        )\n      case 'prerender-runtime':\n        return createRuntimePrerenderSearchParams(\n          underlyingSearchParams,\n          workUnitStore\n        )\n      case 'request':\n        return createRenderSearchParams(underlyingSearchParams, workStore)\n      default:\n        workUnitStore satisfies never\n    }\n  }\n  throwInvariantForMissingStore()\n}\n\nexport function createPrerenderSearchParamsForClientPage(\n  workStore: WorkStore\n): Promise<SearchParams> {\n  if (workStore.forceStatic) {\n    // When using forceStatic we override all other logic and always just return an empty\n    // dictionary object.\n    return Promise.resolve({})\n  }\n\n  const workUnitStore = workUnitAsyncStorage.getStore()\n  if (workUnitStore) {\n    switch (workUnitStore.type) {\n      case 'prerender':\n      case 'prerender-client':\n        // We're prerendering in a mode that aborts (cacheComponents) and should stall\n        // the promise to ensure the RSC side is considered dynamic\n        return makeHangingPromise(\n          workUnitStore.renderSignal,\n          workStore.route,\n          '`searchParams`'\n        )\n      case 'prerender-runtime':\n        throw new InvariantError(\n          'createPrerenderSearchParamsForClientPage should not be called in a runtime prerender.'\n        )\n      case 'cache':\n      case 'private-cache':\n      case 'unstable-cache':\n        throw new InvariantError(\n          'createPrerenderSearchParamsForClientPage should not be called in cache contexts.'\n        )\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n      case 'request':\n        return Promise.resolve({})\n      default:\n        workUnitStore satisfies never\n    }\n  }\n  throwInvariantForMissingStore()\n}\n\nfunction createStaticPrerenderSearchParams(\n  workStore: WorkStore,\n  prerenderStore: StaticPrerenderStore\n): Promise<SearchParams> {\n  if (workStore.forceStatic) {\n    // When using forceStatic we override all other logic and always just return an empty\n    // dictionary object.\n    return Promise.resolve({})\n  }\n\n  switch (prerenderStore.type) {\n    case 'prerender':\n    case 'prerender-client':\n      // We are in a cacheComponents (PPR or otherwise) prerender\n      return makeHangingSearchParams(workStore, prerenderStore)\n    case 'prerender-ppr':\n    case 'prerender-legacy':\n      // We are in a legacy static generation and need to interrupt the\n      // prerender when search params are accessed.\n      return makeErroringExoticSearchParams(workStore, prerenderStore)\n    default:\n      return prerenderStore satisfies never\n  }\n}\n\nfunction createRuntimePrerenderSearchParams(\n  underlyingSearchParams: SearchParams,\n  workUnitStore: PrerenderStoreModernRuntime\n): Promise<SearchParams> {\n  return delayUntilRuntimeStage(\n    workUnitStore,\n    process.env.__NEXT_CACHE_COMPONENTS\n      ? makeUntrackedSearchParams(underlyingSearchParams)\n      : makeUntrackedExoticSearchParams(underlyingSearchParams)\n  )\n}\n\nfunction createRenderSearchParams(\n  underlyingSearchParams: SearchParams,\n  workStore: WorkStore\n): Promise<SearchParams> {\n  if (workStore.forceStatic) {\n    // When using forceStatic we override all other logic and always just return an empty\n    // dictionary object.\n    return Promise.resolve({})\n  } else {\n    if (process.env.NODE_ENV === 'development') {\n      // Semantically we only need the dev tracking when running in `next dev`\n      // but since you would never use next dev with production NODE_ENV we use this\n      // as a proxy so we can statically exclude this code from production builds.\n      if (process.env.__NEXT_CACHE_COMPONENTS) {\n        return makeUntrackedSearchParamsWithDevWarnings(\n          underlyingSearchParams,\n          workStore\n        )\n      }\n\n      return makeDynamicallyTrackedExoticSearchParamsWithDevWarnings(\n        underlyingSearchParams,\n        workStore\n      )\n    } else {\n      if (process.env.__NEXT_CACHE_COMPONENTS) {\n        return makeUntrackedSearchParams(underlyingSearchParams)\n      }\n\n      return makeUntrackedExoticSearchParams(underlyingSearchParams)\n    }\n  }\n}\n\ninterface CacheLifetime {}\nconst CachedSearchParams = new WeakMap<CacheLifetime, Promise<SearchParams>>()\n\nconst CachedSearchParamsForUseCache = new WeakMap<\n  CacheLifetime,\n  Promise<SearchParams>\n>()\n\nfunction makeHangingSearchParams(\n  workStore: WorkStore,\n  prerenderStore: PrerenderStoreModern\n): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParams.get(prerenderStore)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n\n  const promise = makeHangingPromise<SearchParams>(\n    prerenderStore.renderSignal,\n    workStore.route,\n    '`searchParams`'\n  )\n\n  const proxiedPromise = new Proxy(promise, {\n    get(target, prop, receiver) {\n      if (Object.hasOwn(promise, prop)) {\n        // The promise has this property directly. we must return it.\n        // We know it isn't a dynamic access because it can only be something\n        // that was previously written to the promise and thus not an underlying searchParam value\n        return ReflectAdapter.get(target, prop, receiver)\n      }\n\n      switch (prop) {\n        case 'then': {\n          const expression =\n            '`await searchParams`, `searchParams.then`, or similar'\n          annotateDynamicAccess(expression, prerenderStore)\n          return ReflectAdapter.get(target, prop, receiver)\n        }\n        case 'status': {\n          const expression =\n            '`use(searchParams)`, `searchParams.status`, or similar'\n          annotateDynamicAccess(expression, prerenderStore)\n          return ReflectAdapter.get(target, prop, receiver)\n        }\n\n        default: {\n          return ReflectAdapter.get(target, prop, receiver)\n        }\n      }\n    },\n  })\n\n  CachedSearchParams.set(prerenderStore, proxiedPromise)\n  return proxiedPromise\n}\n\nfunction makeErroringExoticSearchParams(\n  workStore: WorkStore,\n  prerenderStore: PrerenderStoreLegacy | PrerenderStorePPR\n): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParams.get(workStore)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n\n  const underlyingSearchParams = {}\n  // For search params we don't construct a ReactPromise because we want to interrupt\n  // rendering on any property access that was not set from outside and so we only want\n  // to have properties like value and status if React sets them.\n  const promise = Promise.resolve(underlyingSearchParams)\n\n  const proxiedPromise = new Proxy(promise, {\n    get(target, prop, receiver) {\n      if (Object.hasOwn(promise, prop)) {\n        // The promise has this property directly. we must return it.\n        // We know it isn't a dynamic access because it can only be something\n        // that was previously written to the promise and thus not an underlying searchParam value\n        return ReflectAdapter.get(target, prop, receiver)\n      }\n\n      switch (prop) {\n        case 'then': {\n          const expression =\n            '`await searchParams`, `searchParams.then`, or similar'\n          if (workStore.dynamicShouldError) {\n            throwWithStaticGenerationBailoutErrorWithDynamicError(\n              workStore.route,\n              expression\n            )\n          } else if (prerenderStore.type === 'prerender-ppr') {\n            // PPR Prerender (no cacheComponents)\n            postponeWithTracking(\n              workStore.route,\n              expression,\n              prerenderStore.dynamicTracking\n            )\n          } else {\n            // Legacy Prerender\n            throwToInterruptStaticGeneration(\n              expression,\n              workStore,\n              prerenderStore\n            )\n          }\n          return\n        }\n        case 'status': {\n          const expression =\n            '`use(searchParams)`, `searchParams.status`, or similar'\n          if (workStore.dynamicShouldError) {\n            throwWithStaticGenerationBailoutErrorWithDynamicError(\n              workStore.route,\n              expression\n            )\n          } else if (prerenderStore.type === 'prerender-ppr') {\n            // PPR Prerender (no cacheComponents)\n            postponeWithTracking(\n              workStore.route,\n              expression,\n              prerenderStore.dynamicTracking\n            )\n          } else {\n            // Legacy Prerender\n            throwToInterruptStaticGeneration(\n              expression,\n              workStore,\n              prerenderStore\n            )\n          }\n          return\n        }\n        default: {\n          if (typeof prop === 'string' && !wellKnownProperties.has(prop)) {\n            const expression = describeStringPropertyAccess(\n              'searchParams',\n              prop\n            )\n            if (workStore.dynamicShouldError) {\n              throwWithStaticGenerationBailoutErrorWithDynamicError(\n                workStore.route,\n                expression\n              )\n            } else if (prerenderStore.type === 'prerender-ppr') {\n              // PPR Prerender (no cacheComponents)\n              postponeWithTracking(\n                workStore.route,\n                expression,\n                prerenderStore.dynamicTracking\n              )\n            } else {\n              // Legacy Prerender\n              throwToInterruptStaticGeneration(\n                expression,\n                workStore,\n                prerenderStore\n              )\n            }\n          }\n          return ReflectAdapter.get(target, prop, receiver)\n        }\n      }\n    },\n    has(target, prop) {\n      // We don't expect key checking to be used except for testing the existence of\n      // searchParams so we make all has tests trigger dynamic. this means that `promise.then`\n      // can resolve to the then function on the Promise prototype but 'then' in promise will assume\n      // you are testing whether the searchParams has a 'then' property.\n      if (typeof prop === 'string') {\n        const expression = describeHasCheckingStringProperty(\n          'searchParams',\n          prop\n        )\n        if (workStore.dynamicShouldError) {\n          throwWithStaticGenerationBailoutErrorWithDynamicError(\n            workStore.route,\n            expression\n          )\n        } else if (prerenderStore.type === 'prerender-ppr') {\n          // PPR Prerender (no cacheComponents)\n          postponeWithTracking(\n            workStore.route,\n            expression,\n            prerenderStore.dynamicTracking\n          )\n        } else {\n          // Legacy Prerender\n          throwToInterruptStaticGeneration(\n            expression,\n            workStore,\n            prerenderStore\n          )\n        }\n        return false\n      }\n      return ReflectAdapter.has(target, prop)\n    },\n    ownKeys() {\n      const expression =\n        '`{...searchParams}`, `Object.keys(searchParams)`, or similar'\n      if (workStore.dynamicShouldError) {\n        throwWithStaticGenerationBailoutErrorWithDynamicError(\n          workStore.route,\n          expression\n        )\n      } else if (prerenderStore.type === 'prerender-ppr') {\n        // PPR Prerender (no cacheComponents)\n        postponeWithTracking(\n          workStore.route,\n          expression,\n          prerenderStore.dynamicTracking\n        )\n      } else {\n        // Legacy Prerender\n        throwToInterruptStaticGeneration(expression, workStore, prerenderStore)\n      }\n    },\n  })\n\n  CachedSearchParams.set(workStore, proxiedPromise)\n  return proxiedPromise\n}\n\n/**\n * This is a variation of `makeErroringExoticSearchParams` that always throws an\n * error on access, because accessing searchParams inside of `\"use cache\"` is\n * not allowed.\n */\nexport function makeErroringSearchParamsForUseCache(\n  workStore: WorkStore\n): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParamsForUseCache.get(workStore)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n\n  const promise = Promise.resolve({})\n\n  const proxiedPromise = new Proxy(promise, {\n    get: function get(target, prop, receiver) {\n      if (Object.hasOwn(promise, prop)) {\n        // The promise has this property directly. we must return it. We know it\n        // isn't a dynamic access because it can only be something that was\n        // previously written to the promise and thus not an underlying\n        // searchParam value\n        return ReflectAdapter.get(target, prop, receiver)\n      }\n\n      if (\n        typeof prop === 'string' &&\n        (prop === 'then' || !wellKnownProperties.has(prop))\n      ) {\n        throwForSearchParamsAccessInUseCache(workStore, get)\n      }\n\n      return ReflectAdapter.get(target, prop, receiver)\n    },\n    has: function has(target, prop) {\n      // We don't expect key checking to be used except for testing the existence of\n      // searchParams so we make all has tests throw an error. this means that `promise.then`\n      // can resolve to the then function on the Promise prototype but 'then' in promise will assume\n      // you are testing whether the searchParams has a 'then' property.\n      if (\n        typeof prop === 'string' &&\n        (prop === 'then' || !wellKnownProperties.has(prop))\n      ) {\n        throwForSearchParamsAccessInUseCache(workStore, has)\n      }\n\n      return ReflectAdapter.has(target, prop)\n    },\n    ownKeys: function ownKeys() {\n      throwForSearchParamsAccessInUseCache(workStore, ownKeys)\n    },\n  })\n\n  CachedSearchParamsForUseCache.set(workStore, proxiedPromise)\n  return proxiedPromise\n}\n\nfunction makeUntrackedExoticSearchParams(\n  underlyingSearchParams: SearchParams\n): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n\n  // We don't use makeResolvedReactPromise here because searchParams\n  // supports copying with spread and we don't want to unnecessarily\n  // instrument the promise with spreadable properties of ReactPromise.\n  const promise = Promise.resolve(underlyingSearchParams)\n  CachedSearchParams.set(underlyingSearchParams, promise)\n\n  Object.keys(underlyingSearchParams).forEach((prop) => {\n    if (!wellKnownProperties.has(prop)) {\n      Object.defineProperty(promise, prop, {\n        get() {\n          const workUnitStore = workUnitAsyncStorage.getStore()\n          if (workUnitStore) {\n            trackDynamicDataInDynamicRender(workUnitStore)\n          }\n          return underlyingSearchParams[prop]\n        },\n        set(value) {\n          Object.defineProperty(promise, prop, {\n            value,\n            writable: true,\n            enumerable: true,\n          })\n        },\n        enumerable: true,\n        configurable: true,\n      })\n    }\n  })\n\n  return promise\n}\n\nfunction makeUntrackedSearchParams(\n  underlyingSearchParams: SearchParams\n): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n\n  const promise = Promise.resolve(underlyingSearchParams)\n  CachedSearchParams.set(underlyingSearchParams, promise)\n\n  return promise\n}\n\nfunction makeDynamicallyTrackedExoticSearchParamsWithDevWarnings(\n  underlyingSearchParams: SearchParams,\n  store: WorkStore\n): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n\n  const proxiedProperties = new Set<string>()\n  const unproxiedProperties: Array<string> = []\n\n  // We have an unfortunate sequence of events that requires this initialization logic. We want to instrument the underlying\n  // searchParams object to detect if you are accessing values in dev. This is used for warnings and for things like the static prerender\n  // indicator. However when we pass this proxy to our Promise.resolve() below the VM checks if the resolved value is a promise by looking\n  // at the `.then` property. To our dynamic tracking logic this is indistinguishable from a `then` searchParam and so we would normally trigger\n  // dynamic tracking. However we know that this .then is not real dynamic access, it's just how thenables resolve in sequence. So we introduce\n  // this initialization concept so we omit the dynamic check until after we've constructed our resolved promise.\n  let promiseInitialized = false\n  const proxiedUnderlying = new Proxy(underlyingSearchParams, {\n    get(target, prop, receiver) {\n      if (typeof prop === 'string' && promiseInitialized) {\n        if (store.dynamicShouldError) {\n          const expression = describeStringPropertyAccess('searchParams', prop)\n          throwWithStaticGenerationBailoutErrorWithDynamicError(\n            store.route,\n            expression\n          )\n        }\n        const workUnitStore = workUnitAsyncStorage.getStore()\n        if (workUnitStore) {\n          trackDynamicDataInDynamicRender(workUnitStore)\n        }\n      }\n      return ReflectAdapter.get(target, prop, receiver)\n    },\n    has(target, prop) {\n      if (typeof prop === 'string') {\n        if (store.dynamicShouldError) {\n          const expression = describeHasCheckingStringProperty(\n            'searchParams',\n            prop\n          )\n          throwWithStaticGenerationBailoutErrorWithDynamicError(\n            store.route,\n            expression\n          )\n        }\n      }\n      return Reflect.has(target, prop)\n    },\n    ownKeys(target) {\n      if (store.dynamicShouldError) {\n        const expression =\n          '`{...searchParams}`, `Object.keys(searchParams)`, or similar'\n        throwWithStaticGenerationBailoutErrorWithDynamicError(\n          store.route,\n          expression\n        )\n      }\n      return Reflect.ownKeys(target)\n    },\n  })\n\n  // We don't use makeResolvedReactPromise here because searchParams\n  // supports copying with spread and we don't want to unnecessarily\n  // instrument the promise with spreadable properties of ReactPromise.\n  const promise = makeDevtoolsIOAwarePromise(underlyingSearchParams)\n  promise.then(() => {\n    promiseInitialized = true\n  })\n\n  Object.keys(underlyingSearchParams).forEach((prop) => {\n    if (wellKnownProperties.has(prop)) {\n      // These properties cannot be shadowed because they need to be the\n      // true underlying value for Promises to work correctly at runtime\n      unproxiedProperties.push(prop)\n    } else {\n      proxiedProperties.add(prop)\n      Object.defineProperty(promise, prop, {\n        get() {\n          return proxiedUnderlying[prop]\n        },\n        set(newValue) {\n          Object.defineProperty(promise, prop, {\n            value: newValue,\n            writable: true,\n            enumerable: true,\n          })\n        },\n        enumerable: true,\n        configurable: true,\n      })\n    }\n  })\n\n  const proxiedPromise = new Proxy(promise, {\n    get(target, prop, receiver) {\n      if (prop === 'then' && store.dynamicShouldError) {\n        const expression = '`searchParams.then`'\n        throwWithStaticGenerationBailoutErrorWithDynamicError(\n          store.route,\n          expression\n        )\n      }\n      if (typeof prop === 'string') {\n        if (\n          !wellKnownProperties.has(prop) &&\n          (proxiedProperties.has(prop) ||\n            // We are accessing a property that doesn't exist on the promise nor\n            // the underlying searchParams.\n            Reflect.has(target, prop) === false)\n        ) {\n          const expression = describeStringPropertyAccess('searchParams', prop)\n          syncIODev(store.route, expression)\n        }\n      }\n      return ReflectAdapter.get(target, prop, receiver)\n    },\n    set(target, prop, value, receiver) {\n      if (typeof prop === 'string') {\n        proxiedProperties.delete(prop)\n      }\n      return Reflect.set(target, prop, value, receiver)\n    },\n    has(target, prop) {\n      if (typeof prop === 'string') {\n        if (\n          !wellKnownProperties.has(prop) &&\n          (proxiedProperties.has(prop) ||\n            // We are accessing a property that doesn't exist on the promise nor\n            // the underlying searchParams.\n            Reflect.has(target, prop) === false)\n        ) {\n          const expression = describeHasCheckingStringProperty(\n            'searchParams',\n            prop\n          )\n          syncIODev(store.route, expression)\n        }\n      }\n      return Reflect.has(target, prop)\n    },\n    ownKeys(target) {\n      const expression = '`Object.keys(searchParams)` or similar'\n      syncIODev(store.route, expression, unproxiedProperties)\n      return Reflect.ownKeys(target)\n    },\n  })\n\n  CachedSearchParams.set(underlyingSearchParams, proxiedPromise)\n  return proxiedPromise\n}\n\n// Similar to `makeDynamicallyTrackedExoticSearchParamsWithDevWarnings`, but\n// just logging the sync access without actually defining the search params on\n// the promise.\nfunction makeUntrackedSearchParamsWithDevWarnings(\n  underlyingSearchParams: SearchParams,\n  store: WorkStore\n): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n\n  const proxiedProperties = new Set<string>()\n  const unproxiedProperties: Array<string> = []\n  const promise = makeDevtoolsIOAwarePromise(underlyingSearchParams)\n\n  Object.keys(underlyingSearchParams).forEach((prop) => {\n    if (wellKnownProperties.has(prop)) {\n      // These properties cannot be shadowed because they need to be the\n      // true underlying value for Promises to work correctly at runtime\n      unproxiedProperties.push(prop)\n    } else {\n      proxiedProperties.add(prop)\n    }\n  })\n\n  const proxiedPromise = new Proxy(promise, {\n    get(target, prop, receiver) {\n      if (typeof prop === 'string') {\n        if (\n          !wellKnownProperties.has(prop) &&\n          (proxiedProperties.has(prop) ||\n            // We are accessing a property that doesn't exist on the promise nor\n            // the underlying searchParams.\n            Reflect.has(target, prop) === false)\n        ) {\n          const expression = describeStringPropertyAccess('searchParams', prop)\n          warnForSyncAccess(store.route, expression)\n        }\n      }\n      return ReflectAdapter.get(target, prop, receiver)\n    },\n    set(target, prop, value, receiver) {\n      if (typeof prop === 'string') {\n        proxiedProperties.delete(prop)\n      }\n      return Reflect.set(target, prop, value, receiver)\n    },\n    has(target, prop) {\n      if (typeof prop === 'string') {\n        if (\n          !wellKnownProperties.has(prop) &&\n          (proxiedProperties.has(prop) ||\n            // We are accessing a property that doesn't exist on the promise nor\n            // the underlying searchParams.\n            Reflect.has(target, prop) === false)\n        ) {\n          const expression = describeHasCheckingStringProperty(\n            'searchParams',\n            prop\n          )\n          warnForSyncAccess(store.route, expression)\n        }\n      }\n      return Reflect.has(target, prop)\n    },\n    ownKeys(target) {\n      const expression = '`Object.keys(searchParams)` or similar'\n      warnForIncompleteEnumeration(store.route, expression, unproxiedProperties)\n      return Reflect.ownKeys(target)\n    },\n  })\n\n  CachedSearchParams.set(underlyingSearchParams, proxiedPromise)\n  return proxiedPromise\n}\n\nfunction syncIODev(\n  route: string | undefined,\n  expression: string,\n  missingProperties?: Array<string>\n) {\n  // In all cases we warn normally\n  if (missingProperties && missingProperties.length > 0) {\n    warnForIncompleteEnumeration(route, expression, missingProperties)\n  } else {\n    warnForSyncAccess(route, expression)\n  }\n\n  const workUnitStore = workUnitAsyncStorage.getStore()\n  if (workUnitStore) {\n    switch (workUnitStore.type) {\n      case 'request':\n        if (workUnitStore.prerenderPhase === true) {\n          // When we're rendering dynamically in dev, we need to advance out of\n          // the Prerender environment when we read Request data synchronously.\n          trackSynchronousRequestDataAccessInDev(workUnitStore)\n        }\n        break\n      case 'prerender':\n      case 'prerender-client':\n      case 'prerender-runtime':\n      case 'prerender-ppr':\n      case 'prerender-legacy':\n      case 'cache':\n      case 'private-cache':\n      case 'unstable-cache':\n        break\n      default:\n        workUnitStore satisfies never\n    }\n  }\n}\n\nconst warnForSyncAccess = createDedupedByCallsiteServerErrorLoggerDev(\n  createSearchAccessError\n)\n\nconst warnForIncompleteEnumeration =\n  createDedupedByCallsiteServerErrorLoggerDev(createIncompleteEnumerationError)\n\nfunction createSearchAccessError(\n  route: string | undefined,\n  expression: string\n) {\n  const prefix = route ? `Route \"${route}\" ` : 'This route '\n  return new Error(\n    `${prefix}used ${expression}. ` +\n      `\\`searchParams\\` should be awaited before using its properties. ` +\n      `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`\n  )\n}\n\nfunction createIncompleteEnumerationError(\n  route: string | undefined,\n  expression: string,\n  missingProperties: Array<string>\n) {\n  const prefix = route ? `Route \"${route}\" ` : 'This route '\n  return new Error(\n    `${prefix}used ${expression}. ` +\n      `\\`searchParams\\` should be awaited before using its properties. ` +\n      `The following properties were not available through enumeration ` +\n      `because they conflict with builtin or well-known property names: ` +\n      `${describeListOfPropertyNames(missingProperties)}. ` +\n      `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`\n  )\n}\n\nfunction describeListOfPropertyNames(properties: Array<string>) {\n  switch (properties.length) {\n    case 0:\n      throw new InvariantError(\n        'Expected describeListOfPropertyNames to be called with a non-empty list of strings.'\n      )\n    case 1:\n      return `\\`${properties[0]}\\``\n    case 2:\n      return `\\`${properties[0]}\\` and \\`${properties[1]}\\``\n    default: {\n      let description = ''\n      for (let i = 0; i < properties.length - 1; i++) {\n        description += `\\`${properties[i]}\\`, `\n      }\n      description += `, and \\`${properties[properties.length - 1]}\\``\n      return description\n    }\n  }\n}\n"],"names":["createPrerenderSearchParamsForClientPage","createSearchParamsFromClient","createServerSearchParamsForMetadata","createServerSearchParamsForServerPage","makeErroringSearchParamsForUseCache","underlyingSearchParams","workStore","workUnitStore","workUnitAsyncStorage","getStore","type","createStaticPrerenderSearchParams","InvariantError","createRenderSearchParams","throwInvariantForMissingStore","createRuntimePrerenderSearchParams","forceStatic","Promise","resolve","makeHangingPromise","renderSignal","route","prerenderStore","makeHangingSearchParams","makeErroringExoticSearchParams","delayUntilRuntimeStage","process","env","__NEXT_CACHE_COMPONENTS","makeUntrackedSearchParams","makeUntrackedExoticSearchParams","NODE_ENV","makeUntrackedSearchParamsWithDevWarnings","makeDynamicallyTrackedExoticSearchParamsWithDevWarnings","CachedSearchParams","WeakMap","CachedSearchParamsForUseCache","cachedSearchParams","get","promise","proxiedPromise","Proxy","target","prop","receiver","Object","hasOwn","ReflectAdapter","expression","annotateDynamicAccess","set","dynamicShouldError","throwWithStaticGenerationBailoutErrorWithDynamicError","postponeWithTracking","dynamicTracking","throwToInterruptStaticGeneration","wellKnownProperties","has","describeStringPropertyAccess","describeHasCheckingStringProperty","ownKeys","throwForSearchParamsAccessInUseCache","keys","forEach","defineProperty","trackDynamicDataInDynamicRender","value","writable","enumerable","configurable","store","proxiedProperties","Set","unproxiedProperties","promiseInitialized","proxiedUnderlying","Reflect","makeDevtoolsIOAwarePromise","then","push","add","newValue","syncIODev","delete","warnForSyncAccess","warnForIncompleteEnumeration","missingProperties","length","prerenderPhase","trackSynchronousRequestDataAccessInDev","createDedupedByCallsiteServerErrorLoggerDev","createSearchAccessError","createIncompleteEnumerationError","prefix","Error","describeListOfPropertyNames","properties","description","i"],"mappings":"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","ignoreList":[0]}