one 1.25.13 → 1.25.16

package/src/headless.tsx

@@ -4,6 +4,7 @@ import type { OneLinkingConfig } from './link/getLinking'
 import { Root } from './Root'
 import { resolveClientLoader } from './clientLoaderResolver'
 import { render } from './render'
+import { handleSkewError, isChunkLoadError } from './utils/dynamicImport'
 import { findRootLayout } from './utils/findRootLayout'
 import type { One } from './vite/types'
 
@@ -51,5 +52,9 @@ export function createApp(options: CreateHeadlessAppProps) {
     })
     .catch((err) => {
       console.error(`[one/headless] Error during initialization:`, err)
+      if (isChunkLoadError(err)) {
+        handleSkewError()
+      }
     })
 }
+

package/src/router/diagnoseRouteLoadFailure.ts

@@ -28,7 +28,9 @@ function collectImports(source: string, base: string): string[] {
       out.push(new URL(spec, base).href)
     } catch {}
   }
-  for (const m of source.matchAll(/(?:^|[\s;}])(?:import|export)[^'"]{0,300}?from\s*["']([^"']+)["']/g))
+  for (const m of source.matchAll(
+    /(?:^|[\s;}])(?:import|export)[^'"]{0,300}?from\s*["']([^"']+)["']/g
+  ))
     add(m[1])
   for (const m of source.matchAll(/\bimport\s*\(\s*["']([^"']+)["']\s*\)/g)) add(m[1])
   for (const m of source.matchAll(/(?:^|[\s;}])import\s*["']([^"']+)["']/g)) add(m[1])

package/src/router/useViteRoutes.tsx

@@ -1,5 +1,6 @@
 import type { GlobbedRouteImports } from '../types'
 import type { One } from '../vite/types'
+import { handleSkewError, isChunkLoadError } from '../utils/dynamicImport'
 import { diagnoseRouteLoadFailure } from './diagnoseRouteLoadFailure'
 import { hmrImport } from './hmrImport'
 
@@ -146,7 +147,11 @@ export async function preloadRouteModules(href: string): Promise<void> {
           .then((mod: any) => {
             preloadedModules[key] = mod
           })
-          .catch(() => {})
+          .catch((err: any) => {
+            if (isChunkLoadError(err)) {
+              handleSkewError()
+            }
+          })
       )
     }
   }
@@ -284,6 +289,9 @@ export function globbedRoutesToRouteContext(
         })
         .catch((err) => {
           console.error(`Error loading route`, id, err, new Error().stack)
+          if (isChunkLoadError(err)) {
+            handleSkewError()
+          }
           // rendering an empty component keeps one bad route from taking down the
           // app, but it also makes the failure invisible: nothing inside the route
           // mounts and the only trace is the line above. in dev, hand it to the

package/src/server/oneServe.ts

@@ -16,10 +16,12 @@ import {
 } from '../createHandleRequest'
 import type { RenderAppProps } from '../types'
 import { getPathFromLoaderPath } from '../utils/cleanUrl'
+import { getRouterRootFromOneOptions } from '../utils/getRouterRootFromOneOptions'
 import { toAbsoluteUrl } from '../utils/toAbsolute'
 import { toServerOutputPath } from '../utils/toServerOutputPath'
 import type { One } from '../vite/types'
 import type { RouteInfoCompiled } from './createRoutesManifest'
+import { getRouteExportsFromEntry } from './routeExportsFromEntry'
 import { setSSRLoaderData } from './ssrLoaderData'
 import { getFetchStaticHtml } from './staticHtmlFetcher'
 
@@ -74,8 +76,8 @@ async function readStaticHtml(htmlPath: string, outDir = 'dist'): Promise<string
  * Modules are loaded on-demand when a route is matched, not all upfront.
  */
 type LazyRoutes = {
+  pages?: Record<string, () => Promise<any>>
   serverEntry: () => Promise<{ default: { render: (props: any) => any } }>
-  pages: Record<string, () => Promise<any>>
   api: Record<string, () => Promise<any>>
   middlewares: Record<string, () => Promise<any>>
 }
@@ -150,6 +152,7 @@ export async function oneServe(
   }
 
   const apiCJS = oneOptions.build?.api?.outputFormat === 'cjs'
+  const routerRoot = getRouterRootFromOneOptions(oneOptions)
 
   // pre-computed constants to avoid per-request overhead
   const useStreaming = !process.env.ONE_BUFFERED_SSR
@@ -169,6 +172,26 @@ export async function oneServe(
     { promise: Promise<any>; expires: number }
   >()
 
+  // route modules are resolved through the built server entry, see
+  // routeExportsFromEntry
+  async function importRouteModule(
+    lazyKey: string | undefined,
+    serverPath: string | undefined
+  ): Promise<any> {
+    if (lazyKey && options?.lazyRoutes?.pages?.[lazyKey]) {
+      return await options.lazyRoutes.pages[lazyKey]()
+    }
+    if (lazyKey) {
+      const entry = await loadServerEntry()
+      const exported = await getRouteExportsFromEntry(entry, routerRoot, lazyKey)
+      if (exported) return exported
+    }
+    // layouts and middlewares outside the router root still resolve by path
+    return await import(
+      toAbsoluteUrl(toServerOutputPath(serverPath || lazyKey || '', outDir))
+    )
+  }
+
   // resolve a route module's loader - sync on cache hit, async on cold start
   function resolveLoaderSync(
     serverPath: string | undefined,
@@ -180,18 +203,11 @@ export async function oneServe(
 
     // cold path - async import
     return (async () => {
-      const pathToResolve = serverPath || lazyKey || ''
-      const resolvedPath = toServerOutputPath(pathToResolve, outDir)
-
       let routeExported: any
       if (moduleImportCache.has(cacheKey)) {
         routeExported = moduleImportCache.get(cacheKey)
       } else {
-        routeExported = lazyKey
-          ? options?.lazyRoutes?.pages?.[lazyKey]
-            ? await options.lazyRoutes.pages[lazyKey]()
-            : await import(toAbsoluteUrl(resolvedPath))
-          : await import(toAbsoluteUrl(serverPath!))
+        routeExported = await importRouteModule(lazyKey, serverPath)
         setBounded(moduleImportCache, cacheKey, routeExported, MODULE_CACHE_MAX)
       }
 
@@ -286,18 +302,26 @@ export async function oneServe(
   let render: ((props: RenderAppProps) => any) | null = null
   let renderStream: ((props: RenderAppProps) => Promise<ReadableStream>) | null = null
   let renderLoading: Promise<void> | null = null
+  let entryLoading: Promise<any> | null = null
 
-  function ensureRenderLoaded(): void | Promise<void> {
-    if (render) return // sync!
-    if (renderLoading) return renderLoading
-    renderLoading = (async () => {
-      const entry = options?.lazyRoutes?.serverEntry
-        ? await options.lazyRoutes.serverEntry()
-        : await import(
+  function loadServerEntry(): Promise<any> {
+    if (!entryLoading) {
+      entryLoading = options?.lazyRoutes?.serverEntry
+        ? options.lazyRoutes.serverEntry()
+        : import(
             toAbsoluteUrl(
               `${serverOptions.root}/${outDir}/server/_virtual_one-entry.${typeof oneOptions.build?.server === 'object' && oneOptions.build.server.outputFormat === 'cjs' ? 'c' : ''}js`
             )
           )
+    }
+    return entryLoading
+  }
+
+  function ensureRenderLoaded(): void | Promise<void> {
+    if (render) return // sync!
+    if (renderLoading) return renderLoading
+    renderLoading = (async () => {
+      const entry = await loadServerEntry()
       render = entry.default.render as (props: RenderAppProps) => any
       renderStream = entry.default.renderStream as
         | ((props: RenderAppProps) => Promise<ReadableStream>)

package/src/server/routeExportsFromEntry.ts

@@ -0,0 +1,59 @@
+/**
+ * route modules have to be read through the built server entry's own route map,
+ * never by importing whichever output chunk happens to contain them.
+ *
+ * a bundler makes no promise that a chunk re-exports a module's bindings under
+ * their source names. when a route is both dynamically imported by the entry and
+ * statically imported by another route (docs pages mirrored under a second url,
+ * say), or when the app sets `output.strictExecutionOrder`, rolldown emits the
+ * chunk as
+ *
+ *   export { loader as a, init__slug_ as i, _slug__exports as n, generateStaticParams as r }
+ *
+ * so every read by source name comes back undefined: the build then reports a
+ * route that exports generateStaticParams as missing it, and any loader on that
+ * route silently stops running.
+ *
+ * the entry's `import.meta.glob` map is written by the bundler itself, which
+ * rewrites each entry to whatever preserves the real namespace
+ * (`import(chunk).then((n) => (n.i(), n.n))` for the wrapped case above). so it
+ * resolves correctly no matter how the chunking lands.
+ */
+
+/** the key the entry's globs use: `./posts/[slug]+ssg.tsx` -> `/app/posts/[slug]+ssg.tsx` */
+export function routeEntryKey(routerRoot: string, routeFile: string) {
+  return `/${routerRoot}/${routeFile.replace(/^\.?\//, '')}`
+}
+
+/**
+ * resolve one route's exports out of an already-loaded server entry namespace.
+ * returns null when the entry has no such route.
+ */
+export async function getRouteExportsFromEntry(
+  entry: any,
+  routerRoot: string,
+  routeFile: string
+): Promise<Record<string, any> | null> {
+  const key = routeEntryKey(routerRoot, routeFile)
+
+  // a route that declares spa by filename or parent directory is stubbed out of
+  // the route map, so the server never holds its page component. every stubbed
+  // route has an entry in this parallel per-export map whether or not it
+  // actually exports a loader, which is what tells a stub from a real route. a
+  // route that is spa only because of `web.defaultRenderMode` is never stubbed.
+  const spaExports = entry?.oneServerSpaRouteExports
+  if (spaExports?.loader && key in spaExports.loader) {
+    const [loader, loaderCache, generateStaticParams, sitemap] = await Promise.all([
+      spaExports.loader[key](),
+      spaExports.loaderCache?.[key]?.(),
+      spaExports.generateStaticParams?.[key]?.(),
+      spaExports.sitemap?.[key]?.(),
+    ])
+    return { loader, loaderCache, generateStaticParams, sitemap }
+  }
+
+  // some output formats nest the entry default one level deeper
+  const app = entry?.default?.options ? entry.default : entry?.default?.default
+  const importRoute = app?.options?.routes?.[key]
+  return importRoute ? await importRoute() : null
+}

package/src/server/workerHandler.test.ts

@@ -2,8 +2,9 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { One } from '../vite/types'
 import { createWorkerHandler, type LazyRoutes } from './workerHandler'
 
+// route files are router-root relative, the way createRoutesManifest emits them
 const pageRoute = {
-  file: 'app/some-page.tsx',
+  file: './some-page.tsx',
   page: '/some-page',
   namedRegex: '^/some-page(?:/)?$',
   urlPath: '/some-page',
@@ -14,7 +15,7 @@ const pageRoute = {
 } satisfies One.BuildInfo['manifest']['pageRoutes'][number]
 
 const apiRoute = {
-  file: 'app/api/status+api.ts',
+  file: './api/status+api.ts',
   page: '/api/status',
   namedRegex: '^/api/status(?:/)?$',
   urlPath: '/api/status',
@@ -57,15 +58,21 @@ const buildInfo = {
   loaders: {},
 } satisfies One.BuildInfo
 
-const lazyRoutes = {
-  serverEntry: async () => ({
+// route modules are reached through the server entry's own route map, keyed by
+// the router-root prefixed path its `import.meta.glob` produces
+const routeKey = `/app/${pageRoute.file.slice(2)}`
+
+const makeServerEntry =
+  (importPage: () => Promise<any> = async () => ({})) =>
+  async () => ({
     default: {
       render: () => '<html></html>',
+      options: { routes: { [routeKey]: importPage } },
     },
-  }),
-  pages: {
-    [pageRoute.file]: async () => ({}),
-  },
+  })
+
+const lazyRoutes = {
+  serverEntry: makeServerEntry(),
   api: {
     [apiRoute.page]: async () => ({
       HEAD: () => new Response(null, { status: 204 }),
@@ -77,7 +84,7 @@ const lazyRoutes = {
 function createHandler() {
   vi.stubEnv('ONE_BUFFERED_SSR', '1')
   return createWorkerHandler({
-    oneOptions: { web: { defaultRenderMode: 'ssr' } },
+    oneOptions: { router: { root: 'app' }, web: { defaultRenderMode: 'ssr' } },
     buildInfo,
     lazyRoutes,
   }).handleRequest
@@ -127,17 +134,15 @@ describe('createWorkerHandler', () => {
     vi.stubEnv('ONE_BUFFERED_SSR', '1')
     let imports = 0
     const handleRequest = createWorkerHandler({
-      oneOptions: { web: { defaultRenderMode: 'ssr' } },
+      oneOptions: { router: { root: 'app' }, web: { defaultRenderMode: 'ssr' } },
       buildInfo,
       disableModuleCache: true,
       lazyRoutes: {
         ...lazyRoutes,
-        pages: {
-          [pageRoute.file]: async () => {
-            imports += 1
-            return {}
-          },
-        },
+        serverEntry: makeServerEntry(async () => {
+          imports += 1
+          return {}
+        }),
       },
     }).handleRequest
 

package/src/server/workerHandler.ts

@@ -15,21 +15,23 @@ import {
 } from '../createHandleRequest'
 import type { RenderAppProps } from '../types'
 import { getPathFromLoaderPath } from '../utils/cleanUrl'
+import { getRouterRootFromOneOptions } from '../utils/getRouterRootFromOneOptions'
 import { isResponse } from '../utils/isResponse'
 import { resolveResponse } from '../vite/resolveResponse'
 import type { One } from '../vite/types'
 import type { RouteInfoCompiled } from './createRoutesManifest'
+import { getRouteExportsFromEntry } from './routeExportsFromEntry'
 import { setSSRLoaderData } from './ssrLoaderData'
 import { getFetchStaticHtml } from './staticHtmlFetcher'
 
 export type LazyRoutes = {
+  pages?: Record<string, () => Promise<any>>
   serverEntry: () => Promise<{
     default: {
       render: (props: any) => any
       renderStream?: (props: any) => Promise<ReadableStream>
     }
   }>
-  pages: Record<string, () => Promise<any>>
   api: Record<string, () => Promise<any>>
   middlewares: Record<string, () => Promise<any>>
 }
@@ -46,6 +48,7 @@ type WorkerHandlerOptions = {
 export function createWorkerHandler(options: WorkerHandlerOptions) {
   const { oneOptions } = options
   const disableModuleCache = !!options.disableModuleCache
+  const routerRoot = getRouterRootFromOneOptions(oneOptions)
 
   // mutable state for route swapping
   let currentLazyRoutes = options.lazyRoutes
@@ -95,13 +98,21 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
   let renderStream: ((props: RenderAppProps) => Promise<ReadableStream>) | null = null
   let renderLoading: Promise<void> | null = null
   let renderGeneration = 0
+  let entryLoading: Promise<any> | null = null
+
+  // route modules are resolved through the built server entry, see
+  // routeExportsFromEntry
+  function loadServerEntry(): Promise<any> {
+    if (!entryLoading) entryLoading = currentLazyRoutes.serverEntry()
+    return entryLoading
+  }
 
   function ensureRenderLoaded(): void | Promise<void> {
     if (render) return
     if (renderLoading) return renderLoading
     const gen = ++renderGeneration
     renderLoading = (async () => {
-      const entry = await currentLazyRoutes.serverEntry()
+      const entry = await loadServerEntry()
       // if updateRoutes was called while we were loading, discard stale entry
       if (gen !== renderGeneration) return
       render = entry.default.render as any
@@ -150,13 +161,19 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
       let routeExported: any
       if (!disableModuleCache && moduleImportCache.has(cacheKey)) {
         routeExported = moduleImportCache.get(cacheKey)
-      } else if (lazyKey && currentLazyRoutes.pages[lazyKey]) {
-        routeExported = await currentLazyRoutes.pages[lazyKey]()
+      } else if (currentLazyRoutes.pages?.[cacheKey]) {
+        routeExported = await currentLazyRoutes.pages[cacheKey]()
         if (!disableModuleCache) moduleImportCache.set(cacheKey, routeExported)
       } else {
-        console.warn(`[one/worker] no lazy route for ${cacheKey}`)
-        if (!disableModuleCache) loaderCache.set(cacheKey, null)
-        return null
+        routeExported = lazyKey
+          ? await getRouteExportsFromEntry(await loadServerEntry(), routerRoot, lazyKey)
+          : null
+        if (!routeExported) {
+          console.warn(`[one/worker] no lazy route for ${cacheKey}`)
+          if (!disableModuleCache) loaderCache.set(cacheKey, null)
+          return null
+        }
+        if (!disableModuleCache) moduleImportCache.set(cacheKey, routeExported)
       }
 
       const loader = routeExported?.loader || null
@@ -797,6 +814,7 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
     render = null
     renderStream = null
     renderLoading = null
+    entryLoading = null
   }
 
   return { handleRequest, updateRoutes }

package/src/views/ScrollBehavior.tsx

@@ -1,6 +1,10 @@
 import { useEffect } from 'react'
 import { setLastAction } from '../router/lastAction'
-import { routeInfo, subscribeToLoadingState, subscribeToRootState } from '../router/router'
+import {
+  routeInfo,
+  subscribeToLoadingState,
+  subscribeToRootState,
+} from '../router/router'
 
 const KEY = 'one-sr'
 const GROUP_KEY = 'one-sr-groups'

package/src/vite/cloudflareWranglerConfig.ts

@@ -122,9 +122,10 @@ export function hasUserWranglerConfig(root: string): boolean {
   return false
 }
 
-function parseUserWranglerFile(
-  configPath: string
-): { path: string; config: Record<string, JsonValue> } {
+function parseUserWranglerFile(configPath: string): {
+  path: string
+  config: Record<string, JsonValue>
+} {
   const contents = readFileSync(configPath, 'utf-8')
   let parsed: unknown
   try {
@@ -242,7 +243,10 @@ export function isExperimentalWorkerDevEnabled(): boolean {
 
 export function shouldEnableWorkerdDev(deploy: unknown, root: string): boolean {
   if (!isExperimentalWorkerDevEnabled()) return false
-  const target = typeof deploy === 'string' ? deploy : (deploy as { target?: string } | undefined)?.target
+  const target =
+    typeof deploy === 'string'
+      ? deploy
+      : (deploy as { target?: string } | undefined)?.target
   if (target === 'cloudflare') return true
   return hasUserWranglerConfig(root)
 }

package/src/vite/one.ts

@@ -34,7 +34,10 @@ import { SSRCSSPlugin } from './plugins/SSRCSSPlugin'
 import { virtualEntryId } from './plugins/virtualEntryConstants'
 import { createVirtualEntry } from './plugins/virtualEntryPlugin'
 import { environmentGuardPlugin } from './plugins/environmentGuardPlugin'
-import { createWorkerdDevPlugins, shouldEnableWorkerdDev } from './plugins/workerdDevPlugin'
+import {
+  createWorkerdDevPlugins,
+  shouldEnableWorkerdDev,
+} from './plugins/workerdDevPlugin'
 import type { One } from './types'
 
 type MetroOptions = MetroPluginOptions
@@ -837,11 +840,13 @@ export function one(options: One.PluginOptions = {}): PluginOption {
   ] satisfies Plugin[]
 
   // TODO move to single config and through environments
-  const nativeWebDevAndProdPlugsin: Plugin[] = [clientTreeShakePlugin()]
+  const nativeWebDevAndProdPlugsin: Plugin[] = [clientTreeShakePlugin({ routerRoot })]
 
   // TODO make this passed into vxrn through real API
   if (!nativeDisabled) {
-    globalThis.__vxrnAddNativePlugins = [clientTreeShakePlugin({ runtime: 'rolldown' })]
+    globalThis.__vxrnAddNativePlugins = [
+      clientTreeShakePlugin({ runtime: 'rolldown', routerRoot }),
+    ]
   }
   globalThis.__vxrnAddWebPluginsProd = devAndProdPlugins
 

package/src/vite/plugins/clientTreeShakePlugin.test.ts

@@ -148,6 +148,34 @@ export default function Layout() {
       expect(result!.code).not.toContain('__vxrn__loader__')
     })
 
+    it('should strip a custom router root from the loader stub routeId', async () => {
+      const code = `
+import { serverOnlyModule } from 'server-only-pkg'
+import { useLoader } from 'one'
+
+export const loader = async () => {
+  return serverOnlyModule()
+}
+
+export default function Page() {
+  const data = useLoader(loader)
+  return data
+}
+`
+      const result = await transformTreeShakeClient(
+        code,
+        '/project/app-sootsim/(marketing)/changelog/index+ssg.tsx',
+        '/project',
+        'app-sootsim'
+      )
+      expect(result).toBeDefined()
+      // buildPage looks the stub up by the route contextKey, which is relative
+      // to the configured router root rather than to a hardcoded app/
+      expect(result!.code).toContain(
+        'export function loader() {return "./(marketing)/changelog/index+ssg.tsx"}'
+      )
+    })
+
     it('should embed routeId with render mode suffix in loader stub', async () => {
       const code = `
 import { serverOnlyModule } from 'server-only-pkg'

package/src/vite/plugins/clientTreeShakePlugin.ts

@@ -54,8 +54,13 @@ function restoreTypeImports(ast: t.File, typeImports: t.ImportDeclaration[]) {
 export const clientTreeShakePlugin = (opts?: {
   // 'rolldown' when used in the native rolldown DevEngine (no vite environment context)
   runtime?: 'vite' | 'rolldown'
+  // the configured router root (One.PluginOptions.router.root), relative to the
+  // project root. the loader stub's routeId is built off it, so it must be the
+  // real one or buildPage cannot match the stub back to the route.
+  routerRoot?: string
 }): Plugin => {
   const runtime = opts?.runtime ?? 'vite'
+  const routerRoot = opts?.routerRoot ?? 'app'
 
   return {
     name: 'one-client-tree-shake',
@@ -81,7 +86,7 @@ export const clientTreeShakePlugin = (opts?: {
           return
         }
 
-        const out = await transformTreeShakeClient(code, id, process.cwd())
+        const out = await transformTreeShakeClient(code, id, process.cwd(), routerRoot)
 
         return out
       },
@@ -89,7 +94,12 @@ export const clientTreeShakePlugin = (opts?: {
   } satisfies Plugin
 }
 
-export async function transformTreeShakeClient(code: string, id: string, root?: string) {
+export async function transformTreeShakeClient(
+  code: string,
+  id: string,
+  root?: string,
+  routerRoot = 'app'
+) {
   if (!/generateStaticParams|loader/.test(code)) {
     return
   }
@@ -199,10 +209,13 @@ export async function transformTreeShakeClient(code: string, id: string, root?:
           .map((key) => {
             if (key === 'loader') {
               if (root) {
-                // compute routeId relative to the app/ directory to match route contextKey format
+                // compute routeId relative to the router root so it matches the
+                // route contextKey format buildPage looks the stub up by.
                 // contextKeys are like "./_layout.tsx", "./matches-test/page1+ssg.tsx"
                 const fromRoot = relative(root, id).replace(/\\/g, '/')
-                const routeId = './' + fromRoot.replace(/^app\//, '')
+                const prefix = routerRoot.replace(/^\.\//, '').replace(/\/$/, '') + '/'
+                const routeId =
+                  './' + (fromRoot.startsWith(prefix) ? fromRoot.slice(prefix.length) : fromRoot)
                 return makeLoaderRouteIdStub(routeId)
               }
               return EMPTY_LOADER_STRING

package/src/vite/plugins/fileSystemRouterPlugin.tsx

@@ -18,7 +18,6 @@ import { promiseWithResolvers } from '../../utils/promiseWithResolvers'
 import type { RouteIndex } from '../../utils/routeIndex'
 import { isRouteFileWatchEvent } from '../../utils/routeFileWatch'
 import { trackLoaderDependencies } from '../../utils/trackLoaderDependencies'
-import { replaceLoader } from '../../vite/replaceLoader'
 import type { One, RouteInfo } from '../../vite/types'
 import { setServerContext } from '../one-server-only'
 import { virtalEntryIdClient, virtualEntryId } from './virtualEntryConstants'
@@ -561,14 +560,6 @@ export function createFileSystemRouterPlugin(
             }
           }
 
-          if (loaderData) {
-            // add loader back in!
-            transformedJS = replaceLoader({
-              code: transformedJS,
-              loaderData,
-            })
-          }
-
           const platform = url.searchParams.get('platform')
 
           if (platform === 'ios' || platform === 'android' || platform === 'native') {
@@ -582,10 +573,13 @@ export function createFileSystemRouterPlugin(
               )
             }
 
-            // [3] Just use a simple function to return the loader data for now.
-            const nativeTransformedJS = `exports.loader = () => (${JSON.stringify(loaderData)});`
+            return `exports.loader = () => (${JSON.stringify(loaderData)});`
+          }
 
-            return nativeTransformedJS
+          if (loaderData) {
+            // the client only reads loader() off this module, so serve the data
+            // alone instead of the whole route module with its stub rewritten
+            return `export function loader(){return ${JSON.stringify(loaderData)}}`
           }
 
           return transformedJS

package/src/vite/plugins/virtualEntryPlugin.ts

@@ -211,12 +211,12 @@ export function createVirtualEntry(options: {
           const serverSpaBuildGlobs = serverSpaRouteFiles.map(
             (file) => `/${options.root}/${file}`
           )
+          const serverSpaExportGlob = (name: string) =>
+            `  ${name}: import.meta.glob(${JSON.stringify(serverSpaBuildGlobs)}, { exhaustive: true, import: '${name}', query: '?one-spa-build' })`
           const serverSpaBuildRoutes = serverSpaBuildGlobs.length
-            ? `{
-  loader: import.meta.glob(${JSON.stringify(serverSpaBuildGlobs)}, { exhaustive: true, import: 'loader', query: '?one-spa-build' }),
-  generateStaticParams: import.meta.glob(${JSON.stringify(serverSpaBuildGlobs)}, { exhaustive: true, import: 'generateStaticParams', query: '?one-spa-build' }),
-  sitemap: import.meta.glob(${JSON.stringify(serverSpaBuildGlobs)}, { exhaustive: true, import: 'sitemap', query: '?one-spa-build' })
-}`
+            ? `{\n${['loader', 'loaderCache', 'generateStaticParams', 'sitemap']
+                .map(serverSpaExportGlob)
+                .join(',\n')}\n}`
             : '{}'
           const webRouteGlobs = [
             ...routeGlobs,
@@ -301,9 +301,11 @@ if (typeof window !== 'undefined') {
   window.__oneRegisterPreloadedRoute = registerPreloadedRoute
 }
 
-// build-only spa exports generate route artifacts without exposing the page
-// component to the runtime server route map.
-export const oneBuildOnlySpaRoutes = ${serverSpaBuildRoutes}
+// a route that declares spa by filename or parent directory is stubbed out of
+// the route map below so the server never holds its page component. its
+// server-side exports come from here instead, one glob per export so the page
+// never comes with them.
+export const oneServerSpaRouteExports = ${serverSpaBuildRoutes}
 
 // globbing ${JSON.stringify(webRouteGlobs)}
 export default createApp({