one 1.2.20 → 1.2.22-1765155190908

package/src/hooks.tsx

@@ -133,24 +133,26 @@ export function useParams<TParams extends Object = SearchParams>(): Partial<TPar
   const params = React.useContext(RouteParamsContext) ?? {}
 
   return Object.fromEntries(
-    Object.entries(params).map(([key, value]) => {
-      if (Array.isArray(value)) {
-        return [
-          key,
-          value.map((v) => {
-            try {
-              return decodeURIComponent(v)
-            } catch {
-              return v
-            }
-          }),
-        ]
-      }
-      try {
-        return [key, decodeURIComponent(value as string)]
-      } catch {
-        return [key, value]
-      }
-    })
+    Object.entries(params)
+      .filter(([_, value]) => value !== undefined)
+      .map(([key, value]) => {
+        if (Array.isArray(value)) {
+          return [
+            key,
+            value.map((v) => {
+              try {
+                return decodeURIComponent(v)
+              } catch {
+                return v
+              }
+            }),
+          ]
+        }
+        try {
+          return [key, decodeURIComponent(value as string)]
+        } catch {
+          return [key, value]
+        }
+      })
   ) as TParams
 }

package/src/index.ts

@@ -66,6 +66,7 @@ export { createRoute, route } from './router/createRoute'
 export { router } from './router/imperative-api'
 export * as routerStore from './router/router'
 export { useNavigation } from './router/useNavigation'
+export { registerPreloadedRoute } from './router/useViteRoutes'
 export type { Endpoint, LoaderProps } from './types'
 // React Navigation
 export { useFocusEffect } from './useFocusEffect'

package/src/router/getRoutes.ts

@@ -3,7 +3,6 @@ import { getPageExport } from '../utils/getPageExport'
 import type { One } from '../vite/types'
 import {
   matchArrayGroupName,
-  matchDeepDynamicRouteName,
   matchDynamicName,
   matchGroupName,
   removeSupportedExtensions,
@@ -479,11 +478,9 @@ export function generateDynamic(path: string): DynamicConvention[] | null {
         }
       }
 
-      const deepDynamicName = matchDeepDynamicRouteName(part)
-      const dynamicName = deepDynamicName ?? matchDynamicName(part)
-
-      if (!dynamicName) return null
-      return { name: dynamicName, deep: !!deepDynamicName }
+      const dynamicMatch = matchDynamicName(part)
+      if (!dynamicMatch) return null
+      return { name: dynamicMatch.name, deep: dynamicMatch.deep }
     })
     .filter((part): part is DynamicConvention => !!part)
 

package/src/router/matchers.test.ts

@@ -46,8 +46,8 @@ describe(matchDynamicName, () => {
   it(`matches`, () => {
     expect(matchDynamicName('[[...foobar]]')).toEqual(undefined)
     expect(matchDynamicName('[[foobar]]')).toEqual(undefined)
-    expect(matchDynamicName('[...foobar]')).toEqual(undefined)
-    expect(matchDynamicName('[foobar]')).toEqual('foobar')
+    expect(matchDynamicName('[...foobar]')).toEqual({ name: 'foobar', deep: true })
+    expect(matchDynamicName('[foobar]')).toEqual({ name: 'foobar', deep: false })
     expect(matchDynamicName('foobar')).toEqual(undefined)
   })
 })

package/src/router/matchers.ts

