@swissjs/swite 0.3.0

package/src/dev-engine/handlers/node-module-handler.ts

@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+
+import type { Response } from "express";
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import chalk from "chalk";
+import { rewriteImports } from "../../resolution/rewriting/import-rewriter.js";
+import { BaseHandler, type HandlerContext } from "./base-handler.js";
+import { UIHandler } from "./ui-handler.js";
+import { UIXHandler } from "./uix-handler.js";
+import { TSHandler } from "./ts-handler.js";
+import { findWorkspaceRoot } from "../../kernel/workspace.js";
+import { shouldUseCdnFallback } from "../../resolution/cdn/cdn-fallback.js";
+
+export class NodeModuleHandler extends BaseHandler {
+  private uiHandler: UIHandler;
+  private uixHandler: UIXHandler;
+  private tsHandler: TSHandler;
+
+  constructor(context: HandlerContext) {
+    super(context);
+    this.uiHandler = new UIHandler(context);
+    this.uixHandler = new UIXHandler(context);
+    this.tsHandler = new TSHandler(context);
+  }
+
+  async handle(url: string, res: Response): Promise<void> {
+    try {
+      // Special case: reflect-metadata/reflect.js -> Reflect.js (case fix)
+      if (url.includes("/reflect-metadata/reflect.js")) {
+        url = url.replace("/reflect.js", "/Reflect.js");
+      }
+
+      // Handle node_modules paths - try multiple locations
+      // URL is like /node_modules/reflect-metadata/Reflect.js
+      // We need to remove the leading / and join with the appropriate root
+      const urlPath = url.startsWith("/") ? url.slice(1) : url;
+      let filePath: string | null = null;
+      const workspaceRoot =
+        this.context.workspaceRoot ||
+        (await findWorkspaceRoot(this.context.root));
+
+      console.log(chalk.blue(`[node_modules] Processing: ${url}`));
+      console.log(chalk.blue(`[node_modules] App root: ${this.context.root}`));
+      console.log(
+        chalk.blue(`[node_modules] Workspace root: ${workspaceRoot || "none"}`),
+      );
+
+      // Walk up directory tree from app root to find node_modules at any level
+      // (handles pnpm isolated AND hoisted workspace layouts)
+      {
+        let current = path.resolve(this.context.root);
+        const visited = new Set<string>();
+        for (let i = 0; i < 8; i++) {
+          const candidate = path.join(current, urlPath);
+          if (!visited.has(candidate)) {
+            visited.add(candidate);
+            console.log(chalk.blue(`[node_modules] Trying path: ${candidate}`));
+            try {
+              const resolvedPath = await fs.realpath(candidate);
+              console.log(chalk.blue(`[node_modules] Resolved to: ${resolvedPath}`));
+              await fs.access(resolvedPath);
+              filePath = resolvedPath;
+              console.log(chalk.green(`[node_modules] ✓ Found: ${urlPath}`));
+              break;
+            } catch (err) {
+              console.log(chalk.yellow(`[node_modules] Path failed: ${err instanceof Error ? err.message : String(err)}`));
+            }
+          }
+          const parent = path.dirname(current);
+          if (parent === current) break;
+          current = parent;
+        }
+      }
+      if (!filePath) {
+        // Try workspace root node_modules
+        if (workspaceRoot) {
+          const workspaceNodeModulesPath = path.join(workspaceRoot, urlPath);
+          console.log(
+            chalk.blue(
+              `[node_modules] Trying workspace path: ${workspaceNodeModulesPath}`,
+            ),
+          );
+          try {
+            // Try to resolve symlinks first (realpath works even if path is a symlink)
+            const resolvedPath = await fs.realpath(workspaceNodeModulesPath);
+            console.log(
+              chalk.blue(`[node_modules] Resolved to: ${resolvedPath}`),
+            );
+            // Verify the resolved path exists
+            await fs.access(resolvedPath);
+            filePath = resolvedPath;
+            console.log(
+              chalk.green(`[node_modules] ✓ Found in workspace: ${urlPath}`),
+            );
+          } catch (err2) {
+            console.log(
+              chalk.yellow(
+                `[node_modules] Workspace path failed: ${err2 instanceof Error ? err2.message : String(err2)}`,
+              ),
+            );
+            // Try swiss-lib monorepo node_modules (dynamically found)
+            const { findSwissLibMonorepo } = await import("../../kernel/package-finder.js");
+            const swissLib = await findSwissLibMonorepo(this.context.root);
+            if (swissLib) {
+              const swissNodeModulesPath = path.join(swissLib, urlPath);
+              console.log(
+                chalk.blue(
+                  `[node_modules] Trying swiss-lib path: ${swissNodeModulesPath}`,
+                ),
+              );
+              try {
+                // Try to resolve symlinks first (realpath works even if path is a symlink)
+                const resolvedPath = await fs.realpath(swissNodeModulesPath);
+                console.log(
+                  chalk.blue(`[node_modules] Resolved to: ${resolvedPath}`),
+                );
+                // Verify the resolved path exists
+                await fs.access(resolvedPath);
+                filePath = resolvedPath;
+                console.log(
+                  chalk.green(
+                    `[node_modules] ✓ Found in swiss-lib monorepo: ${urlPath}`,
+                  ),
+                );
+              } catch (err3) {
+                console.log(
+                  chalk.yellow(
+                    `[node_modules] swiss-lib path failed: ${err3 instanceof Error ? err3.message : String(err3)}`,
+                  ),
+                );
+                // File not found in any location, will trigger case-insensitive search below
+                filePath = path.join(this.context.root, urlPath);
+              }
+            } else {
+              // File not found in any location, will trigger case-insensitive search below
+              filePath = path.join(this.context.root, urlPath);
+            }
+          }
+        } else {
+          filePath = path.join(this.context.root, urlPath);
+        }
+      }
+
+      console.log(
+        chalk.gray(`[node_modules] Resolving: ${url} -> ${filePath}`),
+      );
+
+      // File path is already resolved from above, no need to resolve again
+
+      // Check if file exists, if .js doesn't exist try case-insensitive match and alternatives
+      try {
+        await fs.access(filePath);
+      } catch (error) {
+        console.log(
+          chalk.yellow(
+            `[node_modules] File not found at ${filePath}, trying case-insensitive match...`,
+          ),
+        );
+        // File doesn't exist with exact case, try case-insensitive match (for Reflect.js vs reflect.js)
+        if (url.endsWith(".js")) {
+          const dir = path.dirname(filePath);
+          const requestedName = path.basename(filePath);
+          try {
+            // Resolve directory symlink (for pnpm)
+            const resolvedDir = await fs.realpath(dir).catch(() => dir);
+            // Check if directory exists first
+            await fs.access(resolvedDir);
+            const files = await fs.readdir(resolvedDir);
+            const caseInsensitiveMatch = files.find(
+              (f) => f.toLowerCase() === requestedName.toLowerCase(),
+            );
+            if (caseInsensitiveMatch) {
+              filePath = path.join(resolvedDir, caseInsensitiveMatch);
+              console.log(
+                chalk.yellow(
+                  `[node_modules] Case-insensitive match: ${requestedName} -> ${caseInsensitiveMatch}`,
+                ),
+              );
+              // Verify the file exists with the correct case
+              await fs.access(filePath);
+              // File found, continue to serve it below
+            } else {
+              throw new Error("No case-insensitive match found");
+            }
+          } catch {
+            // Directory doesn't exist or no case-insensitive match, try alternatives
+            console.log(
+              chalk.gray(
+                `[node_modules] Case-insensitive match failed for ${url}, trying alternatives...`,
+              ),
+            );
+            const basePath = filePath.slice(0, -3); // Remove .js
+            const alternatives = [
+              {
+                ext: ".ts",
+                handler: () =>
+                  this.tsHandler.handle(url.replace(/\.js$/, ".ts"), res),
+              },
+              {
+                ext: ".ui",
+                handler: () =>
+                  this.uiHandler.handle(url.replace(/\.js$/, ".ui"), res),
+              },
+              {
+                ext: ".uix",
+                handler: () =>
+                  this.uixHandler.handle(url.replace(/\.js$/, ".uix"), res),
+              },
+            ];
+
+            for (const alt of alternatives) {
+              try {
+                await fs.access(basePath + alt.ext);
+                console.log(
+                  chalk.yellow(
+                    `[.js→${alt.ext}] ${url} → ${url.replace(/\.js$/, alt.ext)}`,
+                  ),
+                );
+                return await alt.handler();
+              } catch {
+                // Try next alternative
+              }
+            }
+
+            // No alternatives found - redirect to CDN instead of 500
+            const cdnRedirect = this.getNodeModuleCdnRedirect(url);
+            if (cdnRedirect) {
+              console.log(chalk.yellow(`[node_modules] Not found locally, redirecting to CDN: ${cdnRedirect}`));
+              res.redirect(302, cdnRedirect);
+              return;
+            }
+            res.status(404).send(`Module not found: ${url}`);
+            return;
+          }
+        } else {
+          // Not a .js file and doesn't exist - try CDN redirect or 404
+          const cdnRedirect = this.getNodeModuleCdnRedirect(url);
+          if (cdnRedirect) {
+            res.redirect(302, cdnRedirect);
+            return;
+          }
+          res.status(404).send(`Module not found: ${url}`);
+          return;
+        }
+      }
+
+      // File exists, process it normally
+      // For node_modules files, skip import rewriting - they should work as-is
+      // and rewriting can cause issues with package internals
+      try {
+        console.log(chalk.blue(`[node_modules] Reading file: ${filePath}`));
+        const source = await fs.readFile(filePath, "utf-8");
+        console.log(
+          chalk.green(
+            `[node_modules] ✓ File read successfully, length: ${source.length}`,
+          ),
+        );
+
+        // Skip import rewriting for node_modules - serve as-is
+        // This is safer and faster for third-party packages
+        res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+        res.send(source);
+        console.log(chalk.green(`[node_modules] ✓ Served ${url} successfully`));
+      } catch (error) {
+        console.error(
+          chalk.red(`[node_modules] Error processing ${url} at ${filePath}:`),
+        );
+        console.error(chalk.red(`[node_modules] Error details:`), error);
+        if (error instanceof Error) {
+          console.error(chalk.red(`[node_modules] Error stack:`), error.stack);
+        }
+        throw error;
+      }
+    } catch (outerError) {
+      console.error(chalk.red(`[node_modules] FATAL ERROR handling ${url}:`));
+      console.error(
+        chalk.red(
+          `[node_modules] Error type: ${outerError instanceof Error ? outerError.constructor.name : typeof outerError}`,
+        ),
+      );
+      console.error(
+        chalk.red(
+          `[node_modules] Error message: ${outerError instanceof Error ? outerError.message : String(outerError)}`,
+        ),
+      );
+      if (outerError instanceof Error && outerError.stack) {
+        console.error(chalk.red(`[node_modules] Stack trace:`));
+        console.error(outerError.stack);
+      }
+      // Try CDN redirect before giving up with 500
+      const cdnRedirect = this.getNodeModuleCdnRedirect(url);
+      if (cdnRedirect) {
+        console.log(chalk.yellow(`[node_modules] Error handling locally, redirecting to CDN: ${cdnRedirect}`));
+        res.redirect(302, cdnRedirect);
+        return;
+      }
+      res.status(404).setHeader("Content-Type", "text/plain").send(
+        `Module not found: ${url}. ${outerError instanceof Error ? outerError.message : String(outerError)}`,
+      );
+    }
+  }
+
+  /**
+   * Get CDN URL for a /node_modules/... request when the file is not found locally.
+   * Uses jsDelivr (+esm) for reliable ESM delivery; esm.sh can return 500 for some packages.
+   * e.g. /node_modules/reflect-metadata/Reflect.js -> https://cdn.jsdelivr.net/npm/reflect-metadata/+esm
+   */
+  private getNodeModuleCdnRedirect(url: string): string | null {
+    const prefix = "/node_modules/";
+    if (!url.startsWith(prefix)) return null;
+
+    // For nested paths like /node_modules/@scope/pkg/node_modules/dep/file.js,
+    // find the LAST node_modules segment and extract the package name from there.
+    const lastNodeModulesIdx = url.lastIndexOf("/node_modules/");
+    const after = url.slice(lastNodeModulesIdx + prefix.length);
+    if (!after) return null;
+
+    // Extract package name: handle @scope/name and plain-name
+    let pkgName: string;
+    if (after.startsWith("@")) {
+      // Scoped package: need TWO path segments — @scope/name
+      const secondSlash = after.indexOf("/", after.indexOf("/") + 1);
+      pkgName = secondSlash === -1 ? after : after.slice(0, secondSlash);
+    } else {
+      const firstSlash = after.indexOf("/");
+      pkgName = firstSlash === -1 ? after : after.slice(0, firstSlash);
+    }
+
+    if (!pkgName || pkgName === "." || pkgName === "..") return null;
+    if (!shouldUseCdnFallback(pkgName)) return null;
+    // jsDelivr +esm serves ESM build; works for reflect-metadata and most npm packages
+    return `https://cdn.jsdelivr.net/npm/${pkgName}/+esm`;
+  }
+}

