@wular/pnext 0.0.3 → 0.0.6

package/src/cli/create.ts

@@ -1,43 +1,45 @@
-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 { 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 { formatDuration } from '../utils/verbose'
 
 export interface CreateAppOptions {
-  install: boolean;
+  install: boolean
 }
 
 export async function createApp(dir: string | undefined, options: CreateAppOptions) {
   if (!dir) {
-    console.log('Usage: pnext create <directory> [--no-install]');
-    throw new Error('pnext create requires a directory argument');
+    console.log('Usage: pnext create <directory> [--no-install]')
+    throw new Error('pnext create requires a directory argument')
   }
 
-  const target = path.resolve(dir);
+  const target = path.resolve(dir)
   if (existsSync(target)) {
     if ((await readdir(target)).length > 0) {
-      throw new Error(`Directory already exists and is not empty: ${target}`);
+      throw new Error(`Directory already exists and is not empty: ${target}`)
     }
   } else {
-    await mkdir(target, { recursive: true });
+    await mkdir(target, { recursive: true })
   }
 
-  const name = sanitizePackageName(path.basename(target));
-  console.log(`${cyan('▲')} ${bold('pnext create')} ${dim(`— scaffolding ${name}`)}\n`);
+  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 Promise.all(
     Object.entries(files).map(([file, source]) => Bun.write(path.join(target, file), source)),
-  );
-  for (const file of Object.keys(files)) console.log(`  ${green('+')} ${dim(file)}`);
+  )
+  for (const file of Object.keys(files)) console.log(`  ${green('+')} ${dim(file)}`)
 
-  let installed = false;
+  let installed = false
   if (options.install) {
-    console.log('');
-    installed = await install(target, dir);
+    console.log('')
+    installed = await install(target, dir)
   }
 
-  printNextSteps(dir, installed);
+  printNextSteps(dir, installed)
 }
 
 // npm package name rules: lowercase, url-safe, no leading dot/underscore.
@@ -46,71 +48,68 @@ function sanitizePackageName(raw: string) {
     .trim()
     .toLowerCase()
     .replace(/[^a-z0-9._-]+/g, '-')
-    .replace(/^[-._]+|[-._]+$/g, '');
-  return name || 'pnext-app';
+    .replace(/^[-._]+|[-._]+$/g, '')
+  return name || 'pnext-app'
 }
 
 async function install(target: string, dir: string) {
-  const stop = spinner('Installing dependencies...');
-  const start = Bun.nanoseconds();
-  const proc = Bun.spawn(['bun', 'install'], { cwd: target, stdout: 'pipe', stderr: 'pipe' });
+  const stop = spinner('Installing dependencies...')
+  const start = Bun.nanoseconds()
+  const proc = Bun.spawn(['bun', 'install'], { cwd: target, stdout: 'pipe', stderr: 'pipe' })
   // Drain both pipes: an unread pipe can fill and stall the child.
   const [stderr, , code] = await Promise.all([
     new Response(proc.stderr).text(),
     new Response(proc.stdout).text(),
     proc.exited,
-  ]);
-  stop();
+  ])
+  stop()
 
   if (code === 0) {
-    const durationMs = (Bun.nanoseconds() - start) / 1e6;
-    console.log(`${green('✓')} ${bold('Installed dependencies')} ${dim(`in ${formatDuration(durationMs)}`)}`);
-    return true;
+    const durationMs = (Bun.nanoseconds() - start) / 1e6
+    console.log(
+      `${green('✓')} ${bold('Installed dependencies')} ${dim(`in ${formatDuration(durationMs)}`)}`,
+    )
+    return true
   }
