@swissjs/swite 0.3.1 → 0.3.2

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

@@ -7,14 +7,15 @@
 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";
+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 { findPackage } from "../../kernel/package-finder.js";
+import { shouldUseCdnFallback } from "../../resolution/cdn/cdn-fallback.js";
 
 export class NodeModuleHandler extends BaseHandler {
   private uiHandler: UIHandler;
@@ -76,76 +77,39 @@ export class NodeModuleHandler extends BaseHandler {
           current = parent;
         }
       }
+      // CONSOLIDATED DISCOVERY: Use the Generalized Package Finder
+      // This follows our "Local-First" priority: Siblings > Local node_modules > Workspace node_modules
       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);
+        const urlParts = urlPath.split("/");
+        const packageName = urlParts[1].startsWith("@") ? `${urlParts[1]}/${urlParts[2]}` : urlParts[1];
+        const remainingPath = urlParts[1].startsWith("@") ? urlParts.slice(3).join("/") : urlParts.slice(2).join("/");
+
+        const location = await findPackage(packageName, this.context.root, workspaceRoot);
+
+        if (location) {
+          filePath = path.join(location.path, remainingPath);
+          console.log(chalk.green(`[node_modules] ✓ Found ${packageName} via ${location.type}: ${filePath}`));
+
+          // Re-use dist -> src fallback for local siblings
+          if (location.type !== 'node_modules' && filePath.includes("/dist/")) {
+            const srcPath = filePath.replace("/dist/", "/src/").replace(/\.[mc]?js$/, ".ts");
+            try {
+              await fs.access(srcPath);
+              console.log(chalk.yellow(`[node_modules] Intercept: Serving local source instead of dist: ${srcPath}`));
+              filePath = srcPath;
+
+              if (srcPath.endsWith(".ts")) {
+                return await this.tsHandler.handle(url.replace(/\.[mc]?js$/, ".ts"), res);
               }
-            } else {
-              // File not found in any location, will trigger case-insensitive search below
-              filePath = path.join(this.context.root, urlPath);
-            }
+            } catch { /* Fallback to original filePath */ }
           }
-        } else {
-          filePath = path.join(this.context.root, urlPath);
         }
       }
 
+      if (!filePath) {
+        filePath = path.join(this.context.root, urlPath);
+      }
+
       console.log(
         chalk.gray(`[node_modules] Resolving: ${url} -> ${filePath}`),
       );
