one 1.2.41 → 1.2.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "one",
-  "version": "1.2.41",
+  "version": "1.2.43",
   "license": "BSD-3-Clause",
   "sideEffects": [
     "setup.mjs",
@@ -124,17 +124,17 @@
     "@react-navigation/routers": "~7.5.1",
     "@swc/core": "^1.14.0",
     "@ungap/structured-clone": "^1.2.0",
-    "@vxrn/color-scheme": "1.2.41",
-    "@vxrn/compiler": "1.2.41",
-    "@vxrn/resolve": "1.2.41",
-    "@vxrn/tslib-lite": "1.2.41",
-    "@vxrn/use-isomorphic-layout-effect": "1.2.41",
-    "@vxrn/vite-plugin-metro": "1.2.41",
+    "@vxrn/color-scheme": "1.2.43",
+    "@vxrn/compiler": "1.2.43",
+    "@vxrn/resolve": "1.2.43",
+    "@vxrn/tslib-lite": "1.2.43",
+    "@vxrn/use-isomorphic-layout-effect": "1.2.43",
+    "@vxrn/vite-plugin-metro": "1.2.43",
     "babel-dead-code-elimination": "^1.0.10",
     "babel-plugin-module-resolver": "^5.0.2",
     "citty": "^0.1.6",
     "core-js": "^3.38.1",
-    "create-vxrn": "1.2.41",
+    "create-vxrn": "1.2.43",
     "escape-string-regexp": "^5.0.0",
     "expo-linking": "~8.0.8",
     "expo-modules-core": "~3.0.24",
@@ -160,7 +160,7 @@
     "vite": "^7.1.12",
     "vite-plugin-barrel": "^0.4.1",
     "vite-tsconfig-paths": "^5.1.4",
-    "vxrn": "1.2.41",
+    "vxrn": "1.2.43",
     "ws": "^8.18.0",
     "xxhashjs": "^0.2.2"
   },
