{"version":3,"sources":["../../../src/server/request/search-params.ts"],"sourcesContent":["import {\n  workAsyncStorage,\n  type WorkStore,\n} from '../app-render/work-async-storage.external'\nimport type { VaryParamsAccumulator } from '../app-render/vary-params'\nimport {\n  createVaryingSearchParams,\n  getMetadataVaryParamsAccumulator,\n} from '../app-render/vary-params'\n\nimport { ReflectAdapter } from '../web/spec-extension/adapters/reflect'\nimport {\n  throwToInterruptStaticGeneration,\n  postponeWithTracking,\n  annotateDynamicAccess,\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  type RequestStore,\n  type ValidationStoreClient,\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'\nimport { RenderStage } from '../app-render/staged-rendering'\n\nexport type SearchParams = { [key: string]: string | string[] | undefined }\n\nexport function createSearchParamsFromClient(\n  underlyingSearchParams: SearchParams\n): Promise<SearchParams> {\n  const workStore = workAsyncStorage.getStore()\n  if (!workStore) {\n    throw new InvariantError('Expected workStore to be initialized')\n  }\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 'validation-client': {\n        return createClientSearchParamsInValidation(\n          underlyingSearchParams,\n          workStore,\n          workUnitStore\n        )\n      }\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 'generate-static-params':\n        throw new InvariantError(\n          'createSearchParamsFromClient should not be called inside generateStaticParams.'\n        )\n      case 'request':\n        // Client searchParams are not runtime prefetchable\n        const isRuntimePrefetchable = false\n        return createRenderSearchParams(\n          underlyingSearchParams,\n          workStore,\n          workUnitStore,\n          isRuntimePrefetchable\n        )\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 function createServerSearchParamsForMetadata(\n  underlyingSearchParams: SearchParams,\n  isRuntimePrefetchable: boolean\n): Promise<SearchParams> {\n  const metadataVaryParamsAccumulator = getMetadataVaryParamsAccumulator()\n  return createServerSearchParamsForServerPage(\n    underlyingSearchParams,\n    metadataVaryParamsAccumulator,\n    isRuntimePrefetchable\n  )\n}\n\nexport function createServerSearchParamsForServerPage(\n  underlyingSearchParams: SearchParams,\n  varyParamsAccumulator: VaryParamsAccumulator | null,\n  isRuntimePrefetchable: boolean\n): Promise<SearchParams> {\n  const workStore = workAsyncStorage.getStore()\n  if (!workStore) {\n    throw new InvariantError('Expected workStore to be initialized')\n  }\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 'validation-client':\n        throw new InvariantError(\n          'createServerSearchParamsForServerPage should not be called in a client validation.'\n        )\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 'generate-static-params':\n        throw new InvariantError(\n          'createServerSearchParamsForServerPage should not be called inside generateStaticParams.'\n        )\n      case 'prerender-runtime':\n        return createRuntimePrerenderSearchParams(\n          underlyingSearchParams,\n          workUnitStore,\n          varyParamsAccumulator,\n          isRuntimePrefetchable\n        )\n      case 'request':\n        return createRenderSearchParams(\n          underlyingSearchParams,\n          workStore,\n          workUnitStore,\n          isRuntimePrefetchable\n        )\n      default:\n        workUnitStore satisfies never\n    }\n  }\n  throwInvariantForMissingStore()\n}\n\nexport function createPrerenderSearchParamsForClientPage(): Promise<SearchParams> {\n  const workStore = workAsyncStorage.getStore()\n  if (!workStore) {\n    throw new InvariantError('Expected workStore to be initialized')\n  }\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 'validation-client':\n        throw new InvariantError(\n          'createPrerenderSearchParamsForClientPage should not be called in a client validation.'\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 'generate-static-params':\n        throw new InvariantError(\n          'createPrerenderSearchParamsForClientPage should not be called inside generateStaticParams.'\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 makeErroringSearchParams(workStore, prerenderStore)\n    default:\n      return prerenderStore satisfies never\n  }\n}\n\nfunction createRuntimePrerenderSearchParams(\n  underlyingSearchParams: SearchParams,\n  workUnitStore: PrerenderStoreModernRuntime,\n  varyParamsAccumulator: VaryParamsAccumulator | null,\n  isRuntimePrefetchable: boolean\n): Promise<SearchParams> {\n  const underlyingSearchParamsWithVarying =\n    varyParamsAccumulator !== null\n      ? createVaryingSearchParams(varyParamsAccumulator, underlyingSearchParams)\n      : underlyingSearchParams\n\n  const result = makeUntrackedSearchParams(underlyingSearchParamsWithVarying)\n  const { stagedRendering } = workUnitStore\n  if (!stagedRendering) {\n    return result\n  }\n  const stage = isRuntimePrefetchable\n    ? RenderStage.EarlyRuntime\n    : RenderStage.Runtime\n  return stagedRendering.waitForStage(stage).then(() => result)\n}\n\nfunction createRenderSearchParams(\n  underlyingSearchParams: SearchParams,\n  workStore: WorkStore,\n  requestStore: RequestStore,\n  isRuntimePrefetchable: boolean\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      return makeUntrackedSearchParamsWithDevWarnings(\n        underlyingSearchParams,\n        workStore,\n        requestStore,\n        isRuntimePrefetchable\n      )\n    } else if (requestStore.asyncApiPromises) {\n      if (requestStore.validationSamples) {\n        const { createExhaustiveSearchParamsProxy } =\n          require('../app-render/instant-validation/instant-samples') as typeof import('../app-render/instant-validation/instant-samples')\n        const declaredKeys = new Set(\n          Object.keys(requestStore.validationSamples.searchParams ?? {})\n        )\n        underlyingSearchParams = createExhaustiveSearchParamsProxy(\n          underlyingSearchParams,\n          declaredKeys,\n          workStore.route\n        )\n      }\n\n      return (\n        isRuntimePrefetchable\n          ? requestStore.asyncApiPromises.earlySharedSearchParamsParent\n          : requestStore.asyncApiPromises.sharedSearchParamsParent\n      ).then(() => underlyingSearchParams)\n    } else {\n      return makeUntrackedSearchParams(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 makeErroringSearchParams(\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      if (typeof prop === 'string' && prop === '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      }\n      return ReflectAdapter.get(target, prop, receiver)\n    },\n  })\n\n  CachedSearchParams.set(workStore, proxiedPromise)\n  return proxiedPromise\n}\n\n/**\n * This is a variation of `makeErroringSearchParams` that always throws an\n * error on access, because accessing searchParams inside of `\"use cache\"` is\n * not allowed.\n */\nexport function makeErroringSearchParamsForUseCache(): Promise<SearchParams> {\n  const workStore = workAsyncStorage.getStore()\n  if (!workStore) {\n    throw new InvariantError('Expected workStore to be initialized')\n  }\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  })\n\n  CachedSearchParamsForUseCache.set(workStore, proxiedPromise)\n  return proxiedPromise\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 makeUntrackedSearchParamsWithDevWarnings(\n  underlyingSearchParams: SearchParams,\n  workStore: WorkStore,\n  requestStore: RequestStore,\n  isRuntimePrefetchable: boolean\n): Promise<SearchParams> {\n  if (requestStore.asyncApiPromises) {\n    // Do not cache the resulting promise. If we do, we'll only show the first \"awaited at\"\n    // across all segments that receive searchParams.\n    return makeUntrackedSearchParamsWithDevWarningsImpl(\n      underlyingSearchParams,\n      workStore,\n      requestStore,\n      isRuntimePrefetchable\n    )\n  } else {\n    const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)\n    if (cachedSearchParams) {\n      return cachedSearchParams\n    }\n    const promise = makeUntrackedSearchParamsWithDevWarningsImpl(\n      underlyingSearchParams,\n      workStore,\n      requestStore,\n      isRuntimePrefetchable\n    )\n    CachedSearchParams.set(requestStore, promise)\n    return promise\n  }\n}\n\nfunction makeUntrackedSearchParamsWithDevWarningsImpl(\n  underlyingSearchParams: SearchParams,\n  workStore: WorkStore,\n  requestStore: RequestStore,\n  isRuntimePrefetchable: boolean\n): Promise<SearchParams> {\n  const promiseInitialized = { current: false }\n  const proxiedUnderlying = instrumentSearchParamsObjectWithDevWarnings(\n    underlyingSearchParams,\n    workStore,\n    promiseInitialized\n  )\n\n  let promise: Promise<SearchParams>\n  if (requestStore.asyncApiPromises) {\n    // We wrap each instance of searchParams in a `new Promise()`.\n    // This is important when all awaits are in third party which would otherwise\n    // track all the way to the internal params.\n    const sharedSearchParamsParent = isRuntimePrefetchable\n      ? requestStore.asyncApiPromises.earlySharedSearchParamsParent\n      : requestStore.asyncApiPromises.sharedSearchParamsParent\n    promise = new Promise((resolve, reject) => {\n      sharedSearchParamsParent.then(() => resolve(proxiedUnderlying), reject)\n    })\n    // @ts-expect-error\n    promise.displayName = 'searchParams'\n  } else {\n    promise = makeDevtoolsIOAwarePromise(\n      proxiedUnderlying,\n      requestStore,\n      RenderStage.Runtime\n    )\n  }\n  promise.then(\n    () => {\n      promiseInitialized.current = true\n    },\n    // If we're in staged rendering, this promise will reject if the render\n    // is aborted before it can reach the runtime stage.\n    // In that case, we have to prevent an unhandled rejection from the promise\n    // created by this `.then()` call.\n    // This does not affect the `promiseInitialized` logic above,\n    // because `proxiedUnderlying` will not be used to resolve the promise,\n    // so there's no risk of any of its properties being accessed and triggering\n    // an undesireable warning.\n    ignoreReject\n  )\n\n  return instrumentSearchParamsPromiseWithDevWarnings(\n    underlyingSearchParams,\n    promise,\n    workStore\n  )\n}\n\nfunction ignoreReject() {}\n\nfunction instrumentSearchParamsObjectWithDevWarnings(\n  underlyingSearchParams: SearchParams,\n  workStore: WorkStore,\n  promiseInitialized: { current: boolean }\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  return new Proxy(underlyingSearchParams, {\n    get(target, prop, receiver) {\n      if (typeof prop === 'string' && promiseInitialized.current) {\n        if (workStore.dynamicShouldError) {\n          const expression = describeStringPropertyAccess('searchParams', prop)\n          throwWithStaticGenerationBailoutErrorWithDynamicError(\n            workStore.route,\n            expression\n          )\n        }\n      }\n      return ReflectAdapter.get(target, prop, receiver)\n    },\n    has(target, prop) {\n      if (typeof prop === 'string') {\n        if (workStore.dynamicShouldError) {\n          const expression = describeHasCheckingStringProperty(\n            'searchParams',\n            prop\n          )\n          throwWithStaticGenerationBailoutErrorWithDynamicError(\n            workStore.route,\n            expression\n          )\n        }\n      }\n      return Reflect.has(target, prop)\n    },\n    ownKeys(target) {\n      if (workStore.dynamicShouldError) {\n        const expression =\n          '`{...searchParams}`, `Object.keys(searchParams)`, or similar'\n        throwWithStaticGenerationBailoutErrorWithDynamicError(\n          workStore.route,\n          expression\n        )\n      }\n      return Reflect.ownKeys(target)\n    },\n  })\n}\n\nfunction instrumentSearchParamsPromiseWithDevWarnings(\n  underlyingSearchParams: SearchParams,\n  promise: Promise<SearchParams>,\n  workStore: WorkStore\n) {\n  // Track which properties we should warn for.\n  const proxiedProperties = new Set<string>()\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    } else {\n      proxiedProperties.add(prop)\n    }\n  })\n\n  return new Proxy(promise, {\n    get(target, prop, receiver) {\n      if (prop === 'then' && workStore.dynamicShouldError) {\n        const expression = '`searchParams.then`'\n        throwWithStaticGenerationBailoutErrorWithDynamicError(\n          workStore.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          warnForSyncAccess(workStore.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(workStore.route, expression)\n        }\n      }\n      return Reflect.has(target, prop)\n    },\n    ownKeys(target) {\n      const expression = '`Object.keys(searchParams)` or similar'\n      warnForSyncAccess(workStore.route, expression)\n      return Reflect.ownKeys(target)\n    },\n  })\n}\n\nconst warnForSyncAccess = createDedupedByCallsiteServerErrorLoggerDev(\n  createSearchAccessError\n)\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\\` is a Promise and must be unwrapped with \\`await\\` or \\`React.use()\\` before accessing its properties. ` +\n      `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`\n  )\n}\n\nfunction createClientSearchParamsInValidation(\n  underlyingSearchParams: SearchParams,\n  workStore: WorkStore,\n  workUnitStore: ValidationStoreClient\n) {\n  const { createExhaustiveSearchParamsProxy } =\n    require('../app-render/instant-validation/instant-samples') as typeof import('../app-render/instant-validation/instant-samples')\n  const declaredKeys = new Set(\n    Object.keys(workUnitStore.validationSamples?.searchParams ?? {})\n  )\n  underlyingSearchParams = createExhaustiveSearchParamsProxy(\n    underlyingSearchParams,\n    declaredKeys,\n    workStore.route\n  )\n  return Promise.resolve(underlyingSearchParams)\n}\n"],"names":["createPrerenderSearchParamsForClientPage","createSearchParamsFromClient","createServerSearchParamsForMetadata","createServerSearchParamsForServerPage","makeErroringSearchParamsForUseCache","underlyingSearchParams","workStore","workAsyncStorage","getStore","InvariantError","workUnitStore","workUnitAsyncStorage","type","createStaticPrerenderSearchParams","createClientSearchParamsInValidation","isRuntimePrefetchable","createRenderSearchParams","throwInvariantForMissingStore","metadataVaryParamsAccumulator","getMetadataVaryParamsAccumulator","varyParamsAccumulator","createRuntimePrerenderSearchParams","forceStatic","Promise","resolve","makeHangingPromise","renderSignal","route","prerenderStore","makeHangingSearchParams","makeErroringSearchParams","underlyingSearchParamsWithVarying","createVaryingSearchParams","result","makeUntrackedSearchParams","stagedRendering","stage","RenderStage","EarlyRuntime","Runtime","waitForStage","then","requestStore","process","env","NODE_ENV","makeUntrackedSearchParamsWithDevWarnings","asyncApiPromises","validationSamples","createExhaustiveSearchParamsProxy","require","declaredKeys","Set","Object","keys","searchParams","earlySharedSearchParamsParent","sharedSearchParamsParent","CachedSearchParams","WeakMap","CachedSearchParamsForUseCache","cachedSearchParams","get","promise","proxiedPromise","Proxy","target","prop","receiver","hasOwn","ReflectAdapter","expression","annotateDynamicAccess","set","dynamicShouldError","throwWithStaticGenerationBailoutErrorWithDynamicError","postponeWithTracking","dynamicTracking","throwToInterruptStaticGeneration","wellKnownProperties","has","throwForSearchParamsAccessInUseCache","makeUntrackedSearchParamsWithDevWarningsImpl","promiseInitialized","current","proxiedUnderlying","instrumentSearchParamsObjectWithDevWarnings","reject","displayName","makeDevtoolsIOAwarePromise","ignoreReject","instrumentSearchParamsPromiseWithDevWarnings","describeStringPropertyAccess","describeHasCheckingStringProperty","Reflect","ownKeys","proxiedProperties","forEach","add","warnForSyncAccess","value","delete","createDedupedByCallsiteServerErrorLoggerDev","createSearchAccessError","prefix","Error"],"mappings":"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","ignoreList":[0]}