@@ -331,9 +295,18 @@ export class NodeModuleHandler extends BaseHandler {
       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`;
-  }
-}
+    if (!pkgName || pkgName === "." || pkgName === "..") return null;
+
+    // Never redirect internal/private scoped packages to public CDNs
+    const internalScopes = this.context.userConfig?.internalScopes || [];
+    const isInternal = internalScopes.some(scope => pkgName === scope || pkgName.startsWith(scope + "/"));
+    if (isInternal) {
+      console.log(chalk.red(`[node_modules] CDN Blocked: Internal scope package ${pkgName} cannot be served from jsDelivr.`));
+      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/middleware/middleware-setup.ts

@@ -35,6 +35,7 @@ export interface MiddlewareConfig {
   publicDir: string;
   resolver: ModuleResolver;
   hmr: HMREngine;
+  userConfig?: import("../../config/config.js").SwiteUserConfig;
 }
 
 export interface MiddlewareResult {

package/src/dev-engine/server.ts

@@ -16,20 +16,21 @@ import chalk from "chalk";
 import { setupMiddleware } from "./middleware/middleware-setup.js";
 import { buildSymlinkRegistry } from "../resolution/symlink-registry.js";
 import { findSwissLibMonorepo } from "../kernel/package-finder.js";
+import { loadUserConfig } from "../config/config-loader.js";
 
-export interface SwiteConfig {
-  root: string;
-  // Workspace/monorepo root. When set, Swite will use this for resolving
-  // node_modules, workspace packages, and import-map generation.
-  // This avoids relying on auto-detection (pnpm-workspace.yaml) which may not
-  // exist in some deployment contexts.
-  rootDir?: string;
-  publicDir: string;
-  port: number;
-  host: string;
-  open: boolean;
-  hmrPort?: number; // Optional HMR WebSocket port
-}
+export interface SwiteConfig {
+  root: string;
+  // Workspace/monorepo root. When set, Swite will use this for resolving
+  // node_modules, workspace packages, and import-map generation.
+  // This avoids relying on auto-detection (pnpm-workspace.yaml) which may not
+  // exist in some deployment contexts.
+  rootDir?: string;
+  publicDir: string;
+  port: number;
+  host: string;
+  open: boolean;
+  hmrPort?: number; // Optional HMR WebSocket port
+}
 
 export class SwiteServer {
   private app = express();
@@ -55,16 +56,16 @@ export class SwiteServer {
     this.hmr = new HMREngine(this.config.root, this.config.hmrPort);
   }
 
-  // CG-03: find workspace root by walking up from startDir
-  private async findWorkspaceRoot(startDir: string): Promise<string | null> {
-    if (this.config.rootDir) {
-      return path.resolve(this.config.rootDir);
-    }
-    let current = startDir;
-    for (let i = 0; i < 6; i++) {
-      try {
-        await fs.access(path.join(current, "pnpm-workspace.yaml"));
-        return current;
+  // CG-03: find workspace root by walking up from startDir
+  private async findWorkspaceRoot(startDir: string): Promise<string | null> {
+    if (this.config.rootDir) {
+      return path.resolve(this.config.rootDir);
+    }
+    let current = startDir;
+    for (let i = 0; i < 6; i++) {
+      try {
+        await fs.access(path.join(current, "pnpm-workspace.yaml"));
+        return current;
       } catch {}
       try {
         const pkgJson = JSON.parse(
@@ -110,16 +111,20 @@ export class SwiteServer {
     }
     console.timeEnd("Symlink Registry");
 
-    // Setup middleware
-    console.time("Middleware Setup");
-    const workspaceRoot = await this.findWorkspaceRoot(this.config.root);
-    const middlewareResult = await setupMiddleware(this.app, {
-      root: this.config.root,
-      workspaceRoot,
-      publicDir: this.config.publicDir,
-      resolver: this.resolver,
-      hmr: this.hmr,
-    });
+    // Load user config (swiss.config.ts) so internalScopes etc. flow into handlers
+    const userConfig = await loadUserConfig(this.config.root);
+
+    // Setup middleware
+    console.time("Middleware Setup");
+    const workspaceRoot = await this.findWorkspaceRoot(this.config.root);
+    const middlewareResult = await setupMiddleware(this.app, {
+      root: this.config.root,
+      workspaceRoot,
+      publicDir: this.config.publicDir,
+      resolver: this.resolver,
+      hmr: this.hmr,
+      userConfig,
+    });
     this.routes = middlewareResult.routes;
     this.routeScanner = middlewareResult.routeScanner;
     this.routeWatcher = middlewareResult.routeWatcher;

package/src/kernel/package-finder.ts

@@ -18,55 +18,54 @@ export interface PackageLocation {
 }
 
 /**
- * Find a co-located framework monorepo by scanning sibling directories at each
- * ancestor level for any workspace root (pnpm-workspace.yaml) that also has a
- * packages/ directory. Works for any framework directory name.
+ * Find any sibling monorepo by searching for its package.json
  */
-export async function findSwissLibMonorepo(startPath: string): Promise<string | null> {
-  let current = path.resolve(startPath);
-
+export async function findSiblingRepository(startPath: string, repoName: string): Promise<string | null> {
+  let current = startPath;
   for (let i = 0; i < 20; i++) {
-    const parent = path.dirname(current);
-    if (parent === current) break;
+    const siblingPath = path.join(current, repoName);
+    const pkgJson = path.join(siblingPath, "package.json");
+    if (await fileExists(pkgJson)) {
+      return siblingPath;
+    }
 
-    // Scan siblings of `current` at this parent level
     try {
-      const entries = await fs.readdir(parent, { withFileTypes: true });
+      const entries = await fs.readdir(current, { withFileTypes: true });
       for (const entry of entries) {
-        if (entry.name === "node_modules") continue;
-        if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-        const sibling = path.join(parent, entry.name);
-        if (path.resolve(sibling) === path.resolve(current)) continue; // skip self
-
-        if (
-          await fileExists(path.join(sibling, "pnpm-workspace.yaml")) &&
-          await fileExists(path.join(sibling, "packages"))
-        ) {
-          return sibling;
+        if (entry.name === repoName && (entry.isDirectory() || entry.isSymbolicLink())) {
+          const subDir = path.join(current, entry.name);
+          if (await fileExists(path.join(subDir, "package.json"))) {
+            return subDir;
+          }
         }
       }
-    } catch {
-      // Skip on permission errors
-    }
+    } catch { /* Continue */ }
 
-    current = parent;
+    current = path.dirname(current);
+    if (current === path.dirname(current)) break;
   }
-
   return null;
 }
 
 /**
- * Find a specific package by name, searching in:
- * 1. node_modules (local and workspace)
- * 2. swiss-lib/packages (if found)
- * 3. workspace packages (lib/, packages/, modules/)
+ * Backward compatibility wrapper for finding swiss-lib
+ */
+export async function findSwissLibMonorepo(startPath: string): Promise<string | null> {
+  return findSiblingRepository(startPath, 'swiss-lib');
+}
+
+/**
+ * Find a specific package by name, with priority given based on environment.
+ * In development, we prioritize local sibling source code.
  */
 export async function findPackage(
   packageName: string,
   startPath: string,
   workspaceRoot?: string | null
 ): Promise<PackageLocation | null> {
-  // 1. Check local node_modules
+  const isDev = process.env.NODE_ENV !== 'production';
+
+  // 1. Check local node_modules (Standard resolution) - HIGHEST PRIORITY in Remote-First
   const localNodeModules = path.join(startPath, "node_modules", packageName);
   if (await fileExists(path.join(localNodeModules, "package.json"))) {
     return { path: localNodeModules, type: 'node_modules' };
@@ -79,7 +78,7 @@ export async function findPackage(
       return { path: workspaceNodeModules, type: 'node_modules' };
     }
   }
-  
+
   // 3. Check co-located framework monorepo packages/ for any scoped package
   if (packageName.startsWith("@")) {
     const monorepo = await findSwissLibMonorepo(startPath);
@@ -92,24 +91,41 @@ export async function findPackage(
     }
   }
 
-  // 4. Check workspace packages (lib/, packages/, modules/)
+  // 4. In dev: broader sibling scan across parent directories
+  if (isDev && packageName.includes("/")) {
+    const parts = packageName.split("/");
+    const unscoped = parts[parts.length - 1];
+    const parentDirs = [
+      path.join(startPath, ".."),
+      path.join(startPath, "../.."),
+      path.join(startPath, "../../.."),
+    ];
+    for (const parent of parentDirs) {
+      try {
+        const potentialRepos = await fs.readdir(parent);
+        for (const repo of potentialRepos) {
+          const siblingPath = path.join(parent, repo);
+          const packagePath = path.join(siblingPath, "packages", unscoped);
+          if (await fileExists(path.join(packagePath, "package.json"))) {
+            console.log(`[package-finder] Dev Intercept: Serving ${packageName} from local source: ${packagePath}`);
+            return { path: packagePath, type: 'swiss-lib' };
+          }
+        }
+      } catch { /* Continue */ }
+    }
+  }
+
+  // 5. Fallback search in internal workspace packages (lib/, packages/, modules/)
   if (workspaceRoot) {
     const packageDirs = ["lib", "packages", "modules", "libraries", "apps"];
     for (const dir of packageDirs) {
       const searchDir = path.join(workspaceRoot, dir);
       if (!(await fileExists(searchDir))) continue;
       
-      // Try scoped package name
-      if (packageName.startsWith("@")) {
-        const unscoped = packageName.split("/")[1];
-        const packagePath = path.join(searchDir, unscoped);
-        if (await fileExists(path.join(packagePath, "package.json"))) {
-          return { path: packagePath, type: 'workspace' };
-        }
-      }
-      
-      // Try full package name
-      const packagePath = path.join(searchDir, packageName);
+      const parts = packageName.split("/");
+      const unscoped = parts.length > 1 ? parts[1] : parts[0];
+      const packagePath = path.join(searchDir, unscoped);
+
       if (await fileExists(path.join(packagePath, "package.json"))) {
         return { path: packagePath, type: 'workspace' };
       }

package/src/resolution/bare-import-resolver.ts

@@ -47,7 +47,7 @@ export async function resolveBareImport(
       nodeModulesLocations.push(path.join(workspaceRoot, "node_modules"));
     }
 
-    // Add swiss-lib monorepo node_modules
+    // Add monorepo node_modules if present
     const swissLib = await findSwissLibMonorepo(context.root);
     if (swissLib) {
       const swissNodeModules = path.join(swissLib, "node_modules");
@@ -209,9 +209,19 @@ export async function resolveBareImport(
 
     const fullPath = path.join(pkgDir, entryPoint);
 
-    // Try the exact path first
-    if (await context.fileExists(fullPath)) {
-      return await toUrl(fullPath, context);
+    // Try a few Swiss-specific variations of the entry point before CDN fallback
+    const swissVariations = [
+      fullPath,
+      fullPath.replace(/\.(js|mjs|ts)$/, '.ui'),
+      fullPath.replace(/\.(js|mjs|ts)$/, '.uix'),
+      path.join(pkgDir, 'src/index.ui'),
+      path.join(pkgDir, 'src/index.uix'),
+    ];
+
+    for (const v of swissVariations) {
+      if (await context.fileExists(v)) {
+        return await toUrl(v, context);
+      }
     }
 
     // Try with extensions

package/src/resolution/path/file-path-resolver.ts

@@ -7,11 +7,12 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { findWorkspaceRoot } from "../../kernel/workspace.js";
-import { findSwissLibMonorepo } from "../../kernel/package-finder.js";
+import { findSwissLibMonorepo, findPackage } from "../../kernel/package-finder.js";
 
 export interface PathResolverContext {
   root: string;
   workspaceRoot: string | null;
+  userConfig?: any; // SwiteUserConfig
 }
 
 /**
@@ -21,15 +22,52 @@ export async function resolveFilePath(
   url: string,
   root: string,
   workspaceRoot: string | null = null,
+  userConfig?: any
 ): Promise<string> {
+  // Consolidate workspace root discovery for consistency across resolution blocks
+  const wsRoot = workspaceRoot || (await findWorkspaceRoot(root));
+
   // /node_modules/ URLs: walk up from app root until we find the package.
   // pnpm may place deps at the app root, one level up (workspace pkg), or at
   // the monorepo root depending on hoisting config and pnpm version.
   if (url.startsWith("/node_modules/")) {
     const urlPath = url.startsWith("/") ? url.slice(1) : url;
+    const parts = urlPath.split("/");
+    // Handle @scoped/package or standard-package
+    const packageName = parts[1].startsWith("@") ? `${parts[1]}/${parts[2]}` : parts[1];
+      // NEW: PNPM-aware Interceptor. Check if this request is for an "internal" scope package.
+      // In development, we always prioritize local siblings if they exist.
+      const internalScopes = userConfig?.internalScopes || [];
+      const match = internalScopes.length > 0 
+        ? url.match(new RegExp(`(${internalScopes.join("|")})\/([^/]+)`))
+        : null;
+
+      if (process.env.NODE_ENV !== 'production' && match) {
+        const packageName = match[0];
+        const remainingPath = url.split(match[0])[1];
+
+        const localLoc = await findPackage(packageName, root, wsRoot);
+        if (localLoc && localLoc.type !== 'node_modules') {
+          // Found local source! Redirect the base path
+          const fullPath = path.join(localLoc.path, remainingPath);
+          
+          // Re-use workspace fallback logic for dist -> src transition
+          if (fullPath.includes("/dist/")) {
+            const srcPath = fullPath.replace("/dist/", "/src/").replace(/\.[mc]?js$/, ".ts");
+            try {
+              await fs.access(srcPath);
+              console.log(`[file-path-resolver] Intercept: ${packageName} redirecting to local src: ${srcPath}`);
+              return srcPath;
+            } catch { /* Fallback to dist if src not found */ }
+          }
+          
+          console.log(`[file-path-resolver] Intercept: ${packageName} redirecting to local source: ${fullPath}`);
+          return fullPath;
+        }
+      }
 
-    // Walk up the directory tree from root, trying node_modules at each level
-    let current = path.resolve(root);
+      // Walk up the directory tree from root, trying node_modules at each level
+      let current = path.resolve(root);
     const visited = new Set<string>();
     for (let i = 0; i < 8; i++) {
       const candidate = path.join(current, urlPath);
@@ -49,7 +87,6 @@ export async function resolveFilePath(
     }
 
     // Explicit workspace root (covers hoisted-to-root installs)
-    const wsRoot = workspaceRoot || (await findWorkspaceRoot(root));
     if (wsRoot) {
       const wsPath = path.join(wsRoot, urlPath);
       if (!visited.has(wsPath)) {
@@ -92,14 +129,12 @@ export async function resolveFilePath(
     url.startsWith("/packages/") ||
     url.startsWith("/modules/")
   ) {
-    let wsRoot = workspaceRoot;
-    if (!wsRoot) {
-      wsRoot = await findWorkspaceRoot(root);
-      console.log(`[file-path-resolver] Detected workspace root: ${wsRoot} (from app root: ${root})`);
-    }
+    // Already detected wsRoot at function start
     
     // Normalize URL: path.join with leading slash is wrong on Windows (treats as drive root)
     const urlPath = url.startsWith("/") ? url.slice(1) : url;
+    
+    // ...
 
     // CRITICAL: For /lib/ paths, we MUST find the SWS root (which has lib/ directory)
     // Start from app root and walk up until we find a directory with both pnpm-workspace.yaml AND lib/
@@ -156,7 +191,6 @@ export async function resolveFilePath(
   }
 
   // For app files, check if URL already includes the app path
-  const wsRoot = workspaceRoot || (await findWorkspaceRoot(root));
   if (wsRoot) {
     const appRelativeToWorkspace = path
       .relative(wsRoot, root)