@swissjs/swite 0.3.0 → 0.3.1

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"}

package/dist/resolution/rewriting/import-rewriter.js

@@ -0,0 +1,199 @@
+/*
+ * 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";
+export async function rewriteImports(code, importer, resolver) {
+    await init;
+    try {
+        const [imports] = parse(code);
+        if (imports.length === 0)
+            return code;
+        const replacements = [];
+        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;
+            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;
+            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, rawSpecifier, rawStart, rawEnd) {
+    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, importer) {
+    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/dist/{resolver → resolution}/symlink-registry.d.ts

@@ -7,7 +7,7 @@ export declare function buildSymlinkRegistry(nodeModulesDirs: string[]): Promise
  *
  * Example:
  *   /mnt/c/.../swiss-lib/packages/core/src/index.ts
- *   → /node_modules/@kibologic/core/src/index.ts
+ *   → /node_modules/@swissjs/core/src/index.ts
  */
 export declare function lookupInSymlinkRegistry(absolutePath: string): string | null;
 //# sourceMappingURL=symlink-registry.d.ts.map

package/dist/resolution/symlink-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symlink-registry.d.ts","sourceRoot":"","sources":["../../src/resolution/symlink-registry.ts"],"names":[],"mappings":"AAoBA,wBAAsB,oBAAoB,CACxC,eAAe,EAAE,MAAM,EAAE,GACxB,OAAO,CAAC,IAAI,CAAC,CAQf;AA8DD;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAW3E"}

package/dist/{resolver → resolution}/symlink-registry.js

