@swissjs/swite 0.3.0

package/dist/resolver/url-resolver.js

@@ -0,0 +1,268 @@
+/*
+ * URL Resolver - Converts file paths to URLs
+ * Extracted from resolver.ts for modularity
+ */
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { findSwissLibMonorepo } from "../utils/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;
+}
+/**
+ * Convert file path to URL for browser
+ */
+export async function toUrl(filePath, context) {
+    const normalized = filePath.replace(/\\/g, "/");
+    // CG-03: Check symlink registry FIRST.
+    // Absolute filesystem paths (both realpath-resolved and unresolved symlinks)
+    // must be mapped back to browser URLs before the startsWith("/") early-return
+    // fires and mangled by normalizeResult().
+    // The registry maps realpath → /node_modules/<pkg> browser URL prefix.
+    if (path.isAbsolute(filePath)) {
+        // Direct lookup (path is already a realpath, e.g. from fs.realpath() in ts-handler)
+        let registryUrl = lookupInSymlinkRegistry(normalized);
+        // Fallback: resolve symlinks and retry (path may still contain symlink segments,
+        // e.g. app/node_modules/@alpine/core/... where app/node_modules is itself a symlink)
+        if (!registryUrl) {
+            try {
+                const realPath = (await fs.realpath(filePath)).replace(/\\/g, "/");
+                if (realPath !== normalized) {
+                    registryUrl = lookupInSymlinkRegistry(realPath);
+                }
+            }
+            catch {
+                // file may not exist yet; ignore
+            }
+        }
+        if (registryUrl) {
+            console.log(`[SWITE] toUrl: symlink registry hit: ${filePath} → ${registryUrl}`);
+            return registryUrl;
+        }
+        // If the absolute filesystem path contains /node_modules/, convert it to a
+        // browser-relative URL (/node_modules/...) before the startsWith("/") early
+        // return below swallows it as an already-resolved URL.
+        if (normalized.toLowerCase().includes("/node_modules/")) {
+            const nodeModulesIndex = normalized.toLowerCase().indexOf("/node_modules/");
+            const afterNodeModules = normalized.slice(nodeModulesIndex + "/node_modules/".length);
+            const url = "/node_modules/" + afterNodeModules;
+            console.log(`[SWITE] toUrl: abs→node_modules URL: ${filePath} → ${url}`);
+            return normalizeResult(url);
+        }
+        // Convert absolute workspace/app paths to browser-relative URLs before the
+        // startsWith("/") early-return below treats them as already-resolved URLs.
+        // e.g. /app/modules/pos/src/index.ui → /modules/pos/src/index.ui
+        const workspaceRootForAbs = await context.getWorkspaceRoot();
+        const normalizedLower = normalized.toLowerCase();
+        if (workspaceRootForAbs) {
+            const wsRoot = path.resolve(workspaceRootForAbs).replace(/\\/g, "/");
+            if (normalizedLower.startsWith(wsRoot.toLowerCase() + "/") || normalizedLower === wsRoot.toLowerCase()) {
+                const relative = normalized.slice(wsRoot.length);
+                const url = relative.startsWith("/") ? relative : "/" + relative;
+                console.log(`[SWITE] toUrl: abs→workspace URL: ${filePath} → ${url}`);
+                return normalizeResult(url);
+            }
+        }
+        const appRoot = path.resolve(context.root).replace(/\\/g, "/");
+        if (normalizedLower.startsWith(appRoot.toLowerCase() + "/") || normalizedLower === appRoot.toLowerCase()) {
+            const relative = normalized.slice(appRoot.length);
+            const url = relative.startsWith("/") ? relative : "/" + relative;
+            console.log(`[SWITE] toUrl: abs→approot URL: ${filePath} → ${url}`);
+            return normalizeResult(url);
+        }
+    }
+    // If path is already a URL (starts with / or http), check for source file first
+    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");
+            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);
+    }
+    // If path is absolute, try to make it relative to workspace root or server root
+    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;
+            let resolvedFilePath;
+            try {
+                resolvedSwissPackages = await fs.realpath(swissPackagesPath);
+                resolvedFilePath = await fs.realpath(filePath);
+            }
+            catch {
+                resolvedSwissPackages = path.resolve(swissPackagesPath);
+                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 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)}`);
+                    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
+        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);
+        }
+        // Try relative to app root FIRST
+        const normalizedRoot = path.resolve(context.root).replace(/\\/g, "/").toLowerCase();
+        const normalizedFilePath = path.resolve(filePath).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);
+        }
+        // Try workspace root
+        if (workspaceRoot) {
+            const normalizedWorkspaceRoot = path.resolve(workspaceRoot).replace(/\\/g, "/").toLowerCase();
+            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");
+                    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 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.
+        let url;
+        if (path.isAbsolute(rawRelative) || rawRelative.startsWith("..")) {
+            const normalizedBase = path.resolve(baseRoot).replace(/\\/g, "/");
+            const normalizedFile = path.resolve(filePath).replace(/\\/g, "/");
+            const stripped = normalizedFile.startsWith(normalizedBase)
+                ? normalizedFile.slice(normalizedBase.length)
+                : "/" + normalizedFile;
+            url = stripped.startsWith("/") ? stripped : "/" + stripped;
+        }
+        else {
+            url = "/" + rawRelative.replace(/\\/g, "/");
+        }
+        console.warn(`[SWITE] toUrl fallback: ${filePath} -> ${url} (may not work if path goes outside root)`);
+        return normalizeResult(url);
+    }
+    // Default: make relative to root
+    const rawRelative = path.relative(context.root, filePath);
+    // CG-03: guard against absolute result from path.relative() on cross-drive/WSL paths.
+    let defaultUrl;
+    if (path.isAbsolute(rawRelative) || rawRelative.startsWith("..")) {
+        const normalizedRoot = path.resolve(context.root).replace(/\\/g, "/");
+        const normalizedFile = path.resolve(filePath).replace(/\\/g, "/");
+        const stripped = normalizedFile.startsWith(normalizedRoot)
+            ? normalizedFile.slice(normalizedRoot.length)
+            : "/" + normalizedFile;
+        defaultUrl = stripped.startsWith("/") ? stripped : "/" + stripped;
+    }
+    else {
+        defaultUrl = "/" + rawRelative.replace(/\\/g, "/");
+    }
+    return normalizeResult(defaultUrl);
+}

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

@@ -0,0 +1,10 @@
+export interface WorkspacePackageResolverContext {
+    root: string;
+    getWorkspaceRoot: () => Promise<string | null>;
+    fileExists: (filePath: string) => Promise<boolean>;
+}
+/**
+ * Resolve workspace package location
+ */
+export declare function resolveWorkspacePackage(pkgName: string, context: WorkspacePackageResolverContext): Promise<string | null>;
+//# sourceMappingURL=workspace-package-resolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-package-resolver.d.ts","sourceRoot":"","sources":["../../src/resolver/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,CAiMxB"}

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

@@ -0,0 +1,185 @@
+/*
+ * Workspace Package Resolver - Finds packages in workspace
+ * Uses dynamic package registry instead of hardcoded paths
+ */
+import path from "node:path";
+import { findSwissLibMonorepo } from "../utils/package-finder.js";
+import { getPackageRegistry } from "../utils/package-registry.js";
+/**
+ * Resolve workspace package location
+ */
+export async function resolveWorkspacePackage(pkgName, context) {
+    let workspaceRoot = null;
+    const workspaceRoots = [];
+    if (pkgName.startsWith("@swiss-enterprise/") ||
+        pkgName.startsWith("@swiss-module/") ||
+        pkgName.startsWith("@kibologic/") ||
+        pkgName.startsWith("@swiss-framework/")) {
+        console.log(`[SWITE] Looking for SWS root for @swiss-enterprise package...`);
+        console.log(`[SWITE] Starting from app root: ${context.root}`);
+        const fallbackPaths = [
+            path.join(context.root, "..", ".."),
+            path.join(context.root, ".."),
+        ];
+        const detectedWorkspaceRoot = await context.getWorkspaceRoot();
+        if (detectedWorkspaceRoot) {
+            const hasLibraries = await context.fileExists(path.join(detectedWorkspaceRoot, "libraries"));
+            const hasModules = await context.fileExists(path.join(detectedWorkspaceRoot, "modules"));
+            if (hasLibraries || hasModules) {
+                console.log(`[SWITE] ✅ Found workspace root via getWorkspaceRoot(): ${detectedWorkspaceRoot}`);
+                workspaceRoot = detectedWorkspaceRoot;
+                workspaceRoots.push(workspaceRoot);
+            }
+        }
+        for (const fallbackPath of fallbackPaths) {
+            const normalizedFallback = path.resolve(fallbackPath);
+            console.log(`[SWITE] Checking path: ${normalizedFallback}`);
+            const hasWorkspace = await context.fileExists(path.join(normalizedFallback, "pnpm-workspace.yaml"));
+            const hasModules = await context.fileExists(path.join(normalizedFallback, "modules"));
+            const hasLibraries = await context.fileExists(path.join(normalizedFallback, "libraries"));
+            const hasPackages = await context.fileExists(path.join(normalizedFallback, "packages"));
+            const hasAiAgents = await context.fileExists(path.join(normalizedFallback, "packages", "ai-agents", "package.json"));
+            console.log(`[SWITE]   hasWorkspace: ${hasWorkspace}, hasModules: ${hasModules}, hasLibraries: ${hasLibraries}, hasPackages: ${hasPackages}, hasAiAgents: ${hasAiAgents}`);
+            if (hasWorkspace || hasModules || hasLibraries || hasPackages || hasAiAgents) {
+                workspaceRoot = normalizedFallback;
+                console.log(`[SWITE] ✅ Found workspace root at: ${workspaceRoot}`);
+                workspaceRoots.push(workspaceRoot);
+                break;
+            }
+        }
+        if (!workspaceRoot) {
+            console.warn(`[SWITE] ⚠️ Could not find workspace root via fallback paths, trying getWorkspaceRoot()...`);
+            workspaceRoot = await context.getWorkspaceRoot();
+            if (workspaceRoot) {
+                console.log(`[SWITE] ✅ Found workspace root via fallback getWorkspaceRoot(): ${workspaceRoot}`);
+                workspaceRoots.push(workspaceRoot);
+            }
+            else {
+                console.warn(`[SWITE] ⚠️ Could not find workspace root, using last resort path...`);
+                workspaceRoots.push(path.join(context.root, "..", ".."));
+            }
+        }
+    }
+    else {
+        workspaceRoot = await context.getWorkspaceRoot();
+        if (!workspaceRoot) {
+            console.log(`[SWITE] Workspace root not found via pnpm-workspace.yaml, trying fallbacks...`);
+            const fallbackPaths = [
+                path.join(context.root, "..", ".."),
+                path.join(context.root, ".."),
+            ];
+            for (const fallbackPath of fallbackPaths) {
+                const normalizedFallback = path.resolve(fallbackPath);
+                if ((await context.fileExists(path.join(normalizedFallback, "pnpm-workspace.yaml"))) ||
+                    (await context.fileExists(path.join(normalizedFallback, "modules"))) ||
+                    (await context.fileExists(path.join(normalizedFallback, "libraries")))) {
+                    workspaceRoot = normalizedFallback;
+                    console.log(`[SWITE] Found workspace root via fallback: ${workspaceRoot}`);
+                    break;
+                }
+            }
+        }
+        if (workspaceRoot) {
+            workspaceRoots.push(workspaceRoot);
+        }
+        else {
+            workspaceRoots.push(path.join(context.root, "..", ".."));
+            workspaceRoots.push(path.join(context.root, "..", "..", ".."));
+        }
+    }
+    // For @kibologic/* packages, also check swiss-lib monorepo
+    if (pkgName.startsWith("@kibologic/")) {
+        const swissLib = await findSwissLibMonorepo(context.root);
+        if (swissLib) {
+            console.log(`[SWITE] Found swiss-lib monorepo at ${swissLib}`);
+            workspaceRoots.unshift(swissLib);
+        }
+    }
+    console.log(`[SWITE] Searching for workspace package: ${pkgName}`);
+    console.log(`[SWITE] Workspace roots: ${workspaceRoots.map((r) => path.resolve(r)).join(", ")}`);
+    // Use dynamic package registry instead of hardcoded directory searches
+    const registry = getPackageRegistry();
+    // Determine primary workspace root for scanning
+    let primaryRoot = workspaceRoots[0] ?? "";
+    if (!primaryRoot) {
+        primaryRoot = (await context.getWorkspaceRoot()) ?? context.root;
+    }
+    if (!primaryRoot) {
+        primaryRoot = context.root;
+    }
+    const additionalRoots = workspaceRoots.slice(1);
+    // Add swiss-lib monorepo if it exists (for @kibologic/* packages)
+    if (pkgName.startsWith("@kibologic/")) {
+        try {
+            const swissLib = await findSwissLibMonorepo(context.root);
+            if (swissLib && !additionalRoots.includes(swissLib) && swissLib !== primaryRoot) {
+                additionalRoots.unshift(swissLib); // Prioritize swiss-lib
+            }
+            // Also add swiss-lib/packages to ensure packages are found
+            if (swissLib) {
+                const swissLibPackages = path.join(swissLib, "packages");
+                if (await context.fileExists(swissLibPackages) && !additionalRoots.includes(swissLibPackages)) {
+                    console.log(`[SWITE] Adding swiss-lib/packages to scan roots: ${swissLibPackages}`);
+                    additionalRoots.unshift(swissLibPackages);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`[SWITE] Error finding swiss-lib monorepo:`, error.message);
+        }
+    }
+    // Ensure registry is scanned
+    if (!registry.getPackageCount() && primaryRoot) {
+        console.log(`[SWITE] Package registry not scanned yet, scanning workspace at ${primaryRoot}...`);
+        try {
+            await registry.scanWorkspace(primaryRoot, additionalRoots);
+        }
+        catch (error) {
+            console.error(`[SWITE] Error scanning package registry:`, error.message);
+            console.error(`[SWITE] Stack:`, error.stack);
+        }
+    }
+    else if (registry.getPackageCount() && pkgName.startsWith("@kibologic/")) {
+        // Registry already scanned but may not have swiss-lib/packages
+        // Check if @kibologic/core is missing from registry
+        const existingPkg = registry.findPackage(pkgName);
+        if (!existingPkg) {
+            console.log(`[SWITE] ${pkgName} not in registry, forcing rescan with swiss-lib/packages...`);
+            await registry.rescan();
+            // After rescan, if still not found, explicitly scan swiss-lib/packages
+            const stillMissing = !registry.findPackage(pkgName);
+            if (stillMissing) {
+                const swissLib = await findSwissLibMonorepo(context.root);
+                if (swissLib) {
+                    const swissLibPackages = path.join(swissLib, "packages");
+                    if (await context.fileExists(swissLibPackages)) {
+                        console.log(`[SWITE] Explicitly scanning swiss-lib/packages: ${swissLibPackages}`);
+                        await registry.scanWorkspace(swissLibPackages, []);
+                    }
+                }
+            }
+        }
+    }
+    else if (!primaryRoot) {
+        console.warn(`[SWITE] No workspace root found, cannot scan packages`);
+    }
+    // Look up package in registry
+    let packageInfo = registry.findPackage(pkgName);
+    if (packageInfo) {
+        console.log(`[SWITE] ✅ Found ${pkgName} at ${packageInfo.path} (via dynamic registry)`);
+        return packageInfo.path;
+    }
+    // If not found, try rescanning (in case packages were added or registry was stale)
+    console.log(`[SWITE] Package ${pkgName} not in registry, rescanning...`);
+    await registry.rescan();
+    packageInfo = registry.findPackage(pkgName);
+    if (packageInfo) {
+        console.log(`[SWITE] ✅ Found ${pkgName} at ${packageInfo.path} (after rescan)`);
+        return packageInfo.path;
+    }
+    // Log all found packages for debugging
+    const allPackages = registry.getAllPackages().map(p => p.name).join(", ");
+    console.log(`[SWITE] ❌ Package ${pkgName} not found in workspace`);
+    console.log(`[SWITE] Scanned ${registry.getPackageCount()} packages: ${allPackages}`);
+    return null;
+}

package/dist/resolver.d.ts

@@ -0,0 +1,17 @@
+import type { ImportMap } from "./utils/generate-import-map.js";
+export declare class ModuleResolver {
+    private root;
+    private workspaceRoot;
+    private importMap;
+    constructor(root: string);
+    /**
+     * Set pre-resolved import map (from build-time generation)
+     */
+    setImportMap(importMap: ImportMap | null): void;
+    private getWorkspaceRoot;
+    resolve(specifier: string, importer: string): Promise<string>;
+    private fileExists;
+    private resolveWorkspacePackage;
+    private toUrl;
+}
+//# sourceMappingURL=resolver.d.ts.map

package/dist/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAMhE,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;IA4BxB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;YAqJrD,UAAU;YASV,uBAAuB;YAavB,KAAK;CAUpB"}