one 2.10.0 → 2.11.0

package/src/platform/mac/PopUpButton.macos.tsx

@@ -0,0 +1,31 @@
+import type { ViewProps } from 'react-native'
+import { useControlled } from '../controlled'
+import NativePopUpButton, { type ChangeEvent } from './OneMacPopUpButtonNativeComponent'
+
+export type PopUpButtonProps = Omit<ViewProps, 'children'> & {
+  labels: readonly string[]
+  /** zero based selection, or -1 for no selection. */
+  selectedIndex: number
+  disabled?: boolean
+  revision?: number
+  onChange?: (event: { selectedIndex: number; revision: number }) => void
+}
+
+export function PopUpButton({ labels, selectedIndex, revision = 0, onChange, ...props }: PopUpButtonProps) {
+  if (!Number.isInteger(selectedIndex) || selectedIndex < -1 || selectedIndex >= labels.length) {
+    throw new Error('PopUpButton selectedIndex must be -1 or an index in labels')
+  }
+  const controlled = useControlled((event: ChangeEvent) => {
+    onChange?.({ selectedIndex: event.selectedIndex, revision: event.revision })
+  }, revision)
+  return (
+    <NativePopUpButton
+      {...props}
+      labels={labels}
+      selectedIndex={selectedIndex}
+      revision={controlled.revision}
+      acknowledgedEvent={controlled.acknowledgedEvent}
+      onSelectedIndexChange={(event) => controlled.onNativeChange(event.nativeEvent)}
+    />
+  )
+}

package/src/platform/mac/SegmentedControl.macos.tsx

@@ -0,0 +1,11 @@
+import { createSegmentedControl, type DesktopSegmentedControlProps } from '../desktop/createControls'
+import NativeSegmentedControl, { type ChangeEvent } from './OneMacSegmentedControlNativeComponent'
+
+export type SegmentedControlProps = DesktopSegmentedControlProps
+
+export const SegmentedControl = createSegmentedControl<ChangeEvent>(
+  (props, binding) => <NativeSegmentedControl {...props} revision={binding.revision}
+    acknowledgedEvent={binding.acknowledgedEvent}
+    onSelectedIndexChange={({ nativeEvent }) => binding.onNativeChange(nativeEvent)} />,
+  (event) => event.selectedIndex,
+)

package/src/platform/mac/Toggle.macos.tsx

@@ -0,0 +1,12 @@
+import type { ReactElement } from 'react'
+import { createToggle, type DesktopToggleProps } from '../desktop/createControls'
+import NativeToggle, { type ChangeEvent } from './OneMacToggleNativeComponent'
+
+export type ToggleProps = Omit<DesktopToggleProps, 'disabled'>
+
+export const Toggle: (props: ToggleProps) => ReactElement = createToggle<ChangeEvent>(
+  (props, binding) => <NativeToggle {...props} revision={binding.revision}
+    acknowledgedEvent={binding.acknowledgedEvent}
+    onIsOnChange={({ nativeEvent }) => binding.onNativeChange(nativeEvent)} />,
+  (event) => event.isOn,
+)

package/src/platform/specs/OneDOMHostNativeComponent.ts

@@ -0,0 +1,30 @@
+import type * as React from 'react'
+import type { HostComponent, ViewProps } from 'react-native'
+import type {
+  DirectEventHandler,
+  Double,
+  WithDefault,
+} from 'react-native/Libraries/Types/CodegenTypes'
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent'
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands'
+
+interface NativeProps extends ViewProps {
+  entryId: string
+  developmentURL?: string
+  bootstrapState: string
+  scrollEnabled?: WithDefault<boolean, true>
+  onDocumentStart?: DirectEventHandler<Readonly<{ epoch: string; revision: Double }>>
+  onMessage?: DirectEventHandler<Readonly<{ message: string }>>
+  onLoad?: DirectEventHandler<Readonly<{ epoch: string }>>
+  onError?: DirectEventHandler<Readonly<{ epoch: string; message: string; code: string }>>
+  onProcessTerminated?: DirectEventHandler<Readonly<{ epoch: string }>>
+}
+
+interface NativeCommands {
+  post(viewRef: React.ElementRef<HostComponent<NativeProps>>, message: string): void
+}
+
+export const Commands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['post'],
+})
+export default codegenNativeComponent<NativeProps>('OneDOMHost')

