@davaux/multisite 0.8.0 → 0.8.1

package/src/index.ts

@@ -1,1219 +0,0 @@
-import { spawn } from 'node:child_process'
-import { createReadStream, existsSync, watch as fsWatch, statSync } from 'node:fs'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import { createServer } from 'node:http'
-import { join, relative } from 'node:path'
-import type {
-  IslandFile,
-  LayoutFile,
-  MiddlewareFile,
-  RequestContext,
-  RouteFile,
-  RouteType,
-  ScanResult,
-} from 'davaux'
-import {
-  collectCss,
-  cssCollectorPlugin,
-  generateIslandsEntry,
-  islandServerPlugin,
-} from 'davaux/build'
-import {
-  collectEsbuildPlugins,
-  collectScannerSuffixes,
-  type DavauxPlugin,
-  pathsToAlias,
-} from 'davaux/config'
-import type { CompiledApp } from 'davaux/handler'
-import { buildApp, dispatch } from 'davaux/handler'
-import { scanIslands, scanRoutes } from 'davaux/scanner'
-import { context, type Plugin } from 'esbuild'
-
-// Keyed on the Node IncomingMessage object — auto-cleaned when the request is GC'd.
-const siteConfigMap = new WeakMap<IncomingMessage, unknown>()
-
-// ─── Public types ─────────────────────────────────────────────────────────────
-
-export interface SiteDefinition<T = Record<string, unknown>> {
-  /** Unique name for this site. Used in logging. */
-  name: string
-  /**
-   * Hostname(s) that route to this site. Supply `'*'` as a catch-all fallback.
-   * Port is stripped before matching, so `'example.com'` matches both
-   * `example.com` and `example.com:3000`.
-   */
-  hostname: string | string[]
-  /**
-   * Absolute path to the site-specific routes directory. Routes here are
-   * overlaid on top of `baseDir`: same URL pattern + type in the overlay wins.
-   * Omit to run the base routes without any site-specific overrides.
-   */
-  routesDir?: string
-  /**
-   * Absolute path to the site-specific islands directory. Islands here are
-   * merged with those in `MultisiteConfig.islandsDir` for this site's client bundle.
-   */
-  islandsDir?: string
-  /**
-   * Absolute path to the site-specific public directory. Static files here are
-   * served at their URL path before route dispatch, taking priority over the
-   * shared `publicDir` when both contain a file at the same path.
-   */
-  publicDir?: string
-  /**
-   * Absolute path to a site-specific client-side entry file. Overrides
-   * `MultisiteConfig.clientEntry` for this site when set.
-   */
-  clientEntry?: string
-  /** Arbitrary per-site config — accessible via `getSite<T>(ctx)` in any handler, layout, or middleware. */
-  config?: T
-}
-
-export interface MultisiteConfig<T = Record<string, unknown>> {
-  /** Absolute path to the shared base routes directory. */
-  baseDir?: string
-  /** Absolute path to the shared islands directory. Islands here are included in every site's client bundle. */
-  islandsDir?: string
-  /** Absolute path to the shared public directory. Static files are served at their URL path before route dispatch. */
-  publicDir?: string
-  /**
-   * Absolute path to a shared client-side entry file compiled to `/_davaux/client.js` and
-   * injected into every page. Per-site `clientEntry` overrides this when set.
-   */
-  clientEntry?: string
-  /** Site definitions — one entry per hostname (or hostname group). */
-  sites: SiteDefinition<T>[]
-  /** Extra route suffixes forwarded from plugins (e.g. `[['.page.md', 'page']]`). */
-  extraSuffixes?: [string, RouteType][]
-}
-
-export interface BuildOptions {
-  isDev?: boolean
-  clientScripts?: string[]
-  clientStylesheets?: string[]
-  basePath?: string
-  /** Absolute path to a compiled app-level middleware file (runs before route matching on every request). */
-  appMiddlewarePath?: string
-  /**
-   * Absolute path to the `src/middleware.ts` source file. In dev mode it is
-   * compiled alongside route files and used as `appMiddlewarePath`.
-   * `startMultisite` auto-detects `<cwd>/src/middleware.ts` when `cwd` is set.
-   */
-  middlewareSrc?: string
-  /**
-   * Absolute path to the project root — used in dev mode to locate the esbuild
-   * temp directory (`.davaux-multisite/`). Defaults to `process.cwd()`.
-   * Pass `import.meta.dirname` from your `server.ts` for reliable resolution.
-   */
-  cwd?: string
-  /**
-   * Davaux plugins to apply — contributes esbuild transforms and scanner suffix
-   * extensions. Use the same list here as in `buildMultisite`.
-   *
-   * @example
-   * import { mdx } from '@davaux/mdx'
-   * startMultisite(sites, { plugins: [mdx()] })
-   */
-  plugins?: DavauxPlugin[]
-  /**
-   * tsconfig-style path aliases forwarded to esbuild `alias` in every build context.
-   * Same format as `compilerOptions.paths` — use `{ '~/*': ['./src/*'] }`.
-   */
-  paths?: Record<string, string>
-  /**
-   * Extra packages to mark as external beyond the defaults (`node:*`, `davaux`,
-   * `@davaux/multisite`). Useful for native or CJS-only packages like `canvas` or
-   * `better-sqlite3`.
-   */
-  external?: string[]
-}
-
-export interface ServerOptions {
-  port?: number
-  hostname?: string
-}
-
-export interface StartMultisiteOptions extends BuildOptions, ServerOptions {}
-
-// ─── Internal types ───────────────────────────────────────────────────────────
-
-interface SiteEntry<T> {
-  app: CompiledApp
-  config: T | undefined
-  /** Absolute path to the compiled client islands bundle, if any. */
-  islandsPath?: string
-  /** Absolute path to the compiled CSS stylesheet, if any. */
-  stylesPath?: string
-  /** Absolute path to the compiled client entry bundle, if any. */
-  clientPath?: string
-  /** Ordered list of public directories to serve static files from (per-site first, then shared). */
-  publicDirs: string[]
-}
-
-function contentTypeFor(filePath: string): string {
-  const ext = filePath.slice(filePath.lastIndexOf('.') + 1).toLowerCase()
-  const types: Record<string, string> = {
-    css: 'text/css',
-    gif: 'image/gif',
-    html: 'text/html',
-    ico: 'image/x-icon',
-    jpeg: 'image/jpeg',
-    jpg: 'image/jpeg',
-    js: 'application/javascript',
-    json: 'application/json',
-    mjs: 'application/javascript',
-    pdf: 'application/pdf',
-    png: 'image/png',
-    svg: 'image/svg+xml',
-    txt: 'text/plain',
-    webmanifest: 'application/manifest+json',
-    webp: 'image/webp',
-    woff: 'font/woff',
-    woff2: 'font/woff2',
-    xml: 'text/xml',
-  }
-  return types[ext] ?? 'application/octet-stream'
-}
-
-// ─── Route sort helpers (mirrors scanRoutes internals) ────────────────────────
-
-const TYPE_PRIORITY: Record<string, number> = { page: 1 }
-
-function dynamicWeight(pattern: string): number {
-  const segs = pattern.split('/')
-  if (segs.some((s) => s.startsWith('*'))) return 1000
-  return segs.filter((s) => s.startsWith(':')).length
-}
-
-function sortRoutes(routes: RouteFile[]): RouteFile[] {
-  return [...routes].sort((a, b) => {
-    const aw = dynamicWeight(a.urlPattern)
-    const bw = dynamicWeight(b.urlPattern)
-    if (aw !== bw) return aw - bw
-    if (a.urlPattern.length !== b.urlPattern.length)
-      return a.urlPattern.length - b.urlPattern.length
-    return (TYPE_PRIORITY[a.type] ?? 0) - (TYPE_PRIORITY[b.type] ?? 0)
-  })
-}
-
-// ─── Merge logic ──────────────────────────────────────────────────────────────
-
-/**
- * Merge a site-specific `ScanResult` on top of a base `ScanResult`.
- *
- * - **Routes**: overlay wins at the same `urlPattern + type`. The merged list
- *   is re-sorted so static routes still precede dynamic ones.
- * - **Layouts**: overlay wins at the same `dirPath` (directory-level override).
- *   Layouts in directories unique to either tree are kept as-is.
- * - **Middlewares**: overlay wins at the same `dirPath`. Middlewares unique to
- *   the base still run; overlapping ones are replaced by the site version.
- * - **Error page**: overlay wins if present, otherwise falls back to base.
- */
-export function mergeScanResults(base: ScanResult, overlay: ScanResult): ScanResult {
-  // Routes — overlay wins by URL pattern + type
-  const overlayRouteKeys = new Set(overlay.routes.map((r) => `${r.type}:${r.urlPattern}`))
-  const routes: RouteFile[] = sortRoutes([
-    ...overlay.routes,
-    ...base.routes.filter((r) => !overlayRouteKeys.has(`${r.type}:${r.urlPattern}`)),
-  ])
-
-  // Layouts — overlay wins by dirPath
-  const overlayLayoutDirs = new Set(overlay.layouts.map((l) => l.dirPath))
-  const layouts: LayoutFile[] = [
-    ...overlay.layouts,
-    ...base.layouts.filter((l) => !overlayLayoutDirs.has(l.dirPath)),
-  ]
-
-  // Middlewares — overlay wins by dirPath; base middlewares for non-overlapping
-  // dirs still run (they're naturally ordered outermost-first by the handler)
-  const overlayMiddlewareDirs = new Set(overlay.middlewares.map((m) => m.dirPath))
-  const middlewares: MiddlewareFile[] = [
-    ...base.middlewares.filter((m) => !overlayMiddlewareDirs.has(m.dirPath)),
-    ...overlay.middlewares,
-  ]
-
-  return {
-    routes,
-    layouts,
-    middlewares,
-    errorPage: overlay.errorPage ?? base.errorPage,
-  }
-}
-
-// ─── Config helper ────────────────────────────────────────────────────────────
-
-/** Identity function — returns config unchanged. Provides TypeScript inference for the site config type `T`. */
-export function defineSites<T = Record<string, unknown>>(
-  config: MultisiteConfig<T>,
-): MultisiteConfig<T> {
-  return config
-}
-
-// ─── Build ────────────────────────────────────────────────────────────────────
-
-/**
- * Scan all site route directories, merge each with the shared base, and return
- * a per-hostname map of compiled apps ready for dispatch.
- *
- * In dev mode (`isDev: true`), all route files are compiled with esbuild
- * (applying plugin transforms and wrapping island imports server-side) and
- * per-site client island bundles are built before the server starts.
- *
- * @example
- * const apps = await buildMultisiteApps(sites, { isDev: true, cwd: import.meta.dirname })
- * startMultisiteServer(apps, { port: 3000 })
- */
-export async function buildMultisiteApps<T = Record<string, unknown>>(
-  config: MultisiteConfig<T>,
-  options: BuildOptions = {},
-): Promise<Map<string, SiteEntry<T>>> {
-  const { baseDir, islandsDir: baseIslandsDir, sites, extraSuffixes: configSuffixes = [] } = config
-  const {
-    isDev = false,
-    clientScripts = [],
-    clientStylesheets = [],
-    basePath = '',
-    appMiddlewarePath,
-    middlewareSrc,
-    cwd: cwdOpt,
-    plugins: davauxPlugins = [],
-    paths,
-    external: userExternal = [],
-  } = options
-
-  const cwd = cwdOpt ?? process.cwd()
-  const allSuffixes = [...configSuffixes, ...collectScannerSuffixes(davauxPlugins)]
-  const userAlias = pathsToAlias(paths ?? {})
-  const devExternal = ['node:*', 'davaux', '@davaux/multisite', ...userExternal]
-
-  // All island directories across base + all sites (for the server-side island plugin)
-  const allIslandDirs: string[] = [
-    ...(baseIslandsDir ? [baseIslandsDir] : []),
-    ...sites.flatMap((s) => (s.islandsDir ? [s.islandsDir] : [])),
-  ]
-
-  // Scan all route directories upfront
-  const baseScanRaw: ScanResult = baseDir
-    ? await scanRoutes(baseDir, allSuffixes)
-    : { routes: [], layouts: [], middlewares: [] }
-
-  const siteScanMap = new Map<string, ScanResult>()
-  for (const site of sites) {
-    siteScanMap.set(
-      site.name,
-      site.routesDir
-        ? await scanRoutes(site.routesDir, allSuffixes)
-        : { routes: [], layouts: [], middlewares: [] },
-    )
-  }
-
-  // Populated during the blocks below; consumed when building per-site SiteEntry
-  const siteIslandsPaths = new Map<string, string>()
-  const siteClientPaths = new Map<string, string>()
-  let sharedStylesPath: string | undefined
-
-  // Path-mapping functions — identity in production, remapped in dev
-  let toCompiledPath = (p: string) => p
-  let toCompiledDir = (d: string) => d
-
-  if (isDev) {
-    const { build } = await import('esbuild')
-    const dauxDir = join(cwd, '.davaux-multisite')
-    const routesOutDir = join(dauxDir, 'routes')
-    sharedStylesPath = join(dauxDir, 'styles.css')
-
-    // Compile all route files — applies plugin transforms and server-side island wrapping
-    function collectRouteFiles(scan: ScanResult): string[] {
-      return [
-        ...scan.routes.map((r) => r.filePath),
-        ...scan.layouts.map((l) => l.filePath),
-        ...scan.middlewares.map((m) => m.filePath),
-        ...(scan.errorPage ? [scan.errorPage] : []),
-      ]
-    }
-
-    const allRouteFiles = [
-      ...collectRouteFiles(baseScanRaw),
-      ...[...siteScanMap.values()].flatMap(collectRouteFiles),
-      ...(middlewareSrc && existsSync(middlewareSrc) ? [middlewareSrc] : []),
-    ]
-
-    if (allRouteFiles.length > 0) {
-      await build({
-        entryPoints: allRouteFiles,
-        outdir: routesOutDir,
-        outbase: cwd,
-        format: 'esm',
-        platform: 'node',
-        target: 'node22',
-        bundle: true,
-        external: devExternal,
-        jsx: 'automatic',
-        jsxImportSource: 'davaux',
-        sourcemap: 'inline',
-        alias: { ...userAlias, 'davaux/client': 'davaux/signal' },
-        plugins: [
-          ...(allIslandDirs.length > 0 ? [islandServerPlugin(allIslandDirs)] : []),
-          ...collectEsbuildPlugins(davauxPlugins),
-        ],
-      })
-    }
-
-    // Compile per-site client island bundles
-    const baseIslands: IslandFile[] = baseIslandsDir ? await scanIslands(baseIslandsDir) : []
-
-    for (const site of sites) {
-      const siteIslands: IslandFile[] = site.islandsDir ? await scanIslands(site.islandsDir) : []
-      const allIslands = [...baseIslands, ...siteIslands]
-      if (allIslands.length === 0) continue
-
-      const islandsPath = join(dauxDir, site.name, 'islands.js')
-      await build({
-        stdin: {
-          contents: generateIslandsEntry(allIslands),
-          loader: 'ts',
-          resolveDir: cwd,
-        },
-        outfile: islandsPath,
-        format: 'esm',
-        platform: 'browser',
-        target: 'es2022',
-        bundle: true,
-        jsx: 'automatic',
-        jsxImportSource: 'davaux/client',
-        sourcemap: 'inline',
-        plugins: collectEsbuildPlugins(davauxPlugins),
-      })
-      siteIslandsPaths.set(site.name, islandsPath)
-    }
-
-    // Compile per-site client bundles
-    for (const site of sites) {
-      const clientEntry = site.clientEntry ?? config.clientEntry
-      if (!clientEntry || !existsSync(clientEntry)) continue
-      const clientPath = join(dauxDir, site.name, 'client.js')
-      await build({
-        entryPoints: [clientEntry],
-        outfile: clientPath,
-        format: 'esm',
-        platform: 'browser',
-        target: 'es2022',
-        bundle: true,
-        jsx: 'automatic',
-        jsxImportSource: 'davaux/client',
-        sourcemap: 'inline',
-        plugins: collectEsbuildPlugins(davauxPlugins),
-      })
-      siteClientPaths.set(site.name, clientPath)
-    }
-
-    // Collect all CSS emitted by the builds into one shared stylesheet
-    await collectCss(dauxDir, sharedStylesPath)
-
-    toCompiledPath = (src: string) =>
-      join(routesOutDir, relative(cwd, src).replace(/\.(tsx?|jsx?|mdx?)$/, '.js'))
-    toCompiledDir = (srcDir: string) => join(routesOutDir, relative(cwd, srcDir))
-  } else {
-    // Production: pick up pre-compiled bundles written by buildMultisite
-    for (const site of sites) {
-      const islands = join(cwd, '_davaux', site.name, 'islands.js')
-      if (existsSync(islands)) siteIslandsPaths.set(site.name, islands)
-      const client = join(cwd, '_davaux', site.name, 'client.js')
-      if (existsSync(client)) siteClientPaths.set(site.name, client)
-    }
-    const prodStyles = join(cwd, '_davaux', 'styles.css')
-    if (existsSync(prodStyles)) sharedStylesPath = prodStyles
-  }
-
-  function remapScan(scan: ScanResult): ScanResult {
-    return {
-      routes: scan.routes.map((r) => ({ ...r, filePath: toCompiledPath(r.filePath) })),
-      layouts: scan.layouts.map((l) => ({
-        filePath: toCompiledPath(l.filePath),
-        dirPath: toCompiledDir(l.dirPath),
-      })),
-      middlewares: scan.middlewares.map((m) => ({
-        filePath: toCompiledPath(m.filePath),
-        dirPath: toCompiledDir(m.dirPath),
-      })),
-      errorPage: scan.errorPage ? toCompiledPath(scan.errorPage) : undefined,
-    }
-  }
-
-  const effectiveMiddlewarePath =
-    isDev && middlewareSrc && existsSync(middlewareSrc)
-      ? toCompiledPath(middlewareSrc)
-      : appMiddlewarePath
-
-  const baseScan = isDev ? remapScan(baseScanRaw) : baseScanRaw
-  const result = new Map<string, SiteEntry<T>>()
-
-  for (const site of sites) {
-    const rawSiteScan = siteScanMap.get(site.name) ?? { routes: [], layouts: [], middlewares: [] }
-    const siteScan = isDev ? remapScan(rawSiteScan) : rawSiteScan
-    const merged = mergeScanResults(baseScan, siteScan)
-
-    const islandsPath = siteIslandsPaths.get(site.name)
-    const clientPath = siteClientPaths.get(site.name)
-    const siteClientScripts = [
-      ...(islandsPath ? ['/_davaux/islands.js'] : []),
-      ...(clientPath ? ['/_davaux/client.js'] : []),
-      ...clientScripts,
-    ]
-    const siteClientStylesheets = [
-      ...(sharedStylesPath ? ['/_davaux/styles.css'] : []),
-      ...clientStylesheets,
-    ]
-
-    const publicDirs: string[] = [
-      ...(site.publicDir ? [site.publicDir] : []),
-      ...(config.publicDir ? [config.publicDir] : []),
-    ]
-
-    const app = buildApp(
-      merged,
-      isDev,
-      siteClientScripts,
-      siteClientStylesheets,
-      effectiveMiddlewarePath,
-      basePath,
-    )
-
-    const entry: SiteEntry<T> = {
-      app,
-      config: site.config,
-      islandsPath,
-      stylesPath: sharedStylesPath,
-      clientPath,
-      publicDirs,
-    }
-    const hostnames = Array.isArray(site.hostname) ? site.hostname : [site.hostname]
-    for (const h of hostnames) result.set(h, entry)
-  }
-
-  return result
-}
-
-// ─── Server ───────────────────────────────────────────────────────────────────
-
-/**
- * Start an HTTP server that dispatches each request to the matching site by
- * hostname. Falls back to the `'*'` entry if the hostname is not explicitly
- * registered. Responds 404 if neither matches.
- *
- * `sites` may be a `() => Map` factory so the caller can hot-swap compiled apps
- * in dev mode without restarting the server.
- */
-export function startMultisiteServer<T = Record<string, unknown>>(
-  sites: Map<string, SiteEntry<T>> | (() => Map<string, SiteEntry<T>>),
-  options: ServerOptions = {},
-): ReturnType<typeof createServer> {
-  const { port = 3000, hostname = 'localhost' } = options
-  const getSites = typeof sites === 'function' ? sites : () => sites
-
-  const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
-    const host = (req.headers.host ?? '').split(':')[0]
-    const currentSites = getSites()
-    const entry = currentSites.get(host) ?? currentSites.get('*')
-
-    if (!entry) {
-      res.writeHead(404, { 'Content-Type': 'text/plain' })
-      res.end(`[davaux/multisite] No site registered for host: ${host}`)
-      return
-    }
-
-    if (entry.config !== undefined) siteConfigMap.set(req, entry.config)
-
-    // Serve davaux static assets — per-site for islands, shared for CSS
-    const urlPath = req.url?.split('?')[0]
-
-    if (urlPath === '/_davaux/islands.js') {
-      if (entry.islandsPath && existsSync(entry.islandsPath)) {
-        res.writeHead(200, { 'Content-Type': 'application/javascript' })
-        createReadStream(entry.islandsPath).pipe(res)
-      } else {
-        res.writeHead(404, { 'Content-Type': 'text/plain' })
-        res.end('Not Found')
-      }
-      return
-    }
-
-    if (urlPath === '/_davaux/client.js') {
-      if (entry.clientPath && existsSync(entry.clientPath)) {
-        res.writeHead(200, { 'Content-Type': 'application/javascript' })
-        createReadStream(entry.clientPath).pipe(res)
-      } else {
-        res.writeHead(404, { 'Content-Type': 'text/plain' })
-        res.end('Not Found')
-      }
-      return
-    }
-
-    if (urlPath === '/_davaux/styles.css') {
-      res.writeHead(200, { 'Content-Type': 'text/css' })
-      if (entry.stylesPath && existsSync(entry.stylesPath)) {
-        createReadStream(entry.stylesPath).pipe(res)
-      } else {
-        res.end('')
-      }
-      return
-    }
-
-    // Stub livereload endpoints — live reload is not yet supported in multisite
-    if (urlPath === '/_davaux/livereload.js' || urlPath === '/_davaux/livereload-worker.js') {
-      res.writeHead(200, { 'Content-Type': 'application/javascript' })
-      res.end('')
-      return
-    }
-
-    // Serve static files from public directories (per-site dir takes priority over shared)
-    if (urlPath) {
-      const relPath = urlPath.replace(/^\/+/, '')
-      if (relPath) {
-        for (const dir of entry.publicDirs) {
-          const filePath = join(dir, relPath)
-          const normalizedDir = dir.endsWith('/') ? dir : `${dir}/`
-          if (!filePath.startsWith(normalizedDir)) continue // path traversal guard
-          if (existsSync(filePath) && statSync(filePath).isFile()) {
-            res.writeHead(200, { 'Content-Type': contentTypeFor(filePath) })
-            createReadStream(filePath).pipe(res)
-            return
-          }
-        }
-      }
-    }
-
-    dispatch(req, res, entry.app).catch((err) => {
-      console.error('[davaux/multisite] Unhandled dispatch error:', err)
-      if (!res.headersSent) {
-        res.writeHead(500, { 'Content-Type': 'text/plain' })
-        res.end('Internal Server Error')
-      }
-    })
-  })
-
-  server.listen(port, hostname, () => {
-    console.log(`\n  davaux/multisite  http://${hostname}:${port}\n`)
-  })
-
-  return server
-}
-
-// ─── Low-level dispatch ───────────────────────────────────────────────────────
-
-/**
- * Look up the correct site by the request's `host` header, inject the site
- * config into the WeakMap, and dispatch the request. Returns `false` if no
- * site is registered for the host (including the `'*'` fallback).
- *
- * Useful for embedding multisite dispatch into a custom server or for testing
- * without spinning up a real HTTP server.
- *
- * @example
- * const server = createServer(async (req, res) => {
- *   const handled = await dispatchToSite(sites, req, res)
- *   if (!handled) { res.writeHead(404); res.end('No site') }
- * })
- */
-export async function dispatchToSite<T = Record<string, unknown>>(
-  sites: Map<string, SiteEntry<T>>,
-  req: IncomingMessage,
-  res: ServerResponse,
-): Promise<boolean> {
-  const host = (req.headers.host ?? '').split(':')[0]
-  const entry = sites.get(host) ?? sites.get('*')
-  if (!entry) return false
-  if (entry.config !== undefined) siteConfigMap.set(req, entry.config)
-  await dispatch(req, res, entry.app)
-  return true
-}
-
-// ─── Dev mode ────────────────────────────────────────────────────────────────
-
-// SharedWorker fans one SSE connection per origin to all tabs; falls back to per-tab EventSource.
-const SHARED_WORKER_SCRIPT = `var ports=[];var source=null;
-self.onconnect=function(ev){
-  var port=ev.ports[0];port.start();ports.push(port);
-  if(!source){
-    source=new EventSource('/_davaux/livereload');
-    source.onmessage=function(e){
-      ports=ports.filter(function(p){try{p.postMessage(e.data);return true}catch(_){return false}});
-    };
-  }
-};`
-
-const LIVERELOAD_SCRIPT = `;(function(){
-  var overlay=null
-  function esc(s){return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;')}
-  function show(errors){
-    if(!overlay){
-      overlay=document.createElement('div')
-      overlay.style.cssText='position:fixed;inset:0;z-index:99999;overflow:auto;background:#0d0d0d;color:#e8e8e8;font:13px/1.6 monospace;padding:2rem;box-sizing:border-box'
-      document.body.appendChild(overlay)
-    }
-    overlay.innerHTML='<p style="color:#ff5555;font-size:1.1em;margin:0 0 1.5rem 0"><b>[davaux] Build Error</b></p>'+
-      errors.map(function(e){
-        var loc=e.file?(e.file+(e.line?':'+e.line+':'+e.column:'')):'unknown'
-        return '<div style="margin-bottom:1.25rem;border:1px solid #ff3333;border-radius:6px;padding:1rem">'+
-          '<div style="color:#888;font-size:0.9em;margin-bottom:0.4rem">'+esc(loc)+'</div>'+
-          '<div style="color:#ff6b6b">'+esc(e.text)+'</div>'+
-          (e.lineText?'<pre style="margin:0.75rem 0 0;padding:0.5rem;background:#1a1a1a;border-radius:4px;overflow:auto;color:#aaa">'+esc(e.lineText)+'</pre>':'')+
-          '</div>'
-      }).join('')
-  }
-  function handle(data){
-    if(data==='reload'){location.reload()}
-    else if(data.slice(0,6)==='error:'){show(JSON.parse(data.slice(6)))}
-  }
-  if(typeof SharedWorker!=='undefined'){
-    var w=new SharedWorker('/_davaux/livereload-worker.js')
-    w.port.onmessage=function(ev){handle(ev.data)}
-    w.port.start()
-  } else {
-    new EventSource('/_davaux/livereload').onmessage=function(ev){handle(ev.data)}
-  }
-})()`
-
-function startTypeChecker(cwd: string): void {
-  const tscBin = join(cwd, 'node_modules', '.bin', 'tsc')
-  if (!existsSync(tscBin) || !existsSync(join(cwd, 'tsconfig.json'))) return
-  const proc = spawn(tscBin, ['--noEmit', '--watch', '--preserveWatchOutput'], {
-    cwd,
-    stdio: ['ignore', 'inherit', 'inherit'],
-  })
-  proc.on('error', () => {})
-  process.on('exit', () => proc.kill())
-}
-
-/**
- * Start a multisite dev server with file watching, live reload, and TypeScript type checking.
- * Called automatically by `startMultisite` when `NODE_ENV !== 'production'`.
- */
-export async function startMultisiteDev<T = Record<string, unknown>>(
-  config: MultisiteConfig<T>,
-  options: StartMultisiteOptions = {},
-): Promise<ReturnType<typeof createServer>> {
-  const {
-    port = 3000,
-    hostname = 'localhost',
-    clientScripts: extraClientScripts = [],
-    clientStylesheets: extraClientStylesheets = [],
-    basePath = '',
-    appMiddlewarePath: explicitMiddlewarePath,
-    middlewareSrc,
-    cwd: cwdOpt,
-    plugins: davauxPlugins = [],
-    paths,
-    external: userExternal = [],
-  } = options
-
-  const cwd = cwdOpt ?? process.cwd()
-  const { baseDir, islandsDir: baseIslandsDir, sites } = config
-  const allSuffixes = [...(config.extraSuffixes ?? []), ...collectScannerSuffixes(davauxPlugins)]
-  const extraPlugins = collectEsbuildPlugins(davauxPlugins)
-  const userAlias = pathsToAlias(paths ?? {})
-  const serverExternal = ['node:*', 'davaux', '@davaux/multisite', ...userExternal]
-
-  const dauxDir = join(cwd, '.davaux-multisite')
-  const routesOutDir = join(dauxDir, 'routes')
-  const sharedStylesPath = join(dauxDir, 'styles.css')
-
-  const allIslandDirs: string[] = [
-    ...(baseIslandsDir ? [baseIslandsDir] : []),
-    ...sites.flatMap((s) => (s.islandsDir ? [s.islandsDir] : [])),
-  ]
-
-  function toCompiledPath(src: string): string {
-    return join(routesOutDir, relative(cwd, src).replace(/\.(tsx?|jsx?|mdx?)$/, '.js'))
-  }
-  function toCompiledDir(srcDir: string): string {
-    return join(routesOutDir, relative(cwd, srcDir))
-  }
-  function remapScan(scan: ScanResult): ScanResult {
-    return {
-      routes: scan.routes.map((r) => ({ ...r, filePath: toCompiledPath(r.filePath) })),
-      layouts: scan.layouts.map((l) => ({
-        filePath: toCompiledPath(l.filePath),
-        dirPath: toCompiledDir(l.dirPath),
-      })),
-      middlewares: scan.middlewares.map((m) => ({
-        filePath: toCompiledPath(m.filePath),
-        dirPath: toCompiledDir(m.dirPath),
-      })),
-      errorPage: scan.errorPage ? toCompiledPath(scan.errorPage) : undefined,
-    }
-  }
-  function collectRouteFiles(scan: ScanResult): string[] {
-    return [
-      ...scan.routes.map((r) => r.filePath),
-      ...scan.layouts.map((l) => l.filePath),
-      ...scan.middlewares.map((m) => m.filePath),
-      ...(scan.errorPage ? [scan.errorPage] : []),
-    ]
-  }
-
-  // ─── SSE live reload ─────────────────────────────────────────────────────────
-  const sseClients = new Set<ServerResponse>()
-  let serverReady = false
-  let reloadTimer: ReturnType<typeof setTimeout> | undefined
-
-  function sendToClients(data: string): void {
-    for (const client of sseClients) {
-      try {
-        client.write(`data: ${data}\n\n`)
-      } catch {
-        sseClients.delete(client)
-      }
-    }
-  }
-
-  function scheduleReload(): void {
-    if (!serverReady) return
-    if (reloadTimer) clearTimeout(reloadTimer)
-    reloadTimer = setTimeout(() => {
-      reloadTimer = undefined
-      sendToClients('reload')
-    }, 50)
-  }
-
-  const reloadPlugin: Plugin = {
-    name: 'davaux-multisite-reload',
-    setup(build) {
-      build.onEnd((result) => {
-        if (result.errors.length > 0) {
-          console.error('\n[davaux/multisite] Build error:')
-          for (const e of result.errors) {
-            const loc = e.location
-            console.error(loc ? `  ${loc.file}:${loc.line}: ${e.text}` : `  ${e.text}`)
-          }
-          if (serverReady) {
-            const payload = result.errors.map((e) => ({
-              text: e.text,
-              file: e.location?.file,
-              line: e.location?.line,
-              column: e.location?.column,
-              lineText: e.location?.lineText?.trim(),
-            }))
-            sendToClients(`error:${JSON.stringify(payload)}`)
-          }
-          return
-        }
-        scheduleReload()
-      })
-    },
-  }
-
-  // ─── Initial scan ────────────────────────────────────────────────────────────
-  let baseScanRaw: ScanResult = baseDir
-    ? await scanRoutes(baseDir, allSuffixes)
-    : { routes: [], layouts: [], middlewares: [] }
-
-  const siteScanMap = new Map<string, ScanResult>()
-  for (const site of sites) {
-    siteScanMap.set(
-      site.name,
-      site.routesDir
-        ? await scanRoutes(site.routesDir, allSuffixes)
-        : { routes: [], layouts: [], middlewares: [] },
-    )
-  }
-
-  const siteIslandsMap = new Map<string, IslandFile[]>()
-  {
-    const baseIslands: IslandFile[] = baseIslandsDir ? await scanIslands(baseIslandsDir) : []
-    for (const site of sites) {
-      const siteIslands = site.islandsDir ? await scanIslands(site.islandsDir) : []
-      const combined = [...baseIslands, ...siteIslands]
-      if (combined.length > 0) siteIslandsMap.set(site.name, combined)
-    }
-  }
-
-  function currentRouteFiles(): string[] {
-    return [
-      ...collectRouteFiles(baseScanRaw),
-      ...[...siteScanMap.values()].flatMap(collectRouteFiles),
-      ...(middlewareSrc && existsSync(middlewareSrc) ? [middlewareSrc] : []),
-    ]
-  }
-
-  // ─── Esbuild contexts ────────────────────────────────────────────────────────
-  type BuildCtx = Awaited<ReturnType<typeof context>>
-
-  function routesCtxOptions() {
-    return {
-      entryPoints: currentRouteFiles(),
-      outdir: routesOutDir,
-      outbase: cwd,
-      format: 'esm' as const,
-      platform: 'node' as const,
-      target: 'node22',
-      bundle: true,
-      external: serverExternal,
-      jsx: 'automatic' as const,
-      jsxImportSource: 'davaux',
-      sourcemap: 'inline' as const,
-      alias: { ...userAlias, 'davaux/client': 'davaux/signal' },
-      plugins: [
-        reloadPlugin,
-        ...(allIslandDirs.length > 0 ? [islandServerPlugin(allIslandDirs)] : []),
-        cssCollectorPlugin(dauxDir, sharedStylesPath),
-        ...extraPlugins,
-      ],
-    }
-  }
-
-  function islandsCtxOptions(allIslands: IslandFile[], outfile: string) {
-    return {
-      stdin: { contents: generateIslandsEntry(allIslands), loader: 'ts' as const, resolveDir: cwd },
-      outfile,
-      format: 'esm' as const,
-      platform: 'browser' as const,
-      target: 'es2022',
-      bundle: true,
-      jsx: 'automatic' as const,
-      jsxImportSource: 'davaux/client',
-      sourcemap: 'inline' as const,
-      alias: userAlias,
-      plugins: [reloadPlugin, ...extraPlugins],
-    }
-  }
-
-  let routesCtx: BuildCtx = await context(routesCtxOptions())
-  await routesCtx.rebuild()
-
-  const islandCtxMap = new Map<string, BuildCtx>()
-  for (const [siteName, allIslands] of siteIslandsMap) {
-    const islandsCtx = await context(
-      islandsCtxOptions(allIslands, join(dauxDir, siteName, 'islands.js')),
-    )
-    await islandsCtx.rebuild()
-    islandCtxMap.set(siteName, islandsCtx)
-  }
-
-  const clientCtxMap = new Map<string, BuildCtx>()
-  const siteClientPathsMap = new Map<string, string>()
-  for (const site of sites) {
-    const clientEntry = site.clientEntry ?? config.clientEntry
-    if (!clientEntry || !existsSync(clientEntry)) continue
-    const clientPath = join(dauxDir, site.name, 'client.js')
-    const clientCtx = await context({
-      entryPoints: [clientEntry],
-      outfile: clientPath,
-      format: 'esm',
-      platform: 'browser',
-      target: 'es2022',
-      bundle: true,
-      jsx: 'automatic',
-      jsxImportSource: 'davaux/client',
-      sourcemap: 'inline',
-      alias: userAlias,
-      plugins: [reloadPlugin, ...extraPlugins],
-    })
-    await clientCtx.rebuild()
-    clientCtxMap.set(site.name, clientCtx)
-    siteClientPathsMap.set(site.name, clientPath)
-  }
-
-  // ─── App building ────────────────────────────────────────────────────────────
-  const effectiveMiddlewarePath =
-    middlewareSrc && existsSync(middlewareSrc)
-      ? toCompiledPath(middlewareSrc)
-      : explicitMiddlewarePath
-
-  function buildCurrentApps(): Map<string, SiteEntry<T>> {
-    const baseScan = remapScan(baseScanRaw)
-    const result = new Map<string, SiteEntry<T>>()
-    for (const site of sites) {
-      const rawSiteScan = siteScanMap.get(site.name) ?? { routes: [], layouts: [], middlewares: [] }
-      const merged = mergeScanResults(baseScan, remapScan(rawSiteScan))
-      const islandsPath = siteIslandsMap.has(site.name)
-        ? join(dauxDir, site.name, 'islands.js')
-        : undefined
-      const clientPath = siteClientPathsMap.get(site.name)
-      const app = buildApp(
-        merged,
-        true,
-        [
-          ...(islandsPath ? ['/_davaux/islands.js'] : []),
-          ...(clientPath ? ['/_davaux/client.js'] : []),
-          ...extraClientScripts,
-        ],
-        ['/_davaux/styles.css', ...extraClientStylesheets],
-        effectiveMiddlewarePath,
-        basePath,
-      )
-      const entry: SiteEntry<T> = {
-        app,
-        config: site.config,
-        islandsPath,
-        stylesPath: sharedStylesPath,
-        clientPath,
-        publicDirs: [
-          ...(site.publicDir ? [site.publicDir] : []),
-          ...(config.publicDir ? [config.publicDir] : []),
-        ],
-      }
-      const hostnames = Array.isArray(site.hostname) ? site.hostname : [site.hostname]
-      for (const h of hostnames) result.set(h, entry)
-    }
-    return result
-  }
-
-  let currentApps = buildCurrentApps()
-
-  // ─── HTTP server ─────────────────────────────────────────────────────────────
-  const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
-    const host = (req.headers.host ?? '').split(':')[0]
-    const entry = currentApps.get(host) ?? currentApps.get('*')
-
-    if (!entry) {
-      res.writeHead(404, { 'Content-Type': 'text/plain' })
-      res.end(`[davaux/multisite] No site registered for host: ${host}`)
-      return
-    }
-
-    if (entry.config !== undefined) siteConfigMap.set(req, entry.config)
-    const urlPath = req.url?.split('?')[0]
-
-    if (urlPath === '/_davaux/livereload') {
-      res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        Connection: 'keep-alive',
-      })
-      res.write('\n')
-      sseClients.add(res)
-      req.on('close', () => sseClients.delete(res))
-      return
-    }
-    if (urlPath === '/_davaux/livereload.js') {
-      res.writeHead(200, { 'Content-Type': 'application/javascript' })
-      res.end(LIVERELOAD_SCRIPT)
-      return
-    }
-    if (urlPath === '/_davaux/livereload-worker.js') {
-      res.writeHead(200, { 'Content-Type': 'application/javascript' })
-      res.end(SHARED_WORKER_SCRIPT)
-      return
-    }
-    if (urlPath === '/_davaux/islands.js') {
-      if (entry.islandsPath && existsSync(entry.islandsPath)) {
-        res.writeHead(200, { 'Content-Type': 'application/javascript' })
-        createReadStream(entry.islandsPath).pipe(res)
-      } else {
-        res.writeHead(404, { 'Content-Type': 'text/plain' })
-        res.end('Not Found')
-      }
-      return
-    }
-    if (urlPath === '/_davaux/client.js') {
-      if (entry.clientPath && existsSync(entry.clientPath)) {
-        res.writeHead(200, { 'Content-Type': 'application/javascript' })
-        createReadStream(entry.clientPath).pipe(res)
-      } else {
-        res.writeHead(404, { 'Content-Type': 'text/plain' })
-        res.end('Not Found')
-      }
-      return
-    }
-    if (urlPath === '/_davaux/styles.css') {
-      res.writeHead(200, { 'Content-Type': 'text/css' })
-      if (existsSync(sharedStylesPath)) {
-        createReadStream(sharedStylesPath).pipe(res)
-      } else {
-        res.end('')
-      }
-      return
-    }
-
-    if (urlPath) {
-      const relPath = urlPath.replace(/^\/+/, '')
-      if (relPath) {
-        for (const dir of entry.publicDirs) {
-          const filePath = join(dir, relPath)
-          const normalizedDir = dir.endsWith('/') ? dir : `${dir}/`
-          if (!filePath.startsWith(normalizedDir)) continue
-          if (existsSync(filePath) && statSync(filePath).isFile()) {
-            res.writeHead(200, { 'Content-Type': contentTypeFor(filePath) })
-            createReadStream(filePath).pipe(res)
-            return
-          }
-        }
-      }
-    }
-
-    dispatch(req, res, entry.app).catch((err) => {
-      console.error('[davaux/multisite] Unhandled dispatch error:', err)
-      if (!res.headersSent) {
-        res.writeHead(500, { 'Content-Type': 'text/plain' })
-        res.end('Internal Server Error')
-      }
-    })
-  })
-
-  server.listen(port, hostname, () => {
-    console.log(`\n  davaux/multisite  http://${hostname}:${port}\n`)
-  })
-  serverReady = true
-
-  // ─── Start watching ──────────────────────────────────────────────────────────
-  await routesCtx.watch()
-  for (const islandsCtx of islandCtxMap.values()) await islandsCtx.watch()
-  for (const clientCtx of clientCtxMap.values()) await clientCtx.watch()
-  console.log('  Watching for changes...')
-
-  // ─── Structural rebuild ───────────────────────────────────────────────────────
-  // Triggered when route or island files are added or removed. esbuild's built-in
-  // watch handles content changes; fsWatch fires only 'rename' events (create/delete).
-
-  let isRebuilding = false
-  let rebuildTimer: ReturnType<typeof setTimeout> | undefined
-
-  async function handleStructuralChange(): Promise<void> {
-    // Re-scan all directories with current state
-    baseScanRaw = baseDir
-      ? await scanRoutes(baseDir, allSuffixes)
-      : { routes: [], layouts: [], middlewares: [] }
-    for (const site of sites) {
-      siteScanMap.set(
-        site.name,
-        site.routesDir
-          ? await scanRoutes(site.routesDir, allSuffixes)
-          : { routes: [], layouts: [], middlewares: [] },
-      )
-    }
-    const newBaseIslands: IslandFile[] = baseIslandsDir ? await scanIslands(baseIslandsDir) : []
-    siteIslandsMap.clear()
-    for (const site of sites) {
-      const siteIslands = site.islandsDir ? await scanIslands(site.islandsDir) : []
-      const combined = [...newBaseIslands, ...siteIslands]
-      if (combined.length > 0) siteIslandsMap.set(site.name, combined)
-    }
-
-    // Recreate routes context (all were disposed in onStructuralChange)
-    const routeFiles = currentRouteFiles()
-    if (routeFiles.length > 0) {
-      routesCtx = await context(routesCtxOptions())
-      await routesCtx.rebuild()
-      await routesCtx.watch()
-    }
-
-    // Recreate all island contexts
-    islandCtxMap.clear()
-    for (const [siteName, allIslands] of siteIslandsMap) {
-      const islandsCtx = await context(
-        islandsCtxOptions(allIslands, join(dauxDir, siteName, 'islands.js')),
-      )
-      await islandsCtx.rebuild()
-      await islandsCtx.watch()
-      islandCtxMap.set(siteName, islandsCtx)
-    }
-
-    currentApps = buildCurrentApps()
-    scheduleReload()
-    console.log('[davaux/multisite] Routes updated')
-  }
-
-  function onStructuralChange(): void {
-    // Dispose immediately so esbuild doesn't try to rebuild a stale entry list
-    // (e.g. an entry point file that was just deleted).
-    routesCtx.dispose().catch(() => {})
-    for (const ctx of islandCtxMap.values()) ctx.dispose().catch(() => {})
-
-    if (rebuildTimer) clearTimeout(rebuildTimer)
-    rebuildTimer = setTimeout(() => {
-      if (isRebuilding) return
-      isRebuilding = true
-      handleStructuralChange()
-        .catch((err) => console.error('[davaux/multisite] Route rebuild failed:', err))
-        .finally(() => {
-          isRebuilding = false
-        })
-    }, 200)
-  }
-
-  const routeWatchDirs = [
-    ...(baseDir ? [baseDir] : []),
-    ...sites.flatMap((s) => (s.routesDir ? [s.routesDir] : [])),
-  ]
-  for (const dir of routeWatchDirs) {
-    if (!existsSync(dir)) continue
-    fsWatch(dir, { recursive: true }, (event, filename) => {
-      if (event !== 'rename' || !filename) return
-      if (!/\.(tsx?|jsx?|mdx?)$/.test(filename)) return
-      onStructuralChange()
-    })
-  }
-  for (const dir of allIslandDirs) {
-    if (!existsSync(dir)) continue
-    fsWatch(dir, { recursive: true }, (event, filename) => {
-      if (event !== 'rename' || !filename) return
-      if (!/\.(tsx?|jsx?|mdx?)$/.test(filename)) return
-      onStructuralChange()
-    })
-  }
-
-  startTypeChecker(cwd)
-
-  return server
-}
-
-// ─── Convenience wrapper ──────────────────────────────────────────────────────
-
-/**
- * Build and start a multisite server in one call.
- *
- * Combines `buildMultisiteApps` and `startMultisiteServer`. Automatically sets
- * `isDev` from `NODE_ENV` unless explicitly provided — `true` in development
- * (cache-busting for TypeScript routes), `false` in production.
- *
- * @example
- * // server.ts
- * import { startMultisite } from '@davaux/multisite'
- * import { sites } from './multisite.config.js'
- *
- * startMultisite(sites, { port: 3000, hostname: 'localhost' })
- */
-export async function startMultisite<T = Record<string, unknown>>(
-  config: MultisiteConfig<T>,
-  options: StartMultisiteOptions = {},
-): Promise<ReturnType<typeof createServer>> {
-  const { port, hostname, isDev = process.env.NODE_ENV !== 'production', ...buildOpts } = options
-
-  // Auto-detect src/middleware.ts when cwd is set and no middleware path is explicitly provided
-  const cwd = buildOpts.cwd
-  if (cwd && !buildOpts.appMiddlewarePath && !buildOpts.middlewareSrc) {
-    if (isDev) {
-      const mwSrc = join(cwd, 'src', 'middleware.ts')
-      if (existsSync(mwSrc)) buildOpts.middlewareSrc = mwSrc
-    } else {
-      const mwCompiled = join(cwd, 'src', 'middleware.js')
-      if (existsSync(mwCompiled)) buildOpts.appMiddlewarePath = mwCompiled
-    }
-  }
-
-  if (isDev) return startMultisiteDev(config, { ...buildOpts, port, hostname })
-
-  const apps = await buildMultisiteApps(config, { ...buildOpts, isDev: false })
-  return startMultisiteServer(apps, { port, hostname })
-}
-
-// ─── Runtime helpers ──────────────────────────────────────────────────────────
-
-/**
- * Retrieve the current site's config from a request context.
- *
- * Returns `undefined` when called outside of a multisite server (e.g. in tests
- * using a single-site `startServer`).
- *
- * @example
- * import { getSite } from '@davaux/multisite'
- *
- * export default definePage((ctx) => {
- *   const site = getSite<MySiteConfig>(ctx)
- *   return <Layout theme={site?.theme}>...</Layout>
- * })
- */
-export function getSite<T = Record<string, unknown>>(ctx: RequestContext): T | undefined {
-  return siteConfigMap.get(ctx.req) as T | undefined
-}