@swissjs/swite 0.3.0

package/dist/proxy/proxyToPython.js

@@ -0,0 +1,66 @@
+import { SwiteProxyError } from "./SwiteProxyError.js";
+let _pythonConfig = null;
+let _productionMode = false;
+/**
+ * Called by swite start on startup.
+ * Disables localhost fallback — PYTHON_SERVICE_URL is the only valid base URL.
+ */
+export function setProductionMode() {
+    _productionMode = true;
+}
+/**
+ * Called by the swite dev process manager (S-03) on startup.
+ * Stores the resolved python service config for use by proxyToPython.
+ */
+export function initPythonProxy(config) {
+    _pythonConfig = config;
+}
+/**
+ * Proxy a request from the Node server to the internal Python service.
+ *
+ * Resolves base URL from PYTHON_SERVICE_URL env var if set,
+ * otherwise falls back to http://localhost:{python.port} from config.
+ *
+ * Always injects X-Internal-Token header.
+ * Throws SwiteProxyError on non-2xx responses.
+ */
+export async function proxyToPython(options) {
+    const envBaseUrl = process.env["PYTHON_SERVICE_URL"];
+    let baseUrl;
+    if (envBaseUrl) {
+        baseUrl = envBaseUrl.replace(/\/$/, "");
+    }
+    else if (!_productionMode && _pythonConfig) {
+        baseUrl = `http://localhost:${_pythonConfig.port}`;
+    }
+    else {
+        throw new Error(_productionMode
+            ? "PYTHON_SERVICE_URL is required in production mode but is not set."
+            : "Python service not configured. Call initPythonProxy() before using proxyToPython, or set PYTHON_SERVICE_URL.");
+    }
+    const token = process.env["INTERNAL_API_TOKEN"] ?? "";
+    const url = `${baseUrl}${options.path}`;
+    const requestHeaders = {
+        "X-Internal-Token": token,
+        ...options.headers,
+    };
+    if (options.body !== undefined) {
+        requestHeaders["Content-Type"] = "application/json";
+    }
+    const response = await fetch(url, {
+        method: options.method,
+        headers: requestHeaders,
+        body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    if (!response.ok) {
+        let responseBody;
+        try {
+            responseBody = await response.json();
+        }
+        catch {
+            responseBody = await response.text();
+        }
+        throw new SwiteProxyError(response.status, `Python service responded with ${response.status} on ${options.method} ${options.path}`, responseBody);
+    }
+    return response.json();
+}

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

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

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

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

package/dist/resolver/bare-import-resolver.js

@@ -0,0 +1,363 @@
+/*
+ * Bare Import Resolver - Resolves bare module specifiers (@kibologic/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 { resolveWorkspacePackage } from "./workspace-package-resolver.js";
+import { toUrl } from "./url-resolver.js";
+/**
+ * Resolve bare import specifier (e.g., @kibologic/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("/");
+    const isScoped = specifier.startsWith("@");
+    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;
+        const nodeModulesLocations = [
+            path.join(context.root, "node_modules"),
+            path.join(path.dirname(context.root), "node_modules"),
+        ];
+        // Add workspace root node_modules
+        const workspaceRoot = await context.getWorkspaceRoot();
+        if (workspaceRoot) {
+            nodeModulesLocations.push(path.join(workspaceRoot, "node_modules"));
+        }
+        // Add swiss-lib monorepo node_modules
+        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
+        for (const nodeModulesPath of nodeModulesLocations) {
+            const testPkgDir = path.join(nodeModulesPath, pkgName);
+            const testPkgJsonPath = path.join(testPkgDir, "package.json");
+            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;
+                    }
+                }
+            }
+            // 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`;
+            }
+        }
+        // Continue with normal resolution if we found it
+        if (pkgJsonPath && pkgDir) {
+            return await resolveWorkspacePackageEntry(pkgDir, pkgName, subPath, specifier, context);
+        }
+        // Check if this is a workspace package (symlinked)
+        let realPkgDir;
+        try {
+            realPkgDir = await fs.realpath(pkgDir);
+        }
+        catch {
+            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)
+                .replace(/\\/g, "/")
+                .toLowerCase();
+            const normalizedRealPkgDir = path
+                .resolve(realPkgDir)
+                .replace(/\\/g, "/")
+                .toLowerCase();
+            // 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);
+            }
+        }
+        // Read package.json for exports/main resolution
+        const pkgJson = JSON.parse(await fs.readFile(pkgJsonPath, "utf-8"));
+        // Handle exports field if present
+        if (pkgJson.exports) {
+            const exportKey = subPath ? `./${subPath}` : ".";
+            const exportEntry = pkgJson.exports[exportKey];
+            if (exportEntry) {
+                let entryPoint;
+                if (typeof exportEntry === "string") {
+                    entryPoint = exportEntry;
+                }
+                else if (exportEntry.import) {
+                    entryPoint = exportEntry.import;
+                }
+                else if (exportEntry.default) {
+                    entryPoint = exportEntry.default;
+                }
+                else {
+                    entryPoint = exportEntry;
+                }
+                const fullPath = path.join(pkgDir, entryPoint);
+                // Prefer source over dist
+                const normalizedFullPath = fullPath.replace(/\\/g, "/");
+                if (normalizedFullPath.includes("/dist/")) {
+                    const srcFullPath = normalizedFullPath
+                        .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);
+                    }
+                }
+                if (await context.fileExists(fullPath)) {
+                    return await toUrl(fullPath, context);
+                }
+                // Try extensions
+                for (const ext of [".js", ".mjs", ".ts", ".ui", ".uix"]) {
+                    const withExt = fullPath.replace(/\.(js|mjs|ts|ui|uix)$/, ext);
+                    if (await context.fileExists(withExt)) {
+                        return await toUrl(withExt, context);
+                    }
+                }
+                // Try case-insensitive match
+                const dir = path.dirname(fullPath);
+                const fileName = path.basename(fullPath);
+                try {
+                    const files = await fs.readdir(dir);
+                    const caseInsensitiveMatch = files.find((f) => f.toLowerCase() === fileName.toLowerCase());
+                    if (caseInsensitiveMatch) {
+                        const correctedPath = path.join(dir, caseInsensitiveMatch);
+                        if (await context.fileExists(correctedPath)) {
+                            console.log(chalk.yellow(`[SWITE] Case-insensitive match for ${pkgName}: ${fileName} -> ${caseInsensitiveMatch}`));
+                            return await toUrl(correctedPath, context);
+                        }
+                    }
+                }
+                catch {
+                    // Directory doesn't exist, continue to fallback
+                }
+            }
+        }
+        // Determine entry point
+        let entryPoint;
+        if (subPath) {
+            entryPoint = subPath;
+        }
+        else {
+            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 with extensions
+        for (const ext of [".js", ".mjs", ".ts", ".ui", ".uix"]) {
+            if (await context.fileExists(fullPath + ext)) {
+                return await toUrl(fullPath + ext, context);
+            }
+        }
+        // Fallback to CDN (jsDelivr; esm.sh returns 500 for some packages) when allowed.
+        console.warn(`[SWITE] Could not resolve ${specifier}, using fallback`);
+        return shouldUseCdnFallback(pkgName)
+            ? `https://cdn.jsdelivr.net/npm/${specifier}/+esm`
+            : `/node_modules/${specifier}`;
+    }
+    catch (error) {
+        console.warn(`[SWITE] Error resolving ${specifier}:`, error);
+        return shouldUseCdnFallback(pkgName)
+            ? `https://cdn.jsdelivr.net/npm/${specifier}/+esm`
+            : `/node_modules/${specifier}`;
+    }
+}
+/**
+ * Resolve entry point for workspace package
+ */
+async function resolveWorkspacePackageEntry(workspacePkg, pkgName, subPath, specifier, context) {
+    const workspacePkgJson = JSON.parse(await fs.readFile(path.join(workspacePkg, "package.json"), "utf-8"));
+    // Handle exports field if present
+    if (workspacePkgJson.exports) {
+        const subPathWithoutExt = subPath
+            ? 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) {
+                const withoutExtKey = `./${subPathWithoutExt}`;
+                if (workspacePkgJson.exports[withoutExtKey]) {
+                    exportKey = withoutExtKey;
+                }
+            }
+            if (!workspacePkgJson.exports[exportKey]) {
+                const subPathParts = subPathWithoutExt.split("/");
+                if (subPathParts.length > 1) {
+                    const dirPath = subPathParts.slice(0, -1).join("/");
+                    const dirExportKey = `./${dirPath}`;
+                    if (workspacePkgJson.exports[dirExportKey]) {
+                        exportKey = dirExportKey;
+                    }
+                    else {
+                        const firstDir = subPathParts[0];
+                        const firstDirExportKey = `./${firstDir}`;
+                        if (workspacePkgJson.exports[firstDirExportKey]) {
+                            exportKey = firstDirExportKey;
+                        }
+                        else {
+                            const lastDir = subPathParts[subPathParts.length - 2];
+                            const lastDirExportKey = `./${lastDir}`;
+                            if (workspacePkgJson.exports[lastDirExportKey]) {
+                                exportKey = lastDirExportKey;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        const exportEntry = workspacePkgJson.exports[exportKey];
+        if (exportEntry) {
+            let entryPoint;
+            if (typeof exportEntry === "string") {
+                entryPoint = exportEntry;
+            }
+            else if (exportEntry.import) {
+                entryPoint = exportEntry.import;
+            }
+            else if (exportEntry.default) {
+                entryPoint = exportEntry.default;
+            }
+            else {
+                entryPoint = exportEntry;
+            }
+            const normalizedEntryPoint = entryPoint.startsWith("./")
+                ? entryPoint.slice(2)
+                : entryPoint;
+            const fullPath = path.join(workspacePkg, normalizedEntryPoint);
+            // Dev: prefer src over dist for workspace packages (unbuilt or dev mode)
+            const normalizedFull = fullPath.replace(/\\/g, "/");
+            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);
+                }
+            }
+            if (await context.fileExists(fullPath)) {
+                return await toUrl(fullPath, context);
+            }
+            // Try extensions
+            for (const ext of [".ui", ".uix", ".ts", ".js"]) {
+                const withExt = fullPath.replace(/\.(js|ts|ui|uix)$/, ext);
+                if (await context.fileExists(withExt)) {
+                    return await toUrl(withExt, context);
+                }
+            }
+        }
+    }
+    // Fallback to old logic
+    let entryPoint;
+    if (subPath) {
+        entryPoint = subPath;
+    }
+    else {
+        entryPoint =
+            workspacePkgJson.module || workspacePkgJson.main || "index.js";
+    }
+    const fullPath = path.join(workspacePkg, entryPoint);
+    // Dev: prefer src over dist for workspace packages
+    const normalizedFull = fullPath.replace(/\\/g, "/");
+    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);
+        }
+    }
+    if (await context.fileExists(fullPath)) {
+        return await toUrl(fullPath, context);
+    }
+    // Try extensions
+    const ext = path.extname(entryPoint);
+    if (ext) {
+        const basePath = fullPath.slice(0, -ext.length);
+        for (const tryExt of [".js", ".mjs", ".ts", ".ui", ".uix"]) {
+            if (await context.fileExists(basePath + tryExt)) {
+                return await toUrl(basePath + tryExt, context);
+            }
+        }
+    }
+    else {
+        for (const tryExt of [".js", ".mjs", ".ts", ".ui", ".uix"]) {
+            if (await context.fileExists(fullPath + tryExt)) {
+                return await toUrl(fullPath + tryExt, context);
+            }
+        }
+    }
+    // Try index files
+    for (const tryExt of [".js", ".ts", ".ui", ".uix"]) {
+        const indexFile = path.join(fullPath, `index${tryExt}`);
+        if (await context.fileExists(indexFile)) {
+            return await toUrl(indexFile, context);
+        }
+    }
+    // Try src/ directory
+    const srcDir = path.join(workspacePkg, "src");
+    for (const ext of [".ts", ".ui", ".uix", ".js"]) {
+        const srcIndex = path.join(srcDir, `index${ext}`);
+        if (await context.fileExists(srcIndex)) {
+            console.log(`[SWITE] Found unbuilt workspace package ${pkgName} at ${srcIndex}`);
+            return await toUrl(srcIndex, context);
+        }
+    }
+    console.warn(`[SWITE] Entry point not found for ${pkgName} at ${fullPath}, using fallback`);
+    return shouldUseCdnFallback(pkgName)
+        ? `https://cdn.jsdelivr.net/npm/${specifier}/+esm`
+        : `/node_modules/${specifier}`;
+}

