onejs
diff --git a/‎packages/compiler/src/transformSWC.ts‎
Lines changed: 8 additions & 7 deletions b/‎packages/compiler/src/transformSWC.ts‎
Lines changed: 8 additions & 7 deletions
diff --git a/‎packages/one/src/cli/build.ts‎
Lines changed: 17 additions & 7 deletions b/‎packages/one/src/cli/build.ts‎
Lines changed: 17 additions & 7 deletions
diff --git a/‎packages/one/src/cli/buildPage.ts‎
Lines changed: 3 additions & 1 deletion b/‎packages/one/src/cli/buildPage.ts‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎packages/one/src/metro-config/getViteMetroPluginOptions.ts‎
Lines changed: 13 additions & 7 deletions b/‎packages/one/src/metro-config/getViteMetroPluginOptions.ts‎
Lines changed: 13 additions & 7 deletions
diff --git a/‎packages/one/src/server/oneServe.ts‎
Lines changed: 6 additions & 8 deletions b/‎packages/one/src/server/oneServe.ts‎
Lines changed: 6 additions & 8 deletions
diff --git a/‎packages/one/src/utils/posixPathContract.test.ts‎
Lines changed: 112 additions & 0 deletions b/‎packages/one/src/utils/posixPathContract.test.ts‎
Lines changed: 112 additions & 0 deletions
diff --git a/‎packages/one/src/utils/toServerOutputPath.test.ts‎
Lines changed: 53 additions & 0 deletions b/‎packages/one/src/utils/toServerOutputPath.test.ts‎
Lines changed: 53 additions & 0 deletions
@@ -1,4 +1,4 @@
-import { extname, sep } from 'node:path'
+import { extname } from 'node:path'
 import {
   type Output,
   type ParserConfig,
@@ -7,27 +7,28 @@ import {
   transform,
 } from '@swc/core'
 import { merge } from 'ts-deepmerge'
+import { normalizePath } from 'vite'
 import { configuration } from './configure'
 import { asyncGeneratorRegex, debug, parsers, runtimePublicPath } from './constants'
 import type { Options } from './types'
 
-const ignoreId = new RegExp(`node_modules\\${sep}(\\.vite|vite)\\${sep}`)
+// POSIX-only sentinel — Vite plugin context hands us forward-slash ids; the
+// other caller (patches.ts) hands native paths, so we normalize id below.
+const ignoreId = /node_modules\/(\.vite|vite)\//
 
 export async function transformSWC(
   id: string,
   code: string,
   options: Options & { es5?: boolean },
   swcOptions?: SWCOptions
 ) {
+  // unify caller contracts (Vite plugin: POSIX id; patches.ts: native id)
+  id = normalizePath(id.split('?')[0]).replace(normalizePath(process.cwd()), '')
+
   if (ignoreId.test(id)) {
     return
   }
 
-  id = id
-    .split('?')[0]
-    // fixes hmr
-    .replace(process.cwd(), '')
-
   if (id === runtimePublicPath) {
     return
   }
 
@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module'
 import { cpus } from 'node:os'
-import Path, { join, relative, resolve } from 'node:path'
+import Path, { join, posix, relative, resolve } from 'node:path'
 import { resolvePath } from '@vxrn/resolve'
 import FSExtra from 'fs-extra'
 import MicroMatch from 'micromatch'
@@ -282,7 +282,7 @@ process.on('uncaughtException', (err) => {
 process.on('unhandledRejection', (reason) => {
   try {
     process.stderr.write(
-      `[one build] unhandled rejection\n${formatErrorSafely(reason)}\n`,
+      `[one build] unhandled rejection\n${formatErrorSafely(reason)}\n`
     )
   } catch {}
   process.exit(1)
@@ -547,14 +547,15 @@ export async function build(args: {
                       chunkInfo.name,
                       Path.extname(chunkInfo.name)
                     )
-                    return Path.join(dir, `${name}-[hash].cjs`)
+                    // posix so nested-chunk fileNames stay forward-slash on Windows
+                    return posix.join(dir, `${name}-[hash].cjs`)
                   },
                   assetFileNames: (assetInfo) => {
                     const name = assetInfo.name ?? ''
                     const dir = Path.dirname(name)
                     const baseName = Path.basename(name, Path.extname(name))
                     const ext = Path.extname(name)
-                    return Path.join(dir, `${baseName}-[hash]${ext}`)
+                    return posix.join(dir, `${baseName}-[hash]${ext}`)
                   },
                 }),
           },
@@ -601,7 +602,12 @@ export async function build(args: {
       const outChunks = middlewareBuildInfo.output.filter((x) => x.type === 'chunk')
       const chunk = outChunks.find((x) => x.facadeModuleId === fullPath)
       if (!chunk) throw new Error(`internal err finding middleware`)
-      builtMiddlewares[middleware.file] = join(outDir, 'middlewares', chunk.fileName)
+      // posix so manifest entry stays forward-slash on Windows
+      builtMiddlewares[middleware.file] = posix.join(
+        outDir,
+        'middlewares',
+        chunk.fileName
+      )
     }
   }
 
@@ -1008,7 +1014,8 @@ export async function build(args: {
       })
     }
 
-    const serverJsPath = join(`${outDir}/server`, serverFileName)
+    // posix so downstream `.includes('${outDir}/server')` substring checks match on Windows
+    const serverJsPath = posix.join(outDir, 'server', serverFileName)
 
     let exported
     try {
@@ -1452,7 +1459,10 @@ export default {
         projectName,
         userWranglerConfig?.config
       )
-      wranglerInputConfig.main = relative(join(options.root, outDir), workerSrcPath)
+      // serialized wrangler config is diffed cross-platform; keep forward-slash
+      wranglerInputConfig.main = normalizePath(
+        relative(join(options.root, outDir), workerSrcPath)
+      )
 
       const wranglerInputPath = join(options.root, outDir, '_wrangler.input.jsonc')
       await FSExtra.writeFile(
 
@@ -1,5 +1,6 @@
 import { join } from 'node:path'
 import FSExtra from 'fs-extra'
+import { normalizePath } from 'vite'
 import * as constants from '../constants'
 import { LOADER_JS_POSTFIX_UNCACHED } from '../constants'
 import type { LoaderProps } from '../types'
@@ -64,8 +65,9 @@ export async function buildPage(
   recordTiming('getRender', performance.now() - t0)
 
   const htmlPath = `${path.endsWith('/') ? `${removeTrailingSlash(path)}/index` : path}.html`
+  // forward-slash for cross-platform manifest hygiene (matches serverJsPath)
   const clientJsPath = clientManifestEntry
-    ? join(clientDir, clientManifestEntry.file)
+    ? normalizePath(join(clientDir, clientManifestEntry.file))
     : ''
   const htmlOutPath = toAbsolute(join(staticDir, htmlPath))
   const preloadPath = getPreloadPath(path)
 
@@ -3,6 +3,7 @@ import path from 'node:path'
 import type { metroPlugin } from '@vxrn/vite-plugin-metro'
 import mm from 'micromatch'
 import tsconfigPaths from 'tsconfig-paths'
+import { normalizePath } from 'vite'
 import {
   API_ROUTE_GLOB_PATTERN,
   ROUTE_NATIVE_EXCLUSION_GLOB_PATTERNS,
@@ -232,9 +233,13 @@ export function getViteMetroPluginOptions({
         [
           'one/babel-plugin-one-router-metro',
           {
-            ONE_ROUTER_APP_ROOT_RELATIVE_TO_ENTRY: path.relative(
-              path.dirname(metroEntryPath),
-              path.join(projectRoot, relativeRouterRoot)
+            // both values are inlined by babel into metro-entry.js as JS module
+            // specifiers — Metro's isRelativeImport regex rejects `..\foo` on Windows
+            ONE_ROUTER_APP_ROOT_RELATIVE_TO_ENTRY: normalizePath(
+              path.relative(
+                path.dirname(metroEntryPath),
+                path.join(projectRoot, relativeRouterRoot)
+              )
             ),
             ONE_ROUTER_ROOT_FOLDER_NAME: relativeRouterRoot,
             ONE_ROUTER_REQUIRE_CONTEXT_REGEX_STRING: routerRequireContextRegexString,
@@ -247,10 +252,11 @@ export function getViteMetroPluginOptions({
                   ? setupFile
                   : setupFile.native || setupFile.ios || setupFile.android
               if (!nativeSetupFile) return undefined
-              // Return path relative to metro entry
-              return path.relative(
-                path.dirname(metroEntryPath),
-                path.join(projectRoot, nativeSetupFile)
+              return normalizePath(
+                path.relative(
+                  path.dirname(metroEntryPath),
+                  path.join(projectRoot, nativeSetupFile)
+                )
               )
             })(),
           },
 
@@ -1,7 +1,7 @@
 import type { Hono, MiddlewareHandler } from 'hono'
 import type { BlankEnv } from 'hono/types'
 import { readFile } from 'node:fs/promises'
-import { join } from 'node:path'
+import { join, posix } from 'node:path'
 import {
   CSS_PRELOAD_JS_POSTFIX,
   LOADER_JS_POSTFIX_UNCACHED,
@@ -17,6 +17,7 @@ import {
 import type { RenderAppProps } from '../types'
 import { getPathFromLoaderPath } from '../utils/cleanUrl'
 import { toAbsoluteUrl } from '../utils/toAbsolute'
+import { toServerOutputPath } from '../utils/toServerOutputPath'
 import type { One } from '../vite/types'
 import type { RouteInfoCompiled } from './createRoutesManifest'
 import { setSSRLoaderData } from './ssrLoaderData'
@@ -164,9 +165,7 @@ export async function oneServe(
     // cold path - async import
     return (async () => {
       const pathToResolve = serverPath || lazyKey || ''
-      const resolvedPath = pathToResolve.includes(`${outDir}/server`)
-        ? pathToResolve
-        : join('./', `${outDir}/server`, pathToResolve)
+      const resolvedPath = toServerOutputPath(pathToResolve, outDir)
 
       let routeExported: any
       if (moduleImportCache.has(cacheKey)) {
@@ -314,7 +313,8 @@ export async function oneServe(
       }
       // both vite and rolldown-vite replace brackets with underscores in output filenames
       const fileName = route.page.slice(1).replace(/\[/g, '_').replace(/\]/g, '_')
-      const apiFile = join(outDir, 'api', fileName + (apiCJS ? '.cjs' : '.js'))
+      // posix matches the serverJsPath/builtMiddlewares producer convention
+      const apiFile = posix.join(outDir, 'api', fileName + (apiCJS ? '.cjs' : '.js'))
       return await import(toAbsoluteUrl(apiFile))
     },
 
@@ -328,9 +328,7 @@ export async function oneServe(
 
     async handleLoader({ route, loaderProps }) {
       const routeFile = (route as any).routeFile || route.file
-      const serverPath = route.file.includes(`${outDir}/server`)
-        ? route.file
-        : join('./', `${outDir}/server`, route.file)
+      const serverPath = toServerOutputPath(route.file, outDir)
 
       let loader: Function | null
       try {
 
@@ -0,0 +1,112 @@
+// POSIX path contract tests — locks in the cross-platform behavior of the
+// Node primitives this PR's fixes depend on. If a future Node version
+// changes any of these, the failing test surfaces the regression before
+// the framework breaks on Windows again.
+
+import { posix } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { describe, expect, it } from 'vitest'
+import { normalizePath } from 'vite'
+import { toServerOutputPath } from './toServerOutputPath'
+
+describe('path.posix.join — forward-slash output on every platform', () => {
+  it('joins server-output paths', () => {
+    expect(posix.join('dist', 'server', 'foo.js')).toBe('dist/server/foo.js')
+  })
+
+  it('joins middleware-output paths', () => {
+    expect(posix.join('dist', 'middlewares', 'mw-hash.js')).toBe(
+      'dist/middlewares/mw-hash.js'
+    )
+  })
+
+  it('strips redundant `./` segments', () => {
+    expect(posix.join('./app', './_layout.tsx')).toBe('app/_layout.tsx')
+  })
+
+  it('produces a bare filename for a `.` directory component', () => {
+    expect(posix.join('.', 'foo-[hash].cjs')).toBe('foo-[hash].cjs')
+  })
+
+  it('preserves nested-chunk subdirectories', () => {
+    expect(posix.join('subdir', 'foo-[hash].cjs')).toBe('subdir/foo-[hash].cjs')
+  })
+})
+
+describe('pathToFileURL — canonical file:// URL specifier', () => {
+  it('produces a forward-slash href on every platform', () => {
+    const href = pathToFileURL('/proj/src/setup.ts').href
+    expect(href.startsWith('file://')).toBe(true)
+    expect(href.includes('\\')).toBe(false)
+  })
+
+  it('round-trips through JSON.stringify without backslashes leaking in', () => {
+    // The motivating defect: emitting `import "${absolutePath}"` puts
+    // backslashes into the generated JS source on Windows. A file:// URL
+    // does not.
+    const href = pathToFileURL('/proj/src/setup.ts').href
+    const stringified = JSON.stringify(href)
+    expect(stringified.includes('\\\\')).toBe(false)
+  })
+})
+
+describe('Vite normalizePath — converts on Windows, no-op on POSIX', () => {
+  it('preserves a forward-slash path unchanged', () => {
+    expect(normalizePath('/proj/src/foo.tsx')).toBe('/proj/src/foo.tsx')
+  })
+
+  it('converts backslashes (Windows-shaped input)', () => {
+    // normalizePath only converts on Windows hosts. We assert the contract
+    // shape — on Windows: backslashes converted; on POSIX: passthrough
+    // because backslash is a valid filename character.
+    const input = String.raw`C:\proj\src\foo.tsx`
+    const out = normalizePath(input)
+    if (process.platform === 'win32') {
+      expect(out).toBe('C:/proj/src/foo.tsx')
+    } else {
+      expect(out).toBe(input)
+    }
+  })
+})
+
+describe('toServerOutputPath — cross-platform parity', () => {
+  // toServerOutputPath uses path.posix.join + replace(/\\/g, '/') so the
+  // output must be byte-identical across platforms. The fact that we
+  // converted from Vite's normalizePath to this implementation was driven
+  // by a Linux Docker test failure during initial review.
+  const cases: Array<[string, string, string]> = [
+    ['foo.js', 'dist', 'dist/server/foo.js'],
+    ['subdir/bar.js', 'dist', 'dist/server/subdir/bar.js'],
+    ['dist/server/foo.js', 'dist', 'dist/server/foo.js'],
+    [String.raw`dist\server\foo.js`, 'dist', 'dist/server/foo.js'],
+    [String.raw`subdir\bar.js`, 'dist', 'dist/server/subdir/bar.js'],
+    ['foo/dist/server/bar.js', 'dist', 'dist/server/foo/dist/server/bar.js'],
+    ['dist/server', 'dist', 'dist/server'],
+    ['baz.js', 'build', 'build/server/baz.js'],
+  ]
+
+  for (const [input, outDir, expected] of cases) {
+    it(`("${input}", "${outDir}") → "${expected}"`, () => {
+      expect(toServerOutputPath(input, outDir)).toBe(expected)
+    })
+  }
+})
+
+describe('seed bug regression — SSR loader path doubling on Windows', () => {
+  // Direct regression test for the specific shape that hit production:
+  // build.ts:1031 minted `dist\server\assets\time_ssr-XXX.js` (native sep);
+  // oneServe.ts:168 then ran `.includes('dist/server')` on it (forward slash);
+  // the check missed; `join('./','dist/server','dist\\server\\...')` was
+  // called; result was `dist\server\dist\server\...` — passed to await import().
+  it('does not double-prefix backslash-shaped server-output input', () => {
+    const windowsShapedInput = String.raw`dist\server\assets\time_ssr-COqAsxju.js`
+    expect(toServerOutputPath(windowsShapedInput, 'dist')).toBe(
+      'dist/server/assets/time_ssr-COqAsxju.js'
+    )
+  })
+
+  it('does not double-prefix already-forward-slashed input', () => {
+    const posixInput = 'dist/server/assets/time_ssr-COqAsxju.js'
+    expect(toServerOutputPath(posixInput, 'dist')).toBe(posixInput)
+  })
+})
@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+
+import { toServerOutputPath } from './toServerOutputPath'
+
+describe('toServerOutputPath', () => {
+  it('prepends ${outDir}/server/ to bare filenames from Vite output', () => {
+    expect(toServerOutputPath('assets/loader-abc.js', 'dist')).toBe(
+      'dist/server/assets/loader-abc.js'
+    )
+  })
+
+  it('prepends ${outDir}/server/ to project-relative paths from the route tree', () => {
+    expect(toServerOutputPath('./pages/index.tsx', 'dist')).toBe(
+      'dist/server/pages/index.tsx'
+    )
+  })
+
+  it('returns input unchanged when it is already rooted under ${outDir}/server/', () => {
+    expect(toServerOutputPath('dist/server/assets/loader-abc.js', 'dist')).toBe(
+      'dist/server/assets/loader-abc.js'
+    )
+  })
+
+  it('treats backslashes as separators on every platform (the Windows path-doubling case)', () => {
+    // Simulates what `path.join` produces on Windows after the first prefix
+    // has been added by an earlier caller. The function must convert
+    // backslashes to forward slashes here regardless of host OS so the
+    // sentinel check matches and the prefix isn't doubled.
+    expect(toServerOutputPath('dist\\server\\assets\\loader-abc.js', 'dist')).toBe(
+      'dist/server/assets/loader-abc.js'
+    )
+  })
+
+  it('is idempotent: feeding the output back in returns the same value', () => {
+    const first = toServerOutputPath('assets/loader-abc.js', 'dist')
+    const second = toServerOutputPath(first, 'dist')
+    expect(second).toBe(first)
+  })
+
+  it('honors a custom outDir', () => {
+    expect(toServerOutputPath('assets/loader.js', 'build')).toBe(
+      'build/server/assets/loader.js'
+    )
+  })
+
+  it('does not false-positive on inputs that contain ${outDir}/server as a substring but are not rooted under it', () => {
+    // Without startsWith, `.includes('dist/server')` would match this input
+    // and skip the prefix — incorrectly treating it as already-prefixed.
+    expect(toServerOutputPath('foo/dist/server/bar.js', 'dist')).toBe(
+      'dist/server/foo/dist/server/bar.js'
+    )
+  })
+})