-  console.log(`${dim('Install failed. Run it manually:')}`);
-  console.log(`  ${cyan('cd')} ${dir}`);
-  console.log(`  ${cyan('bun install')}`);
-  if (stderr.trim()) console.log(dim(stderr.trim()));
-  return false;
+  console.log(`${dim('Install failed. Run it manually:')}`)
+  console.log(`  ${cyan('cd')} ${dir}`)
+  console.log(`  ${cyan('bun install')}`)
+  if (stderr.trim()) console.log(dim(stderr.trim()))
+  return false
 }
 
 /** Braille spinner, TTY-only; a plain line prints once and stays put otherwise. */
 function spinner(label: string) {
   if (!process.stdout.isTTY) {
-    console.log(label);
-    return () => undefined;
+    console.log(label)
+    return () => undefined
   }
-  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-  let frame = 0;
-  process.stdout.write(`${cyan(frames[0]!)} ${label}`);
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+  let frame = 0
+  process.stdout.write(`${cyan(frames[0]!)} ${label}`)
   const timer = setInterval(() => {
-    frame = (frame + 1) % frames.length;
-    process.stdout.write(`\r${cyan(frames[frame]!)} ${label}`);
-  }, 80);
+    frame = (frame + 1) % frames.length
+    process.stdout.write(`\r${cyan(frames[frame]!)} ${label}`)
+  }, 80)
   return () => {
-    clearInterval(timer);
-    process.stdout.write('\r\x1b[K');
-  };
-}
-
-function formatDuration(durationMs: number) {
-  const totalSeconds = Math.max(0, durationMs) / 1000;
-  return `${totalSeconds.toFixed(totalSeconds < 10 ? 2 : 1)}s`;
+    clearInterval(timer)
+    process.stdout.write('\r\x1b[K')
+  }
 }
 
 function printNextSteps(dir: string, installed: boolean) {
-  const commands = installed ? [`cd ${dir}`, 'bun dev'] : [`cd ${dir}`, 'bun install', 'bun dev'];
-  const title = 'Next steps';
-  const width = Math.max(title.length, ...commands.map(c => c.length)) + 2;
+  const commands = installed ? [`cd ${dir}`, 'bun dev'] : [`cd ${dir}`, 'bun install', 'bun dev']
+  const title = 'Next steps'
+  const width = Math.max(title.length, ...commands.map(c => c.length)) + 2
   const row = (text: string, colorFn: (s: string) => string = s => s) =>
-    `${dim('│')} ${colorFn(text.padEnd(width))} ${dim('│')}`;
+    `${dim('│')} ${colorFn(text.padEnd(width))} ${dim('│')}`
 
-  console.log('');
-  console.log(dim(`┌${'─'.repeat(width + 2)}┐`));
-  console.log(row(title, bold));
-  console.log(row(''));
-  for (const cmd of commands) console.log(row(cmd, cyan));
-  console.log(dim(`└${'─'.repeat(width + 2)}┘`));
+  console.log('')
+  console.log(dim(`┌${'─'.repeat(width + 2)}┐`))
+  console.log(row(title, bold))
+  console.log(row(''))
+  for (const cmd of commands) console.log(row(cmd, cyan))
+  console.log(dim(`└${'─'.repeat(width + 2)}┘`))
 }
 
 function scaffoldFiles(name: string): Record<string, string> {
@@ -119,9 +118,18 @@ function scaffoldFiles(name: string): Record<string, string> {
       {
         name,
         private: true,
-        scripts: { dev: 'pnext dev', build: 'pnext build', start: 'pnext start', analyze: 'pnext analyze' },
+        scripts: {
+          dev: 'pnext dev',
+          build: 'pnext build',
+          start: 'pnext start',
+          analyze: 'pnext analyze',
+        },
         dependencies: { preact: '^10' },
-        devDependencies: { '@wular/pnext': '^0.0.1', typescript: '^5', '@types/bun': '^1' },
+        devDependencies: {
+          '@wular/pnext': pnextVersionRange(),
+          typescript: '^5',
+          '@types/bun': '^1',
+        },
       },
       null,
       2,
@@ -142,5 +150,5 @@ function scaffoldFiles(name: string): Record<string, string> {
     'app/globals.css': `body {\n  margin: 0;\n  font-family: system-ui, sans-serif;\n}\n`,
     '.gitignore': `node_modules\n.pnext\n`,
     'README.md': `# ${name}\n\nA pnext app.\n\n\`\`\`\nbun install\nbun dev\n\`\`\`\n\nDocs: node_modules/@wular/pnext/reference/overview.md\n`,
-  };
+  }
 }

package/src/cli/dev.ts