@@ -1,11 +1,27 @@
-/** Match `[page]` -> `page` */
-export function matchDynamicName(name: string): string | undefined {
-  // Don't match `...` or `[` or `]` inside the brackets
-  // eslint-disable-next-line no-useless-escape
-  return name.match(/^\[([^[\](?:...)]+?)\]$/)?.[1]
+/** Match `[page]` -> `page` or `[...page]` -> `page` with deep flag */
+const dynamicNameRe = /^\[([^[\]]+?)\]$/
+
+export interface DynamicNameMatch {
+  name: string
+  deep: boolean
+}
+
+/** Match `[page]` -> `{ name: 'page', deep: false }` or `[...page]` -> `{ name: 'page', deep: true }` */
+export function matchDynamicName(name: string): DynamicNameMatch | undefined {
+  const paramName = name.match(dynamicNameRe)?.[1]
+  if (paramName == null) {
+    return undefined
+  } else if (paramName.startsWith('...')) {
+    return { name: paramName.slice(3), deep: true }
+  } else {
+    return { name: paramName, deep: false }
+  }
 }
 
-/** Match `[...page]` -> `page` */
+/**
+ * Match `[...page]` -> `page`
+ * @deprecated Use matchDynamicName instead which returns {name, deep}
+ */
 export function matchDeepDynamicRouteName(name: string): string | undefined {
   return name.match(/^\[\.\.\.([^/]+?)\]$/)?.[1]
 }

package/src/router/router.ts

@@ -24,6 +24,7 @@ import { getLinking, resetLinking, setupLinking } from './linkingConfig'
 import type { RouteNode } from './Route'
 import { sortRoutes } from './sortRoutes'
 import { getQualifiedRouteComponent } from './useScreens'
+import { preloadRouteModules } from './useViteRoutes'
 import { getNavigateAction } from './utils/getNavigateAction'
 
 // Module-scoped variables
@@ -65,7 +66,7 @@ export function initialize(
     throw new Error('No routes found')
   }
 
-  if (process.env.NODE_ENV === 'development' && process.env.ONE_DEBUG_ROUTER && routeNode) {
+  if (process.env.ONE_DEBUG_ROUTER && routeNode) {
     const formatRouteTree = (node: RouteNode, indent = '', isLast = true): string => {
       const prefix = indent + (isLast ? '└─ ' : '├─ ')
       const childIndent = indent + (isLast ? '   ' : '│  ')
@@ -180,7 +181,7 @@ export function push(url: OneRouter.Href, options?: OneRouter.LinkToOptions) {
 }
 
 export function dismiss(count?: number) {
-  if (process.env.NODE_ENV === 'development' && process.env.ONE_DEBUG_ROUTER) {
+  if (process.env.ONE_DEBUG_ROUTER) {
     console.info(`[one] 🔙 dismiss${count ? ` (${count})` : ''}`)
   }
   navigationRef?.dispatch(StackActions.pop(count))
@@ -199,14 +200,14 @@ export function setParams(params: OneRouter.InpurRouteParamsGeneric = {}) {
 }
 
 export function dismissAll() {
-  if (process.env.NODE_ENV === 'development' && process.env.ONE_DEBUG_ROUTER) {
+  if (process.env.ONE_DEBUG_ROUTER) {
     console.info(`[one] 🔙 dismissAll`)
   }
   navigationRef?.dispatch(StackActions.popToTop())
 }
 
 export function goBack() {
-  if (process.env.NODE_ENV === 'development' && process.env.ONE_DEBUG_ROUTER) {
+  if (process.env.ONE_DEBUG_ROUTER) {
     console.info(`[one] 🔙 goBack`)
   }
   assertIsReady(navigationRef)
@@ -250,7 +251,7 @@ export function updateState(state: OneRouter.ResultState, nextStateParam = state
   const nextRouteInfo = getRouteInfo(state)
 
   if (!deepEqual(routeInfo, nextRouteInfo)) {
-    if (process.env.NODE_ENV === 'development' && process.env.ONE_DEBUG_ROUTER) {
+    if (process.env.ONE_DEBUG_ROUTER) {
       const from = routeInfo?.pathname || '(initial)'
       const to = nextRouteInfo.pathname
       const params = Object.keys(nextRouteInfo.params || {}).length
@@ -367,42 +368,53 @@ export function cleanup() {
 }
 
 // TODO
-export const preloadingLoader = {}
-
-function setupPreload(href: string) {
-  if (preloadingLoader[href]) return
-  preloadingLoader[href] = async () => {
-    try {
-      const [_preload, loader] = await Promise.all([
-        dynamicImport(getPreloadPath(href)),
-        dynamicImport(getLoaderPath(href)),
-      ])
-      const response = await loader
-      return await response.loader?.()
-    } catch (err) {
-      console.error(`Error preloading loader: ${err}`)
+export const preloadingLoader: Record<string, Promise<any> | undefined> = {}
+
+async function doPreload(href: string) {
+  const preloadPath = getPreloadPath(href)
+  const loaderPath = getLoaderPath(href)
+  try {
+    const [_preload, loader] = await Promise.all([
+      dynamicImport(preloadPath),
+      dynamicImport(loaderPath),
+      preloadRouteModules(href),
+    ])
+
+    if (!loader?.loader) {
       return null
     }
+
+    const result = await loader.loader()
+    return result ?? null
+  } catch (err) {
+    console.error(`[one] preload error for ${href}:`, err)
+    return null
   }
 }
 
-export function preloadRoute(href: string) {
+// Store resolved preload data separately from promises
+export const preloadedLoaderData: Record<string, any> = {}
+
+export function preloadRoute(href: string): Promise<any> | undefined {
   if (process.env.TAMAGUI_TARGET === 'native') {
-    // not enabled for now
     return
   }
   if (process.env.NODE_ENV === 'development') {
     return
   }
 
-  setupPreload(href)
-  if (typeof preloadingLoader[href] === 'function') {
-    void preloadingLoader[href]()
+  if (!preloadingLoader[href]) {
+    preloadingLoader[href] = doPreload(href).then((data) => {
+      // Store the resolved data for synchronous access
+      preloadedLoaderData[href] = data
+      return data
+    })
   }
+  return preloadingLoader[href]
 }
 
 export async function linkTo(href: string, event?: string, options?: OneRouter.LinkToOptions) {
-  if (process.env.NODE_ENV === 'development' && process.env.ONE_DEBUG_ROUTER) {
+  if (process.env.ONE_DEBUG_ROUTER) {
     console.info(`[one] 🔗 ${event || 'NAVIGATE'} ${href}`)
   }
 
@@ -477,7 +489,8 @@ export async function linkTo(href: string, event?: string, options?: OneRouter.L
 
   setLoadingState('loading')
 
-  preloadRoute(href)
+  // await preload on web to ensure route modules are loaded before navigating
+  await preloadRoute(href)
 
   const rootState = navigationRef.getRootState()
 

package/src/router/useViteRoutes.tsx

@@ -26,6 +26,125 @@ export function useViteRoutes(
   return context
 }
 
+// store preloaded modules so resolve() can use them synchronously
+let preloadedModules: Record<string, any> = {}
+
+export function registerPreloadedRoute(key: string, module: any): void {
+  preloadedModules[key] = module
+}
+
+export function getPreloadedModule(key: string): any {
+  return preloadedModules[key]
+}
+
+export function getPreloadedModuleKeys(): string[] {
+  return Object.keys(preloadedModules)
+}
+
+/**
+ * Checks if a dynamic route pattern matches an actual path.
+ * Used to preload route modules for dynamic routes like [slug].
+ *
+ * @example
+ * matchDynamicRoute("docs/[slug]", "docs/getting-started") // true
+ * matchDynamicRoute("[...slug]", "a/b/c") // true (catch-all)
+ */
+function matchDynamicRoute(routePattern: string, actualPath: string): boolean {
+  const routeSegments = routePattern.split('/')
+  const pathSegments = actualPath.split('/')
+
+  // handle catch-all routes like [...slug]
+  const hasCatchAll = routeSegments.some((s) => s.startsWith('[...'))
+  if (hasCatchAll) {
+    // find the catch-all segment position
+    const catchAllIdx = routeSegments.findIndex((s) => s.startsWith('[...'))
+    // all segments before catch-all must match exactly (or be dynamic)
+    for (let i = 0; i < catchAllIdx; i++) {
+      if (!routeSegments[i]) continue
+      if (routeSegments[i].startsWith('[')) continue // dynamic segment matches anything
+      if (routeSegments[i] !== pathSegments[i]) return false
+    }
+    // catch-all matches any remaining segments
+    return pathSegments.length >= catchAllIdx
+  }
+
+  // for non-catch-all, segment count should match
+  if (routeSegments.length !== pathSegments.length) return false
+
+  for (let i = 0; i < routeSegments.length; i++) {
+    const routeSeg = routeSegments[i]
+    const pathSeg = pathSegments[i]
+
+    // dynamic segment [param] matches any value
+    if (routeSeg.startsWith('[') && routeSeg.endsWith(']')) {
+      continue
+    }
+
+    // static segment must match exactly
+    if (routeSeg !== pathSeg) return false
+  }
+
+  return true
+}
+
+/**
+ * Preloads route modules for a given URL path (production only).
+ * This ensures route components are loaded before navigation completes,
+ * preventing Suspense boundaries from triggering and causing flicker.
+ *
+ * Called during `linkTo()` to preload routes before client-side navigation.
+ */
+export async function preloadRouteModules(href: string): Promise<void> {
+  const globbed = globalThis['__importMetaGlobbed']
+  if (!globbed) return
+
+  // normalize href to match route keys - /docs -> docs
+  const normalizedHref = href === '/' ? '' : href.replace(/^\//, '').replace(/\/$/, '')
+
+  const promises: Promise<any>[] = []
+
+  for (const key of Object.keys(globbed)) {
+    // key looks like "/app/(site)/docs/_layout.tsx" or "/app/(site)/docs/index+ssg.tsx"
+    // strip the /app/ prefix first
+    let routePath = key.replace(/^\/[^/]+\//, '')
+
+    // strip route groups like (site), (app) etc
+    routePath = routePath.replace(/\([^)]+\)\//g, '')
+
+    // strip file suffixes but keep the path structure
+    routePath = routePath
+      .replace(/\/_layout\.tsx$/, '')
+      .replace(/\/index(\+[a-z]+)?\.tsx$/, '')
+      .replace(/(\+[a-z]+)?\.tsx$/, '')
+
+    // remove leading slash if any
+    routePath = routePath.replace(/^\//, '')
+
+    // check if this route is part of the target path
+    const isStaticMatch =
+      routePath === normalizedHref || // exact match
+      routePath.startsWith(normalizedHref + '/') || // child route
+      normalizedHref.startsWith(routePath + '/') || // parent layout
+      routePath === '' || // root layout
+      (normalizedHref !== '' && routePath === normalizedHref.split('/')[0]) // top-level match
+
+    // also check dynamic route patterns like docs/[slug]
+    const isDynamicMatch = routePath.includes('[') && matchDynamicRoute(routePath, normalizedHref)
+
+    if ((isStaticMatch || isDynamicMatch) && typeof globbed[key] === 'function') {
+      promises.push(
+        globbed[key]()
+          .then((mod: any) => {
+            preloadedModules[key] = mod
+          })
+          .catch(() => {})
+      )
+    }
+  }
+
+  await Promise.all(promises)
+}
+
 export function loadRoutes(
   paths: GlobbedRouteImports,
   routerRoot: string,
@@ -77,6 +196,14 @@ export function globbedRoutesToRouteContext(
       return loadedRoutes[id]
     }
 
+    // check if this route was preloaded (via preload file or hydration)
+    const preloadKey = id.replace('./', `/${routerRoot}/`)
+    const preloaded = getPreloadedModule(preloadKey)
+    if (preloaded) {
+      loadedRoutes[id] = preloaded
+      return preloaded
+    }
+
     if (typeof routesSync[id] !== 'function') {
       return routesSync[id]
     }
@@ -98,23 +225,6 @@ export function globbedRoutesToRouteContext(
           console.error(`Error loading route`, id, err, new Error().stack)
           loadedRoutes[id] = {
             default: () => null,
-            // <View
-            //   style={{
-            //     position: 'absolute',
-            //     top: 0,
-            //     left: 0,
-            //     right: 0,
-            //     bottom: 0,
-            //     alignItems: 'center',
-            //     justifyContent: 'center',
-            //     backgroundColor: '#000',
-            //     gap: 20,
-            //   }}
-            // >
-            //   <Text style={{ fontSize: 24, color: '#fff' }}>Error loading route</Text>
-            //   <Text style={{ fontSize: 16, color: '#fff' }}>{id}</Text>
-            //   <Text style={{ fontSize: 18, color: '#fff', maxWidth: 800 }}>{`${err}`}</Text>
-            // </View>
           }
           delete promises[id]
         })

package/src/router/utils/getNavigateAction.ts

@@ -39,14 +39,15 @@ export function getNavigateAction(
     const childState = actionStateRoute.state
     const nextNavigationState = stateRoute.state
 
-    const dynamicName = matchDynamicName(actionStateRoute.name)
+    const dynamicMatch = matchDynamicName(actionStateRoute.name)
 
     const didActionAndCurrentStateDiverge =
       actionStateRoute.name !== stateRoute.name ||
       // !deepEqual(actionStateRoute.params, stateRoute.params) ||
       !childState ||
       !nextNavigationState ||
-      (dynamicName && actionStateRoute.params?.[dynamicName] !== stateRoute.params?.[dynamicName])
+      (dynamicMatch &&
+        actionStateRoute.params?.[dynamicMatch.name] !== stateRoute.params?.[dynamicMatch.name])
 
     if (didActionAndCurrentStateDiverge) {
       break

package/src/server/oneServe.ts

@@ -18,6 +18,8 @@ import { toAbsolute } from '../utils/toAbsolute'
 import type { One } from '../vite/types'
 import type { RouteInfoCompiled } from './createRoutesManifest'
 
+const debugRouter = process.env.ONE_DEBUG_ROUTER
+
 export async function oneServe(oneOptions: One.PluginOptions, buildInfo: One.BuildInfo, app: Hono) {
   const { resolveAPIRoute, resolveLoaderRoute, resolvePageRoute } = await import(
     '../createHandleRequest'
@@ -36,6 +38,9 @@ export async function oneServe(oneOptions: One.PluginOptions, buildInfo: One.Bui
           const paramName = param.substring(1)
           return context.req.param(paramName) || ''
         })
+        if (debugRouter) {
+          console.info(`[one] ↪ redirect ${context.req.path} → ${destinationUrl}`)
+        }
         return context.redirect(destinationUrl, redirect.permanent ? 301 : 302)
       })
     }
@@ -180,11 +185,19 @@ url: ${url}`)
 
           switch (route.type) {
             case 'api': {
+              if (debugRouter) {
+                console.info(`[one] ⚡ ${url.pathname} → matched API route: ${route.page}`)
+              }
               return resolveAPIRoute(requestHandlers, request, url, route)
             }
             case 'ssg':
             case 'spa':
             case 'ssr': {
+              if (debugRouter) {
+                console.info(
+                  `[one] ⚡ ${url.pathname} → matched page route: ${route.page} (${route.type})`
+                )
+              }
               return resolvePageRoute(requestHandlers, request, url, route)
             }
           }

package/src/types.ts

@@ -24,4 +24,5 @@ export type RenderAppProps = {
   loaderServerData?: any
   loaderData?: any
   loaderProps?: LoaderProps
+  routePreloads?: Record<string, string>
 }

package/src/useLoader.ts

@@ -1,7 +1,6 @@
 import { useCallback, useSyncExternalStore } from 'react'
 import { useParams, usePathname } from './hooks'
-import { resolveHref } from './link/href'
-import { preloadingLoader } from './router/router'
+import { preloadedLoaderData, preloadingLoader } from './router/router'
 import { getLoaderPath } from './utils/cleanUrl'
 import { dynamicImport } from './utils/dynamicImport'
 import { weakKey } from './utils/weakKey'
@@ -89,7 +88,9 @@ export function useLoaderState<
 
   const params = useParams()
   const pathname = usePathname()
-  const currentPath = resolveHref({ pathname, params }).replace(/index$/, '')
+  // use just the pathname for matching, don't use resolveHref which adds params as query string
+  // (the pathname is already resolved like /docs/getting-started, not /docs/[slug])
+  const currentPath = pathname.replace(/\/index$/, '').replace(/\/$/, '') || '/'
 
   // server-side
   if (typeof window === 'undefined' && loader) {
@@ -103,9 +104,9 @@ export function useLoaderState<
     return { data: serverData, refetch: async () => {}, state: 'idle' } as any
   }
 
-  // preloaded data from SSR
-  const preloadedData =
-    loaderPropsFromServerContext?.path === currentPath ? loaderDataFromServerContext : undefined
+  // preloaded data from SSR/SSG - only use if server context path matches current path
+  const serverContextPath = loaderPropsFromServerContext?.path
+  const preloadedData = serverContextPath === currentPath ? loaderDataFromServerContext : undefined
 
   const loaderStateEntry = useSyncExternalStore(
     subscribe,
@@ -130,14 +131,21 @@ export function useLoaderState<
     !loaderStateEntry.hasLoadedOnce &&
     loader
   ) {
-    // check for preloading loader first
-    if (preloadingLoader[currentPath]) {
-      if (typeof preloadingLoader[currentPath] === 'function') {
-        preloadingLoader[currentPath] = preloadingLoader[currentPath]()
-      }
-      const promise = preloadingLoader[currentPath]
+    // check for already-resolved preloaded data first (synchronous)
+    const resolvedPreloadData = preloadedLoaderData[currentPath]
+    if (resolvedPreloadData !== undefined) {
+      // Data was preloaded and already resolved - use it directly
+      delete preloadedLoaderData[currentPath]
+      delete preloadingLoader[currentPath]
+      loaderStateEntry.data = resolvedPreloadData
+      loaderStateEntry.hasLoadedOnce = true
+    } else if (preloadingLoader[currentPath]) {
+      // Preload is in progress - wait for it
+      const preloadPromise = preloadingLoader[currentPath]!
+      const promise = preloadPromise
         .then((val: any) => {
           delete preloadingLoader[currentPath]
+          delete preloadedLoaderData[currentPath]
           updateState(currentPath, {
             data: val,
             hasLoadedOnce: true,

package/src/vite/one.ts

@@ -1,15 +1,15 @@
-import events from 'node:events'
-import path from 'node:path'
 import { configureVXRNCompilerPlugin } from '@vxrn/compiler'
 import { resolvePath } from '@vxrn/resolve'
 import type {
   ExpoManifestRequestHandlerPluginPluginOptions,
   MetroPluginOptions,
 } from '@vxrn/vite-plugin-metro'
+import events from 'node:events'
+import path from 'node:path'
 import type { Plugin, PluginOption } from 'vite'
 import { barrel } from 'vite-plugin-barrel'
 import tsconfigPaths from 'vite-tsconfig-paths'
-import { autoDepOptimizePlugin, getOptimizeDeps, getOptionsFilled, loadEnv } from 'vxrn'
+import { autoDepOptimizePlugin, getOptionsFilled, loadEnv } from 'vxrn'
 import vxrnVitePlugin from 'vxrn/vite-plugin'
 import { CACHE_KEY } from '../constants'
 import { getViteMetroPluginOptions } from '../metro-config/getViteMetroPluginOptions'
@@ -121,15 +121,6 @@ export function one(options: One.PluginOptions = {}): PluginOption {
     void ensureTSConfig()
   }
 
-  // build is superset for now
-  const { optimizeDeps } = getOptimizeDeps('build')
-  const optimizeIds = optimizeDeps.include
-  const optimizeIdRegex = new RegExp(
-    // santize ids for regex
-    // https://stackoverflow.com/questions/6300183/sanitize-string-of-regex-characters-before-regexp-build
-    `${optimizeIds.map((id) => id.replace(/[#-.]|[[-^]|[?|{}]/g, '\\$&')).join('|')}`
-  )
-
   let tsConfigPathsPlugin: Plugin | null = null
 
   const vxrnOptions = getOptionsFilled()
@@ -167,7 +158,12 @@ export function one(options: One.PluginOptions = {}): PluginOption {
           userConfig?.envPrefix
         )
         return {
-          define: clientEnvDefine,
+          define: {
+            ...clientEnvDefine,
+            ...(process.env.ONE_DEBUG_ROUTER && {
+              'process.env.ONE_DEBUG_ROUTER': JSON.stringify(process.env.ONE_DEBUG_ROUTER),
+            }),
+          },
         }
       },
     },

package/src/vite/plugins/fileSystemRouterPlugin.tsx

@@ -17,6 +17,8 @@ import type { One } from '../../vite/types'
 import { setServerContext } from '../one-server-only'
 import { virtalEntryIdClient, virtualEntryId } from './virtualEntryConstants'
 
+const debugRouter = process.env.ONE_DEBUG_ROUTER
+
 // server needs better dep optimization
 const USE_SERVER_ENV = false //!!process.env.USE_SERVER_ENV
 
@@ -329,7 +331,9 @@ export function createFileSystemRouterPlugin(options: One.PluginOptions): Plugin
                     })
                   }
 
-                  console.warn(` [one] redirecting via redirect: ${destination}`)
+                  if (debugRouter) {
+                    console.info(`[one] ↪ redirect ${url.pathname} → ${destination}`)
+                  }
 
                   res.writeHead(redirect.permanent ? 301 : 302, { Location: destination })
                   res.end()
@@ -338,13 +342,21 @@ export function createFileSystemRouterPlugin(options: One.PluginOptions): Plugin
               }
             }
 
-            const reply = await handleRequest.handler(await convertIncomingMessageToRequest(req))
+            const reply = await handleRequest.handler(convertIncomingMessageToRequest(req))
 
             if (!reply) {
               return next()
             }
 
             if (typeof reply !== 'string' && isResponse(reply)) {
+              if (debugRouter) {
+                const headers: Record<string, string> = {}
+                reply.headers.forEach((v, k) => {
+                  headers[k] = v
+                })
+                console.info(`[one] 📤 response ${reply.status}`, headers)
+              }
+
               reply.headers.forEach((value, key) => {
                 if (key === 'set-cookie') {
                   // for some reason it wasnt doing working without this?
@@ -359,7 +371,9 @@ export function createFileSystemRouterPlugin(options: One.PluginOptions): Plugin
 
               if (isStatusRedirect(reply.status)) {
                 const location = `${reply.headers.get('location') || ''}`
-                console.info(` ↦ Redirect ${location}`)
+                if (debugRouter) {
+                  console.info(`[one] ↪ response redirect → ${location}`)
+                }
                 if (location) {
                   res.writeHead(reply.status, {
                     Location: location,
@@ -373,8 +387,6 @@ export function createFileSystemRouterPlugin(options: One.PluginOptions): Plugin
               res.statusCode = reply.status
               res.statusMessage = reply.statusText
 
-              let outString = ''
-
               if (reply.body) {
                 if (reply.body.locked) {
                   console.warn(`Body is locked??`, req.url)