@@ -178,7 +178,7 @@
   "devDependencies": {
     "@react-navigation/core": "^7.13.0",
     "@react-navigation/native": "~7.1.19",
-    "@tamagui/build": "^1.141.4",
+    "@tamagui/build": "^1.142.0",
     "@types/node": "^24.10.0",
     "@types/react-dom": "^19.2.2",
     "@types/xxhashjs": "^0.2.4",

package/src/Root.tsx

@@ -88,7 +88,10 @@ export function Root(props: RootProps) {
 
   onRenderId?.(id)
 
-  const value = globalThis['__vxrnrequestAsyncLocalStore']?.getStore() || null
+  // Use Vercel's global ID if available, otherwise use AsyncLocalStorage
+  const value = process.env.VERCEL
+    ? globalThis['__oneGlobalContextId']
+    : globalThis['__vxrnrequestAsyncLocalStore']?.getStore() || null
 
   let contents = (
     <ServerAsyncLocalIDContext.Provider value={value}>

package/src/cli/build.ts

@@ -27,6 +27,7 @@ import { buildPage } from './buildPage'
 import { checkNodeVersion } from './checkNodeVersion'
 import { generateSitemap, type RouteSitemapData } from './generateSitemap'
 import { labelProcess } from './label-process'
+import { isRolldown } from '../utils/isRolldown'
 
 const { ensureDir, writeJSON } = FSExtra
 
@@ -264,28 +265,40 @@ export async function build(args: {
       }
     }
 
-    // gather the initial import.meta.glob js parts:
-    const clientManifestKey =
+    // Match route by server output id against manifest.pageRoutes
+    const foundRoute = manifest.pageRoutes.find((route: RouteInfo<string>) => {
+      if (!route.file) return false
+      const routePath = `${routerRoot}${route.file.slice(1)}`
+      return id.endsWith(routePath)
+    })
+
+    if (!foundRoute) {
+      continue
+    }
+
+    // Find client manifest entry - first by exact key match, then by src property
+    let clientManifestKey =
       Object.keys(vxrnOutput.clientManifest).find((key) => {
         return id.endsWith(key)
       }) || ''
 
+    // If not found by key, search by src property (handles shared chunks)
     if (!clientManifestKey) {
-      // this is something that has /app in it but isnt actually in our manifest, ignore
-      continue
+      const expectedSrc = `${routerRoot}${foundRoute.file.slice(1)}`
+      clientManifestKey =
+        Object.keys(vxrnOutput.clientManifest).find((key) => {
+          const entry = vxrnOutput.clientManifest[key]
+          return entry.src === expectedSrc
+        }) || ''
     }
 
-    const clientManifestEntry = vxrnOutput.clientManifest[clientManifestKey]
-
-    const foundRoute = manifest.pageRoutes.find((route: RouteInfo<string>) => {
-      return route.file && clientManifestKey.replace(routerRootRegexp, '') === route.file.slice(1)
-    })
-
-    if (!foundRoute) {
-      // should probably error?
+    if (!clientManifestKey) {
+      console.warn(`No client manifest entry found for route: ${id}`)
       continue
     }
 
+    const clientManifestEntry = vxrnOutput.clientManifest[clientManifestKey]
+
     foundRoute.loaderServerPath = output.fileName
 
     function collectImports(
@@ -625,6 +638,7 @@ export async function build(args: {
     preloads,
     cssPreloads,
     loaders,
+    useRolldown: await isRolldown(),
   }
 
   await writeJSON(toAbsolute(`dist/buildInfo.json`), buildInfoForWriting)
@@ -662,29 +676,196 @@ export async function build(args: {
       break
     }
 
-    //     case 'cloudflare': {
-    //       await FSExtra.writeFile(
-    //         join(options.root, 'dist', 'worker.js'),
-    //         `import { serve } from 'one/serve-worker'
+    case 'cloudflare': {
+      // Generate lazy import functions - modules load on-demand, not all upfront
+      // Uses find_additional_modules in wrangler config to keep modules separate
+      const pageRouteMap: string[] = []
+      const apiRouteMap: string[] = []
+      const middlewareRouteMap: string[] = []
+
+      // Generate lazy imports for SSR/SSG page server bundles
+      for (const [routeFile, info] of Object.entries(buildInfoForWriting.routeToBuildInfo)) {
+        if (info.serverJsPath) {
+          const importPath = './' + info.serverJsPath.replace(/^dist\//, '')
+          pageRouteMap.push(`  '${routeFile}': () => import('${importPath}')`)
+        }
+      }
+
+      // Generate lazy imports for API routes
+      for (const route of buildInfoForWriting.manifest.apiRoutes) {
+        if (route.file) {
+          // API files are built to dist/api/
+          // route.page is like "/api/hello", files are at "dist/api/api/hello.js"
+          // rolldown preserves brackets, esbuild replaces them with underscores
+          const apiFileName = buildInfoForWriting.useRolldown
+            ? route.page.slice(1)
+            : route.page.slice(1).replace(/\[/g, '_').replace(/\]/g, '_')
+          const importPath = `./api/${apiFileName}.js`
+          apiRouteMap.push(`  '${route.page}': () => import('${importPath}')`)
+        }
+      }
+
+      // Generate lazy imports for middlewares
+      // The key must match the contextKey used to look up the middleware (e.g., "dist/middlewares/_middleware.js")
+      for (const [middlewareFile, builtPath] of Object.entries(builtMiddlewares)) {
+        const importPath = './' + builtPath.replace(/^dist\//, '')
+        middlewareRouteMap.push(`  '${builtPath}': () => import('${importPath}')`)
+      }
+
+      const workerSrcPath = join(options.root, 'dist', '_worker-src.js')
+      const workerCode = `// Polyfill MessageChannel for React SSR (not available in Cloudflare Workers by default)
+if (typeof MessageChannel === 'undefined') {
+  globalThis.MessageChannel = class MessageChannel {
+    constructor() {
+      this.port1 = { postMessage: () => {}, onmessage: null, close: () => {} }
+      this.port2 = { postMessage: () => {}, onmessage: null, close: () => {} }
+    }
+  }
+}
+
+import { serve, setFetchStaticHtml } from 'one/serve-worker'
+
+// Lazy import map - modules load on-demand when route is matched
+const lazyRoutes = {
+  serverEntry: () => import('./server/_virtual_one-entry.js'),
+  pages: {
+${pageRouteMap.join(',\n')}
+  },
+  api: {
+${apiRouteMap.join(',\n')}
+  },
+  middlewares: {
+${middlewareRouteMap.join(',\n')}
+  }
+}
+
+const buildInfo = ${JSON.stringify(buildInfoForWriting)}
+
+let app
+
+export default {
+  async fetch(request, env, ctx) {
+    if (!app) {
+      app = await serve(buildInfo, lazyRoutes)
+    }
+
+    // Set up static HTML fetcher for this request (uses ASSETS binding)
+    if (env.ASSETS) {
+      setFetchStaticHtml(async (path) => {
+        try {
+          const url = new URL(request.url)
+          url.pathname = path
+          const assetResponse = await env.ASSETS.fetch(new Request(url))
+          if (assetResponse && assetResponse.ok) {
+            return await assetResponse.text()
+          }
+        } catch (e) {
+          // Asset not found
+        }
+        return null
+      })
+    }
 
-    // const buildInfo = ${JSON.stringify(buildInfoForWriting)}
+    try {
+      // Try the app first
+      const response = await app.fetch(request, env, ctx)
 
-    // const handler = await serve(buildInfo)
+      // If no route matched (404) or no response, try serving static assets
+      if (!response || response.status === 404) {
+        if (env.ASSETS) {
+          try {
+            const assetResponse = await env.ASSETS.fetch(request)
+            // If asset exists, return it
+            if (assetResponse && assetResponse.status !== 404) {
+              return assetResponse
+            }
+          } catch (e) {
+            // Asset not found, continue with original response
+          }
+        }
+      }
+
+      return response
+    } finally {
+      // Clean up per-request state
+      setFetchStaticHtml(null)
+    }
+  }
+}
+`
+      await FSExtra.writeFile(workerSrcPath, workerCode)
+
+      // Bundle the worker using Vite/esbuild
+      // Cloudflare Workers with nodejs_compat supports Node.js built-ins
+      console.info('\n [cloudflare] Bundling worker...')
+      await viteBuild({
+        root: options.root,
+        logLevel: 'warn',
+        build: {
+          outDir: 'dist',
+          emptyOutDir: false,
+          // Use SSR mode with node target for proper Node.js module resolution
+          ssr: workerSrcPath,
+          rollupOptions: {
+            external: [
+              // React Native dev tools - not needed in production
+              '@react-native/dev-middleware',
+              '@react-native/debugger-shell',
+              'metro',
+              'metro-core',
+              'metro-runtime',
+              // Native modules that can't run in workers
+              /\.node$/,
+            ],
+            output: {
+              entryFileNames: 'worker.js',
+              format: 'es',
+              // Keep dynamic imports separate for lazy loading
+              inlineDynamicImports: false,
+            },
+          },
+          minify: true,
+          target: 'esnext',
+        },
+        define: {
+          'process.env.NODE_ENV': JSON.stringify('production'),
+          'process.env.VITE_ENVIRONMENT': JSON.stringify('ssr'),
+        },
+        resolve: {
+          conditions: ['workerd', 'worker', 'node', 'module', 'default'],
+        },
+        ssr: {
+          target: 'node',
+          noExternal: true,
+        },
+      })
 
-    // export default {
-    //   fetch: handler.fetch,
-    // }`
-    //       )
+      // Clean up temp file
+      await FSExtra.remove(workerSrcPath)
+
+      // Use jsonc for wrangler config (recommended for new projects)
+      // Use assets with run_worker_first so all requests go through worker (enables middleware on SSG pages)
+      const wranglerConfig = `{
+  "name": "one-app",
+  "main": "worker.js",
+  "compatibility_date": "2024-12-05",
+  "compatibility_flags": ["nodejs_compat"],
+  "find_additional_modules": true,
+  "rules": [
+    { "type": "ESModule", "globs": ["./server/**/*.js"], "fallthrough": true },
+    { "type": "ESModule", "globs": ["./api/**/*.js"], "fallthrough": true },
+    { "type": "ESModule", "globs": ["./middlewares/**/*.js"], "fallthrough": true }
+  ],
+  "assets": { "directory": "client", "binding": "ASSETS", "run_worker_first": true }
+}
+`
+      await FSExtra.writeFile(join(options.root, 'dist', 'wrangler.jsonc'), wranglerConfig)
 
-    //       await FSExtra.writeFile(
-    //         join(options.root, 'dist', 'wrangler.toml'),
-    //         `assets = { directory = "client" }
-    // compatibility_date = "2024-12-05"
-    // `
-    //       )
+      postBuildLogs.push(`Cloudflare worker bundled at dist/worker.js`)
+      postBuildLogs.push(`To deploy: cd dist && wrangler deploy`)
 
-    //       break
-    //     }
+      break
+    }
   }
 
   if (process.env.VXRN_ANALYZE_BUNDLE) {

package/src/createHandleRequest.ts

@@ -107,39 +107,41 @@ export async function resolveAPIRoute(
     console.info(`[one] 📡 API ${request.method} ${pathname} → ${route.file}`, params)
   }
 
-  try {
-    return resolveAPIEndpoint(
-      () =>
-        handlers.handleAPI!({
-          request,
-          route,
-          url,
-          loaderProps: {
-            path: pathname,
-            search: url.search,
-            params,
-          },
-        }),
-      request,
-      params || {}
-    )
-  } catch (err) {
-    if (isResponse(err)) {
-      return err
-    }
+  return await runMiddlewares(handlers, request, route, async () => {
+    try {
+      return resolveAPIEndpoint(
+        () =>
+          handlers.handleAPI!({
+            request,
+            route,
+            url,
+            loaderProps: {
+              path: pathname,
+              search: url.search,
+              params,
+            },
+          }),
+        request,
+        params || {}
+      )
+    } catch (err) {
+      if (isResponse(err)) {
+        return err
+      }
 
-    if (process.env.NODE_ENV === 'development') {
-      console.error(`\n [one] Error importing API route at ${pathname}:
+      if (process.env.NODE_ENV === 'development') {
+        console.error(`\n [one] Error importing API route at ${pathname}:
 
-        ${err}
+          ${err}
 
-        If this is an import error, you can likely fix this by adding this dependency to
-        the "optimizeDeps.include" array in your vite.config.ts.
-      `)
-    }
+          If this is an import error, you can likely fix this by adding this dependency to
+          the "optimizeDeps.include" array in your vite.config.ts.
+        `)
+      }
 
-    throw err
-  }
+      throw err
+    }
+  })
 }
 
 export async function resolveLoaderRoute(

package/src/serve-worker.ts

@@ -1,23 +1,40 @@
 import { Hono } from 'hono'
-import { createProdServer } from 'vxrn/serve'
-import { oneServe } from './server/oneServe'
 import { setServerGlobals } from './server/setServerGlobals'
 import { setupBuildInfo } from './server/setupBuildOptions'
 import { ensureExists } from './utils/ensureExists'
 import type { One } from './vite/types'
 
-export async function serve(buildInfo: One.BuildInfo) {
+// Re-export static HTML fetcher utilities for worker use
+export { setFetchStaticHtml, getFetchStaticHtml } from './server/staticHtmlFetcher'
+
+/**
+ * Lazy import functions for route modules.
+ * Modules are loaded on-demand when a route is matched, not all upfront.
+ */
+export type LazyRoutes = {
+  serverEntry: () => Promise<{ default: { render: (props: any) => any } }>
+  pages: Record<string, () => Promise<any>>
+  api: Record<string, () => Promise<any>>
+  middlewares: Record<string, () => Promise<any>>
+}
+
+/**
+ * Creates a Hono app for edge/worker environments (Cloudflare Workers, etc.)
+ * Static assets should be handled by the platform (e.g., wrangler's [assets] config)
+ * This only sets up the dynamic routes (SSR, API, loaders)
+ *
+ * @param buildInfo - Build configuration and route metadata
+ * @param lazyRoutes - Lazy import functions for route modules (loaded on-demand)
+ */
+export async function serve(buildInfo: One.BuildInfo, lazyRoutes?: LazyRoutes) {
   setupBuildInfo(buildInfo)
   ensureExists(buildInfo.oneOptions)
   setServerGlobals()
 
-  const serverOptions = buildInfo.oneOptions.server || {}
-
   const app = new Hono()
 
-  await createProdServer(app, serverOptions)
-
-  await oneServe(buildInfo.oneOptions, buildInfo, app)
+  const { oneServe } = await import('./server/oneServe')
+  await oneServe(buildInfo.oneOptions, buildInfo, app, { lazyRoutes })
 
   return app
 }

package/src/serve.ts

@@ -23,7 +23,7 @@ export async function serve(args: VXRNOptions['server'] & { app?: Hono } = {}) {
   // 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 } = await import('vxrn/serve')
+  const { loadEnv, serve: vxrnServe, serveStaticAssets } = await import('vxrn/serve')
   const { oneServe } = await import('./server/oneServe')
 
   labelProcess('serve')
@@ -44,7 +44,7 @@ export async function serve(args: VXRNOptions['server'] & { app?: Hono } = {}) {
     }),
 
     async beforeRegisterRoutes(options, app) {
-      await oneServe(oneOptions, buildInfo, app)
+      await oneServe(oneOptions, buildInfo, app, { serveStaticAssets })
     },
 
     async afterRegisterRoutes(options, app) {},