@swissjs/swite 0.3.0 → 0.3.2

package/dist/kernel/package-finder.js

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import path from "node:path";
+/**
+ * Find any sibling monorepo by searching for its package.json
+ */
+export async function findSiblingRepository(startPath, repoName) {
+    let current = startPath;
+    for (let i = 0; i < 20; i++) {
+        const siblingPath = path.join(current, repoName);
+        const pkgJson = path.join(siblingPath, "package.json");
+        if (await fileExists(pkgJson)) {
+            return siblingPath;
+        }
+        try {
+            const entries = await fs.readdir(current, { withFileTypes: true });
+            for (const entry of entries) {
+                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 { /* Continue */ }
+        current = path.dirname(current);
+        if (current === path.dirname(current))
+            break;
+    }
+    return null;
+}
+/**
+ * Backward compatibility wrapper for finding swiss-lib
+ */
+export async function findSwissLibMonorepo(startPath) {
+    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, startPath, workspaceRoot) {
+    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' };
+    }
+    // 2. Check workspace root node_modules
+    if (workspaceRoot) {
+        const workspaceNodeModules = path.join(workspaceRoot, "node_modules", packageName);
+        if (await fileExists(path.join(workspaceNodeModules, "package.json"))) {
+            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);
+        if (monorepo) {
+            const shortName = packageName.split("/")[1];
+            const monorepoPackage = path.join(monorepo, "packages", shortName);
+            if (await fileExists(path.join(monorepoPackage, "package.json"))) {
+                return { path: monorepoPackage, type: 'swiss-lib' };
+            }
+        }
+    }
+    // 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;
+            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' };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Find all possible workspace roots by searching up the tree
+ */
+export async function findWorkspaceRoots(startPath) {
+    const roots = [];
+    let current = startPath;
+    for (let i = 0; i < 20; i++) {
+        const workspaceFile = path.join(current, "pnpm-workspace.yaml");
+        const packageJson = path.join(current, "package.json");
+        try {
+            if (await fileExists(workspaceFile)) {
+                roots.push(current);
+            }
+            else if (await fileExists(packageJson)) {
+                const pkg = JSON.parse(await fs.readFile(packageJson, "utf-8"));
+                if (pkg?.workspaces) {
+                    roots.push(current);
+                }
+            }
+        }
+        catch {
+            // Continue
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return roots;
+}
+/**
+ * Check if a file exists
+ */
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/kernel/package-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-registry.d.ts","sourceRoot":"","sources":["../../src/kernel/package-registry.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,GAAG,CAAC;CAClB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAgB;IAEjC;;OAEG;IACG,aAAa,CACjB,aAAa,EAAE,MAAM,EACrB,eAAe,GAAE,MAAM,EAAO,GAC7B,OAAO,CAAC,IAAI,CAAC;IAwChB;;OAEG;YACW,aAAa;IAmF3B;;OAEG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAIpD;;OAEG;IACH,cAAc,IAAI,WAAW,EAAE;IAI/B;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAW7B;;OAEG;IACH,eAAe,IAAI,MAAM;CAG1B;AAKD,wBAAgB,kBAAkB,IAAI,eAAe,CAKpD"}

package/dist/kernel/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/kernel/workspace.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAgD5E"}

package/dist/{resolver → resolution}/bare-import-resolver.d.ts

@@ -3,7 +3,7 @@ export interface BareImportResolverContext extends UrlResolverContext {
     resolveWorkspacePackage: (pkgName: string) => Promise<string | null>;
 }
 /**
- * Resolve bare import specifier (e.g., @kibologic/core, react, etc.)
+ * Resolve bare import specifier (e.g., @swissjs/core, react, etc.)
  */
 export declare function resolveBareImport(specifier: string, context: BareImportResolverContext): Promise<string>;
 //# sourceMappingURL=bare-import-resolver.d.ts.map

package/dist/resolution/bare-import-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bare-import-resolver.d.ts","sourceRoot":"","sources":["../../src/resolution/bare-import-resolver.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,kBAAkB,EAAmC,MAAM,mBAAmB,CAAC;AAI7F,MAAM,WAAW,yBAA0B,SAAQ,kBAAkB;IACnE,uBAAuB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CACtE;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,MAAM,CAAC,CA4NjB"}

package/dist/{resolver → resolution}/bare-import-resolver.js

@@ -1,19 +1,18 @@
 /*
- * Bare Import Resolver - Resolves bare module specifiers (@kibologic/core, etc.)
+ * Bare Import Resolver - Resolves bare module specifiers (@swissjs/core, etc.)
  * Extracted from resolver.ts for modularity
  */
 import path from "node:path";
 import { promises as fs } from "node:fs";
 import chalk from "chalk";
-import { findSwissLibMonorepo } from "../utils/package-finder.js";
-import { shouldUseCdnFallback } from "../utils/cdn-fallback.js";
+import { findSwissLibMonorepo } from "../kernel/package-finder.js";
+import { shouldUseCdnFallback } from "./cdn/cdn-fallback.js";
 import { resolveWorkspacePackage } from "./workspace-package-resolver.js";
 import { toUrl } from "./url-resolver.js";
 /**
- * Resolve bare import specifier (e.g., @kibologic/core, react, etc.)
+ * Resolve bare import specifier (e.g., @swissjs/core, react, etc.)
  */
 export async function resolveBareImport(specifier, context) {
-    console.log(`[SWITE] resolveBareImport CALLED: ${specifier}`);
     // Extract package name outside the try/catch so fallback logic can reference it.
     // This must stay project-agnostic: works for both scoped and unscoped packages.
     const parts = specifier.split("/");
@@ -21,7 +20,6 @@ export async function resolveBareImport(specifier, context) {
     const pkgName = isScoped ? `${parts[0]}/${parts[1]}` : parts[0];
     const subPath = isScoped ? parts.slice(2).join("/") : parts.slice(1).join("/");
     try {
-        console.log(`[SWITE] resolveBareImport: ${specifier} -> pkgName: ${pkgName}, subPath: ${subPath}`);
         // Find package.json - check multiple node_modules locations
         let pkgDir = null;
         let pkgJsonPath = null;
@@ -34,13 +32,12 @@ export async function resolveBareImport(specifier, context) {
         if (workspaceRoot) {
             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");
             if (await context.fileExists(swissNodeModules)) {
                 nodeModulesLocations.push(swissNodeModules);
-                console.log(`[SWITE] Added swiss-lib monorepo node_modules for ${pkgName}`);
             }
         }
         // Try each location
@@ -50,48 +47,20 @@ export async function resolveBareImport(specifier, context) {
             if (await context.fileExists(testPkgJsonPath)) {
                 pkgDir = testPkgDir;
                 pkgJsonPath = testPkgJsonPath;
-                console.log(`[SWITE] Found ${pkgName} in ${nodeModulesPath}`);
                 break;
             }
         }
         if (!pkgJsonPath || !pkgDir) {
-            console.log(`[SWITE] Package ${pkgName} not in node_modules, checking workspace...`);
-            // EMERGENCY FIX: For @kibologic/* packages, try direct path first
-            if (pkgName.startsWith('@kibologic/')) {
-                const pkgShortName = pkgName.replace('@kibologic/', '');
-                // Try relative path from SWS to swiss-lib
-                const potentialPaths = [
-                    path.join(context.root, '../swiss-lib/packages', pkgShortName),
-                    path.join(context.root, '../../swiss-lib/packages', pkgShortName),
-                    path.join(context.root, '../../../swiss-lib/packages', pkgShortName),
-                ];
-                for (const candidatePath of potentialPaths) {
-                    const candidatePkgJson = path.join(candidatePath, 'package.json');
-                    if (await context.fileExists(candidatePkgJson)) {
-                        console.log(`[SWITE] Emergency: Found ${pkgName} at ${candidatePath}`);
-                        pkgDir = candidatePath;
-                        pkgJsonPath = candidatePkgJson;
-                        break;
-                    }
-                }
+            const workspacePkg = await context.resolveWorkspacePackage(pkgName);
+            if (workspacePkg) {
+                return await resolveWorkspacePackageEntry(workspacePkg, pkgName, subPath, specifier, context);
             }
-            // If still not found, try workspace resolver
-            if (!pkgJsonPath || !pkgDir) {
-                const workspacePkg = await context.resolveWorkspacePackage(pkgName);
-                if (workspacePkg) {
-                    return await resolveWorkspacePackageEntry(workspacePkg, pkgName, subPath, specifier, context);
-                }
-                // Last resort: CDN fallback
-                if (!shouldUseCdnFallback(pkgName)) {
-                    // Scoped packages may be private and are not necessarily available on public npm CDNs.
-                    console.warn(`[SWITE] Package ${pkgName} not found anywhere. Scoped package detected; CDN fallback is disabled by default.`);
-                    // Return a same-origin node_modules URL to make failures explicit and allow the
-                    // node-module handler to try serving it.
-                    return `/node_modules/${specifier}`;
-                }
-                console.warn(`[SWITE] Package ${pkgName} not found anywhere, using CDN fallback`);
-                return `https://cdn.jsdelivr.net/npm/${specifier}/+esm`;
+            if (!shouldUseCdnFallback(pkgName)) {
+                console.warn(`[SWITE] Package ${pkgName} not found anywhere. Scoped package detected; CDN fallback is disabled by default.`);
+                return `/node_modules/${specifier}`;
             }
+            console.warn(`[SWITE] Package ${pkgName} not found anywhere, using CDN fallback`);
+            return `https://cdn.jsdelivr.net/npm/${specifier}/+esm`;
         }
         // Continue with normal resolution if we found it
         if (pkgJsonPath && pkgDir) {
@@ -106,7 +75,6 @@ export async function resolveBareImport(specifier, context) {
             realPkgDir = pkgDir;
         }
         const workspacePkg = await context.resolveWorkspacePackage(pkgName);
-        console.log(`[SWITE] resolveBareImport (node_modules): workspacePkg=${workspacePkg}, realPkgDir=${realPkgDir}, pkgName=${pkgName}`);
         if (workspacePkg) {
             const normalizedWorkspacePkg = path
                 .resolve(workspacePkg)
@@ -119,7 +87,6 @@ export async function resolveBareImport(specifier, context) {
             // If the real path is the workspace package, use workspace resolution
             if (normalizedRealPkgDir === normalizedWorkspacePkg ||
                 normalizedRealPkgDir.includes(normalizedWorkspacePkg)) {
-                console.log(`[SWITE] resolveBareImport (node_modules): Using workspace resolution for ${pkgName}`);
                 return await resolveWorkspacePackageEntry(workspacePkg, pkgName, subPath, specifier, context);
             }
         }
@@ -151,7 +118,6 @@ export async function resolveBareImport(specifier, context) {
                         .replace("/dist/", "/src/")
                         .replace(/\.js$/, ".ts");
                     if (await context.fileExists(srcFullPath)) {
-                        console.log(`[SWITE] resolveBareImport: Using source file instead of dist: ${srcFullPath}`);
                         return await toUrl(srcFullPath, context);
                     }
                 }
@@ -193,9 +159,18 @@ export async function resolveBareImport(specifier, context) {
             entryPoint = pkgJson.module || pkgJson.main || "index.js";
         }
         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
         for (const ext of [".js", ".mjs", ".ts", ".ui", ".uix"]) {
@@ -227,7 +202,6 @@ async function resolveWorkspacePackageEntry(workspacePkg, pkgName, subPath, spec
             ? subPath.replace(/\.(js|ts|ui|uix)$/, "")
             : "";
         let exportKey = subPathWithoutExt ? `./${subPathWithoutExt}` : ".";
-        console.log(`[SWITE] resolveBareImport (workspace): pkgName=${pkgName}, subPath=${subPath}, subPathWithoutExt=${subPathWithoutExt}, exportKey=${exportKey}`);
         // Try to find matching export
         if (subPath && !workspacePkgJson.exports[exportKey]) {
             if (subPathWithoutExt) {
@@ -285,7 +259,6 @@ async function resolveWorkspacePackageEntry(workspacePkg, pkgName, subPath, spec
             if (normalizedFull.includes("/dist/")) {
                 const srcPath = fullPath.replace(/[/\\]dist[/\\]/, path.sep + "src" + path.sep).replace(/\.js$/i, ".ts");
                 if (await context.fileExists(srcPath)) {
-                    console.log(`[SWITE] resolveBareImport (workspace): preferring src over dist: ${srcPath}`);
                     return await toUrl(srcPath, context);
                 }
             }
@@ -316,7 +289,6 @@ async function resolveWorkspacePackageEntry(workspacePkg, pkgName, subPath, spec
     if (normalizedFull.includes("/dist/")) {
         const srcPath = fullPath.replace(/[/\\]dist[/\\]/, path.sep + "src" + path.sep).replace(/\.js$/i, ".ts");
         if (await context.fileExists(srcPath)) {
-            console.log(`[SWITE] resolveBareImport (fallback): preferring src over dist: ${srcPath}`);
             return await toUrl(srcPath, context);
         }
     }

package/dist/resolution/cdn/cdn-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdn-fallback.d.ts","sourceRoot":"","sources":["../../../src/resolution/cdn/cdn-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAmBH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAKpE"}

package/dist/{utils → resolution/path}/file-path-resolver.d.ts

@@ -1,9 +1,10 @@
 export interface PathResolverContext {
     root: string;
     workspaceRoot: string | null;
+    userConfig?: any;
 }
 /**
  * Resolve file path from URL, handling SWISS packages, workspace packages, and app files
  */
-export declare function resolveFilePath(url: string, root: string, workspaceRoot?: string | null): Promise<string>;
+export declare function resolveFilePath(url: string, root: string, workspaceRoot?: string | null, userConfig?: any): Promise<string>;
 //# sourceMappingURL=file-path-resolver.d.ts.map

package/dist/resolution/path/file-path-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-path-resolver.d.ts","sourceRoot":"","sources":["../../../src/resolution/path/file-path-resolver.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,UAAU,CAAC,EAAE,GAAG,CAAC;CAClB;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,aAAa,GAAE,MAAM,GAAG,IAAW,EACnC,UAAU,CAAC,EAAE,GAAG,GACf,OAAO,CAAC,MAAM,CAAC,CAsMjB"}

package/dist/{utils → resolution/path}/file-path-resolver.js

@@ -5,17 +5,49 @@
  */
 import { promises as fs } from "node:fs";
 import path from "node:path";
-import { findWorkspaceRoot } from "./workspace.js";
-import { findSwissLibMonorepo } from "./package-finder.js";
+import { findWorkspaceRoot } from "../../kernel/workspace.js";
+import { findSwissLibMonorepo, findPackage } from "../../kernel/package-finder.js";
 /**
  * Resolve file path from URL, handling SWISS packages, workspace packages, and app files
  */
-export async function resolveFilePath(url, root, workspaceRoot = null) {
+export async function resolveFilePath(url, root, workspaceRoot = null, userConfig) {
+    // 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);
         const visited = new Set();
@@ -38,7 +70,6 @@ export async function resolveFilePath(url, root, workspaceRoot = null) {
             current = parent;
         }
         // 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)) {
@@ -54,32 +85,23 @@ export async function resolveFilePath(url, root, workspaceRoot = null) {
         }
         return path.join(path.resolve(root), urlPath); // fallback; handler will 404
     }
-    // Check if this is a swiss-lib package file
+    // /swiss-packages/ URLs point to files in the co-located framework monorepo's packages/ dir
     if (url.startsWith("/swiss-packages/")) {
-        // Dynamically find swiss-lib monorepo instead of hardcoded paths
-        const swissLib = await findSwissLibMonorepo(root);
-        if (swissLib) {
-            // Remove /swiss-packages prefix and use the rest as relative path
-            const relativePath = url.replace(/^\/swiss-packages\//, "");
-            const swissPackagesPath = path.join(swissLib, "packages");
-            const fullPath = path.join(swissPackagesPath, relativePath);
+        const relativePath = url.replace(/^\/swiss-packages\//, "");
+        const monorepo = await findSwissLibMonorepo(root);
+        if (monorepo) {
+            const fullPath = path.join(monorepo, "packages", relativePath);
             try {
                 await fs.access(fullPath);
-                console.log(`[file-path-resolver] Found swiss-lib package at: ${fullPath}`);
                 return fullPath;
             }
             catch {
-                console.warn(`[file-path-resolver] swiss-lib package file not found: ${fullPath}`);
-                return fullPath; // Return path anyway, will error later if needed
+                return fullPath; // Return anyway; handler will 404 if missing
             }
         }
-        else {
-            // Fallback: construct path from root (may not work, but better than nothing)
-            const relativePath = url.replace(/^\/swiss-packages\//, "");
-            const fallbackPath = path.join(root, "..", "..", "..", "swiss-lib", "packages", relativePath);
-            console.warn(`[file-path-resolver] swiss-lib not found, using fallback: ${fallbackPath}`);
-            return fallbackPath;
-        }
+        // No co-located monorepo found — return a path that will 404 cleanly
+        console.warn(`[file-path-resolver] No framework monorepo found for /swiss-packages/${relativePath}`);
+        return path.join(root, "node_modules", relativePath);
     }
     // Workspace-level directories: always resolve from workspace root
     // Updated: lib/ now contains all packages (moved from packages/)
@@ -87,13 +109,10 @@ export async function resolveFilePath(url, root, workspaceRoot = null) {
         url.startsWith("/libraries/") ||
         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/
         if (url.startsWith("/lib/")) {
@@ -150,7 +169,6 @@ export async function resolveFilePath(url, root, workspaceRoot = null) {
         }
     }
     // 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)

package/dist/resolution/path/path-fixup.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Centralised /swiss-lib/ → /swiss-packages/ path fixup.
+ *
+ * Root cause: the UiCompiler emits absolute `/swiss-lib/` paths in some code
+ * paths (compiler was written against an older directory structure). Until the
+ * compiler is fixed at source this single function is the authoritative fixup.
+ * Apply it once per compilation, before passing code to the import rewriter.
+ *
+ * All seven previous fixup locations across ui-handler, uix-handler, and
+ * import-rewriter have been removed in favour of this call.
+ */
+export declare function fixSwissLibPaths(code: string): string;
+//# sourceMappingURL=path-fixup.d.ts.map

package/dist/resolution/path/path-fixup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-fixup.d.ts","sourceRoot":"","sources":["../../../src/resolution/path/path-fixup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOrD"}

package/dist/resolution/path/path-fixup.js

@@ -0,0 +1,20 @@
+/**
+ * Centralised /swiss-lib/ → /swiss-packages/ path fixup.
+ *
+ * Root cause: the UiCompiler emits absolute `/swiss-lib/` paths in some code
+ * paths (compiler was written against an older directory structure). Until the
+ * compiler is fixed at source this single function is the authoritative fixup.
+ * Apply it once per compilation, before passing code to the import rewriter.
+ *
+ * All seven previous fixup locations across ui-handler, uix-handler, and
+ * import-rewriter have been removed in favour of this call.
+ */
+export function fixSwissLibPaths(code) {
+    if (!code.includes('/swiss-lib/'))
+        return code;
+    // More-specific pattern first so `/swiss-lib/packages/` doesn't leave a
+    // dangling `/swiss-packages/packages/` if the replacement ran twice.
+    return code
+        .replace(/\/swiss-lib\/packages\//g, '/swiss-packages/')
+        .replace(/\/swiss-lib\//g, '/swiss-packages/');
+}

package/dist/{resolver.d.ts → resolution/resolver.d.ts}

@@ -1,4 +1,4 @@
-import type { ImportMap } from "./utils/generate-import-map.js";
+import type { ImportMap } from "../internal/generate-import-map.js";
 export declare class ModuleResolver {
     private root;
     private workspaceRoot;

package/dist/resolution/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../src/resolution/resolver.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAMpE,qBAAa,cAAc;IAIb,OAAO,CAAC,IAAI;IAHxB,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,SAAS,CAA0B;gBAEvB,IAAI,EAAE,MAAM;IAEhC;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI;YAWjC,gBAAgB;IAMxB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;YA8HrD,UAAU;YASV,uBAAuB;YAavB,KAAK;CAUpB"}

package/dist/{resolver.js → resolution/resolver.js}

@@ -4,10 +4,10 @@
 import path from "node:path";
 import { promises as fs } from "node:fs";
 import chalk from "chalk";
-import { findSwissLibMonorepo } from "./utils/package-finder.js";
-import { toUrl } from "./resolver/url-resolver.js";
-import { resolveWorkspacePackage } from "./resolver/workspace-package-resolver.js";
-import { resolveBareImport } from "./resolver/bare-import-resolver.js";
+import { findWorkspaceRoot } from "../kernel/workspace.js";
+import { toUrl } from "./url-resolver.js";
+import { resolveWorkspacePackage } from "./workspace-package-resolver.js";
+import { resolveBareImport } from "./bare-import-resolver.js";
 export class ModuleResolver {
     constructor(root) {
         this.root = root;
@@ -26,28 +26,10 @@ export class ModuleResolver {
     async getWorkspaceRoot() {
         if (this.workspaceRoot)
             return this.workspaceRoot;
-        const findWorkspaceRoot = async (startDir) => {
-            let current = startDir;
-            for (let i = 0; i < 5; i++) {
-                const workspaceFile = path.join(current, "pnpm-workspace.yaml");
-                const packageJson = path.join(current, "package.json");
-                if ((await this.fileExists(workspaceFile)) ||
-                    ((await this.fileExists(packageJson)) &&
-                        JSON.parse(await fs.readFile(packageJson, "utf-8")).workspaces)) {
-                    return current;
-                }
-                const parent = path.dirname(current);
-                if (parent === current)
-                    break;
-                current = parent;
-            }
-            return null;
-        };
         this.workspaceRoot = await findWorkspaceRoot(this.root);
         return this.workspaceRoot;
     }
     async resolve(specifier, importer) {
-        console.log(`[SWITE] resolve CALLED: specifier: ${specifier}, importer: ${importer}`);
         // Check import map first (fast path)
         if (this.importMap && !specifier.startsWith(".") && !specifier.startsWith("/")) {
             const mapped = this.importMap.imports[specifier];
@@ -81,9 +63,7 @@ export class ModuleResolver {
                 fileExists: (p) => this.fileExists(p),
                 resolveWorkspacePackage: (pkgName) => this.resolveWorkspacePackage(pkgName),
             };
-            const result = await resolveBareImport(specifier, context);
-            console.log(`[SWITE] resolve RESULT: ${specifier} -> ${result}`);
-            return result;
+            return await resolveBareImport(specifier, context);
         }
         // Handle absolute paths (already URLs)
         if (specifier.startsWith("/")) {
@@ -126,30 +106,21 @@ export class ModuleResolver {
         // This preserves .ui/.uix extensions for SWISS files
         const hasExtension = /\.(ui|uix|ts|tsx|js|jsx|mjs)$/.test(specifier);
         if (hasExtension) {
-            // Specifier has extension, resolve it directly
             const resolved = path.resolve(importerDir, specifier);
-            console.log(`[SWITE] resolve relative (hasExt): ${specifier}, importerDir: ${importerDir}, resolved: ${resolved}, exists: ${await this.fileExists(resolved)}`);
             if (await this.fileExists(resolved)) {
-                const url = await this.toUrl(resolved);
-                console.log(`[SWITE] resolve relative: ${specifier} -> ${resolved} -> ${url}`);
-                return url;
+                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);
-        console.log(`[SWITE] resolve relative (trying extensions): specifierWithoutExt: ${specifierWithoutExt}, resolved: ${resolved}`);
         // 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;
-            const exists = await this.fileExists(withExt);
-            console.log(`[SWITE] trying extension ${ext}: ${withExt}, exists: ${exists}`);
-            if (exists) {
-                const url = await this.toUrl(withExt);
-                console.log(`[SWITE] found with ${ext}: ${url}`);
-                return url;
+            if (await this.fileExists(withExt)) {
+                return await this.toUrl(withExt);
             }
         }
         // Try index files

package/dist/{import-rewriter.d.ts → resolution/rewriting/import-rewriter.d.ts}

@@ -1,3 +1,3 @@
-import { ModuleResolver } from "./resolver.js";
+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/resolution/rewriting/import-rewriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-rewriter.d.ts","sourceRoot":"","sources":["../../../src/resolution/rewriting/import-rewriter.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAYhD,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,CAqHjB"}