one 1.25.12 → 1.25.15

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>>
 }
@@ -38,10 +40,15 @@ type WorkerHandlerOptions = {
   oneOptions: One.PluginOptions
   buildInfo: One.BuildInfo
   lazyRoutes: LazyRoutes
+  // when true, skip the module/loader caches so vite hmr of a route file is
+  // visible on the next request. production omits this.
+  disableModuleCache?: boolean
 }
 
 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
@@ -91,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
@@ -137,25 +152,35 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
     lazyKey: string | undefined
   ): Function | null | Promise<Function | null> {
     const cacheKey = lazyKey || ''
-    const cached = loaderCache.get(cacheKey)
-    if (cached !== undefined) return cached
+    if (!disableModuleCache) {
+      const cached = loaderCache.get(cacheKey)
+      if (cached !== undefined) return cached
+    }
 
     return (async () => {
       let routeExported: any
-      if (moduleImportCache.has(cacheKey)) {
+      if (!disableModuleCache && moduleImportCache.has(cacheKey)) {
         routeExported = moduleImportCache.get(cacheKey)
-      } else if (lazyKey && currentLazyRoutes.pages[lazyKey]) {
-        routeExported = await currentLazyRoutes.pages[lazyKey]()
-        moduleImportCache.set(cacheKey, routeExported)
+      } 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}`)
-        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
-      loaderCache.set(cacheKey, loader)
-      loaderCacheFnMap.set(cacheKey, routeExported?.loaderCache ?? null)
+      if (!disableModuleCache) {
+        loaderCache.set(cacheKey, loader)
+        loaderCacheFnMap.set(cacheKey, routeExported?.loaderCache ?? null)
+      }
       return loader
     })()
   }
@@ -789,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.test.ts

@@ -0,0 +1,101 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+import {
+  createCloudflareWranglerConfig,
+  isExperimentalWorkerDevEnabled,
+  loadUserWranglerConfigSync,
+  shouldEnableWorkerdDev,
+} from './cloudflareWranglerConfig'
+
+describe('createCloudflareWranglerConfig', () => {
+  it('synthesizes a worker config when no user wrangler file exists', () => {
+    const config = createCloudflareWranglerConfig('my-app')
+    expect(config.name).toBe('my-app')
+    expect(config.main).toBe('worker.js')
+    expect(config.compatibility_flags).toEqual(['nodejs_compat'])
+    expect(config.find_additional_modules).toBe(true)
+    expect(config.assets).toEqual({
+      directory: 'client',
+      binding: 'ASSETS',
+      run_worker_first: true,
+    })
+  })
+
+  it('merges user wrangler.jsonc the same way the cloudflare build does', () => {
+    const config = createCloudflareWranglerConfig('generated-name', {
+      name: 'test-cloudflare-user-config',
+      compatibility_date: '2025-01-01',
+      compatibility_flags: ['nodejs_als'],
+      vars: { CUSTOM_VALUE: 'from-root-config' },
+      assets: { html_handling: 'auto-trailing-slash' },
+      rules: [{ type: 'ESModule', globs: ['./extra/**/*.js'], fallthrough: true }],
+    })
+
+    expect(config.name).toBe('test-cloudflare-user-config')
+    expect(config.main).toBe('worker.js')
+    expect(config.compatibility_date).toBe('2025-01-01')
+    expect(config.compatibility_flags).toEqual(['nodejs_compat', 'nodejs_als'])
+    expect(config.vars).toEqual({ CUSTOM_VALUE: 'from-root-config' })
+    expect(config.assets).toEqual({
+      html_handling: 'auto-trailing-slash',
+      directory: 'client',
+      binding: 'ASSETS',
+      run_worker_first: true,
+    })
+    expect(config.rules).toEqual([
+      { type: 'ESModule', globs: ['./server/**/*.js'], fallthrough: true },
+      { type: 'ESModule', globs: ['./api/**/*.js'], fallthrough: true },
+      { type: 'ESModule', globs: ['./middlewares/**/*.js'], fallthrough: true },
+      { type: 'ESModule', globs: ['./assets/**/*.js'], fallthrough: true },
+      { type: 'ESModule', globs: ['./extra/**/*.js'], fallthrough: true },
+    ])
+  })
+})
+
+describe('shouldEnableWorkerdDev', () => {
+  const previous = process.env.ONE_EXPERIMENTAL_WORKER_DEV
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env.ONE_EXPERIMENTAL_WORKER_DEV
+    else process.env.ONE_EXPERIMENTAL_WORKER_DEV = previous
+  })
+
+  it('is off when the flag is unset', () => {
+    delete process.env.ONE_EXPERIMENTAL_WORKER_DEV
+    expect(isExperimentalWorkerDevEnabled()).toBe(false)
+    expect(shouldEnableWorkerdDev('cloudflare', '/tmp')).toBe(false)
+  })
+
+  it('is off when the flag is on but the app has no cloudflare target or wrangler file', () => {
+    process.env.ONE_EXPERIMENTAL_WORKER_DEV = '1'
+    const root = mkdtempSync(join(tmpdir(), 'one-workerd-flag-'))
+    try {
+      expect(shouldEnableWorkerdDev(undefined, root)).toBe(false)
+      expect(shouldEnableWorkerdDev('node', root)).toBe(false)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+
+  it('is on when the flag is set and deploy is cloudflare', () => {
+    process.env.ONE_EXPERIMENTAL_WORKER_DEV = '1'
+    expect(shouldEnableWorkerdDev('cloudflare', '/tmp-does-not-exist')).toBe(true)
+    expect(shouldEnableWorkerdDev({ target: 'cloudflare' }, '/tmp-does-not-exist')).toBe(
+      true
+    )
+  })
+
+  it('is on when the flag is set and wrangler.jsonc exists', () => {
+    process.env.ONE_EXPERIMENTAL_WORKER_DEV = '1'
+    const root = mkdtempSync(join(tmpdir(), 'one-workerd-wrangler-'))
+    try {
+      writeFileSync(join(root, 'wrangler.jsonc'), '{ "name": "from-file" }\n')
+      expect(shouldEnableWorkerdDev(undefined, root)).toBe(true)
+      expect(loadUserWranglerConfigSync(root)?.config.name).toBe('from-file')
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+    }
+  })
+})

package/src/vite/cloudflareWranglerConfig.ts

@@ -0,0 +1,252 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join, relative } from 'node:path'
+import FSExtra from 'fs-extra'
+
+export type JsonPrimitive = string | number | boolean | null
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue }
+
+export const GENERATED_CLOUDFLARE_WRANGLER_RULES: JsonValue[] = [
+  { type: 'ESModule', globs: ['./server/**/*.js'], fallthrough: true },
+  { type: 'ESModule', globs: ['./api/**/*.js'], fallthrough: true },
+  { type: 'ESModule', globs: ['./middlewares/**/*.js'], fallthrough: true },
+  { type: 'ESModule', globs: ['./assets/**/*.js'], fallthrough: true },
+]
+
+export function isPlainObject(value: unknown): value is Record<string, JsonValue> {
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+}
+
+function mergeJsonObjects(
+  base: Record<string, JsonValue>,
+  overrides: Record<string, JsonValue>
+): Record<string, JsonValue> {
+  const merged: Record<string, JsonValue> = { ...base }
+
+  for (const [key, value] of Object.entries(overrides)) {
+    const baseValue = merged[key]
+    if (isPlainObject(baseValue) && isPlainObject(value)) {
+      merged[key] = mergeJsonObjects(baseValue, value)
+    } else {
+      merged[key] = value
+    }
+  }
+
+  return merged
+}
+
+function dedupeJsonValues<T extends JsonValue>(values: T[]): T[] {
+  const seen = new Set<string>()
+  return values.filter((value) => {
+    const key = JSON.stringify(value)
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
+function mergeCloudflareCompatibilityFlags(flags: unknown): string[] {
+  const userFlags = Array.isArray(flags)
+    ? flags.filter((flag): flag is string => typeof flag === 'string')
+    : []
+
+  return dedupeJsonValues<string>(['nodejs_compat', ...userFlags])
+}
+
+function mergeCloudflareRules(rules: unknown): JsonValue[] {
+  const userRules = Array.isArray(rules)
+    ? rules.filter((rule): rule is JsonValue => isPlainObject(rule))
+    : []
+
+  return dedupeJsonValues<JsonValue>([
+    ...GENERATED_CLOUDFLARE_WRANGLER_RULES,
+    ...userRules,
+  ])
+}
+
+// minimal JSONC parser: strips line/block comments (string-aware) and trailing
+// commas, then runs JSON.parse. sufficient for small hand-written config files.
+function parseJsonc(text: string): unknown {
+  let out = ''
+  let i = 0
+  let inString = false
+  let quote = ''
+  while (i < text.length) {
+    const ch = text[i]
+    const next = text[i + 1]
+    if (inString) {
+      if (ch === '\\') {
+        out += ch + (next ?? '')
+        i += 2
+        continue
+      }
+      if (ch === quote) inString = false
+      out += ch
+      i++
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      inString = true
+      quote = ch
+      out += ch
+      i++
+      continue
+    }
+    if (ch === '/' && next === '/') {
+      while (i < text.length && text[i] !== '\n') i++
+      continue
+    }
+    if (ch === '/' && next === '*') {
+      i += 2
+      while (i < text.length - 1 && !(text[i] === '*' && text[i + 1] === '/')) i++
+      i += 2
+      continue
+    }
+    out += ch
+    i++
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, '$1'))
+}
+
+const WRANGLER_FILE_NAMES = ['wrangler.jsonc', 'wrangler.json'] as const
+
+function wranglerCandidateRoots(root: string): string[] {
+  return [...new Set([root, process.cwd()])]
+}
+
+export function hasUserWranglerConfig(root: string): boolean {
+  for (const candidateRoot of wranglerCandidateRoots(root)) {
+    for (const fileName of WRANGLER_FILE_NAMES) {
+      if (existsSync(join(candidateRoot, fileName))) return true
+    }
+  }
+  return false
+}
+
+function parseUserWranglerFile(configPath: string): {
+  path: string
+  config: Record<string, JsonValue>
+} {
+  const contents = readFileSync(configPath, 'utf-8')
+  let parsed: unknown
+  try {
+    parsed = parseJsonc(contents)
+  } catch (err) {
+    throw new Error(
+      `Failed to parse ${relative(process.cwd(), configPath)}: ${(err as Error).message}`
+    )
+  }
+
+  if (!isPlainObject(parsed)) {
+    throw new Error(
+      `Expected ${relative(process.cwd(), configPath)} to contain a top-level JSON object`
+    )
+  }
+
+  return {
+    path: configPath,
+    config: parsed,
+  }
+}
+
+export function loadUserWranglerConfigSync(
+  root: string
+): { path: string; config: Record<string, JsonValue> } | null {
+  for (const candidateRoot of wranglerCandidateRoots(root)) {
+    for (const fileName of WRANGLER_FILE_NAMES) {
+      const configPath = join(candidateRoot, fileName)
+      if (!existsSync(configPath)) continue
+      return parseUserWranglerFile(configPath)
+    }
+  }
+  return null
+}
+
+export async function loadUserWranglerConfig(
+  root: string
+): Promise<{ path: string; config: Record<string, JsonValue> } | null> {
+  const candidateRoots = wranglerCandidateRoots(root)
+
+  for (const candidateRoot of candidateRoots) {
+    for (const fileName of WRANGLER_FILE_NAMES) {
+      const configPath = join(candidateRoot, fileName)
+      if (!(await FSExtra.pathExists(configPath))) {
+        continue
+      }
+      return parseUserWranglerFile(configPath)
+    }
+  }
+
+  return null
+}
+
+export function createCloudflareWranglerConfig(
+  projectName: string,
+  userConfig?: Record<string, JsonValue>
+): Record<string, JsonValue> {
+  const generatedConfig: Record<string, JsonValue> = {
+    name: projectName,
+    main: 'worker.js',
+    compatibility_date: '2024-12-05',
+    compatibility_flags: ['nodejs_compat'],
+    find_additional_modules: true,
+    rules: GENERATED_CLOUDFLARE_WRANGLER_RULES,
+    assets: {
+      directory: 'client',
+      binding: 'ASSETS',
+      run_worker_first: true,
+    },
+  }
+
+  const mergedConfig = userConfig
+    ? mergeJsonObjects(generatedConfig, userConfig)
+    : generatedConfig
+
+  mergedConfig.main = 'worker.js'
+  mergedConfig.find_additional_modules = true
+  mergedConfig.compatibility_flags = mergeCloudflareCompatibilityFlags(
+    mergedConfig.compatibility_flags
+  )
+  mergedConfig.rules = mergeCloudflareRules(mergedConfig.rules)
+  mergedConfig.assets = {
+    ...(isPlainObject(mergedConfig.assets) ? mergedConfig.assets : {}),
+    directory: 'client',
+    binding: 'ASSETS',
+    run_worker_first: true,
+  }
+
+  return mergedConfig
+}
+
+export function getCloudflareProjectNameSync(root: string): string {
+  try {
+    const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8'))
+    if (pkg.name) {
+      return String(pkg.name).replace(/^@[^/]+\//, '')
+    }
+  } catch {}
+  return 'one-app'
+}
+
+export 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'
+}
+
+export function isExperimentalWorkerDevEnabled(): boolean {
+  return process.env.ONE_EXPERIMENTAL_WORKER_DEV === '1'
+}
+
+export function shouldEnableWorkerdDev(deploy: unknown, root: string): boolean {
+  if (!isExperimentalWorkerDevEnabled()) return false
+  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,6 +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 type { One } from './types'
 
 type MetroOptions = MetroPluginOptions
@@ -553,7 +557,11 @@ export function one(options: One.PluginOptions = {}): PluginOption {
       resolveId: {
         filter: { id: RN_DEEP_IMPORT_RE },
         handler(source) {
-          if (this.environment?.name === 'client' || this.environment?.name === 'ssr') {
+          if (
+            this.environment?.name === 'client' ||
+            this.environment?.name === 'ssr' ||
+            this.environment?.name === 'worker'
+          ) {
             return '\0rn-empty-module'
           }
         },
@@ -867,7 +875,12 @@ export function one(options: One.PluginOptions = {}): PluginOption {
     return inspector ? sourceInspectorPlugin({ editor }) : []
   })()
 
+  const workerdDevPlugins = shouldEnableWorkerdDev(options.web?.deploy, root)
+    ? createWorkerdDevPlugins(options, root, routeIndex)
+    : []
+
   return [
+    ...workerdDevPlugins,
     ...vxrnPlugins,
     ...devAndProdPlugins,
     ...inspectorPlugins,

package/src/vite/plugins/SSRCSSPlugin.ts

@@ -1,4 +1,4 @@
-import type { Plugin, ViteDevServer } from 'vite'
+import type { ModuleNode, Plugin, ViteDevServer } from 'vite'
 import { VIRTUAL_SSR_CSS_ENTRY, VIRTUAL_SSR_CSS_HREF } from '../../constants'
 
 // thanks to hi-ogawa https://github.com/hi-ogawa/vite-plugins/tree/main/packages/ssr-css
@@ -152,6 +152,21 @@ async function collectStyleUrls(
 ): Promise<string[]> {
   const visited = new Set<string>()
 
+  // every module in importedModules already carries the id vite resolved when
+  // it entered the graph, so walk them directly. resolveUrl runs the whole
+  // plugin container and was awaited once per import EDGE rather than once per
+  // module, which on a large app is the entire cost of serving this stylesheet.
+  // the walk is an explicit stack so a deep import chain cannot overflow.
+  function walk(root: ModuleNode) {
+    const stack = [root]
+    while (stack.length) {
+      const mod = stack.pop()!
+      if (!mod.id || mod.url.includes('.server.') || visited.has(mod.id)) continue
+      visited.add(mod.id)
+      for (const childMod of mod.importedModules) stack.push(childMod)
+    }
+  }
+
   async function traverse(url: string) {
     if (url.includes('.server.')) return
     const [, id] = await server.moduleGraph.resolveUrl(url)
@@ -163,7 +178,7 @@ async function collectStyleUrls(
     if (!mod) {
       return
     }
-    await Promise.all([...mod.importedModules].map((childMod) => traverse(childMod.url)))
+    for (const childMod of mod.importedModules) walk(childMod)
   }
 
   // ensure vite's import analysis is ready _only_ for top entries to not go too aggresive

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

@@ -135,6 +135,11 @@ describe('environmentGuardPlugin', () => {
       expect(result).toBe('export {}')
     })
 
+    it('web-only: allowed in worker', () => {
+      const result = loadEnvironmentGuard('\0one-env-guard:web-only:worker:server')
+      expect(result).toBe('export {}')
+    })
+
     it('web-only: forbidden in ios', () => {
       const result = loadEnvironmentGuard('\0one-env-guard:web-only:ios:unknown')
       expect(result).toContain('throw new Error')

package/src/vite/plugins/environmentGuardPlugin.ts

@@ -35,11 +35,11 @@ const GUARD_SPECIFIERS = [
 const GUARD_SPECIFIERS_RE = new RegExp(`^(?:${GUARD_SPECIFIERS.join('|')})$`)
 
 type GuardSpecifier = (typeof GUARD_SPECIFIERS)[number]
-type ViteEnvironment = 'client' | 'ssr' | 'ios' | 'android'
+type ViteEnvironment = 'client' | 'ssr' | 'ios' | 'android' | 'worker'
 
 const ALLOWED_BY_NAME: Partial<Record<GuardSpecifier, readonly ViteEnvironment[]>> = {
   'native-only': ['ios', 'android'],
-  'web-only': ['client', 'ssr'],
+  'web-only': ['client', 'ssr', 'worker'],
 }
 
 const ALLOWED_BY_CONSUMER: Partial<Record<GuardSpecifier, 'server' | 'client'>> = {

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

@@ -124,6 +124,50 @@ describe('createFileSystemRouterPlugin', () => {
     )
   })
 
+  it('does not install the node request middleware when a worker environment exists', async () => {
+    process.env.IS_VXRN_CLI = '1'
+    tempRoot = mkdtempSync(path.join(tmpdir(), 'one-router-worker-'))
+    const appDir = path.join(tempRoot, 'app')
+    writeFileSync(path.join(tempRoot, 'package.json'), '{}\n')
+    mkdirSync(appDir)
+    writeFileSync(
+      path.join(appDir, 'index.tsx'),
+      'export default function Index() { return null }\n'
+    )
+
+    ;(globalThis as any).__vxrnPluginConfig__ = {
+      web: {
+        defaultRenderMode: 'ssg',
+      },
+    }
+
+    const { createRouteIndex } = await import('../../utils/routeIndex')
+    const { createFileSystemRouterPlugin } = await import('./fileSystemRouterPlugin')
+    const plugin = createFileSystemRouterPlugin(
+      {
+        router: { root: appDir },
+      },
+      createRouteIndex({ routerRoot: appDir })
+    )
+
+    const use = vi.fn()
+    const server = {
+      environments: {
+        ssr: {},
+        worker: { moduleGraph: { getModuleById: vi.fn() } },
+      },
+      middlewares: { use },
+      watcher: {
+        addListener: vi.fn(),
+        on: vi.fn(),
+      },
+    }
+
+    const installMiddlewares = (plugin as any).configureServer(server)
+    installMiddlewares()
+    expect(use).not.toHaveBeenCalled()
+  })
+
   it('caches dev ssg html until the module runner is invalidated', async () => {
     process.env.VITE_ENVIRONMENT = 'ssr'
     tempRoot = mkdtempSync(path.join(tmpdir(), 'one-router-ssg-cache-'))