one 1.10.6 → 1.11.0

package/src/router/linkingConfig.ts

@@ -8,6 +8,14 @@ import type { RouteNode } from './Route'
 
 let linkingConfig: OneLinkingOptions | undefined
 
+// cache the base linking config (route-tree dependent, not URL-dependent)
+let cachedBaseLinkingConfig: OneLinkingOptions | undefined
+let cachedRouteNodeForLinking: RouteNode | null = null
+
+// cache getStateFromPath results by path for SSR performance
+// same path always produces the same navigation state (route tree is static in prod)
+const ssrStateCache = new Map<string, OneRouter.ResultState | undefined>()
+
 export function getLinking() {
   return linkingConfig
 }
@@ -20,6 +28,46 @@ export function resetLinking() {
   linkingConfig = undefined
 }
 
+/**
+ * Ensure the base linking config is initialized for a given route tree.
+ * Does not set any per-request state.
+ */
+export function ensureBaseLinkingConfig(routeNode: RouteNode | null) {
+  if (
+    routeNode &&
+    (routeNode !== cachedRouteNodeForLinking || !cachedBaseLinkingConfig)
+  ) {
+    cachedBaseLinkingConfig = createLinkingConfig(routeNode)
+    cachedRouteNodeForLinking = routeNode
+  }
+}
+
+/**
+ * Compute initialState from a URL path, with caching for SSR.
+ * Does not modify the global linkingConfig.
+ */
+export function getSSRInitialState(
+  routeNode: RouteNode | null,
+  initialLocation: URL
+): OneRouter.ResultState | undefined {
+  if (!routeNode) return undefined
+
+  ensureBaseLinkingConfig(routeNode)
+  if (!cachedBaseLinkingConfig) return undefined
+
+  const path = initialLocation.pathname + (initialLocation.search || '')
+  if (ssrStateCache.has(path)) return ssrStateCache.get(path)
+
+  const state = cachedBaseLinkingConfig.getStateFromPath?.(
+    path,
+    cachedBaseLinkingConfig.config
+  )
+  // bound cache to prevent memory growth on sites with many unique URLs
+  if (ssrStateCache.size > 10000) ssrStateCache.clear()
+  ssrStateCache.set(path, state)
+  return state
+}
+
 export function setupLinking(
   routeNode: RouteNode | null,
   initialLocation?: URL
@@ -27,7 +75,11 @@ export function setupLinking(
   let initialState: OneRouter.ResultState | undefined
 
   if (routeNode) {
-    linkingConfig = createLinkingConfig(routeNode)
+    // reuse ensureBaseLinkingConfig to avoid duplicating cache logic
+    ensureBaseLinkingConfig(routeNode)
+
+    // shallow copy so per-request mutations (getInitialURL) don't affect cache
+    linkingConfig = { ...cachedBaseLinkingConfig! }
 
     if (initialLocation) {
       linkingConfig.getInitialURL = () => initialLocation.toString()
@@ -35,7 +87,6 @@ export function setupLinking(
       let path = initialLocation.pathname + (initialLocation.search || '')
 
       if (isWebClient) {
-        // Check history.state for temp location (client-only)
         const historyState = window.history.state
         if (historyState?.__tempLocation?.pathname && !historyState.__tempKey) {
           path =

package/src/router/router.ts

@@ -6,6 +6,7 @@
 
 import {
   type NavigationContainerRefWithCurrent,
+  type NavigationState,
   StackActions,
 } from '@react-navigation/native'
 import {
@@ -116,7 +117,9 @@ export function isRouteProtected(href: string): boolean {
         .replace(/^\//, '')
       const routeName = relativePath.split('/')[0] || 'index'
 
-      if (protectedScreens.has(routeName)) {
+      // normalize /index suffix so e.g. "otp/[flow]" matches "otp/[flow]/index"
+      const normalizedRouteName = routeName.replace(/\/index$/, '')
+      if (protectedScreens.has(routeName) || protectedScreens.has(normalizedRouteName)) {
         return true
       }
     }
@@ -135,7 +138,6 @@ let splashScreenAnimationFrame: number | undefined
 
 // we always set it
 export let navigationRef: OneRouter.NavigationRef = null as any
-let navigationRefSubscription: () => void
 
 const rootStateSubscribers = new Set<OneRouter.RootStateListener>()
 const loadingStateSubscribers = new Set<OneRouter.LoadingStateListener>()
@@ -198,6 +200,11 @@ export function useValidationState() {
   )
 }
 
+// cache route tree + root component across SSR requests (they don't change)
+let cachedRouteNode: RouteNode | null = null
+let cachedRootComponent: ComponentType | null = null
+let cachedContext: One.RouteContext | null = null
+
 // Initialize function
 export function initialize(
   context: One.RouteContext,
@@ -206,12 +213,20 @@ export function initialize(
 ) {
   cleanUpState()
 
-  routeNode = getRoutes(context, {
-    ignoreEntryPoints: true,
-    platform: Platform.OS,
-  })
+  // cache route tree - only rebuild when context changes (never in production)
+  if (context !== cachedContext || !cachedRouteNode) {
+    cachedRouteNode = getRoutes(context, {
+      ignoreEntryPoints: true,
+      platform: Platform.OS,
+    })
+    cachedRootComponent = cachedRouteNode
+      ? getQualifiedRouteComponent(cachedRouteNode)
+      : Fragment
+    cachedContext = context
+  }
 
-  rootComponent = routeNode ? getQualifiedRouteComponent(routeNode) : Fragment
+  routeNode = cachedRouteNode
+  rootComponent = cachedRootComponent || Fragment
 
   if (!routeNode && process.env.NODE_ENV === 'production') {
     throw new Error('No routes found')
@@ -271,7 +286,6 @@ function cleanUpState() {
   nextState = undefined
   routeInfo = undefined
   resetLinking()
-  navigationRefSubscription?.()
   rootStateSubscribers.clear()
   storeSubscribers.clear()
 }
@@ -293,46 +307,57 @@ function setupLinkingAndRouteInfo(initialLocation?: URL) {
   }
 }
 
-function subscribeToNavigationChanges() {
-  navigationRefSubscription = navigationRef.addListener('state', (data) => {
-    let state = { ...data.data.state } as OneRouter.ResultState
+/**
+ * called by NavigationContainer's onStateChange callback
+ * uses onStateChange instead of addListener('state') because onStateChange
+ * always provides the full resolved state, avoiding partial state issues
+ * that can cause stale usePathname/useSegments values
+ */
+export function handleNavigationContainerStateChange(
+  navState: Readonly<NavigationState> | undefined
+) {
+  if (!navState) return
 
-    if (state.key) {
-      if (hashes[state.key]) {
-        state.hash = hashes[state.key]
-        delete hashes[state.key]
-      }
-    }
+  // @ts-expect-error
+  let state = { ...navState } as OneRouter.ResultState
 
-    if (!hasAttemptedToHideSplash) {
-      hasAttemptedToHideSplash = true
-      splashScreenAnimationFrame = requestAnimationFrame(() => {
-        // SplashScreen._internal_maybeHideAsync?.();
-      })
+  if (state.key) {
+    if (hashes[state.key]) {
+      state.hash = hashes[state.key]
+      delete hashes[state.key]
     }
+  }
 
-    if (nextOptions) {
-      state = { ...state, linkOptions: nextOptions }
-      nextOptions = null
-    }
+  if (!hasAttemptedToHideSplash) {
+    hasAttemptedToHideSplash = true
+    splashScreenAnimationFrame = requestAnimationFrame(() => {
+      // SplashScreen._internal_maybeHideAsync?.();
+    })
+  }
 
-    let shouldUpdateSubscribers = nextState === state
-    nextState = undefined
+  if (nextOptions) {
+    state = { ...state, linkOptions: nextOptions }
+    nextOptions = null
+  }
 
-    if (state && state !== rootState) {
-      updateState(state, undefined)
-      shouldUpdateSubscribers = true
-    }
+  let shouldUpdateSubscribers = nextState === state
+  nextState = undefined
 
-    if (shouldUpdateSubscribers) {
-      startTransition(() => {
-        for (const subscriber of rootStateSubscribers) {
-          subscriber(state)
-        }
-      })
-    }
-  })
+  if (state && state !== rootState) {
+    updateState(state, undefined)
+    shouldUpdateSubscribers = true
+  }
 
+  if (shouldUpdateSubscribers) {
+    startTransition(() => {
+      for (const subscriber of rootStateSubscribers) {
+        subscriber(state)
+      }
+    })
+  }
+}
+
+function subscribeToNavigationChanges() {
   startTransition(() => {
     updateSnapshot()
     for (const subscriber of storeSubscribers) {
@@ -515,7 +540,6 @@ function getSnapshot() {
     routeInfo,
     splashScreenAnimationFrame,
     navigationRef,
-    navigationRefSubscription,
     rootStateSubscribers,
     storeSubscribers,
   }
@@ -1129,18 +1153,20 @@ export async function linkTo(
   currentMatches = newMatches
   setClientMatches(newMatches)
 
-  const rootState = navigationRef.getRootState()
+  const currentRootState = navigationRef.getRootState()
 
   const hash = href.indexOf('#')
-  if (rootState.key && hash > 0) {
-    hashes[rootState.key] = href.slice(hash)
+  if (currentRootState.key && hash > 0) {
+    hashes[currentRootState.key] = href.slice(hash)
   }
 
   // a bit hacky until can figure out a reliable way to tie it to the state
   nextOptions = options ?? null
 
   startTransition(() => {
-    const action = getNavigateAction(state, rootState, event)
+    // compute target at dispatch time to avoid stale state during first render/effects
+    const freshRootState = navigationRef.getRootState() as NavigationState
+    const action = getNavigateAction(state, freshRootState, event)
     const current = navigationRef.getCurrentRoute()
     navigationRef.dispatch(action)
 

package/src/router/useInitializeOneRouter.ts

@@ -3,8 +3,15 @@ import { resetLoaderState } from '../useLoader'
 import type { One } from '../vite/types'
 import * as routerStore from './router'
 import { initialize } from './router'
+import { getSSRInitialState, ensureBaseLinkingConfig } from './linkingConfig'
 
-let initialized = false
+// client-side initialization tracking via a simple counter
+// resetState increments the version so the router re-initializes on client
+let initVersion = 0
+let lastInitVersion = -1
+
+// track whether the route tree has been initialized for SSR
+let ssrRouteTreeInitialized = false
 
 export function useInitializeOneRouter(
   context: One.RouteContext,
@@ -12,28 +19,53 @@ export function useInitializeOneRouter(
 ) {
   const navigationRef = useNavigationContainerRef()
 
-  if (!initialized) {
+  // SSR: initialize route tree once, then compute per-request state via cache
+  if (typeof window === 'undefined') {
+    if (!ssrRouteTreeInitialized) {
+      // first SSR request: full initialization to set up route tree, root component, etc.
+      initialize(context, navigationRef, initialLocation)
+      ssrRouteTreeInitialized = true
+      // also ensure linking config base is cached
+      ensureBaseLinkingConfig(routerStore.routeNode)
+    }
+
+    // per-request: compute initialState from URL (cached by path)
+    const initialState = initialLocation
+      ? getSSRInitialState(routerStore.routeNode, initialLocation)
+      : routerStore.initialState
+
+    // return per-request snapshot to prevent concurrent request trampling
+    return {
+      rootComponent: routerStore.rootComponent,
+      navigationRef,
+      initialState,
+    } as typeof routerStore
+  }
+
+  // client: use version tracking (no concurrency issue)
+  if (lastInitVersion !== initVersion) {
+    // reset react navigation contexts to avoid stale provider warnings
+    const contexts = '__react_navigation__elements_contexts'
+    globalThis[contexts] = new Map<string, React.Context<any>>()
+
     initialize(context, navigationRef, initialLocation)
-    initialized = true
+    lastInitVersion = initVersion
   }
 
   return routerStore
 }
 
+// increment version to trigger re-initialization on next client render
+export function prepareForSSRRender() {
+  initVersion++
+}
+
+// keep backwards compat but make it lightweight
+// on SSR, router state is computed per-request in useInitializeOneRouter;
+// this only clears useAsyncFn caches used by layout loader fallback path
 export function resetState() {
-  initialized = false
-  resetReactNavigationContexts()
+  prepareForSSRRender()
   resetLoaderState()
 }
 
-// TODO remove global
 globalThis['__vxrnresetState'] = resetState
-
-function resetReactNavigationContexts() {
-  // https://github.com/expo/router/discussions/588
-  // https://github.com/react-navigation/react-navigation/blob/9fe34b445fcb86e5666f61e144007d7540f014fa/packages/elements/src/getNamedContext.tsx#LL3C1-L4C1
-  // React Navigation is storing providers in a global, this is fine for the first static render
-  // but subsequent static renders of Stack or Tabs will cause React to throw a warning. To prevent this warning, we'll reset the globals before rendering.
-  const contexts = '__react_navigation__elements_contexts'
-  globalThis[contexts] = new Map<string, React.Context<any>>()
-}

package/src/router/useScreens.tsx

@@ -74,17 +74,33 @@ export const { Screen, Group } = createNavigatorFactory({} as any)()
 // Cache inline CSS elements at module load (before React hydrates).
 // Reads CSS content from SSR'd <style> elements and creates matching JSX
 // so hydration sees identical content without 100KB+ JSON payload.
+// Also captures <link> stylesheet elements for mixed inline/link CSS mode.
 const cachedInlineCSSElements: React.ReactNode[] =
   typeof document !== 'undefined'
-    ? Array.from(
-        document.querySelectorAll<HTMLStyleElement>('style[id^="__one_css_"]')
-      ).map((el, i) => (
-        <style
-          key={`inline-css-${i}`}
-          id={el.id}
-          dangerouslySetInnerHTML={{ __html: el.innerHTML }}
-        />
-      ))
+    ? (() => {
+        const elements: React.ReactNode[] = []
+        // collect all SSR CSS elements in order (both inline <style> and <link>)
+        const cssElements = document.querySelectorAll<HTMLElement>(
+          'style[id^="__one_css_"], link[rel="stylesheet"][data-one-css]'
+        )
+        cssElements.forEach((el, i) => {
+          if (el.tagName === 'STYLE') {
+            elements.push(
+              <style
+                key={`inline-css-${i}`}
+                id={el.id}
+                dangerouslySetInnerHTML={{ __html: el.innerHTML }}
+              />
+            )
+          } else {
+            const href = el.getAttribute('href')!
+            elements.push(
+              <link key={href} rel="stylesheet" href={href} data-one-css="" />
+            )
+          }
+        })
+        return elements
+      })()
     : []
 
 /**
@@ -154,15 +170,23 @@ function RootLayoutRenderer({
           }}
         />
         {serverContext?.cssContents?.length || serverContext?.cssInlineCount
-          ? // Inline CSS: SSR renders fresh, client uses cached elements from module load
+          ? // inline/mixed CSS: render each entry as <style> (if content) or <link>
             serverContext?.cssContents
-            ? serverContext.cssContents.map((content, i) => (
-                <style
-                  key={`inline-css-${i}`}
-                  id={`__one_css_${i}`}
-                  dangerouslySetInnerHTML={{ __html: content }}
-                />
-              ))
+            ? serverContext.cssContents.map((content, i) =>
+                content ? (
+                  <style
+                    key={`inline-css-${i}`}
+                    id={`__one_css_${i}`}
+                    dangerouslySetInnerHTML={{ __html: content }}
+                  />
+                ) : serverContext.css?.[i] ? (
+                  <link
+                    key={serverContext.css[i]}
+                    rel="stylesheet"
+                    href={serverContext.css![i]}
+                  />
+                ) : null
+              )
             : cachedInlineCSSElements
           : serverContext?.css?.map((file) => (
               <link key={file} rel="stylesheet" href={file} />
@@ -293,7 +317,14 @@ export function useSortedScreens(
       : []
 
     return sorted
-      .filter((value) => !options?.protectedScreens?.has(value.route.route))
+      .filter((value) => {
+        const routeName = value.route.route
+        const normalized = routeName.replace(/\/index$/, '')
+        return !(
+          options?.protectedScreens?.has(routeName) ||
+          options?.protectedScreens?.has(normalized)
+        )
+      })
       .map((value) => routeToScreen(value.route, value.props))
   }, [node?.children, node?.initialRouteName, order, options?.protectedScreens])
 
@@ -348,10 +379,15 @@ export function getQualifiedRouteComponent(value: RouteNode) {
       }, [])
     }
 
-    // in spa-shell mode, non-root-layout routes render a placeholder
+    // in spa-shell mode, only leaf pages render a placeholder.
+    // layouts (routes with children) must render normally so their
+    // navigators stay mounted across the hydration transition.
+    // without this, navigators remount when SpaShellContext flips
+    // and react navigation loses url-matched state, causing
+    // redirects like /beta/signup -> /admin -> /app/undefined
     // eslint-disable-next-line react-hooks/rules-of-hooks
     const isSpaShell = useContext(SpaShellContext)
-    if (isSpaShell && props.segment !== '') {
+    if (isSpaShell && props.segment !== '' && !value.children?.length) {
       return <div data-one-spa-content="" />
     }
 

package/src/screensFeatureFlags.ts

@@ -0,0 +1,23 @@
+// enables synchronous layout updates for react-native-screens
+// this fixes issues like flex: 1 not working properly in formSheet presentations
+// and ensures header config updates are applied synchronously
+// also prevents dismissed screens from being reattached on iOS
+
+let hasInitialized = false
+
+export function initScreensFeatureFlags() {
+  if (hasInitialized) return
+  hasInitialized = true
+
+  try {
+    const { featureFlags } = require('react-native-screens')
+    if (featureFlags?.experiment) {
+      featureFlags.experiment.synchronousScreenUpdatesEnabled = true
+      featureFlags.experiment.synchronousHeaderConfigUpdatesEnabled = true
+      featureFlags.experiment.synchronousHeaderSubviewUpdatesEnabled = true
+      featureFlags.experiment.iosPreventReattachmentOfDismissedScreens = true
+    }
+  } catch {
+    // react-native-screens may not be available (e.g. web-only builds)
+  }
+}

package/src/serve.ts

@@ -12,15 +12,76 @@ process.on('uncaughtException', (err) => {
   console.error(`[one] Uncaught exception`, err?.stack || err)
 })
 
-export async function serve(args: VXRNOptions['server'] & { app?: Hono } = {}) {
-  const buildInfo = (await FSExtra.readJSON(`dist/buildInfo.json`)) as One.BuildInfo
+export async function serve(
+  args: VXRNOptions['server'] & {
+    app?: Hono
+    outDir?: string
+    cluster?: boolean | number
+  } = {}
+) {
+  // cluster mode: --cluster or --cluster=N
+  if (args.cluster) {
+    const cluster = await import('node:cluster')
+    const { cpus } = await import('node:os')
+
+    if (cluster.default.isPrimary) {
+      const numWorkers = typeof args.cluster === 'number' ? args.cluster : cpus().length
+
+      console.info(`[one] cluster: starting ${numWorkers} workers`)
+
+      for (let i = 0; i < numWorkers; i++) {
+        cluster.default.fork()
+      }
+
+      // restart crashed workers with backoff
+      let recentCrashes = 0
+      let lastCrashTime = 0
+
+      cluster.default.on('exit', (worker, code, signal) => {
+        if (code === 0 || signal === 'SIGTERM' || signal === 'SIGINT') return
+
+        const now = Date.now()
+        if (now - lastCrashTime < 5000) {
+          recentCrashes++
+        } else {
+          recentCrashes = 1
+        }
+        lastCrashTime = now
+
+        if (recentCrashes > numWorkers * 2) {
+          console.error(`[one] too many worker crashes, stopping`)
+          process.exit(1)
+        }
+
+        console.error(
+          `[one] worker ${worker.process.pid} died (code ${code}, signal ${signal}), restarting`
+        )
+        setTimeout(() => cluster.default.fork(), Math.min(recentCrashes * 500, 5000))
+      })
+
+      const shutdown = () => {
+        for (const id in cluster.default.workers) {
+          cluster.default.workers[id]?.process.kill('SIGTERM')
+        }
+        setTimeout(() => process.exit(0), 5000)
+      }
+      process.on('SIGINT', shutdown)
+      process.on('SIGTERM', shutdown)
+
+      return
+    }
+  }
+
+  // worker (or single-process mode)
+  const outDir =
+    args.outDir || (FSExtra.existsSync('buildInfo.json') ? '.' : null) || 'dist'
+  const buildInfo = (await FSExtra.readJSON(`${outDir}/buildInfo.json`)) as One.BuildInfo
   const { oneOptions } = buildInfo
 
   setServerGlobals()
   setupBuildInfo(buildInfo)
   ensureExists(oneOptions)
 
-  // to avoid loading the CACHE_KEY before we set it use async imports:
   const { labelProcess } = await import('./cli/label-process')
   const { removeUndefined } = await import('./utils/removeUndefined')
   const { loadEnv, serve: vxrnServe, serveStaticAssets } = await import('vxrn/serve')
@@ -33,10 +94,9 @@ export async function serve(args: VXRNOptions['server'] & { app?: Hono } = {}) {
   }
 
   return await vxrnServe({
+    outDir: buildInfo.outDir || outDir,
     app: args.app,
-    // fallback to one plugin
     ...oneOptions.server,
-    // override with any flags given to cli
     ...removeUndefined({
       port: args.port ? +args.port : undefined,
       host: args.host,

package/src/server/ServerContextScript.tsx

@@ -22,14 +22,24 @@ export function ServerContextScript() {
     const context = useServerContext()
     const cssUrls = context?.css || []
 
-    // Strip cssContents from JSON payload - we'll read it from DOM instead.
-    // This avoids duplicating 100KB+ of CSS as JSON in the HTML.
-    // The CSSPrehydrateScript reads the actual <style> elements' innerHTML
-    // and stores them in globalThis.__oneCSSContents for hydration matching.
+    // strip cssContents - read from DOM instead (CSSPrehydrateScript)
     const { cssContents, ...restContext } = context || {}
+
+    // strip page loaderData from matches to avoid double-serialization
+    const compactMatches = restContext.matches?.map((m: any) => ({
+      routeId: m.routeId,
+      pathname: m.pathname,
+      params: m.params,
+      ...(m.loaderData !== restContext.loaderData ? { loaderData: m.loaderData } : {}),
+    }))
+
     const clientContext = {
       ...restContext,
+      matches: compactMatches,
       cssInlineCount: cssContents?.length || 0,
+      // use placeholder — postRenderData is set during render (after this component)
+      // and replaced in the HTML string after rendering completes
+      postRenderData: SERVER_CONTEXT_POST_RENDER_STRING,
     }
 
     return (
@@ -40,10 +50,7 @@ export function ServerContextScript() {
         suppressHydrationWarning
         dangerouslySetInnerHTML={{
           __html: `
-              globalThis["${SERVER_CONTEXT_KEY}"] = ${safeJsonStringify({
-                ...clientContext,
-                postRenderData: SERVER_CONTEXT_POST_RENDER_STRING,
-              })};
+              globalThis["${SERVER_CONTEXT_KEY}"] = ${safeJsonStringify(clientContext)};
               globalThis.__oneLoadedCSS = new Set(${safeJsonStringify(cssUrls)});
           `,
         }}