one 1.12.5 → 1.12.6

package/src/cli/build.ts

@@ -1116,15 +1116,15 @@ ${middlewareRouteMap.join(',\n')}
 
 const buildInfo = ${JSON.stringify(buildInfoForWriting)}
 
-let app
+let server
 
 export default {
   async fetch(request, env, ctx) {
-    if (!app) {
-      app = await serve(buildInfo, lazyRoutes)
+    if (!server) {
+      server = await serve(buildInfo, lazyRoutes)
     }
 
-    // Set up static HTML fetcher for this request (uses ASSETS binding)
+    // set up static HTML fetcher for this request (uses ASSETS binding)
     if (env.ASSETS) {
       setFetchStaticHtml(async (path) => {
         try {
@@ -1135,34 +1135,31 @@ export default {
             return await assetResponse.text()
           }
         } catch (e) {
-          // Asset not found
+          // asset not found
         }
         return null
       })
     }
 
     try {
-      // Try the app first
-      const response = await app.fetch(request, env, ctx)
+      const response = await server.fetch(request)
 
-      // If no route matched (404) or no response, try serving static assets
+      // no route matched or 404 → try 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
+            // asset not found, continue with original response
           }
         }
       }
 
       return response
     } finally {
-      // Clean up per-request state
       setFetchStaticHtml(null)
     }
   }

package/src/serve-worker.ts

@@ -1,40 +1,38 @@
-import { Hono } from 'hono'
 import { setServerGlobals } from './server/setServerGlobals'
 import { setupBuildInfo } from './server/setupBuildOptions'
+import { createWorkerHandler, type LazyRoutes } from './server/workerHandler'
 import { ensureExists } from './utils/ensureExists'
 import type { One } from './vite/types'
 
-// Re-export static HTML fetcher utilities for worker use
+// re-export static HTML fetcher utilities for worker use
 export { getFetchStaticHtml, setFetchStaticHtml } 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>>
-}
+// re-export for use in generated worker code
+export type { LazyRoutes }
 
 /**
- * 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)
+ * 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.
  *
- * @param buildInfo - Build configuration and route metadata
- * @param lazyRoutes - Lazy import functions for route modules (loaded on-demand)
+ * @returns `{ fetch, updateRoutes }` — call `fetch(request)` to handle requests,
+ *          `updateRoutes(newBuildInfo, newLazyRoutes?)` to hot-swap the route table.
  */
 export async function serve(buildInfo: One.BuildInfo, lazyRoutes?: LazyRoutes) {
   setupBuildInfo(buildInfo)
   ensureExists(buildInfo.oneOptions)
   setServerGlobals()
 
-  const app = new Hono()
-
-  const { oneServe } = await import('./server/oneServe')
-  await oneServe(buildInfo.oneOptions, buildInfo, app, { lazyRoutes })
+  const handler = createWorkerHandler({
+    oneOptions: buildInfo.oneOptions!,
+    buildInfo,
+    lazyRoutes: lazyRoutes!,
+  })
 
-  return app
+  return {
+    fetch: handler.handleRequest,
+    updateRoutes(newBuildInfo: One.BuildInfo, newLazyRoutes?: LazyRoutes) {
+      setupBuildInfo(newBuildInfo)
+      handler.updateRoutes(newBuildInfo, newLazyRoutes)
+    },
+  }
 }

package/src/server/oneServe.ts

@@ -658,7 +658,7 @@ url: ${url}`)
             if (notFoundHtml) {
               // inject 404 marker so client knows this is a 404 response
               // this prevents hydration mismatch when the URL matches a dynamic route
-              const notFoundMarker = `<script>window.__one404={originalPath:"${url.pathname}",notFoundPath:"${notFoundRoute}"}</script>`
+              const notFoundMarker = `<script>window.__one404=${JSON.stringify({ originalPath: url.pathname, notFoundPath: notFoundRoute })}</script>`
               // inject before </head> or at start of <body>
               const injectedHtml = notFoundHtml.includes('</head>')
                 ? notFoundHtml.replace('</head>', `${notFoundMarker}</head>`)