package/dist/resolver/symlink-registry.d.ts

@@ -0,0 +1,13 @@
+export declare function buildSymlinkRegistry(nodeModulesDirs: string[]): Promise<void>;
+/**
+ * Look up an absolute filesystem path in the symlink registry.
+ *
+ * Returns the browser URL if absolutePath is, or is within, a package whose
+ * realpath was registered at startup. Returns null if not found.
+ *
+ * Example:
+ *   /mnt/c/.../swiss-lib/packages/core/src/index.ts
+ *   → /node_modules/@kibologic/core/src/index.ts
+ */
+export declare function lookupInSymlinkRegistry(absolutePath: string): string | null;
+//# sourceMappingURL=symlink-registry.d.ts.map

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

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

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

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

@@ -0,0 +1,11 @@
+export interface UrlResolverContext {
+    root: string;
+    getWorkspaceRoot: () => Promise<string | null>;
+    fileExists: (filePath: string) => Promise<boolean>;
+}
+export type WorkspacePackageResolverContext = UrlResolverContext;
+/**
+ * Convert file path to URL for browser
+ */
+export declare function toUrl(filePath: string, context: UrlResolverContext): Promise<string>;
+//# sourceMappingURL=url-resolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"url-resolver.d.ts","sourceRoot":"","sources":["../../src/resolver/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;AAoBjE;;GAEG;AACH,wBAAsB,KAAK,CACzB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,MAAM,CAAC,CA4QjB"}