@@ -1,28 +1,28 @@
-import { dim } from '../utils/ansi';
-import { moduleGenerationStats } from '../dev/module-generations';
-import { markBoot, printBootTrace } from './boot-trace';
-import { browserHost, ensurePortFree, openBrowser, printServerReady } from './serve-ui';
+import { dim } from '../utils/ansi'
+import { moduleGenerationStats } from '../runtime/module-generations'
+import { markBoot, printBootTrace } from './boot/trace'
+import { browserHost, ensurePortFree, openBrowser, printServerReady } from './serve/ui'
 
-export const devProcessTitle = 'pnext-dev';
-export const devRestartEnv = 'PNEXT_DEV_RESTART';
+export const devProcessTitle = 'pnext-dev'
+export const devRestartEnv = 'PNEXT_DEV_RESTART'
 
-const defaultMaxDevRssMb = 2048;
-const defaultMaxEsbuildRssMb = 1024;
+const defaultMaxDevRssMb = 2048
+const defaultMaxEsbuildRssMb = 1024
 // A leaf edit supersedes a couple of generations, so this caps stale mass at roughly 300 MB -
 // about one recycle per 75 leaf edits, and one per ~30 on wide-shared-module edits that rename
 // most of a route graph.
-const defaultMaxStaleModules = 150;
+const defaultMaxStaleModules = 150
 /** How long a recycle waits for in-flight responses before replacing the image. */
-const drainTimeoutMs = 5_000;
+const drainTimeoutMs = 5_000
 
 export function nameDevProcess() {
-  process.title = devProcessTitle;
+  process.title = devProcessTitle
 }
 
 export interface DevOptions {
-  root?: string;
-  port?: number;
-  hostname?: string;
+  root?: string
+  port?: number
+  hostname?: string
 }
 
 /**
@@ -31,49 +31,49 @@ export interface DevOptions {
  * place, which frees the module graph without paying a second process spawn on every boot.
  */
 export async function dev(options: DevOptions = {}) {
-  nameDevProcess();
+  nameDevProcess()
   // Loaded lazily so config resolution and the server graph start in parallel.
   const [{ loadConfig }, { startDevServer }] = await Promise.all([
     import('../config'),
     import('../dev/server'),
-  ]);
-  markBoot('dev:imports');
-  const config = await loadConfig(options.root, { dev: true });
-  markBoot('dev:config');
-  const port = options.port ?? 3000;
-  const hostname = options.hostname ?? 'localhost';
+  ])
+  markBoot('dev:imports')
+  const config = await loadConfig(options.root, { dev: true })
+  markBoot('dev:config')
+  const port = options.port ?? 3000
+  const hostname = options.hostname ?? 'localhost'
   // A memory-triggered restart can briefly race the previous listener's
   // shutdown, so give the port a moment to free before failing.
-  await ensurePortFree(port, hostname, { attempts: 10 });
-  markBoot('dev:port');
-  const start = Date.now();
+  await ensurePortFree(port, hostname, { attempts: 10 })
+  markBoot('dev:port')
+  const start = Date.now()
   // Bisect switch, same role `PNEXT_DEV_RESTART_CACHE=0` plays for the restart
   // caches: turns the boot warm-up off so a measurement can price it.
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const warm = process.env.PNEXT_DEV_WARM !== '0';
-  const server = await startDevServer({ config, port, hostname, warm });
-  markBoot('dev:server');
-  const elapsedMs = Date.now() - start;
-  const url = `http://${browserHost(hostname)}:${server.port ?? port}`;
-  printServerReady({ mode: 'dev', hostname, port: server.port ?? port, elapsedMs });
-  printBootTrace();
+  const warm = process.env.PNEXT_DEV_WARM !== '0'
+  const server = await startDevServer({ config, port, hostname, warm })
+  markBoot('dev:server')
+  const elapsedMs = Date.now() - start
+  const url = `http://${browserHost(hostname)}:${server.port ?? port}`
+  printServerReady({ mode: 'dev', hostname, port: server.port ?? port, elapsedMs })
+  printBootTrace()
   // Boot compiles nothing (config loads natively), so the first compile would pay esbuild's service
   // spawn. Warm it here, after the banner - readiness must not wait on it. PNEXT_DEV_ESBUILD_WARM=0 opts out.
   // eslint-disable-next-line turbo/no-undeclared-env-vars
   if (process.env.PNEXT_DEV_ESBUILD_WARM !== '0') {
-    void import('../utils/esbuild').then(module => module.warmEsbuildService());
+    void import('../utils/esbuild').then(module => module.warmEsbuildService())
   }
