vxrn 1.21.6 → 1.21.8

package/dist/utils/state.native.js

@@ -1,4 +1,6 @@
 import FSExtra from "fs-extra";
+import { randomUUID } from "crypto";
+import { rename, rm } from "fs/promises";
 import { join } from "path";
 async function readState(cacheDir) {
   var statePath = join(cacheDir, "state.json");
@@ -11,8 +13,16 @@ async function readState(cacheDir) {
 }
 async function writeState(cacheDir, state) {
   var statePath = join(cacheDir, "state.json");
+  var pendingStatePath = `${statePath}.${process.pid}.${randomUUID()}.tmp`;
   await FSExtra.ensureDir(cacheDir);
-  await FSExtra.writeJSON(statePath, state);
+  try {
+    await FSExtra.writeJSON(pendingStatePath, state);
+    await rename(pendingStatePath, statePath);
+  } finally {
+    await rm(pendingStatePath, {
+      force: true
+    });
+  }
 }
 export { readState, writeState };
 //# sourceMappingURL=state.native.js.map

package/dist/utils/state.native.js.map

@@ -1 +1 @@
-{"version":3,"names":["FSExtra","join","readState","cacheDir","statePath","state","pathExists","readJSON","unused","writeState","ensureDir","writeJSON"],"sources":["../../src/utils/state.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAOA,OAAA,MAAa;AACpB,SAASC,IAAA,QAAY;AAMrB,eAAsBC,UAAUC,QAAA,EAAkB;EAChD,IAAAC,SAAM,GAAAH,IAAY,CAAAE,QAAK,cAAU;EACjC,IAAI;IACF,IAAAE,KAAM,UAAgBL,OAAM,CAAAM,UAAQ,CAAAF,SAAW,KAAS,MACpDJ,OAAM,CAAAO,QAAQ,CAAAH,SAAS,IAAS,EAChC;IACJ,OAAOC,KAAA;EACT,SAAQG,MAAA;IAEN,OAAO,CAAC;EACV;AACF;AAEA,eAAsBC,WAAWN,QAAA,EAAkBE,KAAA,EAAc;EAC/D,IAAAD,SAAM,GAAAH,IAAY,CAAAE,QAAK,cAAU;EACjC,MAAMH,OAAA,CAAQU,SAAA,CAAUP,QAAQ;EAChC,MAAMH,OAAA,CAAQW,SAAA,CAAUP,SAAA,EAAWC,KAAK;AAC1C","ignoreList":[]}
+{"version":3,"names":["FSExtra","randomUUID","rename","rm","join","readState","cacheDir","statePath","state","pathExists","readJSON","unused","writeState","pendingStatePath","process","pid","ensureDir","writeJSON","force"],"sources":["../../src/utils/state.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAOA,OAAA,MAAa;AACpB,SAASC,UAAA,QAAkB;AAC3B,SAASC,MAAA,EAAQC,EAAA,QAAU;AAC3B,SAASC,IAAA,QAAY;AAMrB,eAAsBC,UAAUC,QAAA,EAAkB;EAChD,IAAAC,SAAM,GAAAH,IAAY,CAAAE,QAAK,cAAU;EACjC,IAAI;IACF,IAAAE,KAAM,UAAgBR,OAAM,CAAAS,UAAQ,CAAAF,SAAW,KAAS,MACpDP,OAAM,CAAAU,QAAQ,CAAAH,SAAS,IAAS,EAChC;IACJ,OAAOC,KAAA;EACT,SAAQG,MAAA;IAEN,OAAO,CAAC;EACV;AACF;AAEA,eAAsBC,WAAWN,QAAA,EAAkBE,KAAA,EAAc;EAC/D,IAAAD,SAAM,GAAAH,IAAY,CAAAE,QAAK,cAAU;EACjC,IAAAO,gBAAM,MAAmBN,SAAG,IAASO,OAAI,CAAAC,GAAQ,IAAGd,UAAI,QAAY;EACpE,MAAMD,OAAA,CAAQgB,SAAA,CAAUV,QAAQ;EAChC,IAAI;IACF,MAAMN,OAAA,CAAQiB,SAAA,CAAUJ,gBAAA,EAAkBL,KAAK;IAC/C,MAAMN,MAAA,CAAOW,gBAAA,EAAkBN,SAAS;EAC1C,UAAE;IACA,MAAMJ,EAAA,CAAGU,gBAAA,EAAkB;MAC7BK,KAAA;IACF","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vxrn",
-  "version": "1.21.6",
+  "version": "1.21.8",
   "sideEffects": false,
   "type": "module",
   "exports": {
@@ -60,16 +60,16 @@
     "@expo/config-plugins": "~55.0.6",
     "@hono/node-server": "^1.19.14",
     "@react-native/dev-middleware": "^0.83.4",
-    "@vxrn/compiler": "1.21.6",
-    "@vxrn/debug": "1.21.6",
-    "@vxrn/query-string": "1.21.6",
-    "@vxrn/resolve": "1.21.6",
-    "@vxrn/safe-area": "1.21.6",
-    "@vxrn/url-parse": "1.21.6",
-    "@vxrn/utils": "1.21.6",
-    "@vxrn/vendor": "1.21.6",
-    "@vxrn/vite-flow": "1.21.6",
-    "@vxrn/vite-plugin-metro": "1.21.6",
+    "@vxrn/compiler": "1.21.8",
+    "@vxrn/debug": "1.21.8",
+    "@vxrn/query-string": "1.21.8",
+    "@vxrn/resolve": "1.21.8",
+    "@vxrn/safe-area": "1.21.8",
+    "@vxrn/url-parse": "1.21.8",
+    "@vxrn/utils": "1.21.8",
+    "@vxrn/vendor": "1.21.8",
+    "@vxrn/vite-flow": "1.21.8",
+    "@vxrn/vite-plugin-metro": "1.21.8",
     "citty": "^0.1.6",
     "dotenv": "^17.2.1",
     "dotenv-expand": "^12.0.2",

package/src/config/getOptionsFilled.ts

@@ -5,7 +5,7 @@ import { join } from 'node:path'
 import { readPackageJSON } from 'pkg-types'
 import type { Mode, VXRNOptions } from '../types'
 import { getServerOptionsFilled } from './getServerOptionsFilled'
-import { readState, writeState } from '../utils/state'
+import { readState } from '../utils/state'
 import { getCacheDir } from '../utils/getCacheDir'
 
 const require = createRequire(import.meta.url)
@@ -71,9 +71,6 @@ export async function fillOptions(
       ? 'vite'
       : false
 
-  // no need to wait to write state
-  void writeState(cacheDir, { versionHash })
-
   if (typeof options.build?.server !== 'boolean' && !options.build?.server) {
     // default building server to off
     options.build ||= {}
@@ -106,6 +103,7 @@ export async function fillOptions(
     state,
     packageRootDir,
     cacheDir,
+    versionHash,
   } as const
 
   optionsFilled = final

package/src/config/getServerOptionsFilled.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from 'vitest'
+import { getServerOptionsFilled } from './getServerOptionsFilled'
+
+describe('getServerOptionsFilled', () => {
+  test('uses the configured TLS protocol in the public server URL', async () => {
+    const server = await getServerOptionsFilled(
+      {
+        host: '127.0.0.1',
+        https: {
+          cert: 'certificate',
+          key: 'private-key',
+        },
+      },
+      'dev'
+    )
+
+    expect(server.protocol).toBe('https:')
+    expect(server.url).toBe(`https://127.0.0.1:${server.port}`)
+    expect(server.https).toEqual({
+      cert: 'certificate',
+      key: 'private-key',
+    })
+  })
+})

package/src/config/getServerOptionsFilled.ts

@@ -8,6 +8,7 @@ export async function getServerOptionsFilled(
   const {
     host = '0.0.0.0' /* TODO: Better default to 127.0.0.1 due to security reasons, and only dynamically change to 0.0.0.0 if the user is requesting an Expo QR code */,
     port: requestedPort,
+    https,
   } = serverOptions || {}
 
   const envPort = process.env.ONE_PORT ? Number(process.env.ONE_PORT) : undefined
@@ -16,7 +17,7 @@ export async function getServerOptionsFilled(
     : undefined
   const defaultPort = mode === 'dev' ? 8081 : 3000
   const portToUse = forcePort ?? requestedPort ?? envPort ?? defaultPort
-  const protocol = 'http:' as const
+  const protocol = https ? ('https:' as const) : ('http:' as const)
 
   // in cluster worker mode with SO_REUSEPORT, skip the port check —
   // multiple processes intentionally bind the same port

package/src/config/getViteServerConfig.ts

@@ -30,6 +30,7 @@ export async function getViteServerConfig(
           path: '/__vxrnhmr',
         },
         host: server.host,
+        https: server.https,
         port: server.port,
       },
       root,

package/src/exports/clean.test.ts

@@ -0,0 +1,82 @@
+import { execFile } from 'node:child_process'
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { promisify } from 'node:util'
+import { afterEach, describe, expect, it } from 'vitest'
+
+const execFileAsync = promisify(execFile)
+
+describe('prepareCacheForVersion', () => {
+  let root: string | undefined
+
+  afterEach(async () => {
+    if (root) {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it('lets one process clean a stale same-root cache', async () => {
+    root = await mkdtemp(join(tmpdir(), 'vxrn-concurrent-clean-'))
+    const cacheDir = join(root, 'node_modules', '.vxrn')
+    const viteDir = join(root, 'node_modules', '.vite')
+    const participantsDir = join(root, 'participants')
+    const participantCount = 4
+
+    await Promise.all([
+      mkdir(cacheDir, { recursive: true }),
+      mkdir(viteDir, { recursive: true }),
+      mkdir(participantsDir, { recursive: true }),
+    ])
+    await Promise.all([
+      writeFile(join(cacheDir, 'state.json'), JSON.stringify({ versionHash: 'old' })),
+      writeFile(join(cacheDir, 'stale'), 'stale'),
+      writeFile(join(viteDir, 'stale'), 'stale'),
+    ])
+
+    const moduleUrl = pathToFileURL(join(dirname(import.meta.filename), 'clean.ts')).href
+    const workerScript = (participant: number) => `
+      import { readdir, writeFile } from 'node:fs/promises'
+      import { join } from 'node:path'
+      import { prepareCacheForVersion } from ${JSON.stringify(moduleUrl)}
+
+      const root = ${JSON.stringify(root)}
+      const participantsDir = ${JSON.stringify(participantsDir)}
+      await writeFile(join(participantsDir, ${JSON.stringify(String(participant))}), '')
+      while ((await readdir(participantsDir)).length < ${participantCount}) {
+        await Bun.sleep(5)
+      }
+      const cleaned = await prepareCacheForVersion({
+        root,
+        cacheDir: join(root, 'node_modules', '.vxrn'),
+        versionHash: 'new',
+      })
+      console.info(cleaned ? 'cleaned-by-worker' : 'cache-already-current')
+    `
+
+    const results = await Promise.all(
+      Array.from({ length: participantCount }, (_, participant) =>
+        execFileAsync('bun', ['-e', workerScript(participant)], {
+          env: { ...process.env, VXRN_DONT_CLEAN_SELF: '' },
+        })
+      )
+    )
+    const output = results.map(({ stdout }) => stdout).join('\n')
+
+    expect(output.match(/\[vxrn\] cleaning/g)).toHaveLength(1)
+    expect(output.match(/cleaned-by-worker/g)).toHaveLength(1)
+    expect(JSON.parse(await readFile(join(cacheDir, 'state.json'), 'utf8'))).toEqual({
+      versionHash: 'new',
+    })
+    await expect(readFile(join(cacheDir, 'stale'))).rejects.toMatchObject({
+      code: 'ENOENT',
+    })
+    await expect(readFile(join(viteDir, 'stale'))).rejects.toMatchObject({
+      code: 'ENOENT',
+    })
+    await expect(
+      readFile(join(root, 'node_modules', '.vxrn-clean.lock'))
+    ).rejects.toMatchObject({ code: 'ENOENT' })
+  }, 20_000)
+})

package/src/exports/clean.ts

@@ -1,39 +1,73 @@
-import FSExtra from 'fs-extra'
-import { rm } from 'node:fs/promises'
-import { join } from 'node:path'
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
 import type { VXRNOptions } from '../types'
 import { fillOptions } from '../config/getOptionsFilled'
 import { getSSRExternalsCachePath } from '../plugins/autoDepOptimizePlugin'
 import { getCacheDir } from '../utils/getCacheDir'
+import { readState, writeState } from '../utils/state'
 
-/**
- * The main entry point for dev mode
- *
- * Note that much of the logic is being run by plugins:
- *
- *  - createFileSystemRouterPlugin does most of the fs-routes/request handling
- *  - clientTreeShakePlugin handles loaders/transforms
- *
- */
+const CLEAN_LOCK_WAIT_MS = 25
+const CLEAN_LOCK_TIMEOUT_MS = 60_000
 
-export const clean = async (rest: VXRNOptions, only?: 'vite') => {
-  const options = await fillOptions(rest)
-  const { root } = options
+function getErrorCode(err: unknown) {
+  if (err instanceof Error && 'code' in err && typeof err.code === 'string') {
+    return err.code
+  }
+}
+
+async function withCacheCleanLock<T>(cacheDir: string, action: () => Promise<T>) {
+  const lockPath = join(dirname(cacheDir), '.vxrn-clean.lock')
+  const startedAt = Date.now()
+  await mkdir(dirname(lockPath), { recursive: true })
+
+  while (true) {
+    try {
+      await writeFile(lockPath, `${process.pid}\n`, { flag: 'wx' })
+      break
+    } catch (err) {
+      if (getErrorCode(err) !== 'EEXIST') {
+        throw err
+      }
+
+      if (Date.now() - startedAt >= CLEAN_LOCK_TIMEOUT_MS) {
+        let owner = 'unknown process'
+        try {
+          owner = `process ${(await readFile(lockPath, 'utf8')).trim()}`
+        } catch (readErr) {
+          if (getErrorCode(readErr) === 'ENOENT') {
+            continue
+          }
+          throw readErr
+        }
+        throw new Error(`Timed out waiting for VXRN cache cleanup lock held by ${owner}`)
+      }
+      await new Promise<void>((resolve) => setTimeout(resolve, CLEAN_LOCK_WAIT_MS))
+    }
+  }
+
+  try {
+    return await action()
+  } finally {
+    await rm(lockPath, { force: true })
+  }
+}
+
+async function removeCachePaths(root: string, only?: 'vite') {
+  const removeVxrnCache = process.env.VXRN_DONT_CLEAN_SELF
+    ? rm(getSSRExternalsCachePath(root)).catch(throwIfNotMissingError)
+    : rm(getCacheDir(root), {
+        recursive: true,
+        force: true,
+      }).catch(throwIfNotMissingError)
 
   console.info(`[vxrn] cleaning`)
 
   await Promise.all([
-    rm(getSSRExternalsCachePath(root)).catch(throwIfNotMissingError),
     rm(join(root, 'node_modules', '.vite'), {
       recursive: true,
       force: true,
     }).catch(throwIfNotMissingError),
-    process.env.VXRN_DONT_CLEAN_SELF
-      ? null
-      : rm(getCacheDir(root), {
-          recursive: true,
-          force: true,
-        }).catch(throwIfNotMissingError),
+    removeVxrnCache,
     only === 'vite'
       ? null
       : rm(join(root, 'dist'), {
@@ -43,10 +77,40 @@ export const clean = async (rest: VXRNOptions, only?: 'vite') => {
   ])
 }
 
-function throwIfNotMissingError(err: unknown) {
-  if (err instanceof Error) {
-    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
-      throw Error
+export async function prepareCacheForVersion({
+  root,
+  cacheDir,
+  versionHash,
+  forceClean = false,
+}: {
+  root: string
+  cacheDir: string
+  versionHash: string
+  forceClean?: boolean
+}) {
+  return withCacheCleanLock(cacheDir, async () => {
+    const state = await readState(cacheDir)
+    const versionChanged = !!state.versionHash && state.versionHash !== versionHash
+    const shouldClean = forceClean || versionChanged
+
+    if (shouldClean) {
+      await removeCachePaths(root, 'vite')
+    }
+    if (shouldClean || state.versionHash !== versionHash) {
+      await writeState(cacheDir, { versionHash })
     }
+
+    return shouldClean
+  })
+}
+
+export const clean = async (rest: VXRNOptions, only?: 'vite') => {
+  const options = await fillOptions(rest)
+  await withCacheCleanLock(options.cacheDir, () => removeCachePaths(options.root, only))
+}
+
+function throwIfNotMissingError(err: unknown) {
+  if (getErrorCode(err) !== 'ENOENT') {
+    throw err
   }
 }

package/src/exports/dev.ts

@@ -44,7 +44,7 @@ export const dev = async (optionsIn: DevOptions) => {
   const { fillOptions } = await import('../config/getOptionsFilled')
   const { getViteServerConfig } = await import('../config/getViteServerConfig')
   const { printServerUrls } = await import('../utils/printServerUrls')
-  const { clean } = await import('./clean')
+  const { prepareCacheForVersion } = await import('./clean')
   const { filterViteServerResolvedUrls } =
     await import('../utils/filterViteServerResolvedUrls')
   const { removeUndefined } = await import('../utils/removeUndefined')
@@ -94,11 +94,22 @@ export default defineConfig({
   const oneServerConfig = config?.plugins?.find(
     (x) => Array.isArray(x) && x[0]?.['name'] === 'one:config'
   )?.[0]?.['__get']?.server
+  const viteServerConfig = config.server
 
   const options = await fillOptions({
     ...optionsIn,
     server: {
       ...oneServerConfig,
+      ...removeUndefined({
+        host:
+          viteServerConfig?.host === true
+            ? '0.0.0.0'
+            : typeof viteServerConfig?.host === 'string'
+              ? viteServerConfig.host
+              : undefined,
+        https: viteServerConfig?.https,
+        port: viteServerConfig?.port,
+      }),
       ...removeUndefined(optionsIn.server || {}),
     },
   })
@@ -107,8 +118,13 @@ export default defineConfig({
 
   bindKeypressInput()
 
-  if (options.clean) {
-    await clean(optionsIn, options.clean)
+  const cacheWasCleaned = await prepareCacheForVersion({
+    root: options.root,
+    cacheDir,
+    versionHash: options.versionHash,
+    forceClean: optionsIn.clean === true,
+  })
+  if (options.clean || cacheWasCleaned) {
     // signal metro to reset its cache as well
     process.env.METRO_RESET_CACHE = '1'
   }

package/src/serve/node.test.ts

@@ -0,0 +1,63 @@
+import { createServer } from 'node:http'
+import { Hono } from 'hono'
+import { describe, expect, test } from 'vitest'
+import { honoServeNode } from './node'
+
+describe('honoServeNode', () => {
+  test('rejects when the listener cannot bind', async () => {
+    const occupied = createServer()
+    await new Promise<void>((resolve, reject) => {
+      occupied.once('error', reject)
+      occupied.listen(0, '127.0.0.1', resolve)
+    })
+    const address = occupied.address()
+    if (!address || typeof address === 'string') throw new Error('missing test port')
+
+    const app = new Hono().get('/health', (context) => context.text('ok'))
+    await expect(
+      honoServeNode(app, { host: '127.0.0.1', port: address.port })
+    ).rejects.toMatchObject({ code: 'EADDRINUSE' })
+
+    await new Promise<void>((resolve, reject) =>
+      occupied.close((error) => (error ? reject(error) : resolve()))
+    )
+  })
+
+  test('overwrites the trusted peer address header from the socket', async () => {
+    const reservation = createServer()
+    await new Promise<void>((resolve, reject) => {
+      reservation.once('error', reject)
+      reservation.listen(0, '127.0.0.1', resolve)
+    })
+    const address = reservation.address()
+    if (!address || typeof address === 'string') throw new Error('missing test port')
+    await new Promise<void>((resolve, reject) =>
+      reservation.close((error) => (error ? reject(error) : resolve()))
+    )
+
+    const app = new Hono().get('/peer', (context) =>
+      context.text(context.req.header('x-vxrn-peer-address') || '')
+    )
+    const running = honoServeNode(app, { host: '127.0.0.1', port: address.port })
+    await new Promise<void>((resolve, reject) => {
+      const startedAt = Date.now()
+      const probe = async () => {
+        try {
+          const response = await fetch(`http://127.0.0.1:${address.port}/peer`, {
+            headers: { 'x-vxrn-peer-address': '203.0.113.9' },
+          })
+          expect(await response.text()).toBe('127.0.0.1')
+          resolve()
+        } catch (error) {
+          if (Date.now() - startedAt > 2_000) reject(error)
+          else setTimeout(probe, 20)
+        }
+      }
+      void probe()
+    })
+    const shutdown = process.listeners('SIGTERM').at(-1)
+    expect(shutdown).toBeTypeOf('function')
+    shutdown?.('SIGTERM')
+    await running
+  })
+})

package/src/serve/node.ts

@@ -1,8 +1,6 @@
-import { createServer, type Server } from 'node:http'
+import { createServer } from 'node:http'
 import { networkInterfaces, platform } from 'node:os'
 import { getRequestListener } from '@hono/node-server'
-import { serve as honoServe } from '@hono/node-server'
-import type { ServerType } from '@hono/node-server'
 import type { Hono } from 'hono'
 import colors from 'picocolors'
 import type { VXRNServeOptions } from '../types'
@@ -35,21 +33,20 @@ export async function honoServeNode(app: Hono, options: VXRNServeOptions) {
   const port = options.port ?? 3000
   const host = options.host ?? '0.0.0.0'
 
-  let server: Server | ServerType
-
-  if (canReusePort) {
-    // bypass @hono/node-server's serve() to use reusePort directly
-    // kernel distributes connections across workers - no IPC bottleneck
-    const listener = getRequestListener(app.fetch)
-    server = createServer(listener)
-    server.listen({ port, host, reusePort: true })
-  } else {
-    server = honoServe({
-      fetch: app.fetch,
-      port,
-      hostname: host,
-    })
-  }
+  const listener = getRequestListener((request, env) => {
+    request.headers.delete('x-vxrn-peer-address')
+    const address = env.incoming.socket.remoteAddress
+    if (address) request.headers.set('x-vxrn-peer-address', address)
+    return app.fetch(request, env)
+  })
+  const server = createServer(listener)
+  server.listen({
+    port,
+    host,
+    ...(canReusePort && process.env.ONE_CLUSTER_WORKER === '1'
+      ? { reusePort: true }
+      : {}),
+  })
 
   const colorUrl = (url: string) =>
     colors.cyan(url.replace(/:(\d+)\//, (_, port) => `:${colors.bold(port)}/`))
@@ -71,17 +68,16 @@ export async function honoServeNode(app: Hono, options: VXRNServeOptions) {
   }
   console.info()
 
-  const shutdown = () => {
-    server.close(() => {
-      process.exit(0)
-    })
-  }
+  const shutdown = () => server.close()
 
-  process.on('SIGINT', shutdown)
-  process.on('SIGTERM', shutdown)
+  process.once('SIGINT', shutdown)
+  process.once('SIGTERM', shutdown)
 
-  await new Promise<void>((res) => {
+  await new Promise<void>((res, rej) => {
+    server.once('error', rej)
     server.on('close', () => {
+      process.off('SIGINT', shutdown)
+      process.off('SIGTERM', shutdown)
       res()
     })
   })

package/src/types.ts

@@ -1,4 +1,5 @@
 import type { Hono } from 'hono'
+import type { ServerOptions as HttpsServerOptions } from 'node:https'
 import type { OutputAsset, OutputChunk, TreeshakingOptions } from 'rolldown'
 import type { FilterPattern, InlineConfig, UserConfig } from 'vite'
 
@@ -120,6 +121,7 @@ export type VXRNOptions = {
     host?: string
     port?: number
     compress?: boolean
+    https?: HttpsServerOptions
 
     /**
      * Whether to run the Vite logic to load .env files before running the server
@@ -165,9 +167,9 @@ export type HMRListener = (update: { file: string; contents: string }) => void
 type VXRNServeOptionsBase = VXRNOptions['server']
 
 export type VXRNServeOptionsFilled = Required<
-  Omit<NonNullable<VXRNServeOptionsBase>, 'cacheControl'>
+  Omit<NonNullable<VXRNServeOptionsBase>, 'cacheControl' | 'https'>
 > &
-  Pick<NonNullable<VXRNServeOptionsBase>, 'cacheControl'> & {
+  Pick<NonNullable<VXRNServeOptionsBase>, 'cacheControl' | 'https'> & {
     url: string
     protocol: string
   }

package/src/utils/state.ts

@@ -1,4 +1,6 @@
 import FSExtra from 'fs-extra'
+import { randomUUID } from 'node:crypto'
+import { rename, rm } from 'node:fs/promises'
 import { join } from 'node:path'
 
 type State = {
@@ -20,6 +22,12 @@ export async function readState(cacheDir: string) {
 
 export async function writeState(cacheDir: string, state: State) {
   const statePath = join(cacheDir, 'state.json')
+  const pendingStatePath = `${statePath}.${process.pid}.${randomUUID()}.tmp`
   await FSExtra.ensureDir(cacheDir)
-  await FSExtra.writeJSON(statePath, state)
+  try {
+    await FSExtra.writeJSON(pendingStatePath, state)
+    await rename(pendingStatePath, statePath)
+  } finally {
+    await rm(pendingStatePath, { force: true })
+  }
 }

package/types/config/getOptionsFilled.d.ts

@@ -54,6 +54,7 @@ export declare function fillOptions(options: VXRNOptions, { mode }?: {
     };
     readonly packageRootDir: string;
     readonly cacheDir: string;
+    readonly versionHash: string;
     readonly skipEnv?: boolean;
     readonly build?: {
         server?: boolean | import("..").VXRNBuildOptions;
@@ -86,6 +87,7 @@ export declare function getOptionsFilled(): {
     };
     readonly packageRootDir: string;
     readonly cacheDir: string;
+    readonly versionHash: string;
     readonly skipEnv?: boolean;
     readonly build?: {
         server?: boolean | import("..").VXRNBuildOptions;

package/types/config/getOptionsFilled.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getOptionsFilled.d.ts","sourceRoot":"","sources":["../../src/config/getOptionsFilled.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAOjD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,CAAA;AAIvE,wBAAsB,WAAW,CAC/B,OAAO,EAAE,WAAW,EACpB,EAAE,IAAY,EAAE,GAAE;IAAE,IAAI,CAAC,EAAE,IAAI,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;;;;;;;cAelC,CAAN;eAME,CADF;;;;GA+CC;AAED,wBAAgB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;cAtD1B,CAAN;eAME,CADF;;;;SAmDC"}
+{"version":3,"file":"getOptionsFilled.d.ts","sourceRoot":"","sources":["../../src/config/getOptionsFilled.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAOjD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,CAAA;AAIvE,wBAAsB,WAAW,CAC/B,OAAO,EAAE,WAAW,EACpB,EAAE,IAAY,EAAE,GAAE;IAAE,IAAI,CAAC,EAAE,IAAI,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiBnB,CAAC;eAMlB,CAAD;;;;GA0CF;AAED,wBAAgB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;cAlDX,CAAC;eAMlB,CAAD;;;;SA8CF"}

package/types/config/getServerOptionsFilled.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getServerOptionsFilled.d.ts","sourceRoot":"","sources":["../../src/config/getServerOptionsFilled.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEzE,wBAAsB,sBAAsB,CAC1C,aAAa,EAAE,WAAW,CAAC,QAAQ,CAAC,EACpC,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,sBAAsB,CAAC,CAmDjC"}
+{"version":3,"file":"getServerOptionsFilled.d.ts","sourceRoot":"","sources":["../../src/config/getServerOptionsFilled.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEzE,wBAAsB,sBAAsB,CAC1C,aAAa,EAAE,WAAW,CAAC,QAAQ,CAAC,EACpC,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,sBAAsB,CAAC,CAoDjC"}

package/types/config/getServerOptionsFilled.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getServerOptionsFilled.test.d.ts","sourceRoot":"","sources":["../../src/config/getServerOptionsFilled.test.ts"],"names":[],"mappings":""}

package/types/config/getViteServerConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getViteServerConfig.d.ts","sourceRoot":"","sources":["../../src/config/getViteServerConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,UAAU,EAAE,MAAM,MAAM,CAAA;AAItE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAM3D;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,iBAAiB,EACzB,cAAc,CAAC,EAAE,UAAU,uBAiD5B"}
+{"version":3,"file":"getViteServerConfig.d.ts","sourceRoot":"","sources":["../../src/config/getViteServerConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,UAAU,EAAE,MAAM,MAAM,CAAA;AAItE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAM3D;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,iBAAiB,EACzB,cAAc,CAAC,EAAE,UAAU,uBAkD5B"}

package/types/exports/build.d.ts

@@ -29,6 +29,7 @@ export declare const build: (optionsIn: VXRNOptions, buildArgs?: BuildArgs) => P
         };
         readonly packageRootDir: string;
         readonly cacheDir: string;
+        readonly versionHash: string;
         readonly skipEnv?: boolean;
         readonly build?: {
             server?: boolean | import("..").VXRNBuildOptions;

package/types/exports/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/exports/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAkB,MAAM,UAAU,CAAA;AAaxE,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAuBtD,eAAO,MAAM,KAAK,GAAU,WAAW,WAAW,EAAE,YAAW,SAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiDrE,CAAN;mBAKsE,CAAC;;;;;;;;;;;;EA4SxE,CAAA"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/exports/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAkB,MAAM,UAAU,CAAA;AAaxE,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAuBtD,eAAO,MAAM,KAAK,GAAU,WAAW,WAAW,EAAE,YAAW,SAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmDzE,CAAC;mBAI+D,CAAC;;;;;;;;;;;;EA2SpE,CAAA"}