one 1.15.10 → 1.16.0

package/src/metro-config/getViteMetroPluginOptions.ts

@@ -8,6 +8,14 @@ import {
   ROUTE_NATIVE_EXCLUSION_GLOB_PATTERNS,
 } from '../router/glob-patterns'
 
+/**
+ * On Windows, micromatch.makeRe() produces regex patterns with `[\\/]` or `[^\\/]`
+ * instead of `\/` and `[^/]`. Normalize them so the startsWith check works.
+ */
+export function normalizeReSource(source: string): string {
+  return source.replace(/\[\\\\\/\]/g, '\\/').replace(/\[\^\\\\\/\]/g, '[^/]')
+}
+
 export function getViteMetroPluginOptions({
   projectRoot,
   relativeRouterRoot,
@@ -56,7 +64,7 @@ export function getViteMetroPluginOptions({
        * ^(?:(?:^|\/|(?:(?:(?!(?:^|\/)\.).)*?)\/)(?!\.)(?=.)[^/]*?\+api\.(ts|tsx))$
        * ```
        */
-      const reSource = re.source
+      const reSource = normalizeReSource(re.source)
 
       if (
         !(
@@ -112,13 +120,7 @@ export function getViteMetroPluginOptions({
             //     .filter((i): i is NonNullable<typeof i> => !!i)
             // ),
           },
-          nodeModulesPaths: tsconfigPathsConfigLoadResult.absoluteBaseUrl
-            ? [
-                // "vite-tsconfig-paths" for Metro
-                tsconfigPathsConfigLoadResult.absoluteBaseUrl,
-                ...(defaultConfig?.resolver?.nodeModulesPaths || []),
-              ]
-            : defaultConfig?.resolver?.nodeModulesPaths,
+          nodeModulesPaths: defaultConfig?.resolver?.nodeModulesPaths,
           resolveRequest: (context, moduleName, platform) => {
             if (moduleName.endsWith('.css')) {
               return {
@@ -153,12 +155,13 @@ export function getViteMetroPluginOptions({
               const defaultResolveRequest =
                 defaultConfig?.resolver?.resolveRequest || context.resolveRequest
               const res = defaultResolveRequest(context, moduleName, platform)
-              if (res && 'filePath' in res && res.filePath.includes('/src/index.ts')) {
+              const svgSrcSuffix = `${path.sep}src${path.sep}index.ts`
+              if (res && 'filePath' in res && res.filePath.includes(svgSrcSuffix)) {
                 return {
                   ...res,
                   filePath: res.filePath.replace(
-                    '/src/index.ts',
-                    '/lib/commonjs/index.js'
+                    svgSrcSuffix,
+                    `${path.sep}lib${path.sep}commonjs${path.sep}index.js`
                   ),
                 }
               }

package/src/router/Route.tsx

@@ -1,9 +1,13 @@
 import React, { createContext, type ReactNode, useContext } from 'react'
+import { findFocusedRoute } from '../fork/findFocusedRoute'
 import type { ErrorBoundaryProps } from '../views/Try'
 import type { LoaderProps } from '../types'
 import type { One } from '../vite/types'
 import type { ParamValidator, RouteValidationFn } from '../validateParams'
+import { getLinking } from './linkingConfig'
 import { getContextKey } from './matchers'
+import { mergeDynamicParams } from './params'
+import { routeInfo } from './router'
 import { RouteInfoContextProvider } from './RouteInfoContext'
 
 export type DynamicConvention = {
@@ -136,6 +140,34 @@ export function useContextKey(): string {
   return getContextKey(node.contextKey)
 }
 
+/**
+ * Resolve path params from the current URL using the same linking
+ * config (getStateFromPath) that the router uses for navigation.
+ * Returns `undefined` if linking isn't set up yet (SSR, pre-init) or
+ * the URL doesn't produce a focused route with params.
+ *
+ * Reuses the router's existing URL-parsing rather than re-implementing
+ * segment matching, so group/catch-all/index semantics stay consistent.
+ */
+function getParamsFromCurrentUrl(route?: {
+  path?: string
+  params?: Record<string, string | undefined>
+}): Record<string, any> | undefined {
+  const linking = getLinking()
+  if (!linking?.getStateFromPath) return undefined
+  const path =
+    routeInfo?.unstable_globalHref ||
+    route?.path ||
+    (typeof window !== 'undefined' && window.location
+      ? window.location.pathname + window.location.search
+      : undefined)
+  if (!path) return undefined
+  const state = linking.getStateFromPath(path, linking.config)
+  if (!state) return undefined
+  const focused = findFocusedRoute(state)
+  return focused?.params as Record<string, any> | undefined
+}
+
 /** Provides the matching routes and filename to the children. */
 export function Route({
   children,
@@ -144,10 +176,28 @@ export function Route({
 }: {
   children: ReactNode
   node: RouteNode
-  route?: { params?: Record<string, string | undefined> }
+  route?: {
+    path?: string
+    params?: Record<string, string | undefined>
+  }
 }) {
+  // url is the source of truth for path params. react navigation can provide
+  // a `route` whose `params` are missing or stale for the dynamic segments
+  // this node expects (observed in spa-shell mode under strictmode, and when
+  // navigating between sibling dynamic routes under the same layout).
+  //
+  // to keep useParams() aligned with the current route, recover dynamic
+  // segment params by re-parsing the router path through the linking config.
+  // non-dynamic params keep flowing from React Navigation.
+  const resolvedParams = React.useMemo(() => {
+    const rp = route?.params
+    if (!node.dynamic?.length) return rp
+    const fromUrl = getParamsFromCurrentUrl(route)
+    return mergeDynamicParams(rp, node.dynamic, fromUrl)
+  }, [node, route, routeInfo?.unstable_globalHref])
+
   return (
-    <RouteParamsContext.Provider value={route?.params}>
+    <RouteParamsContext.Provider value={resolvedParams}>
       <CurrentRouteContext.Provider value={node}>
         <RouteInfoContextProvider>{children}</RouteInfoContextProvider>
       </CurrentRouteContext.Provider>

package/src/router/interceptRoutes.ts

@@ -4,7 +4,7 @@ import {
   matchRoutePattern,
   stripGroupSegmentsFromPath,
 } from './matchers'
-import { isNative } from '../constants'
+import { hasWebHistory, isNative } from '../constants'
 
 // ============================================
 // Navigation Type Tracking
@@ -333,7 +333,7 @@ let preInterceptUrl: string | null = null
  * Used when activating an intercept route to show the target URL.
  */
 export function updateURLWithoutNavigation(href: string) {
-  if (typeof window !== 'undefined') {
+  if (hasWebHistory) {
     // Store the URL before we change it
     preInterceptUrl = window.location.pathname + window.location.search
 
@@ -361,7 +361,7 @@ export function registerClearSlotStates(callback: () => void) {
  * This should be called from modal close handlers instead of router.back().
  */
 export function closeIntercept(): boolean {
-  if (typeof window === 'undefined') return false
+  if (!hasWebHistory) return false
 
   const state = window.history.state
   if (!state?.__intercepted) {
@@ -385,7 +385,7 @@ export function closeIntercept(): boolean {
  * Check if the current navigation state is from an interception
  */
 export function isInterceptedNavigation(): boolean {
-  if (typeof window === 'undefined') return false
+  if (!hasWebHistory) return false
   return window.history.state?.__intercepted === true
 }
 
@@ -393,7 +393,7 @@ export function isInterceptedNavigation(): boolean {
  * Get the actual path from an intercepted navigation
  */
 export function getInterceptedActualPath(): string | null {
-  if (typeof window === 'undefined') return null
+  if (!hasWebHistory) return null
   return window.history.state?.__actualPath ?? null
 }
 
@@ -401,7 +401,7 @@ export function getInterceptedActualPath(): string | null {
  * Get the URL from before the interception
  */
 export function getPreInterceptUrl(): string | null {
-  if (typeof window === 'undefined') return null
+  if (!hasWebHistory) return null
   return window.history.state?.__preInterceptUrl ?? preInterceptUrl
 }
 
@@ -456,7 +456,7 @@ export function storeInterceptState(
  * Returns true if an intercept was restored, false otherwise.
  */
 export function restoreInterceptFromHistory(): boolean {
-  if (typeof window === 'undefined') return false
+  if (!hasWebHistory) return false
 
   const state = window.history.state
   if (!state?.__intercepted) {

package/src/router/params.ts

@@ -0,0 +1,32 @@
+import type { DynamicConvention } from './Route'
+
+function paramValueEqual(a: unknown, b: unknown) {
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return (
+      Array.isArray(a) &&
+      Array.isArray(b) &&
+      a.length === b.length &&
+      a.every((value, index) => value === b[index])
+    )
+  }
+  return a === b
+}
+
+export function mergeDynamicParams<TParams extends Record<string, any> | undefined>(
+  params: TParams,
+  dynamic: DynamicConvention[] | null | undefined,
+  source: Record<string, any> | undefined
+): TParams {
+  if (!dynamic?.length || !source) return params
+
+  let next: Record<string, any> | undefined
+
+  for (const segment of dynamic) {
+    const value = source[segment.name]
+    if (value == null || paramValueEqual(params?.[segment.name], value)) continue
+    next ??= { ...params }
+    next[segment.name] = value
+  }
+
+  return (next ?? params) as TParams
+}

package/src/router/useScreens.tsx

@@ -13,6 +13,8 @@ import { ServerContextScript } from '../server/ServerContextScript'
 import { getPageExport } from '../utils/getPageExport'
 import { EmptyRoute } from '../views/EmptyRoute'
 import { Try } from '../views/Try'
+import { checkSkewAndReload } from '../skewProtection'
+import { handleSkewError, isChunkLoadError } from '../utils/dynamicImport'
 import { DevHead } from '../vite/DevHead'
 import { useServerContext } from '../vite/one-server-only'
 import { filterRootHTML } from './filterRootHTML'
@@ -626,6 +628,22 @@ class RouteErrorBoundary extends React.Component<
       }\n\n${error.stack}\n\nComponent Stack:\n${errorInfo.componentStack}`
     )
     this.setState({ errorInfo })
+
+    // skew protection: chunk-load errors at the route level are unambiguous,
+    // reload immediately. for any other render error, do a one-shot version
+    // check and only reload if the deployed build actually changed. genuine
+    // bugs fall through to the route error UI.
+    if (
+      process.env.TAMAGUI_TARGET !== 'native' &&
+      process.env.NODE_ENV === 'production' &&
+      process.env.ONE_SKEW_PROTECTION !== 'false'
+    ) {
+      if (isChunkLoadError(error)) {
+        handleSkewError()
+      } else {
+        checkSkewAndReload()
+      }
+    }
   }
 
   clearError() {

package/src/serve-worker.ts

@@ -14,8 +14,10 @@ export type { LazyRoutes }
  * Creates a fetch handler for edge/worker environments (Cloudflare Workers, service workers, etc.)
  * No Hono dependency — routes are matched dynamically via compiled regexes against a mutable table.
  *
- * @returns `{ fetch, updateRoutes }` — call `fetch(request)` to handle requests,
- *          `updateRoutes(newBuildInfo, newLazyRoutes?)` to hot-swap the route table.
+ * @returns `{ fetch, updateRoutes }` — call `fetch(request, env?, ctx?)` to handle requests
+ *          (`env` and `ctx` are forwarded from the worker's fetch handler and surfaced on
+ *          API route handler contexts as `{ env, executionCtx }`).
+ *          Call `updateRoutes(newBuildInfo, newLazyRoutes?)` to hot-swap the route table.
  */
 export async function serve(buildInfo: One.BuildInfo, lazyRoutes?: LazyRoutes) {
   setupBuildInfo(buildInfo)

package/src/server/getServerManifest.ts

@@ -150,13 +150,10 @@ export function getServerManifest(route: RouteNode): OneRouterServerManifestV1 {
   const addedMiddlewares: Record<string, boolean> = {}
 
   for (const [path, node] of flat) {
-    if (node.type === 'api') {
-      const route = getGeneratedNamedRouteRegex(path, node)
-      apiRoutes.push(route)
-      allRoutes.push(route)
-      continue
-    }
-
+    // collect middlewares for every route type, not just pages. a middleware
+    // nested under api/ (e.g. app/api/admin/_middleware.ts) must still end up
+    // in middlewareRoutes so the build pipeline compiles it — otherwise the
+    // compiled file never exists and runtime lookups return undefined.
     if (node.middlewares?.length) {
       for (const middleware of node.middlewares) {
         if (!addedMiddlewares[middleware.contextKey]) {
@@ -166,6 +163,13 @@ export function getServerManifest(route: RouteNode): OneRouterServerManifestV1 {
       }
     }
 
+    if (node.type === 'api') {
+      const route = getGeneratedNamedRouteRegex(path, node)
+      apiRoutes.push(route)
+      allRoutes.push(route)
+      continue
+    }
+
     const route = getGeneratedNamedRouteRegex(path, node)
     pageRoutes.push(route)
     allRoutes.push(route)

package/src/server/oneServe.ts

@@ -1,7 +1,7 @@
 import type { Hono, MiddlewareHandler } from 'hono'
 import type { BlankEnv } from 'hono/types'
 import { readFile } from 'node:fs/promises'
-import { join, resolve } from 'node:path'
+import { join } from 'node:path'
 import {
   CSS_PRELOAD_JS_POSTFIX,
   LOADER_JS_POSTFIX_UNCACHED,
@@ -16,7 +16,7 @@ import {
 } from '../createHandleRequest'
 import type { RenderAppProps } from '../types'
 import { getPathFromLoaderPath } from '../utils/cleanUrl'
-import { toAbsolute } from '../utils/toAbsolute'
+import { toAbsoluteUrl } from '../utils/toAbsolute'
 import type { One } from '../vite/types'
 import type { RouteInfoCompiled } from './createRoutesManifest'
 import { setSSRLoaderData } from './ssrLoaderData'
@@ -175,8 +175,8 @@ export async function oneServe(
         routeExported = lazyKey
           ? options?.lazyRoutes?.pages?.[lazyKey]
             ? await options.lazyRoutes.pages[lazyKey]()
-            : await import(toAbsolute(resolvedPath))
-          : await import(toAbsolute(serverPath!))
+            : await import(toAbsoluteUrl(resolvedPath))
+          : await import(toAbsoluteUrl(serverPath!))
         moduleImportCache.set(cacheKey, routeExported)
       }
 
@@ -279,8 +279,7 @@ export async function oneServe(
       const entry = options?.lazyRoutes?.serverEntry
         ? await options.lazyRoutes.serverEntry()
         : await import(
-            resolve(
-              process.cwd(),
+            toAbsoluteUrl(
               `${serverOptions.root}/${outDir}/server/_virtual_one-entry.${typeof oneOptions.build?.server === 'object' && oneOptions.build.server.outputFormat === 'cjs' ? 'c' : ''}js`
             )
           )
@@ -315,13 +314,8 @@ export async function oneServe(
       }
       // both vite and rolldown-vite replace brackets with underscores in output filenames
       const fileName = route.page.slice(1).replace(/\[/g, '_').replace(/\]/g, '_')
-      const apiFile = join(
-        process.cwd(),
-        outDir,
-        'api',
-        fileName + (apiCJS ? '.cjs' : '.js')
-      )
-      return await import(apiFile)
+      const apiFile = join(outDir, 'api', fileName + (apiCJS ? '.cjs' : '.js'))
+      return await import(toAbsoluteUrl(apiFile))
     },
 
     async loadMiddleware(route) {
@@ -329,7 +323,7 @@ export async function oneServe(
       if (options?.lazyRoutes?.middlewares?.[route.contextKey]) {
         return await options.lazyRoutes.middlewares[route.contextKey]()
       }
-      return await import(toAbsolute(route.contextKey))
+      return await import(toAbsoluteUrl(route.contextKey))
     },
 
     async handleLoader({ route, loaderProps }) {
@@ -916,17 +910,21 @@ url: ${url}`)
 
   for (const route of compiledManifest.apiRoutes) {
     app.get(route.urlPath, createHonoHandler(route))
+    app.on('HEAD', route.urlPath, createHonoHandler(route))
     app.put(route.urlPath, createHonoHandler(route))
     app.post(route.urlPath, createHonoHandler(route))
     app.delete(route.urlPath, createHonoHandler(route))
     app.patch(route.urlPath, createHonoHandler(route))
+    app.options(route.urlPath, createHonoHandler(route))
 
     if (route.urlPath !== route.urlCleanPath) {
       app.get(route.urlCleanPath, createHonoHandler(route))
+      app.on('HEAD', route.urlCleanPath, createHonoHandler(route))
       app.put(route.urlCleanPath, createHonoHandler(route))
       app.post(route.urlCleanPath, createHonoHandler(route))
       app.delete(route.urlCleanPath, createHonoHandler(route))
       app.patch(route.urlCleanPath, createHonoHandler(route))
+      app.options(route.urlCleanPath, createHonoHandler(route))
     }
   }
 

package/src/server/workerHandler.ts

@@ -566,7 +566,11 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
   }
 
   // the main fetch handler - matches request to route and dispatches
-  async function handleRequest(request: Request): Promise<Response | null> {
+  async function handleRequest(
+    request: Request,
+    env?: unknown,
+    executionCtx?: unknown
+  ): Promise<Response | null> {
     const url = getURLfromRequestURL(request)
     const pathname = url.pathname
     const method = request.method
@@ -683,7 +687,14 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
       if (route.compiledRegex.test(pathname)) {
         if (debugRouter)
           console.info(`[one] ⚡ ${pathname} → matched API route: ${route.page}`)
-        const response = await resolveAPIRoute(requestHandlers, request, url, route)
+        const response = await resolveAPIRoute(
+          requestHandlers,
+          request,
+          url,
+          route,
+          env,
+          executionCtx
+        )
         if (response && isResponse(response)) {
           return setCacheHeaders(response, route, true)
         }

package/src/skewProtection.ts

@@ -1,8 +1,10 @@
 import { CACHE_KEY } from './constants'
 import { getURL } from './getURL'
+import { handleSkewError } from './utils/dynamicImport'
 
 let stale = false
 let polling: ReturnType<typeof setTimeout> | null = null
+let inFlightCheck: Promise<boolean> | null = null
 
 export function isVersionStale() {
   if (stale) return true
@@ -11,6 +13,48 @@ export function isVersionStale() {
   return false
 }
 
+function markStale(version?: string) {
+  stale = true
+  if (typeof window !== 'undefined') {
+    ;(window as any).__oneVersionStale = true
+    window.dispatchEvent(new CustomEvent('one-version-update', { detail: { version } }))
+  }
+}
+
+// one-shot version check for use when something already looks wrong
+// (e.g. an error reached the root boundary). reloads if the deployed
+// version no longer matches our build, otherwise leaves the error UI alone.
+// dedupes concurrent calls so a render-loop crash only fetches once.
+export function checkSkewAndReload(): Promise<boolean> {
+  if (typeof window === 'undefined') return Promise.resolve(false)
+  if (process.env.ONE_SKEW_PROTECTION === 'false') return Promise.resolve(false)
+  if (isVersionStale()) {
+    handleSkewError()
+    return Promise.resolve(true)
+  }
+  if (inFlightCheck) return inFlightCheck
+  inFlightCheck = (async () => {
+    try {
+      const res = await fetch(`${getURL()}/version.json`, {
+        headers: { 'cache-control': 'no-cache', pragma: 'no-cache' },
+      })
+      if (!res.ok) return false
+      const data = await res.json()
+      if (data.version && data.version !== CACHE_KEY) {
+        markStale(data.version)
+        handleSkewError()
+        return true
+      }
+      return false
+    } catch {
+      return false
+    } finally {
+      inFlightCheck = null
+    }
+  })()
+  return inFlightCheck
+}
+
 export function setupSkewProtection() {
   if (typeof window === 'undefined') return
   if (process.env.NODE_ENV === 'development') return
@@ -31,11 +75,7 @@ export function setupSkewProtection() {
       }
       const data = await res.json()
       if (data.version !== CACHE_KEY) {
-        stale = true
-        ;(window as any).__oneVersionStale = true
-        window.dispatchEvent(
-          new CustomEvent('one-version-update', { detail: { version: data.version } })
-        )
+        markStale(data.version)
         // stop polling once stale detected
         return
       }

package/src/useLoader.ts

@@ -517,10 +517,12 @@ export function useLoaderState<
               } finally {
                 clearTimeout(timeoutId)
               }
-              // biome-ignore lint/security/noGlobalEval: we need eval for native
-              const result = eval(
-                `() => { var exports = {}; ${loaderJsCode}; return exports; }`
-              )()
+              // use Function constructor instead of direct eval. hermes treats
+              // direct eval as indirect (no lexical scope) and rolldown warns
+              // about it; new Function is predictable across both engines and
+              // explicitly threads the exports object through as a parameter.
+              const result: { loader?: () => any } = {}
+              new Function('exports', loaderJsCode)(result)
               const moduleLoadTime = performance.now() - moduleLoadStart
 
               if (typeof result.loader !== 'function') {

package/src/utils/dynamicImport.ts

@@ -28,12 +28,12 @@ const CHUNK_ERROR_PATTERNS = [
   'Importing a module script failed', // safari
 ]
 
-function isChunkLoadError(err: unknown): boolean {
+export function isChunkLoadError(err: unknown): boolean {
   const msg = err instanceof Error ? err.message : String(err)
   return CHUNK_ERROR_PATTERNS.some((p) => msg.includes(p))
 }
 
-function handleSkewError() {
+export function handleSkewError() {
   if (typeof window === 'undefined') return
   const key = '__one_skew_reload'
   const last = sessionStorage.getItem(key)

package/src/utils/toAbsolute.ts

@@ -1,3 +1,8 @@
 import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
 
+/** Resolve to native filesystem path — for fs operations (readFile, writeFile, join). */
 export const toAbsolute = (p: string) => resolve(process.cwd(), p)
+
+/** Resolve to file:// URL — for dynamic import() which requires URLs on Windows. */
+export const toAbsoluteUrl = (p: string) => pathToFileURL(resolve(process.cwd(), p)).href

package/src/utils/workerImport.ts

@@ -4,7 +4,7 @@
  *
  * Usage: Pass the caller's import.meta.url to resolve relative paths correctly.
  */
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 import { dirname, resolve } from 'node:path'
 
 type ModuleCache = Map<string, any>
@@ -33,7 +33,7 @@ export async function workerImport<T = any>(
   const mjsPath = absolutePath.endsWith('.mjs') ? absolutePath : `${absolutePath}.mjs`
 
   // @ts-ignore - runtime needs .mjs extension for proper ESM resolution
-  const mod = await import(mjsPath)
+  const mod = await import(pathToFileURL(mjsPath).href)
   cache.set(cacheKey, mod)
   return mod
 }

package/src/views/RootErrorBoundary.tsx

@@ -1,5 +1,7 @@
 import React from 'react'
 import { Platform, Text, View } from 'react-native'
+import { checkSkewAndReload } from '../skewProtection'
+import { handleSkewError, isChunkLoadError } from '../utils/dynamicImport'
 
 type RootErrorBoundaryState = {
   hasError: boolean
@@ -28,6 +30,22 @@ export class RootErrorBoundary extends React.Component<
       `[One] Root error boundary caught error:\n${printError(error)}\n${info.componentStack}`
     )
 
+    // skew protection: chunk-load errors are unambiguous → reload immediately.
+    // for any other render error, do a one-shot version check and only reload
+    // if the deployed build actually changed. genuine bugs fall through to the
+    // fallback UI below.
+    if (
+      process.env.TAMAGUI_TARGET !== 'native' &&
+      process.env.NODE_ENV === 'production' &&
+      process.env.ONE_SKEW_PROTECTION !== 'false'
+    ) {
+      if (isChunkLoadError(error)) {
+        handleSkewError()
+      } else {
+        checkSkewAndReload()
+      }
+    }
+
     // Dispatch error event for devtools (web only - CustomEvent doesn't exist on native)
     if (typeof window !== 'undefined' && typeof CustomEvent !== 'undefined') {
       window.dispatchEvent(

package/src/views/Try.tsx

@@ -1,4 +1,6 @@
 import React from 'react'
+import { checkSkewAndReload } from '../skewProtection'
+import { handleSkewError, isChunkLoadError } from '../utils/dynamicImport'
 
 /**
  * Route context information passed to error boundaries.
@@ -65,6 +67,22 @@ export class Try extends React.Component<TryProps, TryState> {
       )
     }
 
+    // skew protection: chunk-load errors at the route level are unambiguous,
+    // reload immediately. for any other render error, do a one-shot version
+    // check and only reload if the deployed build actually changed. genuine
+    // bugs fall through to the route's own ErrorBoundary UI below.
+    if (
+      process.env.TAMAGUI_TARGET !== 'native' &&
+      process.env.NODE_ENV === 'production' &&
+      process.env.ONE_SKEW_PROTECTION !== 'false'
+    ) {
+      if (isChunkLoadError(error)) {
+        handleSkewError()
+      } else {
+        checkSkewAndReload()
+      }
+    }
+
     // Dispatch error event for devtools integration (web only - CustomEvent doesn't exist on native)
     if (typeof window !== 'undefined' && typeof CustomEvent !== 'undefined') {
       window.dispatchEvent(