-  registerShutdown(server);
-  watchServerMemory(server);
-  watchStaleModules(server);
-  watchEsbuildMemory();
+  registerShutdown(server)
+  watchServerMemory(server)
+  watchStaleModules(server)
+  watchEsbuildMemory()
   // Hold the browser until the entry route has compiled, so it opens onto an
   // already-built page instead of a multi-second cold compile.
-  if (server.warmup) console.log(dim('Warming up and opening the browser...'));
-  await server.warmup;
+  if (server.warmup) console.log(dim('Warming up and opening the browser...'))
+  await server.warmup
   // A memory-triggered restart should refresh silently, not open another tab.
-  if (process.env[devRestartEnv] !== '1') openBrowser(url);
-  return server;
+  if (process.env[devRestartEnv] !== '1') openBrowser(url)
+  return server
 }
 
 // Every dev reload imports changed modules under fresh URLs, and the ES module
@@ -82,22 +82,22 @@ export async function dev(options: DevOptions = {}) {
 // preserved on disk) for getting the memory back.
 function watchServerMemory(server: DevServerHandle) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const limitMb = Number(process.env.PNEXT_DEV_MAX_RSS_MB || defaultMaxDevRssMb);
-  if (!Number.isFinite(limitMb) || limitMb <= 0) return;
-  const limitBytes = limitMb * 1024 * 1024;
+  const limitMb = Number(process.env.PNEXT_DEV_MAX_RSS_MB || defaultMaxDevRssMb)
+  if (!Number.isFinite(limitMb) || limitMb <= 0) return
+  const limitBytes = limitMb * 1024 * 1024
   const timer = setInterval(() => {
-    const rss = process.memoryUsage.rss();
-    if (rss < limitBytes) return;
-    clearInterval(timer);
-    const usedMb = Math.round(rss / (1024 * 1024));
+    const rss = process.memoryUsage.rss()
+    if (rss < limitBytes) return
+    clearInterval(timer)
+    const usedMb = Math.round(rss / (1024 * 1024))
     console.log(
       dim(
         `Dev server reached ${usedMb}MB of memory (limit ${limitMb}MB, set PNEXT_DEV_MAX_RSS_MB to change); restarting to release stale modules...`,
       ),
-    );
-    void restartDevProcess(server);
-  }, 15_000);
-  timer.unref();
+    )
+    void restartDevProcess(server)
+  }, 15_000)
+  timer.unref()
 }
 
 // The esbuild Go service self-drains its heap when idle, so two consecutive readings above the
