@wular/pnext 0.0.20 → 0.0.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wular/pnext",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "A fast little framework for server-first React apps, fully compatible with Next.js",
   "type": "module",
   "bin": {

package/src/cli/build/cache.ts

@@ -0,0 +1,324 @@
+import { createHash } from 'node:crypto'
+import { existsSync } from 'node:fs'
+import { lstat, mkdir, readFile, readdir, readlink } from 'node:fs/promises'
+import path from 'node:path'
+import type { ResolvedConfig } from '../../config'
+import { frameworkFingerprint } from '../../runtime/fingerprint'
+import type { BuildManifest } from '../../types'
+import { writeFileAtomic } from '../../utils/fs'
+
+const CACHE_VERSION = 2
+const CACHE_SEGMENTS = ['cache', 'build'] as const
+const SKIP_INPUT_DIRS = new Set([
+  '.claude',
+  '.git',
+  '.husky',
+  '.next',
+  '.pnext',
+  '.tmp',
+  '.turbo',
+  '.vercel',
+  '.vscode',
+  'node_modules',
+])
+const SKIP_INPUT_FILE = /(?:^\.DS_Store$|\.(?:log|pid)$)/i
+const LOCK_FILES = [
+  'bun.lock',
+  'bun.lockb',
+  'package-lock.json',
+  'npm-shrinkwrap.json',
+  'pnpm-lock.yaml',
+  'yarn.lock',
+]
+
+type InputRecord = [mtimeMs: number, size: number, hash: string]
+
+interface CacheRecord {
+  version: number
+  key: string
+  inputs: Record<string, InputRecord>
+  outputHash: string
+  outputs: Record<string, string>
+}
+
+export interface BuildCacheOptions {
+  adapter?: 'vercel'
+  debugBuildPaths?: string
+  buildMode?: 'compile' | 'generate'
+  debugPrerender?: boolean
+}
+
+export interface BuildCacheSession {
+  enabled: boolean
+  context?: string
+  inputs?: Record<string, InputRecord>
+  manifest?: BuildManifest
+  reason?: string
+}
+
+/** Validate the standard production build before its output directory is touched. */
+export async function lookupBuildCache(
+  config: ResolvedConfig,
+  options: BuildCacheOptions,
+): Promise<BuildCacheSession> {
+  if (!cacheEnabled(options)) return { enabled: false }
+  const record = await readRecord(config.outPath)
+  const inputs = await inputRecords(config, record?.inputs)
+  const context = buildContext()
+  const key = buildKey(context, inputs)
+  if (record?.key !== key) return { enabled: true, context, inputs, reason: 'inputs' }
+  const output = await outputSnapshot(config.outPath)
+  if (output.hash !== record.outputHash) {
+    const changed = changedFiles(record.outputs, output.files).slice(0, 3).join(', ')
+    return { enabled: true, context, inputs, reason: `output (${changed || 'unknown'})` }
+  }
+  try {
+    const manifest = JSON.parse(
+      await readFile(path.join(config.outPath, 'manifest.json'), 'utf8'),
+    ) as BuildManifest
+    return { enabled: true, context, inputs, manifest, reason: 'hit' }
+  } catch {
+    return { enabled: true, context, inputs, reason: 'manifest' }
+  }
+}
+
+/** Publish a successful build only after every production artifact has landed. */
+export async function writeBuildCache(
+  config: ResolvedConfig,
+  options: BuildCacheOptions,
+  session: BuildCacheSession,
+) {
+  if (!session.enabled || !session.context || !cacheEnabled(options)) return
+  const inputs = await inputRecords(config, session.inputs)
+  const output = await outputSnapshot(config.outPath)
+  const record: CacheRecord = {
+    version: CACHE_VERSION,
+    key: buildKey(session.context, inputs),
+    inputs,
+    outputHash: output.hash,
+    outputs: output.files,
+  }
+  await mkdir(cacheDir(config.outPath), { recursive: true })
+  await writeFileAtomic(recordFile(config.outPath), JSON.stringify(record))
+}
+
+function cacheEnabled(options: BuildCacheOptions) {
+  // Opt-in until the no-change short-circuit is finished: the key currently hashes the whole
+  // environment, so cross-shell hits are rare and the cache adds bookkeeping without payoff.
+  // eslint-disable-next-line turbo/no-undeclared-env-vars
+  if (process.env.PNEXT_BUILD_CACHE !== '1') return false
+  return (
+    options.adapter === undefined &&
+    options.debugBuildPaths === undefined &&
+    options.buildMode === undefined &&
+    options.debugPrerender !== true
+  )
+}
+
+function cacheDir(outPath: string) {
+  return path.join(outPath, ...CACHE_SEGMENTS)
+}
+
+function recordFile(outPath: string) {
+  return path.join(cacheDir(outPath), 'result.json')
+}
+
+async function readRecord(outPath: string): Promise<CacheRecord | undefined> {
+  try {
+    const parsed = JSON.parse(await readFile(recordFile(outPath), 'utf8')) as CacheRecord
+    if (
+      parsed.version === CACHE_VERSION &&
+      parsed.key &&
+      parsed.inputs &&
+      parsed.outputHash &&
+      parsed.outputs
+    ) {
+      return parsed
+    }
+  } catch {
+    // A partial or older entry is a miss, never a stale hit.
+  }
+  return undefined
+}
+
+function buildContext() {
+  const hash = createHash('sha256')
+  hash.update(`pnext-build-cache:${CACHE_VERSION}\0`)
+  hash.update(frameworkFingerprint())
+  hash.update(`\0bun:${Bun.version}\0`)
+  for (const [name, value] of Object.entries(process.env).sort(([a], [b]) => a.localeCompare(b))) {
+    hash.update(`${name}=${value ?? ''}\0`)
+  }
+  return hash.digest('hex')
+}
+
+function buildKey(context: string, inputs: Record<string, InputRecord>) {
+  const hash = createHash('sha256')
+  hash.update(context)
+  for (const [file, record] of Object.entries(inputs).sort(([a], [b]) => a.localeCompare(b))) {
+    hash.update(`${file}\0${record[2]}\0`)
+  }
+  return hash.digest('hex')
+}
+
+async function inputRecords(
+  config: ResolvedConfig,
+  previous: Record<string, InputRecord> | undefined,
+) {
+  const files = new Map<string, string>()
+  await collectTree(config.root, 'root', files, config.outPath)
+  await collectModuleGraphInputs(config, files)
+
+  // Dependency trees are represented by package-manager content identities,
+  // while first-party modules above are keyed by their own bytes.
+  for (const [prefix, root] of [
+    ['root-deps', config.root],
+    ['workspace-deps', config.workspaceRoot],
+  ] as const) {
+    for (const name of LOCK_FILES) addFile(files, `${prefix}:${name}`, path.join(root, name))
+    addFile(
+      files,
+      `${prefix}:node_modules/.package-lock.json`,
+      path.join(root, 'node_modules', '.package-lock.json'),
+    )
+  }
+
+  const frameworkRoot = path.resolve(import.meta.dirname, '..', '..')
+  addFile(files, 'framework:package.json', path.join(frameworkRoot, 'package.json'))
+  for (const name of LOCK_FILES) {
+    addFile(files, `framework:${name}`, path.join(frameworkRoot, name))
+    addFile(files, `framework-workspace:${name}`, path.join(frameworkRoot, '..', name))
+  }
+
+  const entries = await Promise.all(
+    [...files].map(async ([key, file]): Promise<[string, InputRecord] | undefined> => {
+      const stats = await lstat(file).catch(() => undefined)
+      if (!stats?.isFile() && !stats?.isSymbolicLink()) return undefined
+      const old = previous?.[key]
+      if (old?.[0] === stats.mtimeMs && old[1] === stats.size) return [key, old]
+      const contents = stats.isSymbolicLink()
+        ? Buffer.from(`link:${await readlink(file)}`)
+        : await readFile(file)
+      return [key, [stats.mtimeMs, stats.size, contentHash(contents)]]
+    }),
+  )
+  return Object.fromEntries(
+    entries.filter((entry): entry is [string, InputRecord] => Boolean(entry)),
+  )
+}
+
+interface ModuleGraphIndex {
+  files?: Record<string, unknown>
+}
+
+async function collectModuleGraphInputs(config: ResolvedConfig, files: Map<string, string>) {
+  let parsed: ModuleGraphIndex
+  try {
+    parsed = JSON.parse(
+      await readFile(path.join(config.outPath, 'cache', 'server', 'graph.json'), 'utf8'),
+    ) as ModuleGraphIndex
+  } catch {
+    return
+  }
+  const frameworkRoot = path.resolve(import.meta.dirname, '..', '..')
+  for (const source of Object.keys(parsed.files ?? {})) {
+    const value = source.slice(2).split('/').join(path.sep)
+    const file = source.startsWith('w:')
+      ? path.resolve(config.workspaceRoot, value)
+      : source.startsWith('f:')
+        ? path.resolve(frameworkRoot, value)
+        : source.startsWith('a:')
+          ? value
+          : undefined
+    if (file) addFile(files, `module:${source}`, file)
+  }
+}
+
+async function collectTree(
+  root: string,
+  prefix: string,
+  files: Map<string, string>,
+  outPath: string,
+  dir = root,
+): Promise<void> {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+  await Promise.all(
+    entries.map(async entry => {
+      const file = path.join(dir, entry.name)
+      if (file === outPath || file.startsWith(`${outPath}${path.sep}`)) return
+      if (entry.isDirectory()) {
+        if (!SKIP_INPUT_DIRS.has(entry.name)) await collectTree(root, prefix, files, outPath, file)
+        return
+      }
+      if (!entry.isFile() && !entry.isSymbolicLink()) return
+      const relative = path.relative(root, file)
+      // Local server logs and top-level response captures are not compiler
+      // inputs; watching processes commonly rewrite them during a build.
+      if (
+        SKIP_INPUT_FILE.test(entry.name) ||
+        (!relative.includes(path.sep) && /\.html?$/i.test(entry.name))
+      ) {
+        return
+      }
+      addFile(files, `${prefix}:${toPosix(relative)}`, file)
+    }),
+  )
+}
+
+function addFile(files: Map<string, string>, key: string, file: string) {
+  if (existsSync(file)) files.set(key, file)
+}
+
+async function outputSnapshot(outPath: string) {
+  const files = new Map<string, string>()
+  const entries = await readdir(outPath, { withFileTypes: true }).catch(() => [])
+  await Promise.all(
+    entries.map(async entry => {
+      if (entry.name === 'cache' || entry.name === 'dev') return
+      const file = path.join(outPath, entry.name)
+      if (entry.isDirectory()) await collectOutputTree(outPath, file, files)
+      else if (entry.isFile() || entry.isSymbolicLink()) {
+        files.set(toPosix(entry.name), file)
+      }
+    }),
+  )
+  const hash = createHash('sha256')
+  const hashes: Record<string, string> = {}
+  for (const [name, file] of [...files].sort(([a], [b]) => a.localeCompare(b))) {
+    const stats = await lstat(file)
+    const contents = stats.isSymbolicLink()
+      ? Buffer.from(`link:${await readlink(file)}`)
+      : await readFile(file)
+    const contentsHash = contentHash(contents)
+    hashes[name] = contentsHash
+    hash.update(`${name}\0${contentsHash}\0`)
+  }
+  return { hash: hash.digest('hex'), files: hashes }
+}
+
+function changedFiles(before: Record<string, string>, after: Record<string, string>) {
+  return [...new Set([...Object.keys(before), ...Object.keys(after)])].filter(
+    file => before[file] !== after[file],
+  )
+}
+
+async function collectOutputTree(root: string, dir: string, files: Map<string, string>) {
+  const entries = await readdir(dir, { withFileTypes: true })
+  await Promise.all(
+    entries.map(async entry => {
+      const file = path.join(dir, entry.name)
+      if (entry.isDirectory()) await collectOutputTree(root, file, files)
+      else if (entry.isFile() || entry.isSymbolicLink()) {
+        files.set(toPosix(path.relative(root, file)), file)
+      }
+    }),
+  )
+}
+
+function contentHash(contents: Uint8Array) {
+  return createHash('sha256').update(contents).digest('hex')
+}
+
+function toPosix(file: string) {
+  return path.sep === '/' ? file : file.split(path.sep).join('/')
+}

package/src/cli/build.ts

@@ -84,6 +84,7 @@ import {
 } from '../routing/routes'
 import { interceptionMarkerLevels } from '../routing/slots'
 import { writeTypegen } from './typegen'
+import { lookupBuildCache, writeBuildCache } from './build/cache'
 import { createVerboseLogger, type VerboseLogger } from '../utils/verbose'
 import { bold, cyan, dim, green } from '../utils/ansi'
 import type {
@@ -179,9 +180,7 @@ async function runBuild(root: string | undefined, options: BuildOptions) {
     `${cyan('▲')} ${bold('pnext')} ${dim('— Creating an optimized production build ...\n')}`,
   )
   const config = await loadConfig(root)
-  // Load Tailwind on the CSS worker while the steps below run, so the first
-  // stylesheet doesn't pay its cold boot.
-  warmCssPipeline(config)
+  const buildCache = lookupBuildCache(config, options)
   // Compat plugin loader: the single gated seam that populates the core
   // extension registries when compat is enabled (no-op for pure-core apps).
   // A build compiles immediately, so it takes both tiers up front.
@@ -192,6 +191,21 @@ async function runBuild(root: string | undefined, options: BuildOptions) {
   // server-boot-only hooks out of the build - Next never runs register() during `next build`, so
   // build prerenders must see a noop tracer.
   runInitHooks(config, { build: true })
+  const cached = await buildCache
+  log.log(`build cache ${cached.reason ?? 'disabled'}`)
+  if (cached.manifest) {
+    printBuildSummary(
+      config,
+      cached.manifest.routes,
+      cached.manifest.staticFiles ?? {},
+      performance.now() - startedAt,
+      Boolean(cached.manifest.proxyModule),
+    )
+    return cached.manifest
+  }
+  // Load Tailwind on the CSS worker while the steps below run, so the first
+  // stylesheet doesn't pay its cold boot.
+  warmCssPipeline(config)
   // The vercel adapter's warm pass runs in its own process; start it here so
   // its boot overlaps the build and only the warming itself lands on the
   // adapter step.
@@ -917,6 +931,8 @@ async function runBuild(root: string | undefined, options: BuildOptions) {
   // (typecheck) are awaited next and reported on their own lines.
   const buildDurationMs = performance.now() - startedAt
   const phases = await settleBuildParallelPhases()
+  flushDevModuleCaches()
+  await writeBuildCache(config, options, cached)
 
   printBuildSummary(
     config,

package/src/cli/create.ts

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs'
 import { mkdir, readdir } from 'node:fs/promises'
 import path from 'node:path'
 import { bold, cyan, dim, green } from '../utils/ansi'
-import { pnextVersionRange } from '../utils/fs'
+import { latestPnextVersionRange } from '../utils/registry'
 import { formatDuration } from '../utils/verbose'
 
 export interface CreateAppOptions {
@@ -27,7 +27,7 @@ export async function createApp(dir: string | undefined, options: CreateAppOptio
   const name = sanitizePackageName(path.basename(target))
   console.log(`${cyan('▲')} ${bold('pnext create')} ${dim(`— scaffolding ${name}`)}\n`)
 
-  const files = scaffoldFiles(name)
+  const files = scaffoldFiles(name, await latestPnextVersionRange('create'))
   await Promise.all(
     Object.entries(files).map(([file, source]) => Bun.write(path.join(target, file), source)),
   )
@@ -112,7 +112,7 @@ function printNextSteps(dir: string, installed: boolean) {
   console.log(dim(`└${'─'.repeat(width + 2)}┘`))
 }
 
-function scaffoldFiles(name: string): Record<string, string> {
+function scaffoldFiles(name: string, pnextRange: string): Record<string, string> {
   return {
     'package.json': `${JSON.stringify(
       {
@@ -126,7 +126,7 @@ function scaffoldFiles(name: string): Record<string, string> {
         },
         dependencies: { preact: '^10' },
         devDependencies: {
-          '@wular/pnext': pnextVersionRange(),
+          '@wular/pnext': pnextRange,
           typescript: '^5',
           '@types/bun': '^1',
         },

package/src/cli/migrate/package-json.ts

@@ -3,7 +3,8 @@
 
 import { readFile, writeFile } from 'node:fs/promises'
 import path from 'node:path'
-import { pnextOptionalDependencyRange, pnextVersionRange } from '../../utils/fs'
+import { pnextOptionalDependencyRange } from '../../utils/fs'
+import { latestPnextVersionRange } from '../../utils/registry'
 import type { MigrationResult } from './report'
 
 const SEPARATORS = new Set(['&&', '||', ';', '|', '&'])
@@ -124,7 +125,7 @@ export async function migratePackageJson(
     }
   }
   if (!('@wular/pnext' in devDependencies) && !('@wular/pnext' in dependencies)) {
-    const versionRange = pnextVersionRange()
+    const versionRange = await latestPnextVersionRange('migrate')
     devDependencies['@wular/pnext'] = versionRange
     result.edits.push({
       file: 'package.json',

package/src/cli/serve/entry.ts

@@ -7,6 +7,7 @@ import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import type { Plugin as EsbuildPlugin } from 'esbuild'
+import { frameworkFingerprint } from '../../runtime/fingerprint'
 
 const frameworkRoot = path.resolve(import.meta.dirname, '..', '..', '..')
 
@@ -20,8 +21,17 @@ function frameworkVersion(): string {
   }
 }
 
-function serverEntryDir(outPath: string): string {
-  return path.join(outPath, 'server', `bundle-${frameworkVersion()}`)
+/**
+ * Version AND framework fingerprint: the version alone let an edited `src` keep serving the bundle
+ * built from the previous source, so a fix appeared to have no effect until the app was rebuilt.
+ * The fingerprint is the same one every other compiled artifact is keyed on, taken through the
+ * cache-root record so a restart pays one stat per file rather than re-reading the tree.
+ */
+export function serverEntryDir(outPath: string): string {
+  // Cache root spelled inline, not imported: this module is parsed before anything else on the
+  // start path, and pulling in the module cache for one path.join would drag its whole graph along.
+  const generation = frameworkFingerprint(path.join(outPath, 'cache', 'server'))
+  return path.join(outPath, 'server', `bundle-${frameworkVersion()}-${generation}`)
 }
 
 function serverEntryFile(outPath: string): string {
@@ -30,7 +40,7 @@ function serverEntryFile(outPath: string): string {
 
 /**
  * The prebuilt entry for a project root, or undefined when there is none to
- * use (no build, a custom `outDir`, a version mismatch, or the opt-out). The
+ * use (no build, a custom `outDir`, a version or source-generation mismatch, or the opt-out). The
  * caller then falls back to importing src/cli/start.ts directly, so a miss only
  * costs speed. Deliberately cheap: one existsSync and one package.json read,
  * because it runs before anything else on the start path.
@@ -43,7 +53,7 @@ export function prebuiltServerEntry(root = process.cwd()): string | undefined {
 }
 
 /**
- * Bundle src/cli/start.ts under `<outPath>/server/bundle-<version>/`. Bare
+ * Bundle src/cli/start.ts under `<outPath>/server/bundle-<version>-<fingerprint>/`. Bare
  * specifiers stay external (the framework's deps are already plain JS), so only
  * the framework's own source is inlined. Splitting is on so the graph behind a
  * dynamic import (compat, dev, build) stays in its own chunk — folding it into

package/src/cli/serve/pipeline.ts

@@ -15,6 +15,7 @@ import type { ResolvedConfig } from '../../config'
 import { bootstrapCompat } from '../../compat-bootstrap'
 import { registerServerRuntime, serverBundleTargetForRuntime } from '../../runtime/loader'
 import { importModuleOnce } from '../../runtime/modules'
+import { abortUpstreamFetchOnDisconnect } from '../../runtime/fetch-host'
 import { applyProxyResponse, createProxyRunner } from '../../routing/proxy'
 import {
   isPprShellUpgradeEligible,
@@ -287,6 +288,9 @@ export async function createRequestHandler(
           },
         )
         const response = maybeCloseNodeFetchConnection(finalized, request)
+        // Wired before the close-observer wraps the body: the stream a handler
+        // passed through from fetch is still the one the abort map knows.
+        abortUpstreamFetchOnDisconnect(response.body, request.signal)
         return flushWorkUnitOnClose(response, unit, request.signal)
       } catch (error) {
         // A dropped promise here would close the socket without a response

package/src/cli/start.ts

@@ -48,14 +48,9 @@ export async function start(options: StartOptions = {}) {
   const startedAt = Date.now()
   const port = options.port ?? 3000
   const hostname = options.hostname ?? 'localhost'
-  // Export builds are not served by a production start (Next throws). Standalone builds still serve -
-  // Next only WARNS, pointing at the standalone launcher, and the launcher re-execs this path with
-  // `__NEXT_PRIVATE_STANDALONE_CONFIG` set to suppress that warning. Handle both before binding a
-  // port, matching Next's messages.
+  // Export builds are not served; pnext serves its standalone output directly.
   const config = await guardUnservableOutputMode(options.root)
-  const manifest = JSON.parse(
-    await readFile(path.join(config.outPath, 'manifest.json'), 'utf8'),
-  ) as BuildManifest
+  const manifest = await readProductionManifest(config)
   await ensurePortFree(port, hostname)
 
   // The pipeline import starts right after listen; a request that beats it
@@ -110,10 +105,20 @@ function installProcessErrorHandlers(): void {
   process.on('uncaughtException', report)
 }
 
-// Next's output-mode handling on start: an export build throws (fatal - it is unservable), while a
-// standalone build only warns and serves on, unless the standalone launcher re-execs with
-// `__NEXT_PRIVATE_STANDALONE_CONFIG` set. pnext mirrors that: load the compat config, read the output
-// mode from the build-compat registry, and reproduce Next's exact messages.
+export async function readProductionManifest(config: ResolvedConfig): Promise<BuildManifest> {
+  try {
+    return JSON.parse(
+      await readFile(path.join(config.outPath, 'manifest.json'), 'utf8'),
+    ) as BuildManifest
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      throw new Error("No production build found. Run 'pnext build' first.")
+    }
+    throw error
+  }
+}
+
+// Export output is unservable; pnext production output remains serveable for standalone apps.
 async function guardUnservableOutputMode(root?: string): Promise<ResolvedConfig> {
   const config = await loadConfig(root, { serve: true })
   await bootstrapCompat(config)
@@ -125,6 +130,8 @@ async function guardUnservableOutputMode(root?: string): Promise<ResolvedConfig>
     )
     process.exit(1)
   }
+  // Next warns on `next start` with standalone output; its standalone launcher re-execs this path
+  // with __NEXT_PRIVATE_STANDALONE_CONFIG set to suppress the warning. Mirror both.
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   if (mode === 'standalone' && !process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
     console.warn(

package/src/cli/typegen.ts

@@ -57,7 +57,10 @@ function routeEntry(route: RouteManifestEntry) {
 }
 
 async function writeChecks(config: ResolvedConfig, routes: RouteManifestEntry[]) {
-  const checksDir = path.join(config.typesPath, 'checks')
+  const checksDir = config.checksPath
+  // Checks used to live under typesPath, which the app's own tsconfig includes; a stale
+  // copy there fails the app's compiler on pnext internals, so heal that on every generate.
+  await rm(path.join(config.typesPath, 'checks'), { recursive: true, force: true })
   await rm(checksDir, { recursive: true, force: true })
   await ensureDir(checksDir)
 

package/src/client/build.ts

@@ -479,16 +479,19 @@ export async function buildClientEntry({ config, route, outDir, dev }: ClientBui
   const outfile = path.join(outDir, `${entryName}.js`)
   const pipeline = createClientSourcePipeline(config, dev === true, route.id)
   pipeline.warmRoutes([route])
-  const runtimeFacts = clientRuntimeFacts(
-    [
-      {
-        route,
-        shell: hasClientRootLayout(config, route),
-      },
-    ],
-    nextCompatEnabled(config),
-    suspense,
-  )
+  const runtimeFacts: ClientRuntimeFacts = {
+    ...clientRuntimeFacts(
+      [
+        {
+          route,
+          shell: hasClientRootLayout(config, route),
+        },
+      ],
+      nextCompatEnabled(config),
+      suspense,
+    ),
+    dev: dev === true,
+  }
   const prebuilt = await clientProfile.timeAsync('prebuilt', () =>
     preparePrebuilt(
       config,