one 1.25.12 → 1.25.13

package/src/server/workerHandler.test.ts

@@ -122,4 +122,27 @@ describe('createWorkerHandler', () => {
     expect(response).toBeInstanceOf(Response)
     expect(response?.status).toBe(204)
   })
+
+  it('disableModuleCache re-imports the page module on each request', async () => {
+    vi.stubEnv('ONE_BUFFERED_SSR', '1')
+    let imports = 0
+    const handleRequest = createWorkerHandler({
+      oneOptions: { web: { defaultRenderMode: 'ssr' } },
+      buildInfo,
+      disableModuleCache: true,
+      lazyRoutes: {
+        ...lazyRoutes,
+        pages: {
+          [pageRoute.file]: async () => {
+            imports += 1
+            return {}
+          },
+        },
+      },
+    }).handleRequest
+
+    await handleRequest(new Request('https://example.com/some-page'))
+    await handleRequest(new Request('https://example.com/some-page'))
+    expect(imports).toBeGreaterThan(1)
+  })
 })

package/src/server/workerHandler.ts

@@ -38,10 +38,14 @@ 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
 
   // mutable state for route swapping
   let currentLazyRoutes = options.lazyRoutes
@@ -137,25 +141,29 @@ 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)
+        if (!disableModuleCache) moduleImportCache.set(cacheKey, routeExported)
       } else {
         console.warn(`[one/worker] no lazy route for ${cacheKey}`)
-        loaderCache.set(cacheKey, null)
+        if (!disableModuleCache) loaderCache.set(cacheKey, null)
         return null
       }
 
       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
     })()
   }

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,248 @@
+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,7 @@ 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 +554,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 +872,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-'))

package/src/vite/plugins/fileSystemRouterPlugin.tsx

@@ -7,7 +7,7 @@ import type { Connect, Plugin, ViteDevServer } from 'vite'
 import { createServerModuleRunner, normalizePath } from 'vite'
 import type { ModuleRunner } from 'vite/module-runner'
 import { getSpaHeaderElements } from '../../constants'
-import { createHandleRequest } from '../../createHandleRequest'
+import { createHandleRequest } from '../../createDevHandleRequest'
 import type { RouteNode } from '../../router/Route' // used for type in runLoaderWithTracking
 import type { RenderAppProps } from '../../types'
 import { getPageExport } from '../../utils/getPageExport'
@@ -42,9 +42,6 @@ const routeTypeColors: Record<string, (s: string) => string> = {
   api: colors.magenta,
 }
 
-// server needs better dep optimization
-const USE_SERVER_ENV = false //!!process.env.USE_SERVER_ENV
-
 export function createFileSystemRouterPlugin(
   options: One.PluginOptions,
   routeIndex: RouteIndex
@@ -615,6 +612,11 @@ export function createFileSystemRouterPlugin(
       handleRequest = createRequestHandler()
       ssgHtmlCache.clear()
       needsRouteRefresh = true
+      const workerGraph = server?.environments.worker?.moduleGraph
+      const workerEntry = workerGraph?.getModuleById('\0virtual:one-workerd-dev-entry')
+      if (workerGraph && workerEntry) {
+        workerGraph.invalidateModule(workerEntry)
+      }
     } catch (error) {
       console.warn(`[one] Failed to rebuild routes after ${changedPath} changed.`, error)
     }
@@ -708,10 +710,14 @@ export function createFileSystemRouterPlugin(
         preloads = ['/bundledDevClient.mjs', '/assets/_virtual_one-entry.js']
       }
 
-      // change this to .server to test using the indepedently scoped env
-      runner = createServerModuleRunner(
-        USE_SERVER_ENV ? server.environments.server : server.environments.ssr
-      )
+      const workerDev = !!server.environments.worker
+
+      // workerd-backed worker env handles web requests via @cloudflare/vite-plugin
+      // middleware (node req/res <-> fetch). the node module runner is only for
+      // the default (flag off) path.
+      if (!workerDev) {
+        runner = createServerModuleRunner(server.environments.ssr)
+      }
 
       const appDir = path.resolve(process.cwd(), getRouterRootFromOneOptions(options))
 
@@ -762,6 +768,12 @@ export function createFileSystemRouterPlugin(
       // Vite's transform middleware so that we can focus on handling the requests
       // we're interested in.
       return () => {
+        if (workerDev) {
+          // @cloudflare/vite-plugin already dispatches the request into workerd.
+          // do not run the node handler alongside it.
+          return
+        }
+
         // packager status fallback — runs after one's routing so user-defined
         // /status routes, +api handlers, and custom middleware take priority.
         // only fires if nothing else handled the request.

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

@@ -194,6 +194,19 @@ export const registerPreloadedRoute = () => {}`
       expect(code).not.toContain('__oneGetSetupPromise')
     })
 
+    it('worker environment uses the server setupFile like ssr', () => {
+      const plugin = createVirtualEntry({
+        ...base,
+        setupFile: {
+          client: './src/setupClient.ts',
+          server: './src/setupServer.ts',
+        },
+      })
+      const code = loadEntry(plugin, 'worker', 'serve')
+      expect(code).toContain('import "./src/setupServer.ts"')
+      expect(code).not.toContain('__oneGetSetupPromise')
+    })
+
     it('no setupFile produces no import', () => {
       const plugin = createVirtualEntry(base)
       const code = loadEntry(plugin, 'ssr')

package/src/vite/plugins/virtualEntryPlugin.ts

@@ -88,6 +88,7 @@ function getSetupFileImport(
   const envMap: Record<string, keyof NormalizedSetupFiles> = {
     client: 'client',
     ssr: 'server',
+    worker: 'server',
     ios: 'ios',
     android: 'android',
   }
@@ -170,7 +171,8 @@ export function createVirtualEntry(options: {
       handler(id) {
         if (id === resolvedVirtualEntryId) {
           const isNative = isNativeEnvironment(this.environment)
-          const isSSR = this.environment.name === 'ssr'
+          const isSSR =
+            this.environment.name === 'ssr' || this.environment.name === 'worker'
           const serverSpaRouteFiles = isSSR
             ? options.routeIndex
                 .getPaths()