@swissjs/swite 0.3.0

package/src/resolution/resolver.ts

@@ -0,0 +1,198 @@
+/*
+ * Module Resolver for SWITE
+ */
+
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import chalk from "chalk";
+import type { ImportMap } from "../internal/generate-import-map.js";
+import { findWorkspaceRoot } from "../kernel/workspace.js";
+import { toUrl, type UrlResolverContext, type WorkspacePackageResolverContext } from "./url-resolver.js";
+import { resolveWorkspacePackage } from "./workspace-package-resolver.js";
+import { resolveBareImport, type BareImportResolverContext } from "./bare-import-resolver.js";
+
+export class ModuleResolver {
+  private workspaceRoot: string | null = null;
+  private importMap: ImportMap | null = null;
+
+  constructor(private root: string) {}
+
+  /**
+   * Set pre-resolved import map (from build-time generation)
+   */
+  setImportMap(importMap: ImportMap | null): void {
+    this.importMap = importMap;
+    if (importMap) {
+      console.log(
+        chalk.green(
+          `[Resolver] Loaded import map with ${Object.keys(importMap).length - 2} entries`,
+        ),
+      );
+    }
+  }
+
+  private async getWorkspaceRoot(): Promise<string | null> {
+    if (this.workspaceRoot) return this.workspaceRoot;
+    this.workspaceRoot = await findWorkspaceRoot(this.root);
+    return this.workspaceRoot;
+  }
+
+  async resolve(specifier: string, importer: string): Promise<string> {
+    // Check import map first (fast path)
+    if (this.importMap && !specifier.startsWith(".") && !specifier.startsWith("/")) {
+      const mapped = this.importMap.imports[specifier];
+      if (mapped) {
+        console.log(
+          chalk.green(`[Resolver] ✅ Import map hit: ${specifier} -> ${mapped}`),
+        );
+        return mapped;
+      }
+    }
+
+    // CRITICAL: Skip variable references - they should never be resolved as modules
+    // Variables like def.componentUrl, someVar, etc. should be left as-is
+    // Only resolve actual module specifiers (bare imports starting with @ or valid package names)
+    if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+      // Check if this looks like a variable reference (property access, camelCase without @, etc.)
+      // Valid module specifiers: @scope/name, package-name, ./relative, /absolute
+      // Variable references: def.componentUrl, someVar, obj.prop, etc.
+      if (specifier.includes(".") && !specifier.startsWith("@")) {
+        // Property access pattern (def.componentUrl) - this is a variable, not a module
+        console.warn(
+          `[SWITE] resolve: Skipping variable reference: ${specifier}`,
+        );
+        return specifier; // Return as-is, don't try to resolve
+      }
+
+      // Additional check: if it doesn't look like a valid package name, it might be a variable
+      // Valid package names: start with letter or @, contain only alphanumeric, -, _, /
+      // Also allow file extensions at the end: .js, .ts, .ui, .uix, etc.
+      if (
+        !/^[@a-zA-Z][a-zA-Z0-9_/@-]*(\.(js|ts|ui|uix|mjs|cjs|jsx|tsx))?$/.test(
+          specifier,
+        )
+      ) {
+        console.warn(
+          `[SWITE] resolve: Invalid module specifier (likely variable): ${specifier}`,
+        );
+        return specifier; // Return as-is
+      }
+
+      const context: BareImportResolverContext = {
+        root: this.root,
+        getWorkspaceRoot: () => this.getWorkspaceRoot(),
+        fileExists: (p) => this.fileExists(p),
+        resolveWorkspacePackage: (pkgName) => this.resolveWorkspacePackage(pkgName),
+      };
+      return await resolveBareImport(specifier, context);
+    }
+
+    // Handle absolute paths (already URLs)
+    if (specifier.startsWith("/")) {
+      return specifier;
+    }
+
+    // Handle relative imports
+    // importer might be a URL path (/src/modules/index.ui) or file path
+    // Convert URL to file path if needed
+    let importerPath = importer;
+    if (importer.startsWith("/")) {
+      // URL path - convert to file path
+      // Prioritize app root for app files (src/, public/, assets/)
+      if (
+        importer.startsWith("/src/") ||
+        importer.startsWith("/public/") ||
+        importer.startsWith("/assets/")
+      ) {
+        // App-specific paths - resolve from app root
+        importerPath = path.join(this.root, importer);
+      } else {
+        // Other paths - try workspace root first (for libraries/, packages/)
+        const workspaceRoot = await this.getWorkspaceRoot();
+        if (workspaceRoot) {
+          const workspacePath = path.join(workspaceRoot, importer);
+          if (await this.fileExists(workspacePath)) {
+            importerPath = workspacePath;
+          } else {
+            // Fallback to app root
+            importerPath = path.join(this.root, importer);
+          }
+        } else {
+          // No workspace root, use app root
+          importerPath = path.join(this.root, importer);
+        }
+      }
+    }
+    const importerDir = path.dirname(importerPath);
+
+    // If specifier already has an extension (.ui, .uix, .ts, .js, etc.), try it first
+    // This preserves .ui/.uix extensions for SWISS files
+    const hasExtension = /\.(ui|uix|ts|tsx|js|jsx|mjs)$/.test(specifier);
+
+    if (hasExtension) {
+      const resolved = path.resolve(importerDir, specifier);
+      if (await this.fileExists(resolved)) {
+        return await this.toUrl(resolved);
+      }
+    }
+
+    // If no extension or file not found, try adding extensions
+    // Strip any existing extension from specifier (but preserve .ui/.uix if present)
+    const specifierWithoutExt = specifier.replace(/\.(js|ts|jsx|tsx|mjs)$/, "");
+    const resolved = path.resolve(importerDir, specifierWithoutExt);
+
+    // Try adding extensions (prioritize .ui and .uix for SWISS files)
+    const extensions = [".ui", ".uix", ".ts", ".tsx", ".js", ".jsx", ".mjs"];
+
+    for (const ext of extensions) {
+      const withExt = resolved + ext;
+      if (await this.fileExists(withExt)) {
+        return await this.toUrl(withExt);
+      }
+    }
+
+    // Try index files
+    for (const ext of extensions) {
+      const indexFile = path.join(resolved, `index${ext}`);
+      if (await this.fileExists(indexFile)) {
+        return await this.toUrl(indexFile);
+      }
+    }
+
+    // Return as-is if nothing found
+    return await this.toUrl(resolved);
+  }
+
+  private async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private async resolveWorkspacePackage(
+    pkgName: string,
+  ): Promise<string | null> {
+    const context: WorkspacePackageResolverContext = {
+      root: this.root,
+      getWorkspaceRoot: () => this.getWorkspaceRoot(),
+      fileExists: (p) => this.fileExists(p),
+    };
+    return resolveWorkspacePackage(pkgName, context);
+  }
+
+  // OLD IMPLEMENTATION REMOVED - now uses resolver/workspace-package-resolver.ts
+
+  private async toUrl(filePath: string): Promise<string> {
+    const context: UrlResolverContext = {
+      root: this.root,
+      getWorkspaceRoot: () => this.getWorkspaceRoot(),
+      fileExists: (p) => this.fileExists(p),
+    };
+    return toUrl(filePath, context);
+  }
+
+  // OLD IMPLEMENTATION REMOVED - now uses resolver/url-resolver.ts
+}

