juxscript 1.1.2 → 1.1.3

package/machinery/config.js

@@ -23,12 +23,12 @@ export const defaultConfig = {
 // Load user configuration
 export async function loadConfig(projectRoot) {
   const configPath = path.join(projectRoot, 'juxconfig.js');
-  
+
   if (fs.existsSync(configPath)) {
     try {
       const configModule = await import(`file://${configPath}`);
       const userConfig = configModule.default || configModule;
-      
+
       return {
         ...defaultConfig,
         ...userConfig,
@@ -41,7 +41,7 @@ export async function loadConfig(projectRoot) {
       return defaultConfig;
     }
   }
-  
+
   console.log('ℹ️  No juxconfig.js found, using defaults');
   return defaultConfig;
 }
@@ -51,9 +51,9 @@ export async function runBootstrap(bootstrapFunctions = []) {
   if (!Array.isArray(bootstrapFunctions) || bootstrapFunctions.length === 0) {
     return;
   }
-  
+
   console.log('🚀 Running bootstrap functions...\n');
-  
+
   for (const fn of bootstrapFunctions) {
     if (typeof fn === 'function') {
       try {
@@ -63,6 +63,93 @@ export async function runBootstrap(bootstrapFunctions = []) {
       }
     }
   }
-  
+
   console.log('✅ Bootstrap complete\n');
+}
+
+/**
+ * Type helper for JUX Configuration (Identity function for Autocomplete)
+ * Used in juxconfig.js to provide Intellisense.
+ * @param {Object} config
+ * @returns {Object}
+ */
+export function defineConfig(config) {
+  return config;
+}
+
+/**
+ * Normalizes user configuration into the strict format used by the compiler/server.
+ * Handles "DX Sugar" like:
+ * - Inferring file extensions (.jux, .css)
+ * - Mapping 'dist' -> 'distribution'
+ * - Resolving shortcuts (e.g. layouts)
+ * - Defaulting ports
+ */
+export function resolveConfig(userConfig, projectRoot = process.cwd()) {
+  const root = userConfig.root || projectRoot;
+
+  // 1. Directories (Map 'dist' alias to 'distribution')
+  const dirs = userConfig.directories || {};
+  const directories = {
+    source: dirs.source || 'jux',
+    distribution: dirs.dist || dirs.distribution || '.jux-dist',
+    themes: dirs.themes || 'themes',
+    layouts: dirs.layouts || 'themes/layouts',
+    assets: dirs.assets || 'themes/assets'
+  };
+
+  // 2. Defaults (Infer extensions)
+  const defs = userConfig.defaults || {};
+  const httpPort = defs.port || defs.httpPort || 3000;
+
+  const defaults = {
+    httpPort,
+    wsPort: defs.wsPort || (httpPort + 1),
+    autoRoute: defs.autoRoute !== false, // default true
+    layout: ensureExt(defs.layout, '.jux') || 'base.jux',
+    theme: ensureExt(defs.theme, '.css') || 'base.css'
+  };
+
+  // 3. Pages Normalization (Recursively fix route paths)
+  const pages = normalizePages(userConfig.pages || {});
+
+  // 4. Return Normalized Config
+  return {
+    root,
+    directories,
+    defaults,
+    pages,
+    hooks: userConfig.hooks || {}
+  };
+}
+
+/**
+ * Helper: Appends extension if missing
+ */
+function ensureExt(file, ext) {
+  if (!file) return file;
+  return file.endsWith(ext) ? file : `${file}${ext}`;
+}
+
+/**
+ * Helper: Recursively normalizes page routes
+ */
+function normalizePages(pages) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(pages)) {
+    if (typeof value === 'string') {
+      // Direct route: '/' -> 'experiments/index'
+      // Becomes: '/' -> 'experiments/index.jux'
+      normalized[key] = ensureExt(value, '.jux');
+    } else if (typeof value === 'object') {
+      // Route Group
+      normalized[key] = {
+        ...value,
+        layout: value.layout ? ensureExt(value.layout, '.jux') : undefined,
+        theme: value.theme ? ensureExt(value.theme, '.css') : undefined,
+        routes: normalizePages(value.routes || {})
+      };
+    }
+  }
+  return normalized;
 }

package/machinery/serve.js

@@ -0,0 +1,255 @@
+import express from 'express';
+import path from 'path';
+import fs from 'fs';
+import http from 'http';
+import { fileURLToPath } from 'url';
+import { WebSocketServer } from 'ws';
+import { createWatcher } from './watcher.js';
+import { JuxCompiler } from './compiler3.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ═══════════════════════════════════════════════════════════════
+// CONFIGURATION
+// ═══════════════════════════════════════════════════════════════
+const args = process.argv.slice(2);
+const HOT_RELOAD = args.includes('--hot') || args.includes('-h') || args.includes('--watch');
+
+// Extract port from args (e.g., --port=3000 or -p 3000)
+function getArgValue(flag, shortFlag, defaultValue) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith(`${flag}=`)) return args[i].split('=')[1];
+    if (args[i].startsWith(`${shortFlag}=`)) return args[i].split('=')[1];
+    if ((args[i] === flag || args[i] === shortFlag) && args[i + 1]) return args[i + 1];
+  }
+  return defaultValue;
+}
+
+const PORT = parseInt(getArgValue('--port', '-p', process.env.PORT || '3000'));
+const WS_PORT = parseInt(getArgValue('--ws-port', '-w', process.env.WS_PORT || String(PORT + 1)));
+
+// Resolve paths relative to CWD (user's project)
+const PROJECT_ROOT = process.cwd();
+const DIST_DIR = path.resolve(PROJECT_ROOT, '.jux-dist');
+const SRC_DIR = path.resolve(PROJECT_ROOT, 'jux');
+
+const app = express();
+let lastBuildResult = { success: true, errors: [] };
+
+// Check if dist directory exists - if not, try to build first
+if (!fs.existsSync(DIST_DIR) || !fs.existsSync(path.join(DIST_DIR, 'index.html'))) {
+  console.log('⚠️  Dist directory not found. Running initial build...');
+
+  const compiler = new JuxCompiler({
+    srcDir: SRC_DIR,
+    distDir: DIST_DIR
+  });
+
+  try {
+    const result = await compiler.build();
+    lastBuildResult = result;
+
+    if (!result.success) {
+      console.log('\n❌ Initial build failed. Starting server to show error overlay.\n');
+    }
+  } catch (err) {
+    console.error('❌ Initial build failed:', err.message);
+    lastBuildResult = { success: false, errors: [{ message: err.message }] };
+  }
+}
+
+if (!fs.existsSync(DIST_DIR)) {
+  fs.mkdirSync(DIST_DIR, { recursive: true });
+}
+
+app.use((req, res, next) => {
+  res.setHeader('Cache-Control', 'no-store');
+  next();
+});
+
+app.use((req, res, next) => {
+  if (req.path.endsWith('.js')) {
+    res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
+  }
+  next();
+});
+
+app.get('/favicon.ico', (req, res) => res.status(204).end());
+app.get('/favicon.png', (req, res) => res.status(204).end());
+
+app.get('/__jux_sources.json', (req, res) => {
+  const snapshotPath = path.join(DIST_DIR, '__jux_sources.json');
+  if (fs.existsSync(snapshotPath)) {
+    res.setHeader('Content-Type', 'application/json');
+    res.sendFile(snapshotPath);
+  } else {
+    res.json({});
+  }
+});
+
+const hotReloadScript = `
+<script>
+(function() {
+    var ws = new WebSocket('ws://localhost:${WS_PORT}');
+    ws.onopen = function() { console.log('🔥 Hot reload connected'); };
+    ws.onmessage = function(e) {
+        var data = JSON.parse(e.data);
+        if (data.type === 'reload') location.reload();
+        else if (data.type === 'build-error') console.error('❌ Build error:', data.errors);
+    };
+    ws.onclose = function() { setTimeout(function() { location.reload(); }, 2000); };
+})();
+</script>
+`;
+
+function getErrorPageHtml(errors) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>JUX Build Error</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { font-family: monospace; background: #1a1a2e; color: #eee; min-height: 100vh; padding: 40px; }
+        .container { max-width: 800px; margin: 0 auto; }
+        h1 { color: #ff6b6b; margin-bottom: 8px; }
+        .subtitle { color: #888; margin-bottom: 30px; }
+        .error-card { background: #16213e; padding: 16px 20px; border-radius: 8px; margin-bottom: 12px; border-left: 4px solid #ff6b6b; }
+        .error-header { color: #ff6b6b; font-weight: bold; margin-bottom: 8px; }
+        .error-code { background: #0f0f23; padding: 12px; border-radius: 4px; font-size: 13px; color: #888; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🛑 Build Failed</h1>
+        <p class="subtitle">Fix the errors below and save to rebuild.</p>
+        ${errors.map(err => `
+            <div class="error-card">
+                <div class="error-header">${err.view ? `[${err.view}] ` : ''}${err.message}</div>
+                ${err.code ? `<pre class="error-code">${err.code}</pre>` : ''}
+            </div>
+        `).join('')}
+    </div>
+    ${HOT_RELOAD ? `<script>
+        var ws = new WebSocket('ws://localhost:${WS_PORT}');
+        ws.onmessage = function(e) { if (JSON.parse(e.data).type === 'reload') location.reload(); };
+    </script>` : ''}
+</body>
+</html>`;
+}
+
+if (HOT_RELOAD) {
+  app.get(['/', '/index.html'], (req, res) => {
+    const indexPath = path.join(DIST_DIR, 'index.html');
+
+    if (!fs.existsSync(indexPath) || !lastBuildResult.success) {
+      return res.send(getErrorPageHtml(lastBuildResult.errors));
+    }
+
+    let html = fs.readFileSync(indexPath, 'utf8');
+    html = html.replace('</body>', hotReloadScript + '</body>');
+    res.setHeader('Content-Type', 'text/html');
+    res.send(html);
+  });
+}
+
+app.use(express.static(DIST_DIR));
+
+app.get('*', (req, res) => {
+  if (path.extname(req.path) && req.path !== '/') {
+    return res.status(404).send('Not found');
+  }
+
+  const indexPath = path.join(DIST_DIR, 'index.html');
+
+  if (!fs.existsSync(indexPath) || !lastBuildResult.success) {
+    return res.send(getErrorPageHtml(lastBuildResult.errors));
+  }
+
+  if (HOT_RELOAD) {
+    let html = fs.readFileSync(indexPath, 'utf8');
+    html = html.replace('</body>', hotReloadScript + '</body>');
+    res.setHeader('Content-Type', 'text/html');
+    res.send(html);
+  } else {
+    res.sendFile(indexPath);
+  }
+});
+
+const server = http.createServer(app);
+let wss = null;
+let watcher = null;
+
+if (HOT_RELOAD) {
+  wss = new WebSocketServer({ port: WS_PORT });
+  const clients = new Set();
+
+  wss.on('connection', (ws) => {
+    clients.add(ws);
+    ws.on('close', () => clients.delete(ws));
+  });
+
+  const broadcast = (message) => {
+    const data = JSON.stringify(message);
+    clients.forEach(client => {
+      if (client.readyState === 1) client.send(data);
+    });
+  };
+
+  const compiler = new JuxCompiler({
+    srcDir: SRC_DIR,
+    distDir: DIST_DIR
+  });
+
+  watcher = createWatcher(SRC_DIR, {
+    onChange: async (changedFiles) => {
+      console.log('🔄 Rebuilding...');
+
+      try {
+        const result = await compiler.build();
+        lastBuildResult = result;
+
+        if (!result.success) {
+          console.error('❌ Rebuild failed');
+          broadcast({ type: 'build-error', errors: result.errors });
+          return;
+        }
+
+        console.log('✅ Rebuild complete');
+        broadcast({ type: 'reload', files: changedFiles });
+      } catch (err) {
+        console.error('❌ Rebuild failed:', err.message);
+        lastBuildResult = { success: false, errors: [{ message: err.message }] };
+        broadcast({ type: 'build-error', errors: [{ message: err.message }] });
+      }
+    },
+    onReady: () => {
+      console.log(`👀 Watching: ${SRC_DIR}`);
+    }
+  });
+}
+
+server.listen(PORT, () => {
+  console.log(`\n🚀 JUX Server running at http://localhost:${PORT}`);
+  if (HOT_RELOAD) {
+    console.log(`🔥 Hot reload: ws://localhost:${WS_PORT}`);
+  }
+  if (!lastBuildResult.success) {
+    console.log(`⚠️  Build has errors - fix them and save\n`);
+  }
+});
+
+const shutdown = () => {
+  console.log('\n👋 Shutting down...');
+  if (watcher) watcher.close();
+  if (wss) {
+    wss.clients.forEach(client => client.terminate());
+    wss.close();
+  }
+  server.close(() => process.exit(0));
+  setTimeout(() => process.exit(0), 2000);
+};
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/machinery/watcher.js

@@ -1,171 +1,59 @@
 import fs from 'fs';
 import path from 'path';
-import {
-  copyLibToOutput,
-  bundleJuxFilesToRouter,
-  generateIndexHtml
-} from './compiler.js';
-
-let isRebuilding = false;
-let rebuildQueued = false;
 
 /**
- * Find all .jux files in a directory
+ * Watch a directory for changes and trigger callbacks
  */
-function findJuxFiles(dir, fileList = []) {
-  if (!fs.existsSync(dir)) return fileList;
-
-  const files = fs.readdirSync(dir);
-
-  files.forEach(file => {
-    const filePath = path.join(dir, file);
-    const stat = fs.statSync(filePath);
-
-    if (stat.isDirectory()) {
-      if (file !== 'node_modules' && file !== 'jux-dist' && file !== '.git' && file !== 'server') {
-        findJuxFiles(filePath, fileList);
-      }
-    } else if (file.endsWith('.jux')) {
-      fileList.push(filePath);
-    }
+export function createWatcher(srcDir, options = {}) {
+  const {
+    onChange = () => { },
+    onReady = () => { },
+    debounceMs = 100,
+    extensions = ['.jux', '.js', '.css']
+  } = options;
+
+  const absoluteSrcDir = path.resolve(srcDir);
+  let debounceTimer = null;
+  let pendingChanges = new Set();
+
+  console.log(`👀 Watching: ${absoluteSrcDir}`);
+
+  // Debounced change handler
+  const handleChange = (eventType, filename) => {
+    if (!filename) return;
+
+    // Filter by extension
+    const ext = path.extname(filename);
+    if (!extensions.includes(ext)) return;
+
+    pendingChanges.add(filename);
+
+    // Debounce rapid changes
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      const changes = [...pendingChanges];
+      pendingChanges.clear();
+
+      console.log(`📝 Changed: ${changes.join(', ')}`);
+      onChange(changes);
+    }, debounceMs);
+  };
+
+  // Start watching
+  const watcher = fs.watch(absoluteSrcDir, { recursive: true }, handleChange);
+
+  watcher.on('error', (err) => {
+    console.error('❌ Watcher error:', err);
   });
 
-  return fileList;
-}
-
-/**
- * Full rebuild of the entire bundle
- */
-async function fullRebuild(juxSource, distDir) {
-  const startTime = performance.now(); // ✅ Start timing
-  console.log('\n🔄 Rebuilding bundle...');
-
-  try {
-    // Find all .jux files
-    const projectJuxFiles = findJuxFiles(juxSource);
-    console.log(`   Found ${projectJuxFiles.length} .jux file(s)`);
-
-    // ✅ Time the bundling step
-    const bundleStartTime = performance.now();
-
-    // Bundle all files
-    const mainJsFilename = await bundleJuxFilesToRouter(juxSource, distDir, {
-      routePrefix: ''
-    });
-
-    const bundleTime = performance.now() - bundleStartTime;
-
-    // ✅ Time the route generation step
-    const routeStartTime = performance.now();
-
-    // Generate routes for index.html
-    const routes = projectJuxFiles.map(juxFile => {
-      const relativePath = path.relative(juxSource, juxFile);
-      const parsedPath = path.parse(relativePath);
-
-      const rawFunctionName = parsedPath.dir
-        ? `${parsedPath.dir.replace(/\//g, '_')}_${parsedPath.name}`
-        : parsedPath.name;
-
-      const functionName = rawFunctionName
-        .replace(/[-_]/g, ' ')
-        .split(' ')
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-        .join('');
-
-      const routePath = '/' + (parsedPath.dir ? `${parsedPath.dir}/` : '') + parsedPath.name;
-
-      return {
-        path: routePath.replace(/\/+/g, '/'),
-        functionName
-      };
-    });
-
-    // Generate index.html
-    generateIndexHtml(distDir, routes, mainJsFilename);
-
-    const routeTime = performance.now() - routeStartTime;
-    const totalTime = performance.now() - startTime;
+  onReady();
 
-    // ✅ Pretty-print timing breakdown
-    console.log(`\n⏱️  Rebuild Performance:`);
-    console.log(`   Bundle generation: ${bundleTime.toFixed(0)}ms`);
-    console.log(`   Route/index.html:  ${routeTime.toFixed(0)}ms`);
-    console.log(`   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
-    console.log(`   Total rebuild:     ${totalTime.toFixed(0)}ms`);
-
-    // ✅ Color-coded performance indicator
-    if (totalTime < 100) {
-      console.log(`   ✅ Lightning fast! ⚡`);
-    } else if (totalTime < 500) {
-      console.log(`   ✅ Fast rebuild`);
-    } else if (totalTime < 1000) {
-      console.log(`   ⚠️  Moderate speed`);
-    } else {
-      console.log(`   🐌 Slow rebuild (consider optimizing)`);
-    }
-
-    console.log(`✅ Bundle rebuilt: ${mainJsFilename}\n`);
-    return true;
-
-  } catch (err) {
-    const failTime = performance.now() - startTime;
-    console.error(`❌ Rebuild failed after ${failTime.toFixed(0)}ms:`, err.message);
-    return false;
-  }
-}
-
-/**
- * Start watching for file changes and rebuild on change
- */
-export function startWatcher(juxSource, distDir, wsClients) {
-  console.log(`👀 Watching: ${juxSource}`);
-
-  const watcher = fs.watch(juxSource, { recursive: true }, async (eventType, filename) => {
-    // Ignore non-.jux files and certain patterns
-    if (!filename ||
-      !filename.endsWith('.jux') ||
-      filename.includes('node_modules') ||
-      filename.includes('jux-dist') ||
-      filename.startsWith('.')) {
-      return;
-    }
-
-    // Debounce: If already rebuilding, queue another rebuild
-    if (isRebuilding) {
-      rebuildQueued = true;
-      return;
+  // Return control object
+  return {
+    close: () => {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      watcher.close();
+      console.log('👋 Watcher closed');
     }
-
-    isRebuilding = true;
-    console.log(`\n📝 File changed: ${filename}`);
-
-    // Rebuild the entire bundle
-    const success = await fullRebuild(juxSource, distDir);
-
-    isRebuilding = false;
-
-    // Notify all WebSocket clients to reload
-    if (success && wsClients && wsClients.length > 0) {
-      console.log(`🔌 Notifying ${wsClients.length} client(s) to reload`);
-
-      // ✅ Add small delay to ensure file is fully written
-      setTimeout(() => {
-        wsClients.forEach(client => {
-          if (client.readyState === 1) { // OPEN
-            client.send(JSON.stringify({ type: 'reload' }));
-          }
-        });
-      }, 100);
-    }
-
-    // Process queued rebuild if needed
-    if (rebuildQueued) {
-      rebuildQueued = false;
-      console.log('🔄 Processing queued rebuild...');
-      setTimeout(() => watcher.emit('change', 'change', filename), 500);
-    }
-  });
-
-  return watcher;
+  };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juxscript",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "type": "module",
   "description": "A JavaScript UX authorship platform",
   "main": "index.js",

package/machinery/server.js

@@ -1,166 +0,0 @@
-import express from 'express';
-import http from 'http';
-import path from 'path';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
-import { startWatcher } from './watcher.js';
-import { WebSocketServer } from 'ws';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-/**
- * Try to start a server on a port, with fallback to next port if busy
- * Returns the actual port that was successfully allocated
- */
-async function tryPort(startPort, maxAttempts = 5, reservedPorts = []) {
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const port = startPort + attempt;
-
-    // Skip if this port is already reserved
-    if (reservedPorts.includes(port)) {
-      continue;
-    }
-
-    try {
-      // Test if port is available
-      await new Promise((resolve, reject) => {
-        const testServer = http.createServer();
-        testServer.once('error', reject);
-        testServer.once('listening', () => {
-          testServer.close();
-          resolve(port);
-        });
-        testServer.listen(port);
-      });
-      return port;
-    } catch (err) {
-      if (err.code === 'EADDRINUSE') {
-        if (attempt < maxAttempts - 1) {
-          console.log(`   Port ${port} in use, trying ${port + 1}...`);
-        }
-        continue;
-      }
-      throw err;
-    }
-  }
-  throw new Error(`Could not find available port after ${maxAttempts} attempts starting from ${startPort}`);
-}
-
-async function serve(httpPort = 3000, wsPort = 3001, distDir = './.jux-dist') {
-  const app = express();
-  const absoluteDistDir = path.resolve(distDir);
-  const projectRoot = path.resolve('.');
-
-  app.use(express.json());
-
-  if (!fs.existsSync(absoluteDistDir)) {
-    console.error(`❌ Error: ${path.basename(distDir)}/ directory not found at ${absoluteDistDir}`);
-    console.error('   Run: npx jux build\n');
-    process.exit(1);
-  }
-
-  // Strong cache prevention
-  app.use((req, res, next) => {
-    res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0');
-    res.setHeader('Pragma', 'no-cache');
-    res.setHeader('Expires', '0');
-    res.setHeader('ETag', 'W/"' + Date.now() + '"');
-    next();
-  });
-
-  // ✅ ADD: Explicit MIME type for JavaScript files
-  app.use((req, res, next) => {
-    if (req.path.endsWith('.js')) {
-      res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
-    }
-    next();
-  });
-
-  // Serve static files
-  app.use(express.static(absoluteDistDir));
-
-  // ✅ FIX: Only apply SPA fallback to routes, not static files
-  app.use((req, res, next) => {
-    // Skip SPA fallback for file extensions (static assets)
-    if (/\.[a-zA-Z0-9]+$/.test(req.path)) {
-      return res.status(404).send('File not found');
-    }
-
-    // SPA fallback for routes only
-    if (req.accepts('html')) {
-      const indexPath = path.join(absoluteDistDir, 'index.html');
-      if (fs.existsSync(indexPath)) {
-        res.sendFile(indexPath);
-      } else {
-        res.status(404).send('index.html not found. Run `npx jux build` first.');
-      }
-    } else {
-      res.status(404).send('Not found');
-    }
-  });
-
-  // Find available ports sequentially to avoid collision
-  console.log('🔍 Finding available ports...');
-
-  // First, find HTTP port
-  const availableHttpPort = await tryPort(httpPort);
-
-  // Then find WS port, excluding the HTTP port we just allocated
-  const availableWsPort = await tryPort(wsPort, 5, [availableHttpPort]);
-
-  // Create HTTP server
-  const server = http.createServer(app);
-
-  // WebSocket server for hot reload
-  const wss = new WebSocketServer({ port: availableWsPort });
-  const clients = [];
-
-  wss.on('connection', (ws) => {
-    clients.push(ws);
-    console.log('🔌 WebSocket client connected');
-
-    ws.on('close', () => {
-      console.log('🔌 WebSocket client disconnected');
-      const index = clients.indexOf(ws);
-      if (index > -1) clients.splice(index, 1);
-    });
-
-    ws.on('error', (error) => {
-      console.error('WebSocket error:', error);
-    });
-  });
-
-  console.log(`🔌 WebSocket server running at ws://localhost:${availableWsPort}`);
-
-  // Start HTTP server
-  server.listen(availableHttpPort, () => {
-    console.log(`🚀 JUX dev server running at http://localhost:${availableHttpPort}`);
-    console.log(`   Serving: ${absoluteDistDir}`);
-    console.log(`   Press Ctrl+C to stop\n`);
-  });
-
-  // Start file watcher
-  const juxSource = path.join(projectRoot, 'jux');
-  if (fs.existsSync(juxSource)) {
-    console.log(`👀 Watching: ${juxSource}\n`);
-    startWatcher(juxSource, absoluteDistDir, clients);
-  }
-
-  // Graceful shutdown
-  const shutdown = async () => {
-    console.log('\n\n👋 Shutting down server...');
-    wss.close();
-    server.close();
-    process.exit(0);
-  };
-
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
-
-  return { server, httpPort: availableHttpPort, wsPort: availableWsPort };
-}
-
-export async function start(httpPort = 3000, wsPort = 3001, distDir = './.jux-dist') {
-  return serve(httpPort, wsPort, distDir);
-}