package/src/dev-engine/handlers/ts-handler.ts

@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+
+import type { Response } from "express";
+import { promises as fs } from "node:fs";
+import chalk from "chalk";
+import { rewriteImports } from "../../resolution/rewriting/import-rewriter.js";
+import { inlineEnvReferences } from "../../config/env.js";
+import { compilationCache } from "../../internal/cache/compilation-cache.js";
+import {
+  BaseHandler,
+  setDevHeaders,
+  type HandlerContext,
+} from "./base-handler.js";
+
+export class TSHandler extends BaseHandler {
+  constructor(context: HandlerContext) {
+    super(context);
+  }
+
+  async handle(url: string, res: Response): Promise<void> {
+    const filePath = await this.resolveFilePath(url);
+    console.log(chalk.gray(`[.ts] ${url}`));
+
+    // Check if .ts file exists, if not try .ui, .uix
+    try {
+      await fs.access(filePath);
+    } catch {
+      // .ts doesn't exist, try alternatives
+      const basePath = filePath.slice(0, -3); // Remove .ts
+      const alternatives = [
+        {
+          ext: ".ui",
+          url: url.replace(/\.ts$/, ".ui"),
+        },
+        {
+          ext: ".uix",
+          url: url.replace(/\.ts$/, ".uix"),
+        },
+      ];
+
+      for (const alt of alternatives) {
+        try {
+          const altPath = basePath + alt.ext;
+          await fs.access(altPath);
+          console.log(
+            chalk.yellow(
+              `[.ts→${alt.ext}] ${url} → ${alt.url} (file: ${altPath})`,
+            ),
+          );
+          // Import and use the appropriate handler
+          if (alt.ext === ".ui") {
+            const { UIHandler } = await import("./ui-handler.js");
+            const uiHandler = new UIHandler(this.context);
+            return await uiHandler.handle(alt.url, res);
+          } else if (alt.ext === ".uix") {
+            const { UIXHandler } = await import("./uix-handler.js");
+            const uixHandler = new UIXHandler(this.context);
+            return await uixHandler.handle(alt.url, res);
+          }
+        } catch {
+          // Try next alternative
+          console.log(
+            chalk.gray(
+              `[.ts→${alt.ext}] ${basePath + alt.ext} not found, trying next...`,
+            ),
+          );
+        }
+      }
+
+      // No alternatives found, throw error
+      console.error(
+        chalk.red(`[.ts] File not found: ${filePath} (and no alternatives found)`),
+      );
+      res.status(404).send(`File not found: ${url}`);
+      return;
+    }
+
+    // Check cache first
+    const cached = await compilationCache.get(
+      filePath,
+      (compiled) => this.getDependencies(compiled),
+    );
+    if (cached) {
+      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");
+
+    // Use esbuild for fast TS transformation
+    const esbuild = await import("esbuild");
+    const result = await esbuild.transform(source, {
+      loader: "ts",
+      format: "esm",
+      target: "esnext",
+      sourcefile: filePath,
+    });
+
+    const inlined = inlineEnvReferences(result.code, this.context.env);
+    const rewritten = await rewriteImports(
+      inlined,
+      filePath,
+      this.context.resolver,
+    );
+
+    await compilationCache.set(
+      filePath,
+      result.code,
+      rewritten,
+      (compiled) => this.getDependencies(compiled),
+    );
+
+    // Debug: Check for bare imports after rewriting
+    const bareImportPattern =
+      /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/;
+    if (bareImportPattern.test(rewritten)) {
+      console.log(
+        chalk.red(
+          `[.ts] 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(`[.ts] Unresolved import: ${match[1]}`));
+      }
+    }
+
+    setDevHeaders(res);
+    res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+    res.send(rewritten);
+  }
+}

package/src/dev-engine/handlers/ui-handler.ts

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+
+import type { Response } from "express";
+import { promises as fs } from "node:fs";
+import { UiCompiler } from "@swissjs/compiler";
+import chalk from "chalk";
+import { rewriteImports } from "../../resolution/rewriting/import-rewriter.js";
+import { inlineEnvReferences } from "../../config/env.js";
+import { compilationCache } from "../../internal/cache/compilation-cache.js";
+import { fixSwissLibPaths } from "../../resolution/path/path-fixup.js";
+import {
+  BaseHandler,
+  setDevHeaders,
+  type HandlerContext,
+} from "./base-handler.js";
+
+export class UIHandler extends BaseHandler {
+  private compiler = new UiCompiler();
+
+  constructor(context: HandlerContext) {
+    super(context);
+  }
+
+  async handle(url: string, res: Response): Promise<void> {
+    const filePath = await this.resolveFilePath(url);
+    console.log(chalk.blue(`[.ui] ${url} → ${filePath}`));
+
+    try {
+      await fs.access(filePath);
+    } catch {
+      console.error(chalk.red(`[.ui] File not found: ${filePath}`));
+      throw new Error(`File not found: ${url} (resolved to: ${filePath})`);
+    }
+
+    // Cache hit
+    const cached = await compilationCache.get(filePath, (compiled) => this.getDependencies(compiled));
+    if (cached) {
+      const fixed = fixSwissLibPaths(cached);
+      setDevHeaders(res);
+      res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+      res.setHeader("Content-Length", Buffer.byteLength(fixed, "utf-8"));
+      res.end(fixed, "utf-8");
+      return;
+    }
+
+    // Cache miss — compile
+    const source = await fs.readFile(filePath, "utf-8");
+    let compiled = await this.compiler.compileAsync(source, filePath);
+
+    const esbuild = await import("esbuild");
+    const tsResult = await esbuild.transform(compiled, {
+      loader: "ts",
+      format: "esm",
+      target: "esnext",
+      sourcefile: filePath,
+    });
+    compiled = tsResult.code;
+
+    // Fix compiler-emitted wrong paths before import rewriting
+    compiled = fixSwissLibPaths(compiled);
+
+    // Inline import.meta.env references before import rewriting
+    compiled = inlineEnvReferences(compiled, this.context.env);
+
+    // Strip CSS static-asset imports — they are not ES modules
+    compiled = stripCssImports(compiled, url);
+
+    const bareImportPattern = /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/;
+    if (bareImportPattern.test(compiled)) {
+      console.warn(`[.ui] Compiled output contains bare imports: ${url}`);
+    }
+
+    const rewritten = await rewriteImports(compiled, filePath, this.context.resolver);
+    const finalCode = fixSwissLibPaths(rewritten);
+
+    await compilationCache.set(filePath, compiled, finalCode, (c) => this.getDependencies(c));
+
+    if (bareImportPattern.test(finalCode)) {
+      console.error(`[.ui] Bare imports still present after rewriting: ${url}`);
+      for (const m of Array.from(rewritten.matchAll(/(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/g)).slice(0, 3)) {
+        console.error(`[.ui] Unresolved import: ${m[1]}`);
+      }
+    }
+
+    setDevHeaders(res);
+    res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+    res.setHeader("Content-Length", Buffer.byteLength(finalCode, "utf-8"));
+    res.end(finalCode, "utf-8");
+  }
+}
+
+function stripCssImports(code: string, url: string): string {
+  // Single well-ordered pass: static imports first, then dynamic imports
+  const before = code;
+  code = code.replace(/^[^\S\r\n]*import\s[^'"]*['"][^'"]*\.css['"]\s*;?[^\S\r\n]*$/gm, "");
+  code = code.replace(/\bimport\s*\(\s*['"][^'"]*\.css['"]\s*\)/g, "undefined");
+  if (before !== code) {
+    console.log(chalk.blue(`[.ui] Stripped CSS imports from ${url}`));
+  }
+  return code;
+}

package/src/dev-engine/handlers/uix-handler.ts

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+
+import type { Response } from "express";
+import { promises as fs } from "node:fs";
+import { UiCompiler } from "@swissjs/compiler";
+import chalk from "chalk";
+import { rewriteImports } from "../../resolution/rewriting/import-rewriter.js";
+import { inlineEnvReferences } from "../../config/env.js";
+import { compilationCache } from "../../internal/cache/compilation-cache.js";
+import { fixSwissLibPaths } from "../../resolution/path/path-fixup.js";
+import {
+  BaseHandler,
+  setDevHeaders,
+  type HandlerContext,
+} from "./base-handler.js";
+
+export class UIXHandler extends BaseHandler {
+  private compiler = new UiCompiler();
+
+  constructor(context: HandlerContext) {
+    super(context);
+  }
+
+  async handle(url: string, res: Response): Promise<void> {
+    const filePath = await this.resolveFilePath(url);
+    console.log(chalk.blue(`[.uix] ${url}`));
+
+    // Cache hit
+    const cached = await compilationCache.get(filePath, (compiled) => this.getDependencies(compiled));
+    if (cached) {
+      const fixed = fixSwissLibPaths(cached);
+      setDevHeaders(res);
+      res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+      res.send(fixed);
+      return;
+    }
+
+    // Cache miss — compile
+    const source = await fs.readFile(filePath, "utf-8");
+    let compiled = await this.compiler.compileAsync(source, filePath);
+
+    const esbuild = await import("esbuild");
+    const tsResult = await esbuild.transform(compiled, {
+      loader: "ts",
+      format: "esm",
+      target: "esnext",
+      sourcefile: filePath,
+    });
+    compiled = tsResult.code;
+
+    // Fix compiler-emitted wrong paths before import rewriting
+    compiled = fixSwissLibPaths(compiled);
+
+    // Inline import.meta.env references before import rewriting
+    compiled = inlineEnvReferences(compiled, this.context.env);
+
+    // Strip CSS static-asset imports — they are not ES modules
+    const beforeCss = compiled;
+    compiled = compiled.replace(/^[^\S\r\n]*import\s[^'"]*['"][^'"]*\.css['"]\s*;?[^\S\r\n]*$/gm, "");
+    compiled = compiled.replace(/\bimport\s*\(\s*['"][^'"]*\.css['"]\s*\)/g, "undefined");
+    if (beforeCss !== compiled) {
+      console.log(chalk.blue(`[.uix] Stripped CSS imports from ${url}`));
+    }
+
+    const bareImportPattern = /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/;
+    if (bareImportPattern.test(compiled)) {
+      console.warn(`[.uix] Compiled output contains bare imports: ${url}`);
+    }
+
+    const rewritten = await rewriteImports(compiled, filePath, this.context.resolver);
+    const finalCode = fixSwissLibPaths(rewritten);
+
+    await compilationCache.set(filePath, compiled, finalCode, (c) => this.getDependencies(c));
+
+    if (bareImportPattern.test(finalCode)) {
+      console.error(`[.uix] Bare imports still present after rewriting: ${url}`);
+      for (const m of Array.from(rewritten.matchAll(/(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/g)).slice(0, 3)) {
+        console.error(`[.uix] Unresolved import: ${m[1]}`);
+      }
+    }
+
+    setDevHeaders(res);
+    res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+    res.send(finalCode);
+  }
+}