one 1.12.1 → 1.12.3

package/src/Root.tsx

@@ -27,12 +27,25 @@ import { ServerLocationContext } from './router/serverLocationContext'
 import { useInitializeOneRouter } from './router/useInitializeOneRouter'
 import { useViteRoutes } from './router/useViteRoutes'
 import type { GlobbedRouteImports } from './types'
+import { evictOldest } from './utils/evictOldest'
 import { ServerRenderID } from './useServerHeadInsertion'
 import { PreloadLinks } from './views/PreloadLinks'
 import { RootErrorBoundary } from './views/RootErrorBoundary'
 import { ScrollBehavior } from './views/ScrollBehavior'
 import type { One } from './vite/types'
 
+// cache URL objects for SSR to avoid per-render allocation
+// keyed by path string, evicted when cache grows too large
+const ssrLocationCache = new Map<string, URL>()
+function getCachedSSRLocation(path: string): URL {
+  let url = ssrLocationCache.get(path)
+  if (url) return url
+  url = new URL(path, getURL())
+  evictOldest(ssrLocationCache, 5000, 1000)
+  ssrLocationCache.set(path, url)
+  return url
+}
+
 type RootProps = Omit<InnerProps, 'context'> & {
   onRenderId?: (id: string) => void
   path: string
@@ -87,7 +100,7 @@ export function Root(props: RootProps) {
   const location =
     typeof window !== 'undefined' && window.location
       ? new URL(path || window.location.href || '/', window.location.href)
-      : new URL(path || '/', getURL())
+      : getCachedSSRLocation(path || '/')
 
   const store = useInitializeOneRouter(context, location)
   const userScheme = useUserScheme()

package/src/cli/build.ts

@@ -24,7 +24,7 @@ import { buildVercelOutputDirectory } from '../vercel/build/buildVercelOutputDir
 import { getManifest } from '../vite/getManifest'
 import { loadUserOneOptions } from '../vite/loadConfig'
 import { runWithAsyncLocalContext } from '../vite/one-server-only'
-import type { One, RouteInfo } from '../vite/types'
+import type { DeployConfig, DeployTarget, One, RouteInfo } from '../vite/types'
 import { buildPage, printBuildTimings } from './buildPage'
 import { checkNodeVersion } from './checkNodeVersion'
 import { getWorkerPool, terminateWorkerPool } from './workerPool'
@@ -35,6 +35,25 @@ import { getCriticalCSSOutputPaths } from '../vite/plugins/criticalCSSPlugin'
 
 const { ensureDir, writeJSON } = FSExtra
 
+function normalizeDeploy(
+  deploy?: DeployTarget | DeployConfig
+): { target: DeployTarget; url?: string } | undefined {
+  if (!deploy) return undefined
+  if (typeof deploy === 'string') return { target: deploy }
+  return deploy
+}
+
+// reads package.json name, strips npm scope prefix for use as cloudflare worker name
+async function getCloudflareProjectName(root: string): Promise<string> {
+  try {
+    const pkg = JSON.parse(await FSExtra.readFile(join(root, 'package.json'), 'utf-8'))
+    if (pkg.name) {
+      return pkg.name.replace(/^@[^/]+\//, '')
+    }
+  } catch {}
+  return 'one-app'
+}
+
 // concurrency limit for parallel page builds
 // can be overridden with ONE_BUILD_CONCURRENCY env var
 // default based on CPU count for I/O parallelism benefits
@@ -117,6 +136,22 @@ export async function build(args: {
     process.env.ONE_DEFAULT_RENDER_MODE = oneOptions.web.defaultRenderMode
   }
 
+  const deployConfig = normalizeDeploy(oneOptions.web?.deploy)
+
+  // auto-detect ONE_SERVER_URL from deploy config when not explicitly set
+  if (!process.env.ONE_SERVER_URL && deployConfig) {
+    const url =
+      deployConfig.url ??
+      (deployConfig.target === 'cloudflare'
+        ? `https://${await getCloudflareProjectName(process.cwd())}.workers.dev`
+        : undefined)
+
+    if (url) {
+      process.env.ONE_SERVER_URL = url
+      console.info(`\n ☁️  ONE_SERVER_URL: ${url}\n`)
+    }
+  }
+
   // respect vite's build.outDir config, default to 'dist'
   const outDir = viteLoadedConfig?.config?.build?.outDir ?? 'dist'
 
@@ -981,7 +1016,7 @@ export async function build(args: {
 
   const postBuildLogs: string[] = []
 
-  const platform = oneOptions.web?.deploy
+  const platform = deployConfig?.target
 
   if (platform) {
     postBuildLogs.push(`[one.build] platform ${platform}`)
@@ -1205,16 +1240,7 @@ export default {
 
       // 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)
-      // Read project name from package.json if available
-      let projectName = 'one-app'
-      try {
-        const pkgPath = join(options.root, 'package.json')
-        const pkg = JSON.parse(await FSExtra.readFile(pkgPath, 'utf-8'))
-        if (pkg.name) {
-          // strip scope prefix for CF worker name
-          projectName = pkg.name.replace(/^@[^/]+\//, '')
-        }
-      } catch {}
+      const projectName = await getCloudflareProjectName(options.root)
 
       const wranglerConfig = `{
   "name": ${JSON.stringify(projectName)},

package/src/createApp.tsx

@@ -41,7 +41,10 @@ export function createApp(options: CreateAppProps) {
       render: async (props: RenderAppProps) => {
         // set render mode env before setup so users can conditionally skip setup in ssg/spa
         const renderMode = props.mode === 'spa-shell' ? 'spa' : props.mode
-        process.env.ONE_RENDER_MODE = renderMode
+        // only set if changed to avoid process.env setter overhead
+        if (process.env.ONE_RENDER_MODE !== renderMode) {
+          process.env.ONE_RENDER_MODE = renderMode
+        }
 
         if (!setupDone && options.getSetupPromise) {
           await options.getSetupPromise()
@@ -165,7 +168,10 @@ export function createApp(options: CreateAppProps) {
       // streaming SSR - returns ReadableStream, no post-processing
       renderStream: async (props: RenderAppProps): Promise<ReadableStream> => {
         const renderMode = props.mode === 'spa-shell' ? 'spa' : props.mode
-        process.env.ONE_RENDER_MODE = renderMode
+        // only set if changed to avoid process.env setter overhead
+        if (process.env.ONE_RENDER_MODE !== renderMode) {
+          process.env.ONE_RENDER_MODE = renderMode
+        }
 
         if (!setupDone && options.getSetupPromise) {
           await options.getSetupPromise()

package/src/createHandleRequest.ts

@@ -290,12 +290,19 @@ export async function resolvePageRoute(
   })
 }
 
+// weakmap cache to avoid re-parsing the same request URL
+const _urlCache = new WeakMap<Request, URL>()
+
 export function getURLfromRequestURL(request: Request) {
+  let url = _urlCache.get(request)
+  if (url) return url
   const urlString = request.url || ''
-  return new URL(
+  url = new URL(
     urlString || '',
     request.headers.get('host') ? `http://${request.headers.get('host')}` : ''
   )
+  _urlCache.set(request, url)
+  return url
 }
 
 function compileRouteRegex(route: RouteInfo): RouteInfoCompiled {
@@ -456,7 +463,7 @@ export function createHandleRequest(
   }
 }
 
-function getLoaderParams(
+export function getLoaderParams(
   url: URL,
   config: { compiledRegex: RegExp; routeKeys: Record<string, string> }
 ) {

package/src/fork/SSRNavigationContainer.tsx

@@ -49,14 +49,37 @@ const getPartialState = (state: any): any => {
   }
 }
 
-// cache by initialState reference
-let _cachedState: any = null
-let _cachedCtx: any = null
+// cache state contexts by navigation state identity to avoid deep clone thrashing
+// under concurrent SSR requests with different URLs
+const stateCtxCache = new WeakMap<
+  object,
+  {
+    state: any
+    getKey: () => string | undefined
+    setKey: () => void
+    getState: () => any
+    setState: () => void
+    getIsInitial: () => boolean
+  }
+>()
 
 function getStateContext(initialState: any) {
-  if (_cachedState === initialState && _cachedCtx) return _cachedCtx
+  if (!initialState) {
+    return {
+      state: undefined,
+      getKey: () => undefined as string | undefined,
+      setKey: noop,
+      getState: () => undefined,
+      setState: noop,
+      getIsInitial: () => true,
+    }
+  }
+
+  const cached = stateCtxCache.get(initialState)
+  if (cached) return cached
+
   const partial = getPartialState(initialState)
-  _cachedCtx = {
+  const ctx = {
     state: partial,
     getKey: () => undefined as string | undefined,
     setKey: noop,
@@ -64,8 +87,8 @@ function getStateContext(initialState: any) {
     setState: noop,
     getIsInitial: () => true,
   }
-  _cachedState = initialState
-  return _cachedCtx
+  stateCtxCache.set(initialState, ctx)
+  return ctx
 }
 
 export function SSRNavigationContainer({

package/src/router/linkingConfig.ts

@@ -1,5 +1,6 @@
 import { isWebClient } from '../constants'
 import type { OneRouter } from '../interfaces/router'
+import { evictOldest } from '../utils/evictOldest'
 import {
   getLinkingConfig as createLinkingConfig,
   type OneLinkingOptions,
@@ -62,8 +63,7 @@ export function getSSRInitialState(
     path,
     cachedBaseLinkingConfig.config
   )
-  // bound cache to prevent memory growth on sites with many unique URLs
-  if (ssrStateCache.size > 10000) ssrStateCache.clear()
+  evictOldest(ssrStateCache, 5000, 1000)
   ssrStateCache.set(path, state)
   return state
 }

package/src/serve.ts

@@ -21,60 +21,146 @@ export async function serve(
 ) {
   // cluster mode: --cluster or --cluster=N
   if (args.cluster) {
-    const cluster = await import('node:cluster')
-    const { cpus } = await import('node:os')
+    const { cpus, platform } = await import('node:os')
+    const numWorkers = typeof args.cluster === 'number' ? args.cluster : cpus().length
+
+    // check if we can use SO_REUSEPORT (linux with node 22.12+)
+    const [major, minor] = process.versions.node.split('.').map(Number)
+    const canReusePort =
+      !['win32', 'darwin'].includes(platform()) &&
+      (major > 22 || (major === 22 && minor >= 12) || major >= 23)
+
+    if (canReusePort) {
+      // SO_REUSEPORT: spawn independent child processes, each binds to port directly
+      // kernel distributes connections - no IPC bottleneck
+      return await serveWithReusePort(args, numWorkers)
+    } else {
+      // fallback: node cluster module (IPC-based, works on macOS)
+      return await serveWithCluster(args, numWorkers)
+    }
+  }
+
+  // single-process mode
+  return await startWorker(args)
+}
+
+async function serveWithReusePort(args: Parameters<typeof serve>[0], numWorkers: number) {
+  const { fork } = await import('node:child_process')
+
+  console.info(`[one] cluster: starting ${numWorkers} workers (SO_REUSEPORT)`)
+
+  const workers: ReturnType<typeof fork>[] = []
+  let recentCrashes = 0
+  let lastCrashTime = 0
+
+  function spawnWorker() {
+    const child = fork(
+      process.argv[1]!,
+      process.argv.slice(2).filter((a) => !a.startsWith('--cluster')),
+      {
+        env: { ...process.env, ONE_CLUSTER_WORKER: '1' },
+        stdio: 'inherit',
+      }
+    )
+    workers.push(child)
 
-    if (cluster.default.isPrimary) {
-      const numWorkers = typeof args.cluster === 'number' ? args.cluster : cpus().length
+    child.on('exit', (code, signal) => {
+      const idx = workers.indexOf(child)
+      if (idx >= 0) workers.splice(idx, 1)
 
-      console.info(`[one] cluster: starting ${numWorkers} workers`)
+      if (code === 0 || signal === 'SIGTERM' || signal === 'SIGINT') return
 
-      for (let i = 0; i < numWorkers; i++) {
-        cluster.default.fork()
+      const now = Date.now()
+      if (now - lastCrashTime < 5000) {
+        recentCrashes++
+      } else {
+        recentCrashes = 1
       }
+      lastCrashTime = now
 
-      // 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)
+      if (recentCrashes > numWorkers * 2) {
+        console.error(`[one] too many worker crashes, stopping`)
+        process.exit(1)
       }
-      process.on('SIGINT', shutdown)
-      process.on('SIGTERM', shutdown)
 
-      return
+      console.error(
+        `[one] worker ${child.pid} died (code ${code}, signal ${signal}), restarting`
+      )
+      setTimeout(spawnWorker, Math.min(recentCrashes * 500, 5000))
+    })
+  }
+
+  for (let i = 0; i < numWorkers; i++) {
+    spawnWorker()
+  }
+
+  const shutdown = () => {
+    for (const w of workers) {
+      w.kill('SIGTERM')
     }
+    setTimeout(() => process.exit(0), 5000)
   }
+  process.on('SIGINT', shutdown)
+  process.on('SIGTERM', shutdown)
+
+  // keep primary alive
+  await new Promise(() => {})
+}
+
+async function serveWithCluster(args: Parameters<typeof serve>[0], numWorkers: number) {
+  const cluster = await import('node:cluster')
+
+  if (cluster.default.isPrimary) {
+    console.info(`[one] cluster: starting ${numWorkers} workers (IPC)`)
+
+    for (let i = 0; i < numWorkers; i++) {
+      cluster.default.fork()
+    }
+
+    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
+  }
+
+  // cluster worker
+  return await startWorker(args)
+}
 
-  // worker (or single-process mode)
+async function startWorker(args: Parameters<typeof serve>[0]) {
   const outDir =
-    args.outDir || (FSExtra.existsSync('buildInfo.json') ? '.' : null) || 'dist'
+    args?.outDir || (FSExtra.existsSync('buildInfo.json') ? '.' : null) || 'dist'
   const buildInfo = (await FSExtra.readJSON(`${outDir}/buildInfo.json`)) as One.BuildInfo
   const { oneOptions } = buildInfo
 
@@ -89,18 +175,18 @@ export async function serve(
 
   labelProcess('serve')
 
-  if (args.loadEnv) {
+  if (args?.loadEnv) {
     await loadEnv('production')
   }
 
   return await vxrnServe({
     outDir: buildInfo.outDir || outDir,
-    app: args.app,
+    app: args?.app,
     ...oneOptions.server,
     ...removeUndefined({
-      port: args.port ? +args.port : undefined,
-      host: args.host,
-      compress: args.compress,
+      port: args?.port ? +args.port : undefined,
+      host: args?.host,
+      compress: args?.compress,
     }),
 
     async beforeRegisterRoutes(options, app) {