@@ -82,7 +82,7 @@ async function registerSymlink(symlinkPath, pkgName) {
  *
  * Example:
  *   /mnt/c/.../swiss-lib/packages/core/src/index.ts
- *   → /node_modules/@kibologic/core/src/index.ts
+ *   → /node_modules/@swissjs/core/src/index.ts
  */
 export function lookupInSymlinkRegistry(absolutePath) {
     const normalized = absolutePath.replace(/\\/g, "/");

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

@@ -0,0 +1 @@
+{"version":3,"file":"url-resolver.d.ts","sourceRoot":"","sources":["../../src/resolution/url-resolver.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC/C,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACpD;AAED,MAAM,MAAM,+BAA+B,GAAG,kBAAkB,CAAC;AAMjE;;GAEG;AACH,wBAAsB,KAAK,CACzB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,MAAM,CAAC,CA0MjB"}

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

@@ -4,24 +4,10 @@
  */
 import path from "node:path";
 import { promises as fs } from "node:fs";
-import { findSwissLibMonorepo } from "../utils/package-finder.js";
+import { findSwissLibMonorepo } from "../kernel/package-finder.js";
 import { lookupInSymlinkRegistry } from "./symlink-registry.js";
-/**
- * Normalize result to ensure no /swiss-lib/ paths leak to browser
- */
 function normalizeResult(result) {
-    const original = result;
-    if (result.includes('/swiss-lib/')) {
-        console.log(`[SWITE] normalizeResult: Found /swiss-lib/ in "${result}", fixing...`);
-        result = result.replace(/\/swiss-lib\/packages\//g, '/swiss-packages/');
-        result = result.replace(/\/swiss-lib\//g, '/swiss-packages/');
-        console.log(`[SWITE] normalizeResult: Fixed to "${result}"`);
-    }
-    result = result.replace(/\\/g, '/');
-    if (original !== result && original.includes('swiss-lib')) {
-        console.log(`[SWITE] normalizeResult: Final result "${result}" (was "${original}")`);
-    }
-    return result;
+    return result.replace(/\\/g, '/');
 }
 /**
  * Convert file path to URL for browser
@@ -85,103 +71,72 @@ export async function toUrl(filePath, context) {
             return normalizeResult(url);
         }
     }
-    // If path is already a URL (starts with / or http), check for source file first
+    // If path is already a URL (starts with / or http), prefer src over dist for workspace packages
     if (normalized.startsWith("/") || normalized.startsWith("http")) {
-        let workingPath = normalized;
-        if (normalized.includes("/swiss-lib/packages/")) {
-            workingPath = normalized.replace(/\/swiss-lib\/packages\//g, "/swiss-packages/");
-            console.log(`[SWITE] toUrl: Converting /swiss-lib/ to /swiss-packages/: ${normalized} -> ${workingPath}`);
-            if (workingPath.includes("/dist/") && !workingPath.includes("/src/")) {
-                const srcPath = workingPath.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
-                console.log(`[SWITE] toUrl: Checking for source file: ${srcPath}`);
-                const { resolveFilePath } = await import("../utils/file-path-resolver.js");
-                const workspaceRoot = await context.getWorkspaceRoot();
-                const srcFilePath = await resolveFilePath(srcPath, context.root, workspaceRoot);
-                console.log(`[SWITE] toUrl: Resolved source file path: ${srcFilePath}, exists: ${await context.fileExists(srcFilePath)}`);
-                if (await context.fileExists(srcFilePath)) {
-                    console.log(`[SWITE] toUrl: Preferring source over dist: ${srcPath}`);
-                    return normalizeResult(srcPath);
-                }
-            }
-            return normalizeResult(workingPath);
-        }
-        // Only prefer src over dist for workspace/swiss packages — never for node_modules
-        // (published packages only ship dist; the swiss-lib monorepo finder can
-        // accidentally resolve src/index.ts from a sibling repo for npm packages)
-        if (workingPath.includes("/dist/") && !workingPath.includes("/src/") && !workingPath.includes("/node_modules/")) {
-            const srcPath = workingPath.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
-            console.log(`[SWITE] toUrl: Checking for source file: ${srcPath}`);
-            const { resolveFilePath } = await import("../utils/file-path-resolver.js");
+        // Only prefer src over dist for workspace packages — never for node_modules
+        if (normalized.includes("/dist/") && !normalized.includes("/src/") && !normalized.includes("/node_modules/")) {
+            const srcPath = normalized.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
+            const { resolveFilePath } = await import("./path/file-path-resolver.js");
             const workspaceRoot = await context.getWorkspaceRoot();
             const srcFilePath = await resolveFilePath(srcPath, context.root, workspaceRoot);
-            console.log(`[SWITE] toUrl: Resolved source file path: ${srcFilePath}, exists: ${await context.fileExists(srcFilePath)}`);
             if (await context.fileExists(srcFilePath)) {
-                console.log(`[SWITE] toUrl: Preferring source over dist: ${srcPath}`);
                 return normalizeResult(srcPath);
             }
         }
-        return normalizeResult(workingPath);
+        return normalizeResult(normalized);
     }
-    // If path is absolute, try to make it relative to workspace root or server root
+    // If path is absolute, convert to a browser-relative URL
     if (path.isAbsolute(filePath)) {
         const workspaceRoot = await context.getWorkspaceRoot();
-        // Check if this is a swiss-lib monorepo package (@kibologic/*)
-        const swissLib = await findSwissLibMonorepo(context.root);
-        console.log(`[SWITE] toUrl: swiss-lib check - swissLib=${swissLib}, this.root=${context.root}, filePath=${filePath}`);
-        if (swissLib) {
-            const swissPackagesPath = path.join(swissLib, "packages");
-            let resolvedSwissPackages;
+        // Check if the file lives in a co-located framework monorepo's packages/ directory.
+        // Serve those files under /swiss-packages/ so the browser can request them distinctly
+        // from the app's own files. Works for any framework at any directory name.
+        const monorepo = await findSwissLibMonorepo(context.root);
+        if (monorepo) {
+            const packagesPath = path.join(monorepo, "packages");
+            let resolvedPackages;
             let resolvedFilePath;
             try {
-                resolvedSwissPackages = await fs.realpath(swissPackagesPath);
+                resolvedPackages = await fs.realpath(packagesPath);
                 resolvedFilePath = await fs.realpath(filePath);
             }
             catch {
-                resolvedSwissPackages = path.resolve(swissPackagesPath);
+                resolvedPackages = path.resolve(packagesPath);
                 resolvedFilePath = path.resolve(filePath);
             }
-            const normalizedSwissPackages = resolvedSwissPackages.replace(/\\/g, "/").toLowerCase();
-            const normalizedFilePath = resolvedFilePath.replace(/\\/g, "/").toLowerCase();
-            console.log(`[SWITE] toUrl: swiss-lib path comparison - normalizedSwissPackages="${normalizedSwissPackages}", normalizedFilePath="${normalizedFilePath}", startsWith=${normalizedFilePath.startsWith(normalizedSwissPackages)}`);
-            if (normalizedFilePath.startsWith(normalizedSwissPackages)) {
-                console.log(`[SWITE] toUrl: ✅ swiss-lib path MATCHED! Converting to /swiss-packages/`);
-                const origSwissPackages = resolvedSwissPackages.replace(/\\/g, "/");
-                const origFilePath = resolvedFilePath.replace(/\\/g, "/");
-                const relative = origFilePath.slice(origSwissPackages.length);
+            const normalizedPackages = resolvedPackages.replace(/\\/g, "/").toLowerCase();
+            const normalizedResolved = resolvedFilePath.replace(/\\/g, "/").toLowerCase();
+            if (normalizedResolved.startsWith(normalizedPackages)) {
+                const origPackages = resolvedPackages.replace(/\\/g, "/");
+                const origFile = resolvedFilePath.replace(/\\/g, "/");
+                const relative = origFile.slice(origPackages.length);
                 const url = "/swiss-packages" + (relative.startsWith("/") ? relative : "/" + relative);
                 if (url.includes("/dist/") && !url.includes("/src/")) {
                     const srcUrl = url.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
                     const srcRelative = srcUrl.replace("/swiss-packages/", "");
-                    const srcFilePath = path.join(swissPackagesPath, srcRelative);
-                    console.log(`[SWITE] toUrl: Checking source file: ${srcFilePath}, exists: ${await context.fileExists(srcFilePath)}`);
+                    const srcFilePath = path.join(packagesPath, srcRelative);
                     if (await context.fileExists(srcFilePath)) {
-                        console.log(`[SWITE] toUrl: Preferring source over dist: ${srcUrl}`);
                         return normalizeResult(srcUrl);
                     }
                 }
-                console.log(`[SWITE] toUrl: ${filePath} -> ${url} (swiss-lib package)`);
                 return normalizeResult(url);
             }
         }
-        // Check if this is a node_modules path
+        // node_modules absolute path → browser /node_modules/... URL
         const origFilePathNormalized = path.resolve(filePath).replace(/\\/g, "/");
         if (origFilePathNormalized.toLowerCase().includes("/node_modules/")) {
             const nodeModulesIndex = origFilePathNormalized.toLowerCase().indexOf("/node_modules/");
             const afterNodeModules = origFilePathNormalized.slice(nodeModulesIndex + "/node_modules/".length);
-            const url = "/node_modules/" + afterNodeModules;
-            console.log(`[SWITE] toUrl: ${filePath} -> ${url} (node_modules, preserving case)`);
-            return normalizeResult(url);
+            return normalizeResult("/node_modules/" + afterNodeModules);
         }
-        // Try relative to app root FIRST
-        const normalizedRoot = path.resolve(context.root).replace(/\\/g, "/").toLowerCase();
         const normalizedFilePath = path.resolve(filePath).replace(/\\/g, "/").toLowerCase();
+        // Try relative to app root first
+        const normalizedRoot = path.resolve(context.root).replace(/\\/g, "/").toLowerCase();
         if (normalizedFilePath.startsWith(normalizedRoot)) {
             const origRoot = path.resolve(context.root).replace(/\\/g, "/");
             const origFilePath = path.resolve(filePath).replace(/\\/g, "/");
             const relative = origFilePath.slice(origRoot.length);
-            const url = relative.startsWith("/") ? relative : "/" + relative;
-            console.log(`[SWITE] toUrl: ${filePath} -> ${url} (app root: ${context.root})`);
-            return normalizeResult(url);
+            return normalizeResult(relative.startsWith("/") ? relative : "/" + relative);
         }
         // Try workspace root
         if (workspaceRoot) {
@@ -189,51 +144,25 @@ export async function toUrl(filePath, context) {
             if (normalizedFilePath.startsWith(normalizedWorkspaceRoot)) {
                 const origWorkspaceRoot = path.resolve(workspaceRoot).replace(/\\/g, "/");
                 const origFilePath = path.resolve(filePath).replace(/\\/g, "/");
-                // CRITICAL: Check if this is a swiss-lib path BEFORE computing relative
-                const normalizedOrigFilePath = origFilePath.toLowerCase();
-                console.log(`[SWITE] toUrl DEBUG: origFilePath="${origFilePath}", normalized="${normalizedOrigFilePath}", checking for swiss-lib...`);
-                if (normalizedOrigFilePath.includes("/swiss-lib/packages/") || normalizedOrigFilePath.includes("\\swiss-lib\\packages\\")) {
-                    console.log(`[SWITE] toUrl DEBUG: ✅ Found swiss-lib in path!`);
-                    const swissLibIndex = normalizedOrigFilePath.indexOf("/swiss-lib/packages/");
-                    const swissLibIndexBackslash = normalizedOrigFilePath.indexOf("\\swiss-lib\\packages\\");
-                    const index = swissLibIndex >= 0 ? swissLibIndex : swissLibIndexBackslash;
-                    const separator = swissLibIndex >= 0 ? "/swiss-lib/packages/" : "\\swiss-lib\\packages\\";
-                    const afterSwissLib = origFilePath.slice(index + separator.length);
-                    const url = "/swiss-packages/" + afterSwissLib.replace(/\\/g, "/");
-                    console.log(`[SWITE] toUrl: ${filePath} -> ${url} (swiss-lib via workspace root - FIXED)`);
-                    return normalizeResult(url);
-                }
                 const relative = origFilePath.slice(origWorkspaceRoot.length);
                 let url = relative.startsWith("/") ? relative : "/" + relative;
-                // Prefer src over dist for workspace /packages/ in dev (unbuilt packages)
-                if (url.includes("/packages/") &&
-                    url.includes("/dist/") &&
-                    (await context.fileExists(filePath)) === false) {
-                    const srcPath = filePath.replace(/[/\\]dist[/\\]/, path.sep + "src" + path.sep).replace(/\.js$/i, ".ts");
+                // Prefer src over dist for workspace packages in dev
+                if (url.includes("/packages/") && url.includes("/dist/") && !(await context.fileExists(filePath))) {
+                    const srcPath = filePath
+                        .replace(/[/\\]dist[/\\]/, path.sep + "src" + path.sep)
+                        .replace(/\.js$/i, ".ts");
                     if (await context.fileExists(srcPath)) {
                         const srcRelative = path.relative(workspaceRoot, srcPath).replace(/\\/g, "/");
                         url = "/" + srcRelative;
-                        console.log(`[SWITE] toUrl: Preferring src over dist (packages): ${url}`);
                     }
                 }
-                console.log(`[SWITE] toUrl DOUBLE CHECK: url="${url}", lowercase="${url.toLowerCase()}", includes="/swiss-lib/"=${url.toLowerCase().includes("/swiss-lib/")}`);
-                // DOUBLE CHECK: If computed URL contains /swiss-lib/, fix it
-                if (url.toLowerCase().includes("/swiss-lib/")) {
-                    console.log(`[SWITE] toUrl DOUBLE CHECK: ✅ MATCHED! Fixing URL...`);
-                    const fixedUrl = url.replace(/\/swiss-lib\/packages\//gi, "/swiss-packages/").replace(/\/swiss-lib\//gi, "/swiss-packages/");
-                    console.log(`[SWITE] toUrl: ${filePath} -> ${fixedUrl} (workspace root - FIXED /swiss-lib/ in URL)`);
-                    return normalizeResult(fixedUrl);
-                }
-                console.log(`[SWITE] toUrl: ${filePath} -> ${url} (workspace: ${workspaceRoot})`);
                 return normalizeResult(url);
             }
         }
         // Fallback
-        const fallbackWorkspaceRoot = await context.getWorkspaceRoot();
-        const baseRoot = fallbackWorkspaceRoot || context.root;
+        const baseRoot = workspaceRoot || context.root;
         const rawRelative = path.relative(baseRoot, filePath);
-        // CG-03: path.relative() returns an absolute path when crossing drives or WSL mounts.
-        // Guard: if the result is absolute or escapes root with '..', strip prefix directly.
+        // CG-03: guard against absolute result from path.relative() on cross-drive/WSL paths
         let url;
         if (path.isAbsolute(rawRelative) || rawRelative.startsWith("..")) {
             const normalizedBase = path.resolve(baseRoot).replace(/\\/g, "/");
@@ -246,7 +175,7 @@ export async function toUrl(filePath, context) {
         else {
             url = "/" + rawRelative.replace(/\\/g, "/");
         }
-        console.warn(`[SWITE] toUrl fallback: ${filePath} -> ${url} (may not work if path goes outside root)`);
+        console.warn(`[SWITE] toUrl fallback: ${filePath} -> ${url}`);
         return normalizeResult(url);
     }
     // Default: make relative to root

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-package-resolver.d.ts","sourceRoot":"","sources":["../../src/resolution/workspace-package-resolver.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,+BAA+B;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC/C,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACpD;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAwExB"}

package/dist/resolution/workspace-package-resolver.js

@@ -0,0 +1,77 @@
+/*
+ * Workspace Package Resolver - Finds packages in workspace
+ * Uses dynamic package registry instead of hardcoded paths
+ */
+import path from "node:path";
+import { findSwissLibMonorepo } from "../kernel/package-finder.js";
+import { getPackageRegistry } from "../kernel/package-registry.js";
+/**
+ * Resolve workspace package location
+ */
+export async function resolveWorkspacePackage(pkgName, context) {
+    // Build the ordered list of roots to scan for workspace packages.
+    // Works for any package name/scope — no hardcoded scope guards.
+    const workspaceRoots = [];
+    let workspaceRoot = await context.getWorkspaceRoot();
+    if (workspaceRoot) {
+        workspaceRoots.push(workspaceRoot);
+    }
+    else {
+        // Walk up from app root looking for common workspace markers
+        for (const candidate of [
+            path.join(context.root, ".."),
+            path.join(context.root, "..", ".."),
+        ]) {
+            const normalized = path.resolve(candidate);
+            if ((await context.fileExists(path.join(normalized, "pnpm-workspace.yaml"))) ||
+                (await context.fileExists(path.join(normalized, "modules"))) ||
+                (await context.fileExists(path.join(normalized, "libraries")))) {
+                workspaceRoot = normalized;
+                workspaceRoots.push(normalized);
+                break;
+            }
+        }
+        if (!workspaceRoots.length) {
+            workspaceRoots.push(path.join(context.root, "..", ".."));
+        }
+    }
+    // Also include any co-located framework monorepo (any workspace with packages/)
+    try {
+        const monorepo = await findSwissLibMonorepo(context.root);
+        if (monorepo && !workspaceRoots.includes(monorepo)) {
+            workspaceRoots.unshift(monorepo);
+        }
+        if (monorepo) {
+            const packagesDir = path.join(monorepo, "packages");
+            if (await context.fileExists(packagesDir) && !workspaceRoots.includes(packagesDir)) {
+                workspaceRoots.unshift(packagesDir);
+            }
+        }
+    }
+    catch {
+        // monorepo not found — continue without it
+    }
+    const registry = getPackageRegistry();
+    const primaryRoot = workspaceRoots[0] ?? context.root;
+    const additionalRoots = workspaceRoots.slice(1);
+    if (!registry.getPackageCount() && primaryRoot) {
+        try {
+            await registry.scanWorkspace(primaryRoot, additionalRoots);
+        }
+        catch (error) {
+            console.error(`[SWITE] Error scanning package registry:`, error.message);
+        }
+    }
+    let packageInfo = registry.findPackage(pkgName);
+    if (packageInfo) {
+        return packageInfo.path;
+    }
+    // Rescan in case the package was added after the initial scan
+    await registry.rescan();
+    packageInfo = registry.findPackage(pkgName);
+    if (packageInfo) {
+        return packageInfo.path;
+    }
+    console.log(`[SWITE] Package ${pkgName} not found in workspace (scanned ${registry.getPackageCount()} packages)`);
+    return null;
+}