package/src/resolution/rewriting/import-rewriter.ts

@@ -0,0 +1,237 @@
+/*
+ * Import Rewriter for SWITE
+ *
+ * Design: collect-then-apply-right-to-left
+ *
+ * es-module-lexer gives positions {s, e} in the ORIGINAL string. The previous
+ * implementation tracked a running `offset` as replacements were applied, which
+ * accumulated errors when quote handling changed string lengths in unexpected
+ * ways and required three layers of fallback replacement logic.
+ *
+ * Instead we now:
+ *  1. Collect every replacement as {start, end, text} in original-string coordinates
+ *  2. Sort descending by start position
+ *  3. Apply right-to-left — each substitution cannot shift the position of any
+ *     replacement to its left, so no offset tracking is needed at all.
+ */
+
+import { init, parse } from "es-module-lexer";
+import { ModuleResolver } from "../resolver.js";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { shouldUseCdnFallback } from "../cdn/cdn-fallback.js";
+
+interface Replacement {
+  start: number;
+  end: number;
+  text: string;
+}
+
+export async function rewriteImports(
+  code: string,
+  importer: string,
+  resolver: ModuleResolver,
+): Promise<string> {
+  await init;
+
+  try {
+    const [imports] = parse(code);
+    if (imports.length === 0) return code;
+
+    const replacements: Replacement[] = [];
+
+    for (const imp of imports) {
+      const { s: rawStart, e: rawEnd } = imp;
+      const rawSpecifier = code.slice(rawStart, rawEnd);
+
+      // Skip CSS imports — handled as static assets
+      if (rawSpecifier.includes(".css")) continue;
+
+      // Determine actual specifier string and the span in `code` that includes quotes
+      const { specifier, start, end } = resolveQuotedSpan(code, rawSpecifier, rawStart, rawEnd);
+      if (specifier === null) continue;
+
+      // Fix compiler bug: .uix/.ui imports emitted as .js or .tsx
+      if (
+        specifier.startsWith(".") &&
+        (specifier.endsWith(".js") || specifier.endsWith(".tsx")) &&
+        !specifier.includes("node_modules")
+      ) {
+        const newExt = await resolveExtensionFix(specifier, importer);
+        if (newExt) {
+          const base = specifier.endsWith(".tsx") ? specifier.slice(0, -4) : specifier.slice(0, -3);
+          replacements.push({ start, end, text: `"${base}${newExt}"` });
+          continue;
+        }
+      }
+
+      // Skip relative and absolute path imports (already resolved)
+      if (specifier.startsWith(".") || specifier.startsWith("/")) continue;
+
+      if (!/^[@a-zA-Z]/.test(specifier)) {
+        console.warn(`[SWITE] import-rewriter: Invalid specifier format: ${specifier}`);
+        continue;
+      }
+
+      // Resolve bare import
+      let resolved: string;
+      try {
+        resolved = await resolver.resolve(specifier, importer);
+        if (!resolved || resolved === specifier || (!resolved.startsWith("/") && !resolved.startsWith("http"))) {
+          console.warn(chalk.yellow(`[SWITE] import-rewriter: Resolver returned invalid result for ${specifier}, using CDN fallback`));
+          resolved = shouldUseCdnFallback(specifier)
+            ? `https://cdn.jsdelivr.net/npm/${specifier}/+esm`
+            : `/node_modules/${specifier}`;
+        }
+      } catch (error) {
+        console.error(chalk.red(`[SWITE] import-rewriter: Error resolving ${specifier}:`), error);
+        resolved = shouldUseCdnFallback(specifier)
+          ? `https://cdn.jsdelivr.net/npm/${specifier}/+esm`
+          : `/node_modules/${specifier}`;
+      }
+
+      // Prefer src/ over dist/ for workspace/swiss packages in dev
+      if (resolved.includes("/dist/") && (resolved.includes("/swiss-packages/") || resolved.includes("/packages/"))) {
+        resolved = resolved.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
+      }
+
+      replacements.push({ start, end, text: `"${resolved}"` });
+    }
+
+    // Apply right-to-left so earlier positions are never shifted by later replacements
+    replacements.sort((a, b) => b.start - a.start);
+    let result = code;
+    for (const { start, end, text } of replacements) {
+      result = result.slice(0, start) + text + result.slice(end);
+    }
+
+    // Safety net: catch any bare scoped imports the lexer may have missed
+    const barePattern = /(?:import|from|export)\s+['"](@[^'"]+\/[^'"]+)[^'"]*['"]/g;
+    for (const match of Array.from(result.matchAll(barePattern))) {
+      const bareImport = match[1];
+      if (!bareImport.startsWith("/") && !bareImport.startsWith("http") && !bareImport.startsWith(".")) {
+        console.error(chalk.red(`[SWITE] import-rewriter: CRITICAL — bare import "${bareImport}" still present after rewriting`));
+        const replacement = shouldUseCdnFallback(bareImport)
+          ? `https://cdn.jsdelivr.net/npm/${bareImport}/+esm`
+          : `/node_modules/${bareImport}`;
+        result = result.replace(
+          new RegExp(bareImport.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+          replacement,
+        );
+      }
+    }
+
+    // Regex fallback: fix relative .js/.tsx extension mismatches the lexer may have missed
+    const normalizedImporter = importer.replace(/\\/g, "/");
+    const isSwissPackage = normalizedImporter.includes("/swiss-packages/");
+    const isUixFile = normalizedImporter.endsWith(".uix") || normalizedImporter.endsWith(".ui");
+
+    result = result.replace(
+      /from\s+(["'])(\.\.?\/[^"']*?)(\.js|\.tsx)(\1)/g,
+      (match, quote, importPath, _ext, endQuote) => {
+        if (importPath.includes("node_modules") || !importPath.startsWith(".")) return match;
+        const isLibPath = normalizedImporter.includes("/lib/");
+        let newExt: string;
+        if (isSwissPackage || isLibPath) {
+          newExt = ".ts";
+        } else if (isUixFile) {
+          newExt = normalizedImporter.endsWith(".ui") ? ".ui" : ".uix";
+        } else {
+          newExt = ".ts";
+        }
+        return `from ${quote}${importPath}${newExt}${endQuote}`;
+      },
+    );
+
+    return result;
+  } catch (error) {
+    console.error(chalk.red(`[SWITE] import-rewriter: Error rewriting imports in ${importer}:`), error);
+    return code;
+  }
+}
+
+/**
+ * Given a raw specifier token from es-module-lexer, find the full quoted span
+ * in `code` (including the surrounding quote characters) and extract the clean
+ * specifier string. Returns `{specifier: null}` when the span cannot be found.
+ */
+function resolveQuotedSpan(
+  code: string,
+  rawSpecifier: string,
+  rawStart: number,
+  rawEnd: number,
+): { specifier: string | null; start: number; end: number } {
+  const first = rawSpecifier[0];
+  const last = rawSpecifier[rawSpecifier.length - 1];
+
+  // Case 1: lexer returned the specifier WITH surrounding quotes
+  if ((first === '"' || first === "'") && first === last) {
+    return {
+      specifier: rawSpecifier.slice(1, -1),
+      start: rawStart,
+      end: rawEnd,
+    };
+  }
+
+  // Case 2: lexer returned the bare specifier; look one char back/forward for quotes
+  const charBefore = rawStart > 0 ? code[rawStart - 1] : "";
+  const charAfter = rawEnd < code.length ? code[rawEnd] : "";
+  if ((charBefore === '"' || charBefore === "'") && charBefore === charAfter) {
+    return {
+      specifier: rawSpecifier,
+      start: rawStart - 1,
+      end: rawEnd + 1,
+    };
+  }
+
+  // Case 3: search nearby for a quoted pattern
+  const escaped = rawSpecifier.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&");
+  const pattern = new RegExp(`(['"])${escaped}\\1`);
+  const match = pattern.exec(code);
+  if (match) {
+    return {
+      specifier: rawSpecifier,
+      start: match.index,
+      end: match.index + match[0].length,
+    };
+  }
+
+  console.warn(`[SWITE] import-rewriter: Could not find quotes for specifier: ${rawSpecifier}`);
+  return { specifier: null, start: rawStart, end: rawEnd };
+}
+
+/**
+ * Determine what extension a .js/.tsx import should be rewritten to,
+ * based on the importer's context and the actual files present on disk.
+ * Returns null when no rewrite is needed.
+ */
+async function resolveExtensionFix(specifier: string, importer: string): Promise<string | null> {
+  const normalizedImporter = importer.replace(/\\/g, "/");
+  const isSwissPackage = normalizedImporter.includes("/swiss-packages/");
+  const isLibPath = normalizedImporter.includes("/lib/");
+  const isUixFile = normalizedImporter.endsWith(".uix") || normalizedImporter.endsWith(".ui");
+
+  if (isSwissPackage || isLibPath) return ".ts";
+
+  if (isUixFile) {
+    const base = specifier.endsWith(".tsx") ? specifier.slice(0, -4) : specifier.slice(0, -3);
+    const currentDir = path.dirname(importer);
+    const cleanPath = base.startsWith("./") ? base.slice(2) : base;
+    const uiPath = path.resolve(currentDir, cleanPath + ".ui");
+    const uixPath = path.resolve(currentDir, cleanPath + ".uix");
+    try {
+      await fs.access(uiPath);
+      return ".ui";
+    } catch {
+      try {
+        await fs.access(uixPath);
+        return ".uix";
+      } catch {
+        return ".ui";
+      }
+    }
+  }
+
+  return ".ts";
+}

package/src/resolution/symlink-registry.ts

@@ -0,0 +1,114 @@
+/*
+ * Symlink Registry - CG-03 root cause fix
+ *
+ * fs.realpath() throughout Swite's handler chain resolves symlinks to absolute
+ * filesystem paths (e.g. /mnt/c/.../swiss-lib/packages/core/src/index.ts).
+ * These leak into toUrl() and hit the startsWith("/") early-return before the
+ * proper node_modules/swiss-lib handling logic is reached.
+ *
+ * At server startup we scan node_modules directories for symlinks and build a
+ * map: realpath → /node_modules/<pkg-name>
+ * toUrl() consults this registry FIRST and short-circuits back to the correct
+ * browser URL.
+ */
+
+import { promises as fs } from "node:fs";
+import path from "node:path";
+
+// realpath (normalized, forward slashes) → browser URL prefix
+const registry = new Map<string, string>();
+
+export async function buildSymlinkRegistry(
+  nodeModulesDirs: string[]
+): Promise<void> {
+  registry.clear();
+  for (const dir of nodeModulesDirs) {
+    await scanNodeModulesDir(dir);
+  }
+  console.log(
+    `[SWITE] Symlink registry built: ${registry.size} entries from ${nodeModulesDirs.length} node_modules dirs`
+  );
+}
+
+async function scanNodeModulesDir(nodeModulesDir: string): Promise<void> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let dirents: any[];
+  try {
+    dirents = await fs.readdir(nodeModulesDir, {
+      withFileTypes: true,
+      encoding: "utf8",
+    });
+  } catch {
+    return; // dir doesn't exist — skip silently
+  }
+
+  for (const dirent of dirents) {
+    if (dirent.name.startsWith(".")) continue;
+
+    if (dirent.name.startsWith("@")) {
+      // Scoped scope directory — scan one level deeper
+      const scopeDir = path.join(nodeModulesDir, dirent.name);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let scopedDirents: any[];
+      try {
+        scopedDirents = await fs.readdir(scopeDir, {
+          withFileTypes: true,
+          encoding: "utf8",
+        });
+      } catch {
+        continue;
+      }
+      for (const scoped of scopedDirents) {
+        if (scoped.isSymbolicLink()) {
+          await registerSymlink(
+            path.join(scopeDir, scoped.name),
+            `${dirent.name}/${scoped.name}`
+          );
+        }
+      }
+    } else if (dirent.isSymbolicLink()) {
+      await registerSymlink(
+        path.join(nodeModulesDir, dirent.name),
+        dirent.name
+      );
+    }
+  }
+}
+
+async function registerSymlink(
+  symlinkPath: string,
+  pkgName: string
+): Promise<void> {
+  try {
+    const realPath = await fs.realpath(symlinkPath);
+    const key = realPath.replace(/\\/g, "/");
+    const value = `/node_modules/${pkgName}`;
+    registry.set(key, value);
+    console.log(`[SWITE] Registry: ${pkgName}: ${key} → ${value}`);
+  } catch {
+    // broken symlink — ignore
+  }
+}
+
+/**
+ * Look up an absolute filesystem path in the symlink registry.
+ *
+ * Returns the browser URL if absolutePath is, or is within, a package whose
+ * realpath was registered at startup. Returns null if not found.
+ *
+ * Example:
+ *   /mnt/c/.../swiss-lib/packages/core/src/index.ts
+ *   → /node_modules/@swissjs/core/src/index.ts
+ */
+export function lookupInSymlinkRegistry(absolutePath: string): string | null {
+  const normalized = absolutePath.replace(/\\/g, "/");
+  for (const [realPkgPath, browserPrefix] of registry) {
+    if (normalized === realPkgPath) {
+      return browserPrefix;
+    }
+    if (normalized.startsWith(realPkgPath + "/")) {
+      return browserPrefix + normalized.slice(realPkgPath.length);
+    }
+  }
+  return null;
+}