package/src/platform/specs/OneStoreReview.nitro.ts

@@ -1,5 +1,5 @@
 import type { HybridObject } from 'react-native-nitro-modules'
 
-export interface OneStoreReview extends HybridObject<{ android: 'kotlin' }> {
+export interface OneStoreReview extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
   requestReview(): Promise<void>
 }

package/src/platform/split-view/split-view.linux.tsx

@@ -0,0 +1 @@
+export * from './split-view.macos'

package/src/platform/split-view/split-view.macos.tsx

@@ -0,0 +1,26 @@
+// split view is ios-only; macOS renders the slot on its own like web, without
+// pulling react-native-screens/experimental into the bundle
+
+import type { ComponentType, ReactNode } from 'react'
+
+export interface SplitViewColumnProps {
+  children?: ReactNode
+}
+
+export interface SplitViewProps {
+  children?: ReactNode
+  slot?: ComponentType
+}
+
+function SplitViewNavigator({ slot: Slot }: SplitViewProps) {
+  return Slot ? <Slot /> : null
+}
+
+function SplitViewColumnComponent(props: SplitViewColumnProps) {
+  return <>{props.children}</>
+}
+
+export const SplitView = Object.assign(SplitViewNavigator, {
+  Column: SplitViewColumnComponent,
+  Inspector: SplitViewColumnComponent,
+})

package/src/platform/ui/Image.linux.tsx

@@ -0,0 +1 @@
+export * from './Image.macos'

package/src/platform/ui/Image.macos.tsx

@@ -0,0 +1,9 @@
+import { Image as RNImage } from 'react-native'
+import type { ImageProps } from './Image.native'
+
+// macos has no nitro image backend; react native's image view loads and draws
+// it, and its load events already carry the shapes One.UI.Image reports.
+export function Image({ source, resizeMode = 'cover', recyclingKey: _recyclingKey, ...props }: ImageProps) {
+  const rnSource = typeof source === 'string' ? { uri: source } : source
+  return <RNImage source={rnSource} resizeMode={resizeMode} {...props} />
+}

package/src/router/getRoutes.ts

@@ -35,7 +35,7 @@ type DirectoryNode = {
   renderMode?: One.RouteRenderMode | 'api'
 }
 
