@davaux/multisite 0.8.0 → 0.8.1

package/dist/index.js

@@ -0,0 +1,944 @@
+import { spawn } from 'node:child_process';
+import { createReadStream, existsSync, watch as fsWatch, statSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { join, relative } from 'node:path';
+import { collectCss, cssCollectorPlugin, generateIslandsEntry, islandServerPlugin, } from 'davaux/build';
+import { collectEsbuildPlugins, collectScannerSuffixes, pathsToAlias, } from 'davaux/config';
+import { buildApp, dispatch } from 'davaux/handler';
+import { scanIslands, scanRoutes } from 'davaux/scanner';
+import { context } from 'esbuild';
+// Keyed on the Node IncomingMessage object — auto-cleaned when the request is GC'd.
+const siteConfigMap = new WeakMap();
+function contentTypeFor(filePath) {
+    const ext = filePath.slice(filePath.lastIndexOf('.') + 1).toLowerCase();
+    const types = {
+        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 = { page: 1 };
+function dynamicWeight(pattern) {
+    const segs = pattern.split('/');
+    if (segs.some((s) => s.startsWith('*')))
+        return 1000;
+    return segs.filter((s) => s.startsWith(':')).length;
+}
+function sortRoutes(routes) {
+    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, overlay) {
+    // Routes — overlay wins by URL pattern + type
+    const overlayRouteKeys = new Set(overlay.routes.map((r) => `${r.type}:${r.urlPattern}`));
+    const routes = 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 = [
+        ...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 = [
+        ...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(config) {
+    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(config, options = {}) {
+    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 = [
+        ...(baseIslandsDir ? [baseIslandsDir] : []),
+        ...sites.flatMap((s) => (s.islandsDir ? [s.islandsDir] : [])),
+    ];
+    // Scan all route directories upfront
+    const baseScanRaw = baseDir
+        ? await scanRoutes(baseDir, allSuffixes)
+        : { routes: [], layouts: [], middlewares: [] };
+    const siteScanMap = new Map();
+    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();
+    const siteClientPaths = new Map();
+    let sharedStylesPath;
+    // Path-mapping functions — identity in production, remapped in dev
+    let toCompiledPath = (p) => p;
+    let toCompiledDir = (d) => 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) {
+            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 = baseIslandsDir ? await scanIslands(baseIslandsDir) : [];
+        for (const site of sites) {
+            const siteIslands = 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) => join(routesOutDir, relative(cwd, src).replace(/\.(tsx?|jsx?|mdx?)$/, '.js'));
+        toCompiledDir = (srcDir) => 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) {
+        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();
+    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 = [
+            ...(site.publicDir ? [site.publicDir] : []),
+            ...(config.publicDir ? [config.publicDir] : []),
+        ];
+        const app = buildApp(merged, isDev, siteClientScripts, siteClientStylesheets, effectiveMiddlewarePath, basePath);
+        const entry = {
+            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(sites, options = {}) {
+    const { port = 3000, hostname = 'localhost' } = options;
+    const getSites = typeof sites === 'function' ? sites : () => sites;
+    const server = createServer(async (req, res) => {
+        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(sites, req, res) {
+    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) {
+    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(config, options = {}) {
+    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 = [
+        ...(baseIslandsDir ? [baseIslandsDir] : []),
+        ...sites.flatMap((s) => (s.islandsDir ? [s.islandsDir] : [])),
+    ];
+    function toCompiledPath(src) {
+        return join(routesOutDir, relative(cwd, src).replace(/\.(tsx?|jsx?|mdx?)$/, '.js'));
+    }
+    function toCompiledDir(srcDir) {
+        return join(routesOutDir, relative(cwd, srcDir));
+    }
+    function remapScan(scan) {
+        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) {
+        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();
+    let serverReady = false;
+    let reloadTimer;
+    function sendToClients(data) {
+        for (const client of sseClients) {
+            try {
+                client.write(`data: ${data}\n\n`);
+            }
+            catch {
+                sseClients.delete(client);
+            }
+        }
+    }
+    function scheduleReload() {
+        if (!serverReady)
+            return;
+        if (reloadTimer)
+            clearTimeout(reloadTimer);
+        reloadTimer = setTimeout(() => {
+            reloadTimer = undefined;
+            sendToClients('reload');
+        }, 50);
+    }
+    const reloadPlugin = {
+        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 = baseDir
+        ? await scanRoutes(baseDir, allSuffixes)
+        : { routes: [], layouts: [], middlewares: [] };
+    const siteScanMap = new Map();
+    for (const site of sites) {
+        siteScanMap.set(site.name, site.routesDir
+            ? await scanRoutes(site.routesDir, allSuffixes)
+            : { routes: [], layouts: [], middlewares: [] });
+    }
+    const siteIslandsMap = new Map();
+    {
+        const baseIslands = 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() {
+        return [
+            ...collectRouteFiles(baseScanRaw),
+            ...[...siteScanMap.values()].flatMap(collectRouteFiles),
+            ...(middlewareSrc && existsSync(middlewareSrc) ? [middlewareSrc] : []),
+        ];
+    }
+    function routesCtxOptions() {
+        return {
+            entryPoints: currentRouteFiles(),
+            outdir: routesOutDir,
+            outbase: cwd,
+            format: 'esm',
+            platform: 'node',
+            target: 'node22',
+            bundle: true,
+            external: serverExternal,
+            jsx: 'automatic',
+            jsxImportSource: 'davaux',
+            sourcemap: 'inline',
+            alias: { ...userAlias, 'davaux/client': 'davaux/signal' },
+            plugins: [
+                reloadPlugin,
+                ...(allIslandDirs.length > 0 ? [islandServerPlugin(allIslandDirs)] : []),
+                cssCollectorPlugin(dauxDir, sharedStylesPath),
+                ...extraPlugins,
+            ],
+        };
+    }
+    function islandsCtxOptions(allIslands, outfile) {
+        return {
+            stdin: { contents: generateIslandsEntry(allIslands), loader: 'ts', resolveDir: cwd },
+            outfile,
+            format: 'esm',
+            platform: 'browser',
+            target: 'es2022',
+            bundle: true,
+            jsx: 'automatic',
+            jsxImportSource: 'davaux/client',
+            sourcemap: 'inline',
+            alias: userAlias,
+            plugins: [reloadPlugin, ...extraPlugins],
+        };
+    }
+    let routesCtx = await context(routesCtxOptions());
+    await routesCtx.rebuild();
+    const islandCtxMap = new Map();
+    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();
+    const siteClientPathsMap = new Map();
+    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() {
+        const baseScan = remapScan(baseScanRaw);
+        const result = new Map();
+        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 = {
+                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, res) => {
+        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;
+    async function handleStructuralChange() {
+        // 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 = 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() {
+        // 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(config, options = {}) {
+    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(ctx) {
+    return siteConfigMap.get(ctx.req);
+}
+//# sourceMappingURL=index.js.map