{"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'\nimport { dynamicAccessAsyncStorage } from '../app-render/dynamic-access-async-storage.external'\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  makeRuntimeHangingPromise,\n  makePromiseFromTrigger,\n  trackRuntimeDataAccessed,\n  RENDER_STAGES_BY_DATA_KIND,\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\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 '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 'validation-client': {\n        if (workUnitStore.validationSamples) {\n          return createClientSearchParamsInValidation(\n            underlyingSearchParams,\n            workStore,\n            workUnitStore\n          )\n        }\n        return makeUntrackedSearchParams(underlyingSearchParams)\n      }\n      case 'request':\n        return createRenderSearchParams(\n          underlyingSearchParams,\n          workStore,\n          workUnitStore\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): Promise<SearchParams> {\n  const metadataVaryParamsAccumulator = getMetadataVaryParamsAccumulator()\n  return createServerSearchParamsForServerPage(\n    underlyingSearchParams,\n    metadataVaryParamsAccumulator\n  )\n}\n\nexport function createServerSearchParamsForServerPage(\n  underlyingSearchParams: SearchParams,\n  varyParamsAccumulator: VaryParamsAccumulator | null\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          workStore,\n          workUnitStore,\n          varyParamsAccumulator\n        )\n      case 'request':\n        return createRenderSearchParams(\n          underlyingSearchParams,\n          workStore,\n          workUnitStore\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 makeRuntimeHangingPromise(\n          workUnitStore.renderSignal,\n          workStore.route,\n          '`searchParams`',\n          workUnitStore\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  workStore: WorkStore,\n  workUnitStore: PrerenderStoreModernRuntime,\n  varyParamsAccumulator: VaryParamsAccumulator | null\n): Promise<SearchParams> {\n  const userspaceSearchParams =\n    varyParamsAccumulator !== null\n      ? createVaryingSearchParams(varyParamsAccumulator, underlyingSearchParams)\n      : underlyingSearchParams\n\n  const result = makeUntrackedSearchParams(userspaceSearchParams)\n  const { stagedRendering } = workUnitStore\n  if (!stagedRendering) {\n    // If there's no staging, we're in a prospective runtime prerender.\n    if (workUnitStore.isSessionShell) {\n      // If we're warming up for a session shell, search params should hang,\n      // because they'll be a hanging input in the final prerender.\n      return makeHangingSearchParams(workStore, workUnitStore)\n    }\n    return result\n  }\n  // Unlike `createRuntimePrerenderParams`, which uses `delayUntilStage`, we\n  // resolve with `waitForStage(...).then(...)` here. Switching search params to\n  // `delayUntilStage` drops the source code frame from the instant-validation\n  // \"URL data outside of Suspense\" error when a page awaits `searchParams` at\n  // the top level (params, read via a nested component, is unaffected). See the\n  // `missing suspense around search params` cases in the instant-validation\n  // `suspense-boundaries` tests. The underlying reason in React's async I/O\n  // await tracking isn't understood yet. TODO: align search params with params\n  // on `delayUntilStage` once resolved.\n  const searchParamsStage = RENDER_STAGES_BY_DATA_KIND.runtimeLinkData\n  return stagedRendering.waitForStage(searchParamsStage).then(() => result)\n}\n\nfunction createRenderSearchParams(\n  underlyingSearchParams: SearchParams,\n  workStore: WorkStore,\n  requestStore: RequestStore\n): Promise<SearchParams> {\n  const { asyncApiPromises, validationSamples } = requestStore\n\n  if (asyncApiPromises) {\n    let userspaceSearchParams = underlyingSearchParams\n    if (validationSamples) {\n      userspaceSearchParams = createSearchParamsProxyForInstantValidation(\n        workStore,\n        validationSamples,\n        underlyingSearchParams\n      )\n    }\n\n    return createStagedRenderSearchParams(\n      workStore,\n      asyncApiPromises,\n      underlyingSearchParams,\n      userspaceSearchParams\n    )\n  }\n\n  // No staged rendering = no cacheComponents, or cacheComponents prod without cachedNavigations\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  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    )\n  } else {\n    return makeUntrackedSearchParams(underlyingSearchParams)\n  }\n}\n\nfunction createStagedRenderSearchParams(\n  workStore: WorkStore,\n  asyncApiPromises: NonNullable<RequestStore['asyncApiPromises']>,\n  underlyingSearchParams: SearchParams,\n  userspaceSearchParams: SearchParams\n): Promise<SearchParams> {\n  const trigger = asyncApiPromises.sharedSearchParamsParent\n\n  if (process.env.NODE_ENV === 'development') {\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 promise = new Promise<SearchParams>((resolve, reject) => {\n      trigger.then(() => resolve(userspaceSearchParams), reject)\n    })\n    // @ts-expect-error\n    promise.displayName = 'searchParams'\n    promise.catch(ignoreReject)\n\n    return instrumentSearchParamsPromiseWithDevWarnings(\n      underlyingSearchParams,\n      promise,\n      workStore\n    )\n  } else {\n    return makePromiseFromTrigger(trigger, userspaceSearchParams)\n  }\n}\n\nfunction createSearchParamsProxyForInstantValidation(\n  workStore: WorkStore,\n  validationSamples: NonNullable<RequestStore['validationSamples']>,\n  underlyingSearchParams: SearchParams\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(validationSamples.searchParams ?? {})\n  )\n  return createExhaustiveSearchParamsProxy(\n    underlyingSearchParams,\n    declaredKeys,\n    workStore.route\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 | PrerenderStoreModernRuntime\n): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParams.get(prerenderStore)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n\n  const promise = makeRuntimeHangingPromise<SearchParams>(\n    prerenderStore.renderSignal,\n    workStore.route,\n    '`searchParams`',\n    // This promise is created for every page whether or not it reads search\n    // params, so recording the access at creation would mark every render.\n    // The access is tracked in the proxy traps below instead.\n    null\n  )\n\n  const trackSearchParamsAccessed = () => {\n    // Record against the store that's active at access time: the promise is\n    // created while the RSC payload is constructed, but typically accessed\n    // later, during the render, under a different store.\n    const workUnitStore = workUnitAsyncStorage.getStore()\n    trackRuntimeDataAccessed(workUnitStore ?? prerenderStore)\n  }\n\n  const proxyHandler: ProxyHandler<Promise<SearchParams>> = {\n    get(target, prop, receiver) {\n      if (Object.hasOwn(target, 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        case 'catch':\n        case 'finally': {\n          const originalMethod = ReflectAdapter.get(target, prop, receiver)\n          return {\n            [prop]: (...args: unknown[]) => {\n              const expression =\n                '`await searchParams`, `searchParams.then`, or similar'\n              trackSearchParamsAccessed()\n              annotateDynamicAccess(expression, prerenderStore)\n              // Mirror `makeHangingParams`: when this never-resolving promise\n              // is awaited while a `use cache` key is being encoded\n              // (dynamicAccessAsyncStorage is set), abort so the surrounding\n              // cache bails out to a dynamic hole instead of hanging on it.\n              // Without this, a private cache that reads `searchParams` would\n              // stall the App Shell cache-warming render. Re-wrapping the\n              // result propagates the same behavior to promises derived via\n              // `.then`/`.catch`/`.finally` that are then passed into a cache.\n              const dynamicAccessStore = dynamicAccessAsyncStorage.getStore()\n              if (dynamicAccessStore) {\n                dynamicAccessStore.abortController.abort(\n                  new Error('Accessed `searchParams` during prerendering.')\n                )\n              }\n              return new Proxy(originalMethod.apply(target, args), proxyHandler)\n            },\n          }[prop]\n        }\n        case 'status': {\n          const expression =\n            '`use(searchParams)`, `searchParams.status`, or similar'\n          trackSearchParamsAccessed()\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  const proxiedPromise = new Proxy(promise, proxyHandler)\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): Promise<SearchParams> {\n  const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams)\n  if (cachedSearchParams) {\n    return cachedSearchParams\n  }\n  const promise = makeUntrackedSearchParamsWithDevWarningsImpl(\n    underlyingSearchParams,\n    workStore,\n    requestStore\n  )\n  CachedSearchParams.set(requestStore, promise)\n  return promise\n}\n\nfunction makeUntrackedSearchParamsWithDevWarningsImpl(\n  underlyingSearchParams: SearchParams,\n  workStore: WorkStore,\n  requestStore: RequestStore\n): Promise<SearchParams> {\n  const promiseInitialized = { current: false }\n  const proxiedUnderlying = instrumentSearchParamsObjectWithDevWarnings(\n    underlyingSearchParams,\n    workStore,\n    promiseInitialized\n  )\n\n  const promise = makeDevtoolsIOAwarePromise(\n    proxiedUnderlying,\n    requestStore,\n    RENDER_STAGES_BY_DATA_KIND.runtimeLinkData\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","validationSamples","createClientSearchParamsInValidation","makeUntrackedSearchParams","createRenderSearchParams","throwInvariantForMissingStore","metadataVaryParamsAccumulator","getMetadataVaryParamsAccumulator","varyParamsAccumulator","createRuntimePrerenderSearchParams","forceStatic","Promise","resolve","makeRuntimeHangingPromise","renderSignal","route","prerenderStore","makeHangingSearchParams","makeErroringSearchParams","userspaceSearchParams","createVaryingSearchParams","result","stagedRendering","isSessionShell","searchParamsStage","RENDER_STAGES_BY_DATA_KIND","runtimeLinkData","waitForStage","then","requestStore","asyncApiPromises","createSearchParamsProxyForInstantValidation","createStagedRenderSearchParams","process","env","NODE_ENV","makeUntrackedSearchParamsWithDevWarnings","trigger","sharedSearchParamsParent","promise","reject","displayName","catch","ignoreReject","instrumentSearchParamsPromiseWithDevWarnings","makePromiseFromTrigger","createExhaustiveSearchParamsProxy","require","declaredKeys","Set","Object","keys","searchParams","CachedSearchParams","WeakMap","CachedSearchParamsForUseCache","cachedSearchParams","get","trackSearchParamsAccessed","trackRuntimeDataAccessed","proxyHandler","target","prop","receiver","hasOwn","ReflectAdapter","originalMethod","args","expression","annotateDynamicAccess","dynamicAccessStore","dynamicAccessAsyncStorage","abortController","abort","Error","Proxy","apply","proxiedPromise","set","dynamicShouldError","throwWithStaticGenerationBailoutErrorWithDynamicError","postponeWithTracking","dynamicTracking","throwToInterruptStaticGeneration","wellKnownProperties","has","throwForSearchParamsAccessInUseCache","makeUntrackedSearchParamsWithDevWarningsImpl","promiseInitialized","current","proxiedUnderlying","instrumentSearchParamsObjectWithDevWarnings","makeDevtoolsIOAwarePromise","describeStringPropertyAccess","describeHasCheckingStringProperty","Reflect","ownKeys","proxiedProperties","forEach","add","warnForSyncAccess","value","delete","createDedupedByCallsiteServerErrorLoggerDev","createSearchAccessError","prefix"],"mappings":"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","ignoreList":[0]}