one 1.12.8 → 1.13.0

package/src/createHandleRequest.ts

@@ -28,6 +28,23 @@ type RequestHandlerResponse = null | string | Response
 
 const debugRouter = process.env.ONE_DEBUG_ROUTER
 
+// ensure handler results are always a proper Response so middleware
+// can safely use response.body / response.headers / new Response(response.body, ...)
+function ensureResponse(value: any): Response {
+  // use isResponse (duck-type check) instead of instanceof — the Response
+  // constructor may differ across module realms (e.g. API handler vs middleware)
+  if (isResponse(value)) return value
+  if (typeof value === 'string') {
+    return new Response(value, {
+      headers: { 'Content-Type': 'text/html' },
+    })
+  }
+  if (value && typeof value === 'object') {
+    return Response.json(value)
+  }
+  return new Response(value)
+}
+
 export async function runMiddlewares(
   handlers: RequestHandlers,
   request: Request,
@@ -57,7 +74,7 @@ export async function runMiddlewares(
       if (debugRouter) {
         console.info(`[one] ✓ middleware chain complete`)
       }
-      return await getResponse()
+      return ensureResponse(await getResponse())
     }
 
     if (debugRouter) {
@@ -123,6 +140,7 @@ export async function resolveAPIRoute(
             loaderProps: {
               path: pathname,
               search: url.search,
+              subdomain: getSubdomain(url),
               params,
             },
           }),
@@ -176,6 +194,7 @@ export async function resolveLoaderRoute(
           loaderProps: {
             path: url.pathname,
             search: url.search,
+            subdomain: getSubdomain(url),
             request: route.type === 'ssr' ? request : undefined,
             params: getLoaderParams(url, route),
           },
@@ -272,6 +291,7 @@ export async function resolvePageRoute(
   const loaderProps = {
     path: pathname,
     search: search,
+    subdomain: getSubdomain(url),
     request: route.type === 'ssr' ? request : undefined,
     params: getLoaderParams(url, route),
   }
@@ -305,6 +325,21 @@ export function getURLfromRequestURL(request: Request) {
   return url
 }
 
+export function getSubdomain(url: URL): string | undefined {
+  const host = url.hostname
+  // skip for IP addresses and localhost
+  if (!host || host === 'localhost' || /^\d+\.\d+\.\d+\.\d+$/.test(host)) {
+    return undefined
+  }
+  const parts = host.split('.')
+  // need at least 3 parts for a subdomain (sub.example.com)
+  if (parts.length < 3) {
+    return undefined
+  }
+  // return everything before the last two parts (domain.tld)
+  return parts.slice(0, -2).join('.')
+}
+
 function compileRouteRegex(route: RouteInfo): RouteInfoCompiled {
   return {
     ...route,

package/src/fork/SSRNavigationContainer.tsx

@@ -1,7 +1,7 @@
 /**
  * SSR-optimized replacement for BaseNavigationContainer.
- * Provides only the 4 contexts that child navigators need during SSR render,
- * with static/no-op values. Eliminates 32+ hooks and reduces 8 providers to 4.
+ * Provides only the 5 contexts that child navigators need during SSR render,
+ * with static/no-op values. Eliminates 32+ hooks and reduces 8 providers to 5.
  *
  * Requires @react-navigation/core package.json exports to include internal context paths.
  * See postinstall patch in the repo.
@@ -13,7 +13,7 @@ import { NavigationBuilderContext } from '@react-navigation/core/lib/module/Navi
 import { NavigationStateContext } from '@react-navigation/core/lib/module/NavigationStateContext'
 // @ts-ignore internal module
 import { SingleNavigatorContext } from '@react-navigation/core/lib/module/EnsureSingleNavigator'
-import { ThemeProvider } from '@react-navigation/core'
+import { NavigationContainerRefContext, ThemeProvider } from '@react-navigation/core'
 import { LinkingContext } from '@react-navigation/native'
 import * as React from 'react'
 
@@ -37,6 +37,35 @@ const SSR_SINGLE_NAV_CTX = {
   unregister: noop,
 }
 
+// no-op navigation ref so useNavigation() doesn't throw during SSR
+const SSR_NAV_REF = {
+  dispatch: noop,
+  navigate: noop,
+  reset: noop,
+  goBack: noop,
+  isFocused: () => false,
+  canGoBack: () => false,
+  getParent: () => undefined,
+  getState: () => undefined,
+  getRootState: () => undefined,
+  getCurrentRoute: () => undefined,
+  getCurrentOptions: () => undefined,
+  isReady: () => false,
+  addListener: () => noop,
+  removeListener: noop,
+  resetRoot: noop,
+  setOptions: noop,
+  // CommonActions methods
+  setParams: noop,
+  popTo: noop,
+  pop: noop,
+  popToTop: noop,
+  push: noop,
+  replace: noop,
+  jumpTo: noop,
+  preload: noop,
+} as any
+
 const getPartialState = (state: any): any => {
   if (!state) return undefined
   const { key, routeNames, ...partial } = state
@@ -105,13 +134,15 @@ export function SSRNavigationContainer({
   const linkingCtx = linking ? { options: linking } : SSR_LINKING_CTX
   return (
     <LinkingContext.Provider value={linkingCtx}>
-      <NavigationBuilderContext.Provider value={SSR_BUILDER_CTX}>
-        <NavigationStateContext.Provider value={getStateContext(initialState)}>
-          <SingleNavigatorContext.Provider value={SSR_SINGLE_NAV_CTX}>
-            <ThemeProvider value={theme}>{children}</ThemeProvider>
-          </SingleNavigatorContext.Provider>
-        </NavigationStateContext.Provider>
-      </NavigationBuilderContext.Provider>
+      <NavigationContainerRefContext.Provider value={SSR_NAV_REF}>
+        <NavigationBuilderContext.Provider value={SSR_BUILDER_CTX}>
+          <NavigationStateContext.Provider value={getStateContext(initialState)}>
+            <SingleNavigatorContext.Provider value={SSR_SINGLE_NAV_CTX}>
+              <ThemeProvider value={theme}>{children}</ThemeProvider>
+            </SingleNavigatorContext.Provider>
+          </NavigationStateContext.Provider>
+        </NavigationBuilderContext.Provider>
+      </NavigationContainerRefContext.Provider>
     </LinkingContext.Provider>
   )
 }

package/src/index.ts

@@ -74,6 +74,7 @@ export { href } from './href'
 // components
 export { Stack } from './layouts/Stack'
 export { Tabs } from './layouts/Tabs'
+export { NativeTabs } from './layouts/NativeTabs'
 export { Protected, type ProtectedProps } from './views/Protected'
 // Stack header compositional API types
 export type {

package/src/layouts/NativeTabs.tsx

@@ -0,0 +1,46 @@
+import type { ParamListBase, TabNavigationState } from '@react-navigation/native'
+import type React from 'react'
+
+import { Protected } from '../views/Protected'
+import { withLayoutContext } from './withLayoutContext'
+
+let NativeBottomTabNavigator: React.ComponentType<any> | null = null
+
+try {
+  const mod = require('@bottom-tabs/react-navigation')
+  NativeBottomTabNavigator = mod.createNativeBottomTabNavigator().Navigator
+} catch {
+  // @bottom-tabs/react-navigation not installed
+}
+
+type NativeTabsType = ReturnType<typeof withLayoutContext> & {
+  Protected: typeof Protected
+}
+
+function createNativeTabs(): NativeTabsType {
+  if (!NativeBottomTabNavigator) {
+    throw new Error(
+      'NativeTabs requires @bottom-tabs/react-navigation and react-native-bottom-tabs.\n' +
+        'Install: npx expo install @bottom-tabs/react-navigation react-native-bottom-tabs'
+    )
+  }
+
+  return Object.assign(withLayoutContext(NativeBottomTabNavigator), {
+    Protected,
+  }) as NativeTabsType
+}
+
+let _nativeTabs: NativeTabsType | null = null
+
+export const NativeTabs = new Proxy({} as NativeTabsType, {
+  get(_, prop) {
+    if (!_nativeTabs) _nativeTabs = createNativeTabs()
+    return (_nativeTabs as any)[prop]
+  },
+  apply(_, thisArg, args) {
+    if (!_nativeTabs) _nativeTabs = createNativeTabs()
+    return (_nativeTabs as any).apply(thisArg, args)
+  },
+})
+
+export default NativeTabs

package/src/layouts/Tabs.tsx

@@ -10,6 +10,7 @@ import { Platform, Pressable } from 'react-native'
 
 import type { OneRouter } from '../interfaces/router'
 import { Link } from '../link/Link'
+import { Protected } from '../views/Protected'
 import { withLayoutContext } from './withLayoutContext'
 
 const TabBar = ({ state, ...restProps }: BottomTabBarProps) => {
@@ -41,53 +42,56 @@ type BottomTabNavigationOptionsWithHref = BottomTabNavigationOptions & {
   href?: OneRouter.Href | null
 }
 
-export const Tabs = withLayoutContext<
-  BottomTabNavigationOptionsWithHref,
-  typeof BottomTabNavigator,
-  TabNavigationState<ParamListBase>,
-  BottomTabNavigationEventMap
->(
-  BottomTabNavigator,
-  (screens) => {
-    // Support the `href` shortcut prop.
-    return screens.map((screen) => {
-      if (typeof screen.options !== 'function' && screen.options?.href !== undefined) {
-        const { href, ...options } = screen.options
-        if (options.tabBarButton) {
-          throw new Error('Cannot use `href` and `tabBarButton` together.')
-        }
-        return {
-          ...screen,
-          options: {
-            ...options,
-            tabBarButton: (props) => {
-              if (href == null) {
-                return null
-              }
-              const children =
-                Platform.OS === 'web' ? (
-                  props.children
-                ) : (
-                  <Pressable>{props.children}</Pressable>
+export const Tabs = Object.assign(
+  withLayoutContext<
+    BottomTabNavigationOptionsWithHref,
+    typeof BottomTabNavigator,
+    TabNavigationState<ParamListBase>,
+    BottomTabNavigationEventMap
+  >(
+    BottomTabNavigator,
+    (screens) => {
+      // Support the `href` shortcut prop.
+      return screens.map((screen) => {
+        if (typeof screen.options !== 'function' && screen.options?.href !== undefined) {
+          const { href, ...options } = screen.options
+          if (options.tabBarButton) {
+            throw new Error('Cannot use `href` and `tabBarButton` together.')
+          }
+          return {
+            ...screen,
+            options: {
+              ...options,
+              tabBarButton: (props) => {
+                if (href == null) {
+                  return null
+                }
+                const children =
+                  Platform.OS === 'web' ? (
+                    props.children
+                  ) : (
+                    <Pressable>{props.children}</Pressable>
+                  )
+                return (
+                  <Link
+                    {...(props as any)}
+                    style={[{ display: 'flex' }, props.style]}
+                    href={href}
+                    asChild={Platform.OS !== 'web'}
+                    // biome-ignore lint/correctness/noChildrenProp: children prop needed for asChild pattern
+                    children={children}
+                  />
                 )
-              return (
-                <Link
-                  {...(props as any)}
-                  style={[{ display: 'flex' }, props.style]}
-                  href={href}
-                  asChild={Platform.OS !== 'web'}
-                  // biome-ignore lint/correctness/noChildrenProp: children prop needed for asChild pattern
-                  children={children}
-                />
-              )
+              },
             },
-          },
+          }
         }
-      }
-      return screen
-    })
-  },
-  { props: { tabBar: TabBar } }
+        return screen
+      })
+    },
+    { props: { tabBar: TabBar } }
+  ),
+  { Protected }
 )
 
 export default Tabs

package/src/native-tabs.ts

@@ -0,0 +1 @@
+export { NativeTabs, NativeTabs as default } from './layouts/NativeTabs'

package/src/render.tsx

@@ -11,7 +11,12 @@ export function render(element: React.ReactNode) {
 
   if (globalThis['__vxrnRoot']) {
     globalThis['__vxrnVersion']++
-    globalThis['__vxrnRoot'].render(element)
+    // wrap in startTransition so Suspense-based route resolution keeps the
+    // old tree visible while new route modules resolve, instead of flashing
+    // the fallback (or losing the tree entirely in error boundaries)
+    startTransition(() => {
+      globalThis['__vxrnRoot'].render(element)
+    })
   } else {
     startTransition(() => {
       const rootElement = process.env.ONE_USE_FASTER_DOCUMENT

package/src/router/router.ts

@@ -131,6 +131,10 @@ export function isRouteProtected(href: string): boolean {
 export let hasAttemptedToHideSplash = false
 export let initialState: OneRouter.ResultState | undefined
 export let rootState: OneRouter.ResultState | undefined
+// the original pathname from the initial page load, used by late-mounting
+// navigators to determine the correct initial route even after React Navigation's
+// linking has pushed a different URL during unmount/remount cycles
+export let initialPathname: string | undefined
 
 let nextState: OneRouter.ResultState | undefined
 export let routeInfo: UrlObject | undefined
@@ -282,6 +286,7 @@ export function initialize(
 
 function cleanUpState() {
   initialState = undefined
+  initialPathname = undefined
   rootState = undefined
   nextState = undefined
   routeInfo = undefined
@@ -293,6 +298,11 @@ function cleanUpState() {
 function setupLinkingAndRouteInfo(initialLocation?: URL) {
   initialState = setupLinking(routeNode, initialLocation)
 
+  // capture the original pathname before React Navigation's linking can modify it
+  initialPathname =
+    initialLocation?.pathname ??
+    (typeof window !== 'undefined' ? window.location.pathname : undefined)
+
   if (initialState) {
     rootState = initialState
     routeInfo = getRouteInfo(initialState)
@@ -567,6 +577,17 @@ function syncStoreRootState() {
   if (navigationRef.isReady()) {
     const currentState = navigationRef.getRootState() as unknown as OneRouter.ResultState
     if (rootState !== currentState) {
+      // when a parent layout conditionally renders (e.g. auth gate), getRootState()
+      // can return incomplete/wrong state before all navigators mount. don't
+      // overwrite routeInfo with wrong pathname while initial state is still valid.
+      if (initialState && routeInfo?.pathname) {
+        const nextRouteInfo = getRouteInfo(currentState)
+        if (nextRouteInfo.pathname !== routeInfo.pathname) {
+          // pathname would change — skip to preserve initial URL truth
+          rootState = currentState
+          return
+        }
+      }
       updateState(currentState)
     }
   }

package/src/router/useViteRoutes.tsx

@@ -15,9 +15,15 @@ export function useViteRoutes(
   version?: number
 ) {
   if (version && version > lastVersion) {
-    // reload
+    // reload — clear stale route caches so fresh modules are used
     context = null
     lastVersion = version
+    // clear preloaded modules from previous render cycle — they point to
+    // old route module instances and would short-circuit resolve() before
+    // it reaches the new routesSync functions
+    for (const key of Object.keys(preloadedModules)) {
+      delete preloadedModules[key]
+    }
   }
 
   if (!context) {

package/src/serve.ts

@@ -181,7 +181,12 @@ async function startWorker(args: Parameters<typeof serve>[0]) {
 
   const { labelProcess } = await import('./cli/label-process')
   const { removeUndefined } = await import('./utils/removeUndefined')
-  const { loadEnv, serve: vxrnServe, serveStaticAssets } = await import('vxrn/serve')
+  const {
+    loadEnv,
+    serve: vxrnServe,
+    serveStaticAssets,
+    compileCacheRules,
+  } = await import('vxrn/serve')
   const { oneServe } = await import('./server/oneServe')
 
   labelProcess('serve')
@@ -190,6 +195,11 @@ async function startWorker(args: Parameters<typeof serve>[0]) {
     await loadEnv('production')
   }
 
+  // compile cache rules once at startup so every request is a single regex test
+  const cacheRules = oneOptions.server?.cacheControl
+    ? compileCacheRules(oneOptions.server.cacheControl)
+    : undefined
+
   return await vxrnServe({
     outDir: buildInfo.outDir || outDir,
     app: args?.app,
@@ -201,7 +211,9 @@ async function startWorker(args: Parameters<typeof serve>[0]) {
     }),
 
     async beforeRegisterRoutes(options, app) {
-      await oneServe(oneOptions, buildInfo, app, { serveStaticAssets })
+      await oneServe(oneOptions, buildInfo, app, {
+        serveStaticAssets: (ctx) => serveStaticAssets({ ...ctx, cacheRules }),
+      })
     },
 
     async afterRegisterRoutes(options, app) {},

package/src/server/oneServe.ts

@@ -9,6 +9,7 @@ import {
 } from '../constants'
 import {
   compileManifest,
+  getSubdomain,
   getURLfromRequestURL,
   type RequestHandlers,
   runMiddlewares,
@@ -748,6 +749,7 @@ url: ${url}`)
           const loaderProps = {
             path: pathname,
             search,
+            subdomain: getSubdomain(getURLfromRequestURL(request)),
             request,
             params,
           }

package/src/server/workerHandler.ts

@@ -5,6 +5,7 @@ import {
 } from '../constants'
 import {
   compileManifest,
+  getSubdomain,
   getURLfromRequestURL,
   type RequestHandlers,
   resolveAPIRoute,
@@ -704,6 +705,7 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
           const loaderProps = {
             path: pathname,
             search: url.search,
+            subdomain: getSubdomain(url),
             request,
             params,
           }

package/src/typed-routes/getTypedRoutesDeclarationFile.ts

@@ -52,7 +52,7 @@ ${
  */
 type RouteInfo<Params = Record<string, never>> = {
   Params: Params
-  LoaderProps: { path: string; params: Params; request?: Request }
+  LoaderProps: { path: string; search?: string; subdomain?: string; params: Params; request?: Request }
 }`
     : ''
 }

package/src/types.ts

@@ -12,6 +12,7 @@ export type RenderApp = (props: RenderAppProps) => Promise<string>
 export type LoaderProps<Params extends object = Record<string, string | string[]>> = {
   path: string
   search?: string
+  subdomain?: string
   params: Params
   request?: Request
 }

package/src/utils/getPathnameFromFilePath.test.ts

@@ -92,15 +92,35 @@ describe('getPathnameFromFilePath', () => {
       )
     })
 
-    it('substitutes filename param, dirname params become placeholders', () => {
-      // getPathnameFromFilePath only substitutes params in the filename segment,
-      // dirname params are converted to :param placeholders via regex
+    it('substitutes params in both dirname and filename', () => {
       expect(
         getPathnameFromFilePath('/servers/[serverId]/[channelId]+spa.tsx', {
           serverId: 'abc',
           channelId: '123',
         })
-      ).toBe('/servers/:serverId/123')
+      ).toBe('/servers/abc/123')
+    })
+
+    it('substitutes dirname params for SSG dynamic routes', () => {
+      expect(getPathnameFromFilePath('/[lang]/index+ssg.tsx', { lang: 'en' }, true)).toBe(
+        '/en/'
+      )
+      expect(getPathnameFromFilePath('/[lang]/index+ssg.tsx', { lang: 'ko' }, true)).toBe(
+        '/ko/'
+      )
+    })
+
+    it('substitutes nested dirname params', () => {
+      expect(
+        getPathnameFromFilePath(
+          '/[lang]/[region]/index+ssg.tsx',
+          {
+            lang: 'en',
+            region: 'us',
+          },
+          true
+        )
+      ).toBe('/en/us/')
     })
   })
 

package/src/utils/getPathnameFromFilePath.ts

@@ -7,13 +7,6 @@ export function getPathnameFromFilePath(
   options: { preserveExtensions?: boolean; includeIndex?: boolean } = {}
 ) {
   const path = inputPath.replace(/\+(spa|ssg|ssr|api)\.tsx?$/, '')
-  // remove groups, folder render mode suffixes, and convert [param] to :param in dirname
-  const dirname = Path.dirname(path)
-    .split('/')
-    .map((segment) => segment.replace(/\+(api|ssg|ssr|spa)$/, ''))
-    .join('/')
-    .replace(/\([^/]+\)/gi, '')
-    .replace(/\[([^\]]+)\]/g, ':$1')
   const file = Path.basename(path)
   const fileName = options.preserveExtensions ? file : file.replace(/\.[a-z]+$/, '')
 
@@ -30,6 +23,19 @@ ${JSON.stringify(params, null, 2)}`
     )
   }
 
+  // remove groups, folder render mode suffixes, and substitute [param] in dirname
+  const dirname = Path.dirname(path)
+    .split('/')
+    .map((segment) => segment.replace(/\+(api|ssg|ssr|spa)$/, ''))
+    .join('/')
+    .replace(/\([^/]+\)/gi, '')
+    .replace(/\[([^\]]+)\]/g, (_, paramName) => {
+      const value = params[paramName]
+      if (value != null) return String(value)
+      if (strict) throw paramsError(paramName)
+      return ':' + paramName
+    })
+
   const nameWithParams = (() => {
     if (fileName === 'index' && !options.includeIndex) {
       return '/'

package/src/vercel/build/generate/createSsrServerlessFunction.ts

@@ -101,9 +101,17 @@ export async function createSsrServerlessFunction(
       originalPath = originalPath.replace(\`:$\{key}\`, String(value));
     }
 
+    const host = url.hostname;
+    let subdomain;
+    if (host && host !== 'localhost' && !/^\\d+\\.\\d+\\.\\d+\\.\\d+$/.test(host)) {
+      const parts = host.split('.');
+      if (parts.length >= 3) subdomain = parts.slice(0, -2).join('.');
+    }
+
     const loaderProps = {
       path: originalPath,
       params: routeParams,
+      subdomain,
       request,
     }
 

package/src/views/Navigator.tsx

@@ -13,7 +13,7 @@ import {
   useNotFoundState,
 } from '../notFoundState'
 import { useContextKey } from '../router/Route'
-import { routeNode as globalRouteNode } from '../router/router'
+import { routeNode as globalRouteNode, initialPathname } from '../router/router'
 import { registerProtectedRoutes, unregisterProtectedRoutes } from '../router/router'
 import { useSortedScreens, getQualifiedRouteComponent } from '../router/useScreens'
 import { Screen } from './Screen'
@@ -171,6 +171,38 @@ function QualifiedNavigator({
   contextKey,
   router = StackRouter,
 }: NavigatorProps & { contextKey: string; screens: React.ReactNode[] }) {
+  // LATE MOUNT FIX: when a parent layout conditionally renders (e.g. auth gate),
+  // this navigator may mount after initialState was consumed. compute the
+  // correct initialRouteName from the original URL so the navigator starts on
+  // the right route instead of defaulting to the first one.
+  // uses initialPathname (captured at setup) instead of window.location.pathname
+  // because React Navigation's linking can push a wrong URL during the delay.
+  const resolvedInitialRouteName = React.useMemo(() => {
+    if (initialRouteName) return initialRouteName
+
+    const browserPath =
+      initialPathname ??
+      (typeof window !== 'undefined' ? window.location.pathname : undefined)
+    if (!browserPath) return undefined
+
+    // extract screen names from the screens array
+    const screenNames: string[] = []
+    for (const screen of screens) {
+      const props = (screen as any)?.props
+      if (props?.name) screenNames.push(props.name)
+    }
+
+    // find which screen matches the URL
+    for (const name of screenNames) {
+      const base = name.replace(/\/index$/, '')
+      if (browserPath.endsWith('/' + base) || browserPath.includes('/' + base + '/')) {
+        return name
+      }
+    }
+
+    return undefined
+  }, [initialRouteName, screens])
+
   const { state, navigation, descriptors, NavigationContent } = useNavigationBuilder(
     router,
     {
@@ -178,7 +210,7 @@ function QualifiedNavigator({
       id: contextKey,
       children: screens,
       screenOptions,
-      initialRouteName,
+      initialRouteName: resolvedInitialRouteName,
     }
   )
 
@@ -252,11 +284,13 @@ export function useSlot() {
 
   const renderedElement = descriptorsRef.current[current.key]?.render() ?? null
 
-  // Use static key to prevent layout remounts when route keys change during navigation.
-  // Safe because Slot only renders one screen at a time.
-  // Use cloneElement to properly clone the React element with a new key.
+  // Use key based on route name to prevent layout remounts when route keys change
+  // (same route, different key), while allowing React to swap components when
+  // the actual route changes (e.g. late-mounting navigator correcting its state).
   if (renderedElement !== null) {
-    return React.cloneElement(renderedElement, { key: SLOT_STATIC_KEY })
+    return React.cloneElement(renderedElement, {
+      key: `${SLOT_STATIC_KEY}-${current.name}`,
+    })
   }
 
   return renderedElement