one 2.7.7 → 2.8.1

package/src/layouts/stack-navigator.web.ts

@@ -5,7 +5,10 @@ import { createWebStackNavigator } from '../router/web/WebStackNavigator'
 
 export const createStackNavigator = createWebStackNavigator
 
-export function getStackNavigatorProps(children: ReactNode) {
+export function getStackNavigatorProps(children: ReactNode, screenLayout?: unknown) {
   const headlessChildren = getCustomNavigatorChildren(children)
-  return headlessChildren.length ? { headlessChildren } : {}
+  return {
+    ...(screenLayout ? { screenLayout } : null),
+    ...(headlessChildren.length ? { headlessChildren } : null),
+  }
 }

package/src/metro-config/buildOneMetroResolverOverrides.ts

@@ -27,7 +27,7 @@ export function buildOneMetroResolverOverrides({
   defaultConfig: T
 ) => T {
   const require = module.createRequire(projectRoot + '/')
-  const emptyPath = require.resolve('@vxrn/vite-plugin-metro/empty', {
+  const emptyPath = require.resolve('@vxrn/utils/empty', {
     paths: [projectRoot],
   })
   const projectPackagePath = path.join(projectRoot, 'package.json')

package/src/metro-config/getViteMetroPluginOptions.integration.test.ts

@@ -15,7 +15,7 @@ describe('getViteMetroPluginOptions babel-config coexistence', () => {
 
   beforeAll(() => {
     // place the fixture under the workspace root so Node can walk up to
-    // node_modules and resolve `one/metro-entry` + `@vxrn/vite-plugin-metro/empty`
+    // node_modules and resolve `one/metro-entry` + `@vxrn/utils/empty`
     const workspaceRoot = path.resolve(__dirname, '../../../../')
     tmpDir = fs.mkdtempSync(path.join(workspaceRoot, '.tmp-one-vite-metro-test-'))
     fs.writeFileSync(
@@ -29,7 +29,7 @@ describe('getViteMetroPluginOptions babel-config coexistence', () => {
     fs.rmSync(tmpDir, { recursive: true, force: true })
   })
 
-  it('explains the missing Metro preset in an isolated app', () => {
+  it('explains the missing Metro plugin in an isolated app', () => {
     const isolatedApp = fs.mkdtempSync(path.join(os.tmpdir(), 'one-metro-no-preset-'))
     try {
       expect(() =>
@@ -37,7 +37,9 @@ describe('getViteMetroPluginOptions babel-config coexistence', () => {
           projectRoot: isolatedApp,
           relativeRouterRoot: 'app',
         })
-      ).toThrow(/Metro requires babel-preset-expo.*Install it/)
+      ).toThrow(
+        /Metro requires @vxrn\/vite-plugin-metro and babel-preset-expo in the app.*Install with/
+      )
     } finally {
       fs.rmSync(isolatedApp, { recursive: true, force: true })
     }

package/src/metro-config/getViteMetroPluginOptions.ts

@@ -21,11 +21,17 @@ export function getViteMetroPluginOptions({
   setupFile?: string | { native?: string; ios?: string; android?: string }
 }): Parameters<typeof metroPlugin>[0] {
   const require = createRequire(projectRoot + '/')
-  try {
-    require.resolve('babel-preset-expo')
-  } catch {
+  const missing = ['@vxrn/vite-plugin-metro', 'babel-preset-expo'].filter((name) => {
+    try {
+      require.resolve(name)
+      return false
+    } catch {
+      return true
+    }
+  })
+  if (missing.length) {
     throw new Error(
-      `[one] Metro requires babel-preset-expo in the app at ${projectRoot}. Install it with your package manager, or remove native.bundler: 'metro' to use One's default native bundler.`
+      `[one] Metro requires ${missing.join(' and ')} in the app at ${projectRoot}. Install with your package manager, or remove native.bundler: 'metro' to use One's default native bundler.`
     )
   }
 

package/src/metro-config/withOne.ts

@@ -1,5 +1,4 @@
 import path from 'node:path'
-import { buildMetroConfigInputFromViteConfig } from '@vxrn/vite-plugin-metro'
 import { getViteMetroPluginOptions } from './getViteMetroPluginOptions'
 import { loadUserOneOptions } from '../vite/loadConfig'
 
@@ -93,6 +92,9 @@ export async function withOne(
     root: path.resolve(loaded?.config?.config?.root ?? projectRoot),
   } as any
 
+  // imported after getViteMetroPluginOptions so a missing optional peer gets its
+  // install message instead of a bare module-not-found
+  const { buildMetroConfigInputFromViteConfig } = await import('@vxrn/vite-plugin-metro')
   const { defaultConfig } = await buildMetroConfigInputFromViteConfig(viteConfig, {
     ...metroPluginOptions,
     mainModuleName: 'one/metro-entry',

package/src/native/packedClosure.test.ts

@@ -13,7 +13,7 @@ import {
   writeFileSync,
 } from 'node:fs'
 import { tmpdir } from 'node:os'
-import { dirname, join, resolve } from 'node:path'
+import { dirname, join, relative, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { describe, expect, it } from 'vitest'
 import { auditUnpackedManifest, findForbiddenDependencies } from './closure'
@@ -235,6 +235,15 @@ console.log('one/native ok ' + url);
     const appDir = join(tmp, 'app')
     mkdirSync(join(appDir, 'app'), { recursive: true })
     writeFileSync(join(appDir, '.watchmanconfig'), '{}\n')
+    // the ejected babel config runs one/babel-preset, whose babel packages are
+    // optional peers the app installs (docs/metro-mode)
+    const onePeers = JSON.parse(readFileSync(join(oneDir, 'package.json'), 'utf8'))
+      .peerDependencies as Record<string, string>
+    const babelPresetPeers = Object.fromEntries(
+      Object.entries(onePeers).filter(
+        ([name]) => name.startsWith('@babel/') || name.startsWith('babel-')
+      )
+    )
 
     writeFileSync(
       join(appDir, 'package.json'),
@@ -247,12 +256,13 @@ console.log('one/native ok ' + url);
             vxrn: `file:${packedClosure.vxrn}`,
             '@vxrn/vite-plugin-metro': `file:${packedClosure['@vxrn/vite-plugin-metro']}`,
             '@vxrn/utils': `file:${packedClosure['@vxrn/utils']}`,
-            react: '19.2.3',
-            'react-native': '0.87.1',
+            react: '19.3.0',
+            'react-native': '0.88.0',
             'react-native-web': '^0.21.2',
             vite: '^8.2.2',
-            metro: '^0.87.0',
-            'metro-config': '^0.87.0',
+            metro: '^0.87.1',
+            'metro-config': '^0.87.1',
+            ...babelPresetPeers,
           },
           overrides: Object.fromEntries(
             Object.entries(packedClosure).map(([name, tarball]) => [
@@ -379,7 +389,7 @@ if (!config.dependencies['react-native-nitro-modules']) {
         ['-e', "require('./metro.config.cjs').catch((error) => { console.error(error.message); process.exitCode = 1 })"],
         { cwd: appDir, encoding: 'utf8' }
       )
-    ).toThrow(/Metro requires babel-preset-expo.*Install it/)
+    ).toThrow(/Metro requires babel-preset-expo in the app.*Install with/)
 
     const expoPresetVersion = JSON.parse(
       readFileSync(join(workspaceRoot, '../node_modules/babel-preset-expo/package.json'), 'utf8')
@@ -440,4 +450,56 @@ if (!config.dependencies['react-native-nitro-modules']) {
       process.chdir(previousCwd)
     }
   })
+
+  it('packs every files entry and non-dist export target of each published package', () => {
+    const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'one-packed-files-')))
+    // workspaceRoot here is the packages directory (see packWorkspaceClosure).
+    for (const entry of readdirSync(workspaceRoot, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue
+      const packageDir = join(workspaceRoot, entry.name)
+      const manifestPath = join(packageDir, 'package.json')
+      if (!existsSync(manifestPath)) continue
+      const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
+      if (manifest.private) continue
+      const extracted = unpack(packToDir(packageDir, tmp), join(tmp, entry.name))
+      const packed: string[] = []
+      const collect = (dir: string) => {
+        for (const child of readdirSync(dir, { withFileTypes: true })) {
+          if (child.isDirectory()) collect(join(dir, child.name))
+          else packed.push(relative(extracted, join(dir, child.name)))
+        }
+      }
+      collect(extracted)
+      // npm silently ignores files entries that match nothing, so a stale
+      // entry looks packed until something references the missing path.
+      for (const pattern of manifest.files ?? []) {
+        // dist and types only exist after the release build; everything
+        // else must already match at least one packed path.
+        if (pattern === 'dist' || pattern === 'types') continue
+        expect(
+          packed.some((file) => file === pattern || file.startsWith(`${pattern}/`)),
+          `${manifest.name}: files entry ${pattern} packs nothing`
+        ).toBe(true)
+      }
+      const targets = new Set<string>()
+      const walk = (value: unknown) => {
+        if (typeof value === 'string' && value.startsWith('./') && !value.includes('*')) {
+          if (value !== './') targets.add(value.slice(2))
+        } else if (value && typeof value === 'object') {
+          // comment keys (// ...) carry placeholder values, not targets.
+          Object.entries(value).forEach(([key, entry]) => {
+            if (!key.startsWith('//')) walk(entry)
+          })
+        }
+      }
+      walk(manifest.exports)
+      walk(manifest.bin)
+      for (const target of targets) {
+        if (target.startsWith('dist/') || target.startsWith('types/')) continue
+        expect(packed, `${manifest.name}: export target ${target} is missing`).toContain(
+          target
+        )
+      }
+    }
+  })
 }, 180000)

package/src/native/shippedAndroid.test.ts

@@ -0,0 +1,21 @@
+// guards for what one ships into real android app builds: the native
+// library must stay 16 kb page aligned.
+import { readFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const oneDir = resolve(here, '../..')
+
+describe('shipped android artifacts', () => {
+  it('builds the native library 16 kb page aligned', () => {
+    // google play requires 16 kb page support for targetSdk 35+, and the
+    // pinned ndk 27 defaults to 4 kb. react native's gradle plugin injects
+    // this flag into app modules only, never libraries, so the library
+    // must pass it to cmake itself or libOne.so fails to load on 16 kb
+    // page devices.
+    const gradle = readFileSync(join(oneDir, 'android/build.gradle'), 'utf8')
+    expect(gradle).toContain('-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON')
+  })
+})

package/src/native/shippedArtifacts.test.ts

@@ -0,0 +1,81 @@
+// guards for what one ships into real ios app builds: the pod must
+// carry a privacy manifest covering the required-reason apis its
+// sources use, and reference only resources that exist.
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const oneDir = resolve(here, '../..')
+
+function readSources(dir: string): string[] {
+  const out: string[] = []
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name === 'Tests') continue
+    const full = join(dir, entry.name)
+    if (entry.isDirectory()) out.push(...readSources(full))
+    else if (/\.(swift|m|mm|h|cpp)$/.test(entry.name)) out.push(readFileSync(full, 'utf8'))
+  }
+  return out
+}
+
+describe('shipped ios artifacts', () => {
+  it('ships a privacy manifest covering the required-reason apis in use', () => {
+    const manifestPath = join(oneDir, 'ios/PrivacyInfo.xcprivacy')
+    expect(existsSync(manifestPath)).toBe(true)
+    const manifest = readFileSync(manifestPath, 'utf8')
+    expect(manifest).toContain('<plist version="1.0">')
+    // reasons mirror expo's shipped manifests for the same api surface:
+    // user defaults (expo-constants), boot time (expo-device), file
+    // timestamps and disk space (expo-file-system).
+    const expected: Record<string, string[]> = {
+      NSPrivacyAccessedAPICategoryUserDefaults: ['CA92.1'],
+      NSPrivacyAccessedAPICategorySystemBootTime: ['35F9.1'],
+      NSPrivacyAccessedAPICategoryFileTimestamp: ['0A2A.1', '3B52.1'],
+      NSPrivacyAccessedAPICategoryDiskSpace: ['E174.1', '85F4.1'],
+    }
+    for (const [category, reasons] of Object.entries(expected)) {
+      expect(manifest).toContain(category)
+      for (const reason of reasons) expect(manifest).toContain(reason)
+    }
+    // every declared category must have a use in the shipped sources, and
+    // no other required-reason category may appear without one.
+    const sources = readSources(join(oneDir, 'ios'))
+    const uses: Record<string, RegExp> = {
+      NSPrivacyAccessedAPICategoryUserDefaults: /UserDefaults|AppStorage/,
+      NSPrivacyAccessedAPICategorySystemBootTime: /systemUptime|kern\.boottime/,
+      NSPrivacyAccessedAPICategoryFileTimestamp:
+        /attributesOfItem|\.modificationDate|\.creationDate|\.fileCreationDate/,
+      NSPrivacyAccessedAPICategoryDiskSpace:
+        /attributesOfFileSystem|systemFreeSize|systemSize|volumeAvailableCapacity/,
+    }
+    for (const [category, pattern] of Object.entries(uses)) {
+      expect(sources.some((source) => pattern.test(source))).toBe(true)
+    }
+    expect(sources.some((source) => /activeKeyboards/.test(source))).toBe(false)
+    // the pod must bundle the manifest, and the npm tarball must include it.
+    const podspec = readFileSync(join(oneDir, 'One.podspec'), 'utf8')
+    expect(podspec).toContain('PrivacyInfo.xcprivacy')
+    const files: string[] = JSON.parse(
+      readFileSync(join(oneDir, 'package.json'), 'utf8')
+    ).files
+    expect(files).toContain('ios')
+  })
+
+  it('references only podspec headers that exist', () => {
+    const podspec = readFileSync(join(oneDir, 'One.podspec'), 'utf8')
+    const headers = podspec.match(/'ios\/[^']+\.h'/g) ?? []
+    expect(headers.length).toBeGreaterThan(0)
+    for (const quoted of headers) {
+      expect(existsSync(join(oneDir, quoted.slice(1, -1)))).toBe(true)
+    }
+    for (const generated of [
+      'nitrogen/generated/ios/One+autolinking.rb',
+      'nitrogen/generated/ios/One-Swift-Cxx-Bridge.hpp',
+      'schema.json',
+    ]) {
+      expect(existsSync(join(oneDir, generated))).toBe(true)
+    }
+  })
+})

package/src/router/linkingConfig.test.ts

@@ -1,8 +1,52 @@
-import { describe, expect, it } from 'vitest'
+import { findFocusedRoute } from '@react-navigation/core'
+import { createElement } from 'react'
+import { renderToString } from 'react-dom/server'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { useLinking } from '../fork/useLinking'
 import { getMockContext } from '../testing-utils'
 import { getLinkingConfig } from './getLinkingConfig'
 import { getRoutes } from './getRoutes'
-import { getResolvedLinking, resetLinking, setupLinking } from './linkingConfig'
+import {
+  getResolvedLinking,
+  getSSRInitialState,
+  resetLinking,
+  setupLinking,
+} from './linkingConfig'
+
+const browser = vi.hoisted<{
+  location: URL
+  history: {
+    state: {
+      __tempLocation?: { pathname: string; search?: string; hash?: string }
+      __tempKey?: string
+    } | null
+  }
+}>(() => {
+  const browser = {
+    history: { state: null },
+    location: new URL('https://example.test/'),
+  }
+  Object.defineProperty(globalThis, 'window', {
+    configurable: true,
+    value: browser,
+  })
+  return browser
+})
+
+beforeEach(() => {
+  browser.history.state = null
+  resetLinking()
+})
+
+const nestedRoutes = () =>
+  getRoutes(
+    getMockContext([
+      '_layout.tsx',
+      'home/_layout.tsx',
+      'home/[projectId]/_layout.tsx',
+      'home/[projectId]/files/[...path].tsx',
+    ])
+  )!
 
 describe('setupLinking', () => {
   const routes = () => getRoutes(getMockContext(['_layout.tsx', 'index.tsx']))!
@@ -39,3 +83,101 @@ describe('setupLinking', () => {
     )
   })
 })
+
+describe.each([
+  { name: 'client', initialize: setupLinking },
+  { name: 'SSR', initialize: getSSRInitialState },
+])('$name initial location', ({ initialize }) => {
+  it.each([
+    ['/home/retained/files/first/second#details', 'details'],
+    ['/home/retained/files/first/second?mode=local#details', 'details'],
+    ['/home/retained/files/first/second?mode=left%23right#part%202', 'part%202'],
+    ['/home/retained/files/first/second?mode=local', undefined],
+  ])('round-trips %s through the actual route parser', (href, fragment) => {
+    const tree = nestedRoutes()
+    const state = initialize(tree, new URL(href, 'https://example.test'))!
+    const focused = findFocusedRoute(state)!
+    const linking = getLinkingConfig(tree, true)
+
+    expect(focused.params).toMatchObject({
+      projectId: 'retained',
+      path: ['first', 'second'],
+    })
+    if (fragment === undefined) {
+      expect(focused.params).not.toHaveProperty('#')
+    } else {
+      expect(focused.params).toHaveProperty('#', fragment)
+    }
+    expect(linking.getPathFromState!(state, linking.config)).toBe(href)
+  })
+})
+
+it('keeps fragment-specific SSR cache entries separate and clears the fragment', () => {
+  const tree = nestedRoutes()
+  const base = 'https://example.test/home/retained/files/first/second?mode=local'
+  const first = getSSRInitialState(tree, new URL(`${base}#first`))!
+  const second = getSSRInitialState(tree, new URL(`${base}#second`))!
+  const cleared = getSSRInitialState(tree, new URL(base))!
+
+  expect(findFocusedRoute(first)?.params).toHaveProperty('#', 'first')
+  expect(findFocusedRoute(second)?.params).toHaveProperty('#', 'second')
+  expect(findFocusedRoute(cleared)?.params).not.toHaveProperty('#')
+  expect(second).not.toBe(first)
+  expect(cleared).not.toBe(first)
+  expect(getSSRInitialState(tree, new URL(`${base}#first`))).toBe(first)
+})
+
+it('restores a masked initial location with its own query and fragment', () => {
+  browser.history.state = {
+    __tempLocation: {
+      pathname: '/home/retained/files/first/second',
+      search: '?mode=local',
+      hash: '#masked',
+    },
+  }
+  const tree = nestedRoutes()
+  const state = setupLinking(tree, new URL('https://example.test/display#visible'))!
+  const linking = getLinkingConfig(tree, true)
+
+  expect(linking.getPathFromState!(state, linking.config)).toBe(
+    '/home/retained/files/first/second?mode=local#masked'
+  )
+})
+
+it('keeps the visible fragment when a mask is configured to unmask on reload', () => {
+  browser.history.state = {
+    __tempLocation: { pathname: '/other', hash: '#masked' },
+    __tempKey: 'unmask',
+  }
+  const state = setupLinking(
+    nestedRoutes(),
+    new URL('https://example.test/home/retained/files/first/second#visible')
+  )!
+
+  expect(findFocusedRoute(state)?.params).toHaveProperty('#', 'visible')
+})
+
+it('restores the same masked fragment through the browser linking hook', async () => {
+  browser.history.state = {
+    __tempLocation: {
+      pathname: '/home/retained/files/first/second',
+      search: '?mode=local',
+      hash: '#masked',
+    },
+  }
+  const linking = getLinkingConfig(nestedRoutes(), true)
+  let getInitialState: ReturnType<typeof useLinking>['getInitialState'] | undefined
+  function Harness() {
+    const linkingState = useLinking({ current: null }, linking)
+    getInitialState = linkingState.getInitialState
+    return null
+  }
+
+  renderToString(createElement(Harness))
+  if (!getInitialState) throw new Error('linking hook did not initialize')
+  const state = (await getInitialState())!
+
+  expect(linking.getPathFromState!(state, linking.config)).toBe(
+    '/home/retained/files/first/second?mode=local#masked'
+  )
+})

package/src/router/linkingConfig.ts

@@ -72,7 +72,8 @@ export function getSSRInitialState(
   ensureBaseLinkingConfig(routeNode, linking)
   if (!cachedBaseLinkingConfig) return undefined
 
-  const path = initialLocation.pathname + (initialLocation.search || '')
+  const path =
+    initialLocation.pathname + (initialLocation.search || '') + initialLocation.hash
   if (ssrStateCache.has(path)) return ssrStateCache.get(path)
 
   const state = cachedBaseLinkingConfig.getStateFromPath?.(
@@ -101,14 +102,16 @@ export function setupLinking(
     if (initialLocation) {
       linkingConfig.getInitialURL = () => initialLocation.toString()
 
-      let path = initialLocation.pathname + (initialLocation.search || '')
+      let path =
+        initialLocation.pathname + (initialLocation.search || '') + initialLocation.hash
 
       if (isWebClient) {
         const historyState = window.history.state
         if (historyState?.__tempLocation?.pathname && !historyState.__tempKey) {
           path =
             historyState.__tempLocation.pathname +
-            (historyState.__tempLocation.search || '')
+            (historyState.__tempLocation.search || '') +
+            (historyState.__tempLocation.hash || '')
         }
       }
 

package/src/useLoader.ts

@@ -12,9 +12,7 @@ import {
   getClientMatchesSnapshot,
   updateMatchLoaderData,
 } from './useMatches'
-import { getLoaderPath } from './utils/cleanUrl'
-import { getURL } from './getURL'
-import { LOADER_JS_POSTFIX_UNCACHED } from './constants'
+import { getLoaderPath, getNativeLoaderPath } from './utils/cleanUrl'
 import { dynamicImport } from './utils/dynamicImport'
 import { weakKey } from './utils/weakKey'
 import { useServerContext } from './vite/one-server-only'
@@ -513,18 +511,8 @@ export function useLoaderState<
               // dev: ?platform=native tells vite plugin to return CJS
               nativeLoaderJSUrl = `${getLoaderPath(currentPath, true)}?platform=native`
             } else {
-              // prod: request the .native.js static file directly
-              // use uncached postfix since metro can't inline ONE_CACHE_KEY.
-              // must use the static import — a dynamic require('./getURL') is
-              // left as a runtime string require by metro and resolves to
-              // undefined in the prod native bundle (crashes the route).
-              const base = getURL()
-              const cleanedPath = currentPath
-                .slice(1)
-                .replace(/\/$/, '')
-                .replaceAll('_', '__')
-                .replaceAll('/', '_')
-              nativeLoaderJSUrl = `${base}/assets/${cleanedPath}${LOADER_JS_POSTFIX_UNCACHED.replace('.js', '.native.js')}`
+              // prod: the uncached .native.js file, since metro can't inline ONE_CACHE_KEY
+              nativeLoaderJSUrl = getNativeLoaderPath(currentPath)
             }
 
             try {

package/src/utils/cleanUrl.test.ts

@@ -1,7 +1,9 @@
 import { describe, expect, it } from 'vitest'
+import { LOADER_JS_POSTFIX, NATIVE_LOADER_JS_POSTFIX_UNCACHED } from '../constants'
 import {
   encodeReservedFilenameChars,
   getLoaderPath,
+  getNativeLoaderPath,
   getPathFromLoaderPath,
   getPreloadPath,
 } from './cleanUrl'
@@ -153,6 +155,32 @@ describe('NTFS-reserved characters in route-derived names', () => {
   })
 })
 
+describe('getNativeLoaderPath', () => {
+  // the uncached .native.js file buildPage writes next to each loader
+  const builtNativeLoader = (path: string) =>
+    getLoaderPath(path, false).replace(LOADER_JS_POSTFIX, NATIVE_LOADER_JS_POSTFIX_UNCACHED)
+
+  it.each([
+    '/',
+    '/docs/intro',
+    '/my_page/test',
+    '/events/2026-10-17T10:00',
+    '/posts/YWJj==',
+    '/blog/a:b*c',
+  ])('requests the file the build writes for %s', (path) => {
+    expect(getNativeLoaderPath(path).endsWith(builtNativeLoader(path))).toBe(true)
+  })
+
+  it('encodes reserved characters in route params', () => {
+    expect(getNativeLoaderPath('/events/2026-10-17T10:00')).toMatch(
+      /\/assets\/events_2026-10-17T10=3a00_vxrn_loader\.native\.js$/
+    )
+    expect(getNativeLoaderPath('/posts/YWJj==')).toMatch(
+      /\/assets\/posts_YWJj=3d=3d_vxrn_loader\.native\.js$/
+    )
+  })
+})
+
 describe('getPathFromLoaderPath', () => {
   it('strips /_one/assets prefix', () => {
     expect(getPathFromLoaderPath('/_one/assets/docs_intro_999_vxrn_loader.js')).toBe(

package/src/utils/cleanUrl.ts

@@ -3,6 +3,7 @@ import {
   isNative,
   LOADER_JS_POSTFIX,
   LOADER_JS_POSTFIX_REGEX,
+  NATIVE_LOADER_JS_POSTFIX_UNCACHED,
   PRELOAD_JS_POSTFIX,
 } from '../constants'
 import { getURL } from '../getURL'
@@ -56,12 +57,18 @@ export function getLoaderPath(
   const baseURL = includeUrl ? getURL() : ''
   const devPath = process.env.NODE_ENV === 'development' ? '/_one' : ''
 
-  const currentPathUrl = new URL(currentPath, 'http://example.com')
-
-  const cleanedUrl = cleanUrl(currentPathUrl.pathname.slice(1))
   const cacheBustSegment = cacheBust ? `_refetch_${cacheBust}_` : ''
 
-  return `${baseURL}${devPath}/assets/${cleanedUrl}${cacheBustSegment}${LOADER_JS_POSTFIX}`
+  return `${baseURL}${devPath}/assets/${getLoaderFileStem(currentPath)}${cacheBustSegment}${LOADER_JS_POSTFIX}`
+}
+
+// native prod reads the uncached .native.js copy the build writes beside each loader
+export function getNativeLoaderPath(currentPath: string) {
+  return `${getURL()}/assets/${getLoaderFileStem(currentPath)}${NATIVE_LOADER_JS_POSTFIX_UNCACHED}`
+}
+
+function getLoaderFileStem(currentPath: string) {
+  return cleanUrl(new URL(currentPath, 'http://example.com').pathname.slice(1))
 }
 
 export function getPathFromLoaderPath(loaderPath: string) {

package/src/vite/one.ts

@@ -1,6 +1,7 @@
 import { configureVXRNCompilerPlugin } from '@vxrn/compiler'
 import { resolvePath } from '@vxrn/resolve'
-import { type MetroPluginOptions, getPlatformEnvDefine } from '@vxrn/vite-plugin-metro'
+import type { MetroPluginOptions } from '@vxrn/vite-plugin-metro'
+import { getPlatformEnvDefine } from '@vxrn/utils'
 import events from 'node:events'
 import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'

package/src/vite/plugins/workerdDevPlugin.ts

@@ -3,7 +3,7 @@ import { join, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { resolvePath } from '@vxrn/resolve'
 import { cloudflare } from '@cloudflare/vite-plugin'
-import { getPlatformEnvDefine } from '@vxrn/vite-plugin-metro'
+import { getPlatformEnvDefine } from '@vxrn/utils'
 import { exactRegex } from 'rolldown/filter'
 import { type Plugin, type PluginOption } from 'vite'
 import { CACHE_KEY } from '../../constants'
@@ -285,7 +285,7 @@ export function createWorkerdDevPlugins(
     ? ['/bundledDevClient.mjs', '/assets/_virtual_one-entry.js']
     : ['/@vite/client', virtalEntryIdClient]
 
-  const empty = resolvePath('@vxrn/vite-plugin-metro/empty', root)
+  const empty = resolvePath('@vxrn/utils/empty', root)
   const absorbed = absorbedPackageAliases(root, 'web')
 
   const preparePlugin: Plugin = {

package/src/vite/types.ts

@@ -674,11 +674,11 @@ export namespace One {
       api?: VXRNBuildOptions
 
       /**
-       * maximum number of static pages to build concurrently.
-       * lower this when builds share a machine with other CPU-heavy work.
-       * `ONE_BUILD_CONCURRENCY` overrides this value.
+       * maximum number of static pages to build concurrently. two keeps peak
+       * memory near half of eight workers for a modest slowdown; raise it on a
+       * machine with memory to spare. `ONE_BUILD_CONCURRENCY` overrides this value.
        *
-       * @default Math.min(available CPU cores, 8)
+       * @default Math.min(available CPU cores, 2)
        */
       concurrency?: number
 

package/types/Frozen.d.ts

@@ -2,5 +2,5 @@ import { type ReactNode } from 'react';
 export declare function Frozen({ on, children }: {
     on?: boolean;
     children: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 //# sourceMappingURL=Frozen.d.ts.map

package/types/Frozen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Frozen.d.ts","sourceRoot":"","sources":["../src/Frozen.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,wBAAgB,MAAM,CAAC,EAAE,EAAU,EAAE,QAAQ,EAAE,EAAE;IAAE,EAAE,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,SAAS,CAAA;CAAE,2CASrF"}
+{"version":3,"file":"Frozen.d.ts","sourceRoot":"","sources":["../src/Frozen.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAGtC,wBAAgB,MAAM,CAAC,EAAE,EAAU,EAAE,QAAQ,EAAE,EAAE;IAAE,EAAE,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,SAAS,CAAA;CAAE,+BASrF"}