@swissjs/swite 0.3.0

package/dist/handlers/ui-handler.js

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import { UiCompiler } from "@kibologic/compiler";
+import chalk from "chalk";
+import { rewriteImports } from "../import-rewriter.js";
+import { compilationCache } from "../cache/compilation-cache.js";
+import { BaseHandler, setDevHeaders, } from "./base-handler.js";
+export class UIHandler extends BaseHandler {
+    constructor(context) {
+        super(context);
+        this.compiler = new UiCompiler();
+    }
+    /**
+     * Extract dependencies from compiled code (import paths)
+     */
+    async getDependencies(compiled) {
+        const deps = [];
+        const importPattern = /(?:import|from|export).*['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = importPattern.exec(compiled)) !== null) {
+            const specifier = match[1];
+            // Only track absolute paths and workspace paths (not relative)
+            if (specifier.startsWith("/") || specifier.startsWith("@")) {
+                try {
+                    // Try to resolve to actual file path
+                    const resolved = await this.context.resolver.resolve(specifier, "");
+                    if (resolved && !resolved.startsWith("http")) {
+                        deps.push(resolved);
+                    }
+                }
+                catch {
+                    // Ignore resolution errors for dependency tracking
+                }
+            }
+        }
+        return deps;
+    }
+    async handle(url, res) {
+        const filePath = await this.resolveFilePath(url);
+        console.log(chalk.blue(`[.ui] ${url} → ${filePath}`));
+        // Check if file exists
+        try {
+            await fs.access(filePath);
+        }
+        catch (error) {
+            console.error(chalk.red(`[.ui] File not found: ${filePath}`));
+            throw new Error(`File not found: ${url} (resolved to: ${filePath})`);
+        }
+        // Check cache first
+        let cached = await compilationCache.get(filePath, (compiled) => this.getDependencies(compiled));
+        if (cached) {
+            console.log(chalk.yellow(`[.ui] Cache hit for ${url}`));
+            console.log(chalk.yellow(`[.ui] Cached content starts with: ${cached.substring(0, 50).replace(/\n/g, "\\n")}`));
+            // CRITICAL: Strip /swiss-lib/ paths from cached code too
+            // Old cache entries may have /swiss-lib/ paths from before the fix
+            if (cached.includes("/swiss-lib/")) {
+                console.log(chalk.yellow(`[.ui] Fixing /swiss-lib/ paths in cached code for ${url}`));
+                cached = cached.replace(/\/swiss-lib\/packages\//g, "/swiss-packages/");
+                cached = cached.replace(/\/swiss-lib\//g, "/swiss-packages/");
+                // Also fix in import statements and URLs (preserve quote type)
+                cached = cached.replace(/(['"])\/swiss-lib\//g, '$1/swiss-packages/');
+            }
+            setDevHeaders(res);
+            res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+            res.setHeader("Content-Length", Buffer.byteLength(cached, "utf-8"));
+            res.end(cached, "utf-8");
+            return;
+        }
+        // Cache miss - compile
+        const source = await fs.readFile(filePath, "utf-8");
+        console.log(chalk.yellow(`[.ui] Compiling file: ${filePath}`));
+        console.log(chalk.yellow(`[.ui] Source starts with: ${source.substring(0, 50).replace(/\n/g, "\\n")}`));
+        let compiled = await this.compiler.compileAsync(source, filePath);
+        // Transform TypeScript output to plain JavaScript via esbuild
+        const esbuild = await import("esbuild");
+        const tsResult = await esbuild.transform(compiled, {
+            loader: "ts",
+            format: "esm",
+            target: "esnext",
+            sourcefile: filePath,
+        });
+        compiled = tsResult.code;
+        console.log(chalk.yellow(`[.ui] Compiled result starts with: ${compiled.substring(0, 50).replace(/\n/g, "\\n")}`));
+        // CRITICAL: Strip /swiss-lib/ paths from compiled output BEFORE import rewriting
+        // The compiler may output /swiss-lib/ paths directly in the code
+        if (compiled.includes("/swiss-lib/")) {
+            const beforeSwissLibFix = compiled;
+            // Fix all variations of /swiss-lib/ paths
+            compiled = compiled.replace(/\/swiss-lib\/packages\//g, "/swiss-packages/");
+            compiled = compiled.replace(/\/swiss-lib\//g, "/swiss-packages/");
+            // Also fix in import statements and URLs (preserve quote type)
+            compiled = compiled.replace(/(['"])\/swiss-lib\//g, '$1/swiss-packages/');
+            if (beforeSwissLibFix !== compiled) {
+                console.log(chalk.yellow(`[.ui] Fixed /swiss-lib/ paths in compiled output for ${url}`));
+            }
+        }
+        // Strip CSS imports - they should be handled as static assets, not modules
+        // Use aggressive regex that matches all CSS import patterns
+        const beforeCssStrip = compiled;
+        // Pattern 1: Match standalone import statements for CSS (with or without semicolon, on their own line)
+        compiled = compiled.replace(/^\s*import\s+.*?\.css\s*['"];?\s*$/gm, '');
+        // Pattern 2: Match CSS imports anywhere in the code (more aggressive) - including without quotes
+        compiled = compiled.replace(/\bimport\s+.*?\.css\s*['"];?/g, '');
+        compiled = compiled.replace(/\bimport\s+['"].*?\.css['"];?/g, '');
+        // Pattern 3: Match dynamic imports for CSS
+        compiled = compiled.replace(/import\s*\(\s*['"].*?\.css['"]\s*\)/g, '');
+        // Pattern 4: Match CSS imports with different quote styles and whitespace
+        compiled = compiled.replace(/import\s+['"](.*?\.css)['"];?/g, '');
+        if (beforeCssStrip !== compiled) {
+            console.log(chalk.blue(`[.ui] Stripped CSS imports from ${url}`));
+        }
+        // Debug: Check for bare imports (only match actual bare imports, not paths)
+        // Pattern matches: import ... from "@package/name" or import("@package/name")
+        // But NOT: import ... from "/path/to/@package/name" (already a path)
+        const bareImportPattern = /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/;
+        if (bareImportPattern.test(compiled)) {
+            console.log(chalk.yellow(`[.ui] WARNING: Compiled code contains bare imports: ${url}`));
+        }
+        const rewritten = await rewriteImports(compiled, filePath, this.context.resolver);
+        // FINAL SAFETY: Strip any remaining /swiss-lib/ paths after import rewriting
+        // This catches any paths that might have slipped through
+        let finalCode = rewritten;
+        if (finalCode.includes("/swiss-lib/")) {
+            const beforeFinal = finalCode;
+            const count = (beforeFinal.match(/\/swiss-lib\//g) || []).length;
+            console.log(chalk.red(`[.ui] 🚨 FINAL PASS TRIGGERED: Found ${count} /swiss-lib/ paths in ${url}`));
+            // Multiple passes to catch all variations
+            finalCode = finalCode.replace(/\/swiss-lib\/packages\//g, "/swiss-packages/");
+            finalCode = finalCode.replace(/\/swiss-lib\//g, "/swiss-packages/");
+            finalCode = finalCode.replace(/(['"])\/swiss-lib\//g, '$1/swiss-packages/');
+            if (beforeFinal !== finalCode) {
+                const afterCount = (finalCode.match(/\/swiss-lib\//g) || []).length;
+                console.log(chalk.green(`[.ui] ✅ FINAL PASS: Fixed ${count} /swiss-lib/ paths (${afterCount} remaining) in ${url}`));
+                if (afterCount > 0) {
+                    console.log(chalk.red(`[.ui] ❌ STILL HAS /swiss-lib/: ${finalCode.substring(0, 500)}`));
+                }
+            }
+            else {
+                console.log(chalk.red(`[.ui] ❌ FINAL PASS FAILED: No changes made!`));
+                console.log(chalk.yellow(`[.ui] Sample: ${beforeFinal.substring(0, 200)}`));
+            }
+        }
+        // Store in cache
+        await compilationCache.set(filePath, compiled, finalCode, (compiled) => this.getDependencies(compiled));
+        // Debug: Verify no bare imports remain after rewriting
+        if (bareImportPattern.test(finalCode)) {
+            console.log(chalk.red(`[.ui] ERROR: Bare imports still present after rewriting: ${url}`));
+            const matches = Array.from(rewritten.matchAll(/(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/g));
+            for (const match of matches.slice(0, 3)) {
+                console.log(chalk.red(`[.ui] Unresolved import: ${match[1]}`));
+            }
+        }
+        // Set headers BEFORE sending response
+        setDevHeaders(res);
+        // Explicitly set Content-Type to ensure it's not overridden
+        res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+        // Log the Content-Type being sent
+        console.log(chalk.green(`[.ui] Sending response with Content-Type: ${res.getHeader("Content-Type")}`));
+        console.log(chalk.green(`[.ui] Response body length: ${rewritten.length} chars`));
+        console.log(chalk.green(`[.ui] Response body preview: ${rewritten.substring(0, 100)}...`));
+        // Send response - use res.end() to ensure headers are final
+        // Double-check Content-Type one more time
+        const finalContentType = res.getHeader("Content-Type");
+        if (finalContentType !== "application/javascript; charset=utf-8") {
+            console.error(chalk.red(`[.ui] ⚠️  Content-Type is wrong before send! Expected: application/javascript, Got: ${finalContentType}`));
+            res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+        }
+        console.log(chalk.green(`[.ui] Final Content-Type: ${res.getHeader("Content-Type")}`));
+        console.log(chalk.green(`[.ui] Sending ${finalCode.length} bytes of JavaScript`));
+        // Use res.end() instead of res.send() to have more control
+        res.setHeader("Content-Length", Buffer.byteLength(finalCode, "utf-8"));
+        res.end(finalCode, "utf-8");
+        // Ensure headersSent is set (should be set by res.end(), but verify)
+        if (!res.headersSent) {
+            console.error(chalk.red(`[.ui] ⚠️  res.end() called but headersSent is still false!`));
+        }
+    }
+}

package/dist/handlers/uix-handler.d.ts

@@ -0,0 +1,12 @@
+import type { Response } from "express";
+import { BaseHandler, type HandlerContext } from "./base-handler.js";
+export declare class UIXHandler extends BaseHandler {
+    private compiler;
+    constructor(context: HandlerContext);
+    /**
+     * Extract dependencies from compiled code (import paths)
+     */
+    private getDependencies;
+    handle(url: string, res: Response): Promise<void>;
+}
+//# sourceMappingURL=uix-handler.d.ts.map

package/dist/handlers/uix-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uix-handler.d.ts","sourceRoot":"","sources":["../../src/handlers/uix-handler.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMxC,OAAO,EACL,WAAW,EAEX,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,UAAW,SAAQ,WAAW;IACzC,OAAO,CAAC,QAAQ,CAAoB;gBAExB,OAAO,EAAE,cAAc;IAInC;;OAEG;YACW,eAAe;IAwBvB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAuIxD"}

package/dist/handlers/uix-handler.js

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import { UiCompiler } from "@kibologic/compiler";
+import chalk from "chalk";
+import { rewriteImports } from "../import-rewriter.js";
+import { compilationCache } from "../cache/compilation-cache.js";
+import { BaseHandler, setDevHeaders, } from "./base-handler.js";
+export class UIXHandler extends BaseHandler {
+    constructor(context) {
+        super(context);
+        this.compiler = new UiCompiler();
+    }
+    /**
+     * Extract dependencies from compiled code (import paths)
+     */
+    async getDependencies(compiled) {
+        const deps = [];
+        const importPattern = /(?:import|from|export).*['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = importPattern.exec(compiled)) !== null) {
+            const specifier = match[1];
+            // Only track absolute paths and workspace paths (not relative)
+            if (specifier.startsWith("/") || specifier.startsWith("@")) {
+                try {
+                    const resolved = await this.context.resolver.resolve(specifier, "");
+                    if (resolved && !resolved.startsWith("http")) {
+                        deps.push(resolved);
+                    }
+                }
+                catch {
+                    // Ignore resolution errors
+                }
+            }
+        }
+        return deps;
+    }
+    async handle(url, res) {
+        const filePath = await this.resolveFilePath(url);
+        console.log(chalk.blue(`[.uix] ${url}`));
+        // Check cache first
+        let cached = await compilationCache.get(filePath, (compiled) => this.getDependencies(compiled));
+        if (cached) {
+            // CRITICAL: Strip /swiss-lib/ paths from cached code too
+            // Old cache entries may have /swiss-lib/ paths from before the fix
+            if (cached.includes("/swiss-lib/")) {
+                console.log(chalk.yellow(`[.uix] Fixing /swiss-lib/ paths in cached code for ${url}`));
+                cached = cached.replace(/\/swiss-lib\/packages\//g, "/swiss-packages/");
+                cached = cached.replace(/\/swiss-lib\//g, "/swiss-packages/");
+                // Also fix in import statements and URLs (preserve quote type)
+                cached = cached.replace(/(['"])\/swiss-lib\//g, '$1/swiss-packages/');
+            }
+            setDevHeaders(res);
+            res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+            res.send(cached);
+            return;
+        }
+        // Cache miss - compile
+        const source = await fs.readFile(filePath, "utf-8");
+        let compiled = await this.compiler.compileAsync(source, filePath);
+        // Transform TypeScript output to plain JavaScript via esbuild
+        const esbuild = await import("esbuild");
+        const tsResult = await esbuild.transform(compiled, {
+            loader: "ts",
+            format: "esm",
+            target: "esnext",
+            sourcefile: filePath,
+        });
+        compiled = tsResult.code;
+        // CRITICAL: Strip /swiss-lib/ paths from compiled output BEFORE import rewriting
+        // The compiler may output /swiss-lib/ paths directly in the code
+        if (compiled.includes("/swiss-lib/")) {
+            const beforeSwissLibFix = compiled;
+            // Fix all variations of /swiss-lib/ paths
+            compiled = compiled.replace(/\/swiss-lib\/packages\//g, "/swiss-packages/");
+            compiled = compiled.replace(/\/swiss-lib\//g, "/swiss-packages/");
+            // Also fix in import statements and URLs (preserve quote type)
+            compiled = compiled.replace(/(['"])\/swiss-lib\//g, '$1/swiss-packages/');
+            if (beforeSwissLibFix !== compiled) {
+                console.log(chalk.yellow(`[.uix] Fixed /swiss-lib/ paths in compiled output for ${url}`));
+            }
+        }
+        // Strip CSS imports - they should be handled as static assets, not modules
+        // Use aggressive regex that matches all CSS import patterns
+        const beforeCssStrip = compiled;
+        // Pattern 1: Match standalone import statements for CSS (with or without semicolon, on their own line)
+        compiled = compiled.replace(/^\s*import\s+.*?\.css\s*['"];?\s*$/gm, '');
+        // Pattern 2: Match CSS imports anywhere in the code (more aggressive) - including without quotes
+        compiled = compiled.replace(/\bimport\s+.*?\.css\s*['"];?/g, '');
+        compiled = compiled.replace(/\bimport\s+['"].*?\.css['"];?/g, '');
+        // Pattern 3: Match dynamic imports for CSS
+        compiled = compiled.replace(/import\s*\(\s*['"].*?\.css['"]\s*\)/g, '');
+        // Pattern 4: Match CSS imports with different quote styles and whitespace
+        compiled = compiled.replace(/import\s+['"](.*?\.css)['"];?/g, '');
+        if (beforeCssStrip !== compiled) {
+            console.log(chalk.blue(`[.uix] Stripped CSS imports from ${url}`));
+        }
+        // Debug: Check for bare imports (only match actual bare imports, not paths)
+        // Pattern matches: import ... from "@package/name" or import("@package/name")
+        // But NOT: import ... from "/path/to/@package/name" (already a path)
+        const bareImportPattern = /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/;
+        if (bareImportPattern.test(compiled)) {
+            console.log(chalk.yellow(`[.uix] WARNING: Compiled code contains bare imports: ${url}`));
+        }
+        const rewritten = await rewriteImports(compiled, filePath, this.context.resolver);
+        // FINAL SAFETY: Strip any remaining /swiss-lib/ paths after import rewriting
+        // This catches any paths that might have slipped through
+        let finalCode = rewritten;
+        if (finalCode.includes("/swiss-lib/")) {
+            const beforeFinal = finalCode;
+            finalCode = finalCode.replace(/\/swiss-lib\/packages\//g, "/swiss-packages/");
+            finalCode = finalCode.replace(/\/swiss-lib\//g, "/swiss-packages/");
+            finalCode = finalCode.replace(/(['"])\/swiss-lib\//g, '$1/swiss-packages/');
+            if (beforeFinal !== finalCode) {
+                console.log(chalk.red(`[.uix] ⚠️ FINAL PASS: Fixed ${beforeFinal.split('/swiss-lib/').length - 1} remaining /swiss-lib/ paths in ${url}`));
+            }
+        }
+        // Store in cache
+        await compilationCache.set(filePath, compiled, finalCode, (compiled) => this.getDependencies(compiled));
+        // Debug: Verify no bare imports remain after rewriting
+        if (bareImportPattern.test(finalCode)) {
+            console.log(chalk.red(`[.uix] ERROR: Bare imports still present after rewriting: ${url}`));
+            const matches = Array.from(rewritten.matchAll(/(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/g));
+            for (const match of matches.slice(0, 3)) {
+                console.log(chalk.red(`[.uix] Unresolved import: ${match[1]}`));
+            }
+        }
+        setDevHeaders(res);
+        res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+        res.send(finalCode);
+    }
+}

package/dist/hmr.d.ts

@@ -0,0 +1,20 @@
+export declare class HMREngine {
+    private root;
+    private wss;
+    private watcher?;
+    private clients;
+    private port;
+    constructor(root: string, hmrPort?: number);
+    initialize(): Promise<void>;
+    private checkPortAvailable;
+    private setupWebSocket;
+    private findFreePort;
+    getPort(): number;
+    start(): Promise<void>;
+    notifyChange(filePath: string): void;
+    getClientScript(): string;
+    private getUpdateType;
+    private broadcast;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=hmr.d.ts.map

package/dist/hmr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr.d.ts","sourceRoot":"","sources":["../src/hmr.ts"],"names":[],"mappings":"AASA,qBAAa,SAAS;IAOlB,OAAO,CAAC,IAAI;IANd,OAAO,CAAC,GAAG,CAAmB;IAC9B,OAAO,CAAC,OAAO,CAAC,CAAqB;IACrC,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,IAAI,CAAS;gBAGX,IAAI,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM;IAOZ,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAiBnB,kBAAkB;IAUhC,OAAO,CAAC,cAAc;YAYR,YAAY;IAmB1B,OAAO,IAAI,MAAM;IAIX,KAAK;IA4BX,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAYpC,eAAe,IAAI,MAAM;IAyIzB,OAAO,CAAC,aAAa;IAuBrB,OAAO,CAAC,SAAS;IAcX,IAAI;CAIX"}

package/dist/hmr.js

@@ -0,0 +1,265 @@
+/*
+ * HMR Engine for SWITE
+ */
+import * as chokidar from "chokidar";
+import { WebSocketServer, WebSocket } from "ws";
+import * as net from "net";
+import chalk from "chalk";
+export class HMREngine {
+    constructor(root, hmrPort) {
+        this.root = root;
+        this.clients = new Set();
+        this.port = hmrPort || 24678;
+        // WebSocketServer will be created in initialize() method
+        // This allows async port checking before server creation
+    }
+    async initialize() {
+        // Check if port is available, if not find a free one
+        const isAvailable = await this.checkPortAvailable(this.port);
+        if (!isAvailable) {
+            console.warn(chalk.yellow(`[HMR] Port ${this.port} is in use, finding free port...`));
+            this.port = await this.findFreePort();
+        }
+        this.wss = new WebSocketServer({ port: this.port });
+        this.setupWebSocket();
+        console.log(chalk.green(`[HMR] WebSocket server started on port ${this.port}`));
+    }
+    async checkPortAvailable(port) {
+        return new Promise((resolve) => {
+            const server = net.createServer();
+            server.listen(port, () => {
+                server.close(() => resolve(true));
+            });
+            server.on("error", () => resolve(false));
+        });
+    }
+    setupWebSocket() {
+        this.wss.on("connection", (ws) => {
+            this.clients.add(ws);
+            console.log(chalk.green("[HMR] Client connected"));
+            ws.on("close", () => {
+                this.clients.delete(ws);
+                console.log(chalk.gray("[HMR] Client disconnected"));
+            });
+        });
+    }
+    async findFreePort() {
+        return new Promise((resolve, reject) => {
+            const server = net.createServer();
+            server.listen(0, () => {
+                const address = server.address();
+                const port = address && typeof address === "object" ? address.port : null;
+                server.close(() => {
+                    if (port) {
+                        resolve(port);
+                    }
+                    else {
+                        reject(new Error("Could not find free port"));
+                    }
+                });
+            });
+            server.on("error", reject);
+        });
+    }
+    getPort() {
+        return this.port;
+    }
+    async start() {
+        this.watcher = chokidar.watch(this.root, {
+            ignored: ["**/node_modules/**", "**/.git/**", "**/dist/**"],
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 100,
+            },
+        });
+        this.watcher.on("change", (filePath) => {
+            console.log(chalk.yellow(`[HMR] ${filePath} changed`));
+            // Determine file type and update type
+            const fileExt = filePath.split(".").pop()?.toLowerCase();
+            const updateType = this.getUpdateType(fileExt, filePath);
+            this.broadcast({
+                type: "update",
+                path: filePath,
+                updateType,
+                timestamp: Date.now(),
+            });
+        });
+        console.log(chalk.green("[HMR] Watching for file changes..."));
+    }
+    notifyChange(filePath) {
+        const fileExt = filePath.split(".").pop()?.toLowerCase();
+        const updateType = this.getUpdateType(fileExt, filePath);
+        this.broadcast({
+            type: "update",
+            path: filePath,
+            updateType,
+            timestamp: Date.now(),
+        });
+    }
+    getClientScript() {
+        return `
+// SWITE HMR Client
+console.log('[SWITE] HMR enabled');
+
+const socket = new WebSocket('ws://localhost:${this.port}');
+const moduleGraph = new Map<string, Set<string>>();
+const hotModules = new Map<string, any>();
+
+socket.addEventListener('open', () => {
+  console.log('[SWITE] HMR connected');
+});
+
+socket.addEventListener('message', (event) => {
+  const data = JSON.parse(event.data);
+  
+  if (data.type === 'update') {
+    console.log('[SWITE] Processing update:', data.path, 'Type:', data.updateType);
+    
+    if (data.updateType === 'style') {
+      // Hot swap CSS
+      updateStyles();
+      console.log('[SWITE] Styles hot updated');
+    } else if (data.updateType === 'hot') {
+      // Hot reload component
+      const moduleName = extractModuleName(data.path);
+      
+      if (moduleName && hotModules.has(moduleName)) {
+        const oldModule = hotModules.get(moduleName);
+        try {
+          invalidateModule(moduleName);
+          invalidateDependents(moduleName);
+          
+          const updatedModule = await import(data.path + '?t=' + Date.now());
+          hotModules.set(moduleName, updatedModule);
+          
+          updateComponent(moduleName, updatedModule);
+          console.log('[SWITE] Component hot updated:', moduleName);
+        } catch (error) {
+          console.error('[SWITE] Hot update failed:', error);
+          window.location.reload();
+        }
+      } else {
+        console.log('[SWITE] New component detected, reloading page');
+        window.location.reload();
+      }
+    } else {
+      // Full reload for everything else
+      console.log('[SWITE] Full page reload required');
+      window.location.reload();
+    }
+  }
+});
+
+function updateStyles() {
+  // Find all style and link tags
+  const styles = document.querySelectorAll('link[rel="stylesheet"], style');
+  styles.forEach(style => {
+    if (style.tagName === 'LINK' && style.getAttribute('href')) {
+      const href = style.getAttribute('href');
+      if (href && !href.includes('?t=')) {
+        // Add timestamp to force reload
+        style.setAttribute('href', href + '?t=' + Date.now());
+      }
+    }
+  });
+}
+
+function extractModuleName(path: string): string | null {
+  // Extract module name from file path
+  const parts = path.split('/');
+  const fileName = parts[parts.length - 1];
+  
+  if (fileName) {
+    const nameWithoutExt = fileName.replace(/.[^.]+$/, "");
+    return nameWithoutExt;
+  }
+  
+  return null;
+}
+
+function invalidateModule(moduleName: string) {
+  // Clear module from cache
+  if (typeof window !== 'undefined' && (window as any).__swiss_modules__) {
+    delete (window as any).__swiss_modules__[moduleName];
+  }
+}
+
+function invalidateDependents(moduleName: string) {
+  const dependents = moduleGraph.get(moduleName);
+  if (dependents) {
+    for (const dependent of dependents) {
+      invalidateModule(dependent);
+    }
+  }
+}
+
+function updateComponent(moduleName: string, newModule: any) {
+  // Find and update component instances
+  if (typeof window !== 'undefined' && (window as any).__swiss_instances__) {
+    const instances = (window as any).__swiss_instances__[moduleName];
+    if (instances && Array.isArray(instances)) {
+      instances.forEach(instance => {
+        // Update component state if it has update method
+        if (instance && typeof instance.update === 'function') {
+          instance.update(newModule.default || newModule);
+        }
+      });
+    }
+  }
+}
+
+socket.addEventListener('close', () => {
+  console.log('[SWITE] HMR disconnected');
+});
+
+socket.addEventListener('error', (error) => {
+  console.error('[SWITE] HMR error:', error);
+});
+
+// Register module for hot reloading
+if (typeof window !== 'undefined') {
+  (window as any).__swiss_modules__ = (window as any).__swiss_modules__ || {};
+  (window as any).__swiss_instances__ = (window as any).__swiss_instances__ || {};
+  
+  // Auto-register current module
+  const currentScript = document.currentScript;
+  if (currentScript && currentScript.src) {
+    const moduleName = extractModuleName(currentScript.src);
+    if (moduleName) {
+      (window as any).__swiss_modules__[moduleName] = true;
+    }
+  }
+}
+`;
+    }
+    getUpdateType(fileExt, filePath) {
+        if (!fileExt || !filePath)
+            return "reload";
+        // CSS files can be hot-swapped
+        if (fileExt === "css" || fileExt === "scss" || fileExt === "sass") {
+            return "style";
+        }
+        // Component files can be hot-reloaded
+        if (["js", "ts", "jsx", "tsx"].includes(fileExt)) {
+            // Check if it's in components directory
+            if (filePath.includes("/components/") || filePath.includes("/pages/")) {
+                return "hot";
+            }
+        }
+        // Everything else requires full reload
+        return "reload";
+    }
+    broadcast(message) {
+        const payload = JSON.stringify(message);
+        this.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(payload);
+            }
+        });
+    }
+    async stop() {
+        await this.watcher?.close();
+        this.wss.close();
+    }
+}

package/dist/import-rewriter.d.ts

@@ -0,0 +1,3 @@
+import { ModuleResolver } from "./resolver.js";
+export declare function rewriteImports(code: string, importer: string, resolver: ModuleResolver): Promise<string>;
+//# sourceMappingURL=import-rewriter.d.ts.map

package/dist/import-rewriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-rewriter.d.ts","sourceRoot":"","sources":["../src/import-rewriter.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAM/C,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,CAkbjB"}