-const validPlatforms = new Set(['android', 'ios', 'native', 'web'])
+const validPlatforms = new Set(['android', 'ios', 'linux', 'macos', 'native', 'web'])
 
 /**
  * Given a Metro context module, return an array of nested routes.

package/src/router/router.ts

@@ -27,7 +27,14 @@ import { openExternalURL } from '../link/openExternalURL'
 import { resolve } from '../link/path'
 import { checkBlocker } from '../useBlocker'
 import { assertIsReady } from '../utils/assertIsReady'
-import { getLoaderPath, getPreloadCSSPath, getPreloadPath } from '../utils/cleanUrl'
+import {
+  getLoaderPath,
+  getPreloadCSSPath,
+  getPreloadPath,
+  isLoaderBadRequest,
+  splitLoaderKey,
+  toLoaderKey,
+} from '../utils/cleanUrl'
 import { dynamicImport, isChunkLoadError } from '../utils/dynamicImport'
 import { PLATFORM } from '../utils/platform'
 import { isVersionStale } from '../skewProtection'
@@ -787,7 +794,12 @@ async function doPreloadDev(href: string): Promise<any> {
     }
 
     try {
-      const loaderJSUrl = getLoaderPath(href, true)
+      const loaderJSUrl = getLoaderPath(
+        href,
+        true,
+        undefined,
+        splitLoaderKey(normalizedPath)[1]
+      )
 
       const moduleLoadStart = performance.now()
       const modulePromise = dynamicImport(loaderJSUrl, false)
@@ -851,7 +863,12 @@ async function doPreload(href: string) {
 
   const artifactPaths = getRouteArtifactPaths(href, getResolvedLinking(), routeNode)
   const preloadPath = getPreloadPath(artifactPaths.preload)
-  const loaderPath = getLoaderPath(artifactPaths.loader)
+  const loaderPath = getLoaderPath(
+    artifactPaths.loader,
+    undefined,
+    undefined,
+    splitLoaderKey(normalizeLoaderPath(href))[1]
+  )
   const cssPreloadPath = getPreloadCSSPath(artifactPaths.preload)
 
   recordPreloadStart(href)
@@ -1000,6 +1017,11 @@ export function preloadRoute(href: string, injectCSS = false): Promise<any> | un
           preloadingLoader,
           normalizedHref,
           doPreloadDev(href).then((data) => {
+            // a rejected request is never kept, so a later visit asks the server again
+            if (isLoaderBadRequest(data)) {
+              delete preloadingLoader[normalizedHref]
+              return data
+            }
             setBoundedPreloadRecord(preloadedLoaderData, normalizedHref, data)
             return data
           })
@@ -1008,24 +1030,32 @@ export function preloadRoute(href: string, injectCSS = false): Promise<any> | un
       return preloadingLoader[normalizedHref]
     }
 
-    if (!preloadingLoader[href]) {
+    // an ssr route's data depends on its query, so it is keyed the way useLoader keys it
+    const preloadKey = splitLoaderKey(normalizeLoaderPath(href))[1]
+      ? normalizeLoaderPath(href)
+      : href
+    if (!preloadingLoader[preloadKey]) {
       setBoundedPreloadRecord(
         preloadingLoader,
-        href,
+        preloadKey,
         doPreload(href)
           .then((data) => {
             // store only successful preloads so navigation retries a failed hover.
-            setBoundedPreloadRecord(preloadedLoaderData, href, data)
+            if (isLoaderBadRequest(data)) {
+              delete preloadingLoader[preloadKey]
+              return data
+            }
+            setBoundedPreloadRecord(preloadedLoaderData, preloadKey, data)
             return data
           })
           .catch((err) => {
-            delete preloadingLoader[href]
+            delete preloadingLoader[preloadKey]
             throw err
           })
       )
     }
 
-    return preloadingLoader[href]?.then(
+    return preloadingLoader[preloadKey]?.then(
       async (data) => {
         if (injectCSS) {
           // wait for CSS on navigation (max 800ms).
@@ -1055,11 +1085,22 @@ export function preloadRoute(href: string, injectCSS = false): Promise<any> | un
   }
 }
 
-// normalize path to match what useLoader uses for currentPath
-function normalizeLoaderPath(href: string): string {
-  // remove search params and hash, normalize trailing slashes and /index
+function isSsrHref(href: string): boolean {
+  const linking = getResolvedLinking()
+  if (!linking?.getStateFromPath || !routeNode) return false
+  const state = linking.getStateFromPath(href, linking.config)
+  return findRouteNodeFromState(state, routeNode)?.type === 'ssr'
+}
+
+/**
+ * The key loader data is stored under, as useLoader keys it: the pathname with
+ * trailing slash and /index removed. An ssr route's loader reads the query, so its
+ * key keeps the query (hash removed). Other routes drop it.
+ */
+export function normalizeLoaderPath(href: string): string {
   const url = new URL(href, 'http://example.com')
-  return url.pathname.replace(/\/index$/, '').replace(/\/$/, '') || '/'
+  const path = url.pathname.replace(/\/index$/, '').replace(/\/$/, '') || '/'
+  return url.search && isSsrHref(href) ? toLoaderKey(path, url.search) : path
 }
 
 /**
@@ -1272,7 +1313,14 @@ export async function linkTo(
   // sync fast path: skip async preload when data is already cached
   // (e.g., from hover/viewport/intent prefetching via PreloadLinks)
   if (!(normalizedPreloadPath in preloadedLoaderData) && !(href in preloadedLoaderData)) {
-    await preloadRoute(href, true)
+    const preloaded = await preloadRoute(href, true)
+    // the server rejected this url (a query a search schema rejects) without running
+    // the loader. load it as a document so the server's own response shows.
+    if (isLoaderBadRequest(preloaded)) {
+      setLoadingState('loaded')
+      window.location.assign(href)
+      return
+    }
   } else if (process.env.NODE_ENV !== 'development') {
     // cached data in prod: still inject CSS (non-blocking so we don't delay nav)
     const inject = cssInjectFunctions[href]

package/src/searchParams.ts

@@ -0,0 +1,163 @@
+/**
+ * Reading and writing typed search params.
+ *
+ * The URL is text. A schema reads it as a record of strings (a repeated key is an
+ * array) and returns whatever the schema produces. Going back, a schema cannot turn
+ * a value into text, so values are written by one fixed rule: strings, numbers,
+ * booleans, or arrays of those, with repeated keys for arrays.
+ */
+
+import { validateStandardSchemaSync, type StandardSchemaV1 } from './standardSchema'
+import { parseSearchString, SearchValidationError, setOwn } from './validateSearchParams'
+
+/** What a schema receives: every query key, a string or, when repeated, an array. */
+export type SearchRecord = Record<string, string | string[]>
+
+type Scalar = string | number | boolean
+
+/** A value that has a defined URL form. */
+export type SearchValue = Scalar | readonly Scalar[]
+
+type UpdateValue<Out, In> =
+  NonNullable<Out> extends SearchValue ? Out | null | undefined : In
+
+/**
+ * What the update function accepts. A field whose output is a plain value is
+ * written as that value, and `null` or `undefined` removes the key. A field whose
+ * output cannot be written (a Date, an object) takes the schema's input type, the
+ * text the schema reads, instead.
+ */
+export type SearchParamsUpdate<Schema extends StandardSchemaV1> = {
+  [K in keyof StandardSchemaV1.InferOutput<Schema>]?: UpdateValue<
+    StandardSchemaV1.InferOutput<Schema>[K],
+    K extends keyof StandardSchemaV1.InferInput<Schema>
+      ? StandardSchemaV1.InferInput<Schema>[K]
+      : never
+  >
+}
+
+export type SearchParamsUpdateOptions = {
+  /** Replace the current history entry instead of adding one. Default false. */
+  replace?: boolean
+}
+
+export type SearchParamsOptions = {
+  /** Read the params of the active route even when this one is not focused. */
+  global?: boolean
+}
+
+export type UseSearchParamsSchemaResult<Schema extends StandardSchemaV1> = readonly [
+  StandardSchemaV1.InferOutput<Schema>,
+  (update: SearchParamsUpdate<Schema>, options?: SearchParamsUpdateOptions) => void,
+]
+
+/**
+ * Keeps the query of a params object. Path params, the hash and navigator keys ride
+ * in the same object, but the route's href only carries the query, so its keys say
+ * which entries to keep.
+ */
+export function toSearchRecord(
+  params: Record<string, unknown>,
+  href: string
+): SearchRecord {
+  const search = href.split('#')[0].split('?')[1] ?? ''
+  const queryKeys = new Set(new URLSearchParams(search).keys())
+  const record: SearchRecord = {}
+  for (const [key, value] of Object.entries(params)) {
+    if (value == null || !queryKeys.has(key)) continue
+    setOwn(record, key, Array.isArray(value) ? value.map(String) : String(value))
+  }
+  return record
+}
+
+export function searchRecordKey(record: SearchRecord): string {
+  return JSON.stringify(record)
+}
+
+export function parseSearchRecord<Schema extends StandardSchemaV1>(
+  schema: Schema,
+  record: SearchRecord
+): StandardSchemaV1.InferOutput<Schema> {
+  const result = validateStandardSchemaSync(schema, record)
+  if (result.issues) {
+    throw new SearchValidationError(
+      `Invalid search params (${describeIssues(result.issues)})`,
+      result.issues as unknown[]
+    )
+  }
+  return result.value
+}
+
+export function describeIssues(issues: readonly StandardSchemaV1.Issue[]) {
+  return issues
+    .map((issue) => {
+      const path = issue.path
+        ?.map((segment) => String(typeof segment === 'object' ? segment.key : segment))
+        .join('.')
+      return path ? `${path}: ${issue.message}` : issue.message
+    })
+    .join('; ')
+}
+
+function toStrings(key: string, value: unknown): string[] | undefined {
+  if (value == null) return undefined
+  const values = Array.isArray(value) ? value : [value]
+  for (const item of values) {
+    const type = typeof item
+    if (type !== 'string' && type !== 'number' && type !== 'boolean') {
+      throw new TypeError(
+        `Search param "${key}" cannot be written to the URL: expected a string, number, boolean or an array of those, got ${type === 'object' ? (item === null ? 'null' : item.constructor?.name) : type}. Pass the text the schema reads instead.`
+      )
+    }
+  }
+  return values.length ? values.map(String) : undefined
+}
+
+/**
+ * Applies an update onto the current record. Keys the update does not name keep
+ * their value and position, a named key with no value is removed.
+ */
+export function mergeSearchRecord(
+  current: SearchRecord,
+  update: Record<string, unknown>
+): SearchRecord {
+  const next: SearchRecord = { ...current }
+  for (const [key, value] of Object.entries(update)) {
+    const strings = toStrings(key, value)
+    if (!strings) {
+      delete next[key]
+    } else {
+      setOwn(next, key, strings.length === 1 && !Array.isArray(value) ? strings[0] : strings)
+    }
+  }
+  return next
+}
+
+export function stringifySearchRecord(record: SearchRecord): string {
+  const parts: string[] = []
+  for (const [key, value] of Object.entries(record)) {
+    for (const item of Array.isArray(value) ? value : [value]) {
+      parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(item)}`)
+    }
+  }
+  return parts.join('&')
+}
+
+/**
+ * Adds search params to an href string. Keys in the update replace the same keys
+ * already in the href, the path, other keys and the hash stay.
+ */
+export function applySearchParams(
+  href: string,
+  update: Record<string, unknown> | undefined
+): string {
+  if (!update) return href
+  const hashIndex = href.indexOf('#')
+  const hash = hashIndex === -1 ? '' : href.slice(hashIndex)
+  const withoutHash = hashIndex === -1 ? href : href.slice(0, hashIndex)
+  const queryIndex = withoutHash.indexOf('?')
+  const path = queryIndex === -1 ? withoutHash : withoutHash.slice(0, queryIndex)
+  const current = queryIndex === -1 ? {} : parseSearchString(withoutHash.slice(queryIndex + 1))
+  const query = stringifySearchRecord(mergeSearchRecord(current, update))
+  return `${path}${query ? `?${query}` : ''}${hash}`
+}

package/src/server/oneServe.ts

@@ -21,6 +21,11 @@ import { toAbsoluteUrl } from '../utils/toAbsolute'
 import { toServerOutputPath } from '../utils/toServerOutputPath'
 import type { One } from '../vite/types'
 import type { RouteInfoCompiled } from './createRoutesManifest'
+import {
+  getLoaderSearchSchemas,
+  withLoaderSearchParams,
+  type LoaderSearchSchemas,
+} from '../loaderSearchParams'
 import { getRouteExportsFromEntry } from './routeExportsFromEntry'
 import { setSSRLoaderData } from './ssrLoaderData'
 import { getFetchStaticHtml } from './staticHtmlFetcher'
@@ -167,6 +172,8 @@ export async function oneServe(
   // loader coalescing via static loaderCache export
   // when a route exports loaderCache, concurrent requests with the same key share one execution
   const loaderCacheFnMap = new Map<string, Function | null>()
+  // search schemas the build found for a route's loader, null when it has none
+  const loaderSearchSchemaMap = new Map<string, LoaderSearchSchemas | null>()
   const pendingLoaderResults = new Map<
     string,
     { promise: Promise<any>; expires: number }
@@ -216,6 +223,12 @@ export async function oneServe(
       // also cache loaderCache export for coalescing
       const loaderCacheFn = routeExported?.loaderCache ?? null
       setBounded(loaderCacheFnMap, cacheKey, loaderCacheFn, MODULE_CACHE_MAX)
+      setBounded(
+        loaderSearchSchemaMap,
+        cacheKey,
+        getLoaderSearchSchemas(routeExported),
+        MODULE_CACHE_MAX
+      )
       return loader
     })()
   }
@@ -225,7 +238,9 @@ export async function oneServe(
     routeId: string,
     serverPath: string | undefined,
     lazyKey: string | undefined,
-    loaderProps: any
+    requestLoaderProps: any,
+    // only document requests of ssr routes carry the query a loader can validate
+    withSearchParams = false
   ): Promise<{ loaderData: unknown; routeId: string; isEnoent?: boolean }> {
     if (!serverPath && !lazyKey) {
       return { loaderData: undefined, routeId }
@@ -233,6 +248,13 @@ export async function oneServe(
 
     // check loaderCache BEFORE resolving the loader (fast path for coalesced requests)
     const cacheMapKey = lazyKey || serverPath || ''
+    // validate before any cached result is reused, a cold route is validated once loaded
+    let loaderProps = requestLoaderProps
+    const validateSearch = () => {
+      const schemas = withSearchParams && loaderSearchSchemaMap.get(cacheMapKey)
+      if (schemas) loaderProps = withLoaderSearchParams(schemas, requestLoaderProps)
+    }
+    validateSearch()
     const loaderCacheFn = loaderCacheFnMap.get(cacheMapKey)
     let coalFullKey: string | undefined
     let coalTtl = 0
@@ -261,6 +283,7 @@ export async function oneServe(
       if (!loader) {
         return { loaderData: undefined, routeId }
       }
+      if (loaderProps === requestLoaderProps) validateSearch()
 
       // first caller with loaderCache: execute and register for coalescing
       if (coalFullKey) {
@@ -385,6 +408,11 @@ export async function oneServe(
         return null
       }
 
+      // a client navigation to an ssr route validates its query like the document request
+      const searchSchemas =
+        route.type === 'ssr' && loaderSearchSchemaMap.get(routeFile || serverPath)
+      if (searchSchemas) loaderProps = withLoaderSearchParams(searchSchemas, loaderProps)
+
       let json
       try {
         json = await loader(loaderProps)
@@ -444,7 +472,8 @@ export async function oneServe(
                   layout.contextKey,
                   serverPath,
                   layout.contextKey,
-                  loaderProps
+                  loaderProps,
+                  true
                 )
               )
             }
@@ -455,7 +484,8 @@ export async function oneServe(
             route.file,
             buildInfo.serverJsPath,
             route.file,
-            loaderProps
+            loaderProps,
+            true
           )
 
           // wait for all loaders in parallel

package/src/server/workerHandler.ts

@@ -21,6 +21,11 @@ import { isResponse } from '../utils/isResponse'
 import { resolveResponse } from '../vite/resolveResponse'
 import type { One } from '../vite/types'
 import type { RouteInfoCompiled } from './createRoutesManifest'
+import {
+  getLoaderSearchSchemas,
+  withLoaderSearchParams,
+  type LoaderSearchSchemas,
+} from '../loaderSearchParams'
 import { getRouteExportsFromEntry } from './routeExportsFromEntry'
 import { setSSRLoaderData } from './ssrLoaderData'
 import { getFetchStaticHtml } from './staticHtmlFetcher'
@@ -93,6 +98,8 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
   const loaderCache = new Map<string, Function | null>()
   const moduleImportCache = new Map<string, any>()
   const loaderCacheFnMap = new Map<string, Function | null>()
+  // search schemas the build found for a route's loader, null when it has none
+  const loaderSearchSchemaMap = new Map<string, LoaderSearchSchemas | null>()
   const pendingLoaderResults = new Map<
     string,
     { promise: Promise<any>; expires: number }
@@ -192,6 +199,7 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
       }
 
       const loader = routeExported?.loader || null
+      loaderSearchSchemaMap.set(cacheKey, getLoaderSearchSchemas(routeExported))
       if (!disableModuleCache) {
         loaderCache.set(cacheKey, loader)
         loaderCacheFnMap.set(cacheKey, routeExported?.loaderCache ?? null)
@@ -204,12 +212,21 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
   async function importAndRunLoader(
     routeId: string,
     lazyKey: string | undefined,
-    loaderProps: any
+    requestLoaderProps: any,
+    // only document requests of ssr routes carry the query a loader can validate
+    withSearchParams = false
   ): Promise<{ loaderData: unknown; routeId: string; isEnoent?: boolean }> {
     if (!lazyKey) return { loaderData: undefined, routeId }
 
     // check loaderCache coalescing before resolving
     const cacheMapKey = lazyKey
+    // validate before any cached result is reused, a cold route is validated once loaded
+    let loaderProps = requestLoaderProps
+    const validateSearch = () => {
+      const schemas = withSearchParams && loaderSearchSchemaMap.get(cacheMapKey)
+      if (schemas) loaderProps = withLoaderSearchParams(schemas, requestLoaderProps)
+    }
+    validateSearch()
     const loaderCacheFn = loaderCacheFnMap.get(cacheMapKey)
     let coalFullKey: string | undefined
     let coalTtl = 0
@@ -234,6 +251,7 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
       const loader =
         loaderOrPromise instanceof Promise ? await loaderOrPromise : loaderOrPromise
       if (!loader) return { loaderData: undefined, routeId }
+      if (loaderProps === requestLoaderProps) validateSearch()
 
       if (coalFullKey) {
         const promise = loader(loaderProps)
@@ -299,6 +317,10 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
 
       if (!loader) return null
 
+      // a client navigation to an ssr route validates its query like the document request
+      const searchSchemas = route.type === 'ssr' && loaderSearchSchemaMap.get(routeFile)
+      if (searchSchemas) loaderProps = withLoaderSearchParams(searchSchemas, loaderProps)
+
       let json
       try {
         json = await loader(loaderProps)
@@ -348,7 +370,7 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
               })
             } else {
               layoutLoaderPromises.push(
-                importAndRunLoader(layout.contextKey, layout.contextKey, loaderProps)
+                importAndRunLoader(layout.contextKey, layout.contextKey, loaderProps, true)
               )
             }
           }
@@ -356,7 +378,8 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
           const pageLoaderPromise = importAndRunLoader(
             route.file,
             route.file,
-            loaderProps
+            loaderProps,
+            true
           )
 
           let layoutResults: Array<{
@@ -826,6 +849,7 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
     loaderCache.clear()
     moduleImportCache.clear()
     loaderCacheFnMap.clear()
+    loaderSearchSchemaMap.clear()
     pendingLoaderResults.clear()
     render = null
     renderStream = null