@@ -105,35 +105,35 @@ function watchServerMemory(server: DevServerHandle) {
 // builds, never incremental contexts. A stop that races an in-flight build fails that one build;
 // dev asset caches drop failed builds, so the next request retries.
 function watchEsbuildMemory() {
-  if (process.platform === 'win32') return;
+  if (process.platform === 'win32') return
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const limitMb = Number(process.env.PNEXT_DEV_MAX_ESBUILD_RSS_MB || defaultMaxEsbuildRssMb);
-  if (!Number.isFinite(limitMb) || limitMb <= 0) return;
-  let highTicks = 0;
+  const limitMb = Number(process.env.PNEXT_DEV_MAX_ESBUILD_RSS_MB || defaultMaxEsbuildRssMb)
+  if (!Number.isFinite(limitMb) || limitMb <= 0) return
+  let highTicks = 0
   const timer = setInterval(() => {
-    const rssMb = esbuildServiceRssMb();
-    highTicks = rssMb > limitMb ? highTicks + 1 : 0;
-    if (highTicks < 2) return;
-    highTicks = 0;
+    const rssMb = esbuildServiceRssMb()
+    highTicks = rssMb > limitMb ? highTicks + 1 : 0
+    if (highTicks < 2) return
+    highTicks = 0
     console.log(
       dim(
         `esbuild reached ${Math.round(rssMb)}MB of memory (limit ${limitMb}MB, set PNEXT_DEV_MAX_ESBUILD_RSS_MB to change); restarting it to release the heap...`,
       ),
-    );
+    )
     void (async () => {
       try {
-        const esbuild = await import('esbuild');
-        await esbuild.stop();
+        const esbuild = await import('esbuild')
+        await esbuild.stop()
       } catch {
         // ignore: the service may already be gone
       }
       // stop() can strand in-flight build promises unsettled; fail their
       // waiters so requests retry against the respawned service.
-      const { failInFlightClientBuilds } = await import('../dev/server');
-      failInFlightClientBuilds('esbuild service restarted by the memory watchdog');
-    })();
-  }, 15_000);
-  timer.unref();
+      const { failInFlightClientBuilds } = await import('../dev/server')
+      failInFlightClientBuilds('esbuild service restarted by the memory watchdog')
+    })()
+  }, 15_000)
+  timer.unref()
 }
 
 /**
@@ -146,48 +146,48 @@ function watchEsbuildMemory() {
  */
 function watchStaleModules(server: DevServerHandle) {
   // eslint-disable-next-line turbo/no-undeclared-env-vars
-  const limit = Number(process.env.PNEXT_DEV_MAX_STALE_MODULES || defaultMaxStaleModules);
-  if (!Number.isFinite(limit) || limit <= 0) return;
+  const limit = Number(process.env.PNEXT_DEV_MAX_STALE_MODULES || defaultMaxStaleModules)
+  if (!Number.isFinite(limit) || limit <= 0) return
   const timer = setInterval(() => {
-    const { stale } = moduleGenerationStats();
-    if (stale < limit) return;
-    clearInterval(timer);
+    const { stale } = moduleGenerationStats()
+    if (stale < limit) return
+    clearInterval(timer)
     console.log(
       dim(
         `Dev server is holding ${stale} superseded module generations (limit ${limit}, set PNEXT_DEV_MAX_STALE_MODULES to change); restarting to release them...`,
       ),
-    );
-    void restartDevProcess(server);
-  }, 15_000);
-  timer.unref();
+    )
+    void restartDevProcess(server)
+  }, 15_000)
+  timer.unref()
 }
 
 // Our esbuild service children: [pid, RSS in MB] per process.
 function esbuildServices(): [number, number][] {
-  const found: [number, number][] = [];
+  const found: [number, number][] = []
   try {
-    const stdout = Bun.spawnSync(['ps', '-ax', '-o', 'pid=,ppid=,rss=,ucomm=']).stdout.toString();
+    const stdout = Bun.spawnSync(['ps', '-ax', '-o', 'pid=,ppid=,rss=,ucomm=']).stdout.toString()
     for (const line of stdout.split('\n')) {
-      const [pid, ppid, rss, ...name] = line.trim().split(/\s+/);
+      const [pid, ppid, rss, ...name] = line.trim().split(/\s+/)
       if (Number(ppid) === process.pid && name.join(' ').includes('esbuild')) {
-        found.push([Number(pid), Number(rss) / 1024]);
+        found.push([Number(pid), Number(rss) / 1024])
       }
     }
   } catch {
     // ignore: no ps available means no monitoring, not a broken dev server
   }
-  return found;
+  return found
 }
 
 // RSS of our esbuild service, in MB (0 when not running).
 function esbuildServiceRssMb() {
-  return esbuildServices().reduce((total, [, rssMb]) => total + rssMb, 0);
+  return esbuildServices().reduce((total, [, rssMb]) => total + rssMb, 0)
 }
 
 interface DevServerHandle {
-  stop(closeActiveConnections?: boolean): unknown;
+  stop(closeActiveConnections?: boolean): unknown
   /** Resolves once nothing is being served (or the timeout elapses). */
-  drain?(timeoutMs: number): Promise<boolean>;
+  drain?(timeoutMs: number): Promise<boolean>
 }
 
 /**
@@ -201,9 +201,9 @@ async function restartDevProcess(server: DevServerHandle): Promise<void> {
   try {
     // Stop accepting, then let what is already being served finish: an exec
     // mid-response would leave the browser with a truncated page and no error.
-    server.stop(false);
-    await server.drain?.(drainTimeoutMs);
-    server.stop(true);
+    server.stop(false)
+    await server.drain?.(drainTimeoutMs)
+    server.stop(true)
   } catch {
     // ignore: we are being replaced regardless
   }
@@ -211,72 +211,72 @@ async function restartDevProcess(server: DevServerHandle): Promise<void> {
   // image that owned it — with exactly the heap this restart is reclaiming.
   for (const [pid] of esbuildServices()) {
     try {
-      process.kill(pid, 'SIGTERM');
+      process.kill(pid, 'SIGTERM')
     } catch {
       // ignore: already gone
     }
   }
-  const argv = [process.execPath, '--conditions=react-server', ...process.argv.slice(1)];
-  const env = { ...process.env, [devRestartEnv]: '1' };
+  const argv = [process.execPath, '--conditions=react-server', ...process.argv.slice(1)]
+  const env = { ...process.env, [devRestartEnv]: '1' }
   try {
-    await execSelf(argv, env);
+    await execSelf(argv, env)
   } catch {
     // ignore: fall through to the spawn path
   }
   // Only reached when exec is unavailable or failed.
-  Bun.spawn(argv, { stdin: 'inherit', stdout: 'inherit', stderr: 'inherit', env });
-  process.exit(0);
+  Bun.spawn(argv, { stdin: 'inherit', stdout: 'inherit', stderr: 'inherit', env })
+  process.exit(0)
 }
 
 // execve(2) via libc. argv/envp are NUL-terminated C string arrays, and the
 // pointer array must stay reachable until the call returns (it never does on
 // success).
 async function execSelf(argv: string[], env: Record<string, string | undefined>): Promise<void> {
-  if (process.platform === 'win32') return;
-  const { dlopen, FFIType, ptr, suffix } = await import('bun:ffi');
-  const libc = process.platform === 'darwin' ? '/usr/lib/libSystem.B.dylib' : `libc.${suffix}.6`;
+  if (process.platform === 'win32') return
+  const { dlopen, FFIType, ptr, suffix } = await import('bun:ffi')
+  const libc = process.platform === 'darwin' ? '/usr/lib/libSystem.B.dylib' : `libc.${suffix}.6`
   const { symbols } = dlopen(libc, {
     execve: {
       args: [FFIType.cstring, FFIType.ptr, FFIType.ptr],
       returns: FFIType.i32,
     },
-  });
-  const encoder = new TextEncoder();
-  const cString = (value: string) => encoder.encode(`${value}\0`);
+  })
+  const encoder = new TextEncoder()
+  const cString = (value: string) => encoder.encode(`${value}\0`)
   const cArray = (values: string[]) => {
-    const cells = values.map(cString);
-    const array = new BigInt64Array(cells.length + 1);
+    const cells = values.map(cString)
+    const array = new BigInt64Array(cells.length + 1)
     cells.forEach((cell, index) => {
-      array[index] = BigInt(ptr(cell));
-    });
-    return { array, cells };
-  };
-  const args = cArray(argv);
+      array[index] = BigInt(ptr(cell))
+    })
+    return { array, cells }
+  }
+  const args = cArray(argv)
   const envp = cArray(
     Object.entries(env)
       .filter(([, value]) => value !== undefined)
       .map(([key, value]) => `${key}=${value}`),
-  );
-  symbols.execve(cString(argv[0]!), ptr(args.array), ptr(envp.array));
+  )
+  symbols.execve(cString(argv[0]!), ptr(args.array), ptr(envp.array))
   // execve only returns on failure; keep the buffers alive until then.
-  void [args.cells, envp.cells];
+  void [args.cells, envp.cells]
 }
 
 // Stop the server and run process `exit` handlers on a terminating signal,
 // so killing the dev server never leaves orphaned subprocesses behind.
 function registerShutdown(server: DevServerHandle) {
-  let closing = false;
+  let closing = false
   const shutdown = () => {
-    if (closing) return;
-    closing = true;
+    if (closing) return
+    closing = true
     try {
-      server.stop(true);
+      server.stop(true)
     } catch {
       // ignore: process is exiting regardless
     }
-    process.exit(0);
-  };
+    process.exit(0)
+  }
   for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP'] as const) {
-    process.once(signal, shutdown);
+    process.once(signal, shutdown)
   }
 }