@swissjs/swite 0.3.0

package/dist/handlers/js-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-handler.d.ts","sourceRoot":"","sources":["../../src/handlers/js-handler.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC,OAAO,EACL,WAAW,EAEX,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAK3B,qBAAa,SAAU,SAAQ,WAAW;IACxC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,SAAS,CAAY;gBAEjB,OAAO,EAAE,cAAc;IAO7B,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAsGxD"}

package/dist/handlers/js-handler.js

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import chalk from "chalk";
+import { rewriteImports } from "../import-rewriter.js";
+import { BaseHandler, setDevHeaders, } from "./base-handler.js";
+import { UIHandler } from "./ui-handler.js";
+import { UIXHandler } from "./uix-handler.js";
+import { TSHandler } from "./ts-handler.js";
+export class JSHandler extends BaseHandler {
+    constructor(context) {
+        super(context);
+        this.uiHandler = new UIHandler(context);
+        this.uixHandler = new UIXHandler(context);
+        this.tsHandler = new TSHandler(context);
+    }
+    async handle(url, res) {
+        const filePath = await this.resolveFilePath(url);
+        // Check if .js file exists, if not try .ts, .ui, .uix
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            // .js doesn't exist, try alternatives
+            const basePath = filePath.slice(0, -3); // Remove .js
+            const alternatives = [
+                {
+                    ext: ".ts",
+                    handler: () => this.tsHandler.handle(url.replace(/\.js$/, ".ts"), res),
+                },
+                {
+                    ext: ".ui",
+                    handler: () => this.uiHandler.handle(url.replace(/\.js$/, ".ui"), res),
+                },
+                {
+                    ext: ".uix",
+                    handler: () => this.uixHandler.handle(url.replace(/\.js$/, ".uix"), res),
+                },
+            ];
+            for (const alt of alternatives) {
+                try {
+                    const altPath = basePath + alt.ext;
+                    await fs.access(altPath);
+                    console.log(chalk.yellow(`[.js→${alt.ext}] ${url} → ${url.replace(/\.js$/, alt.ext)} (file: ${altPath})`));
+                    return await alt.handler();
+                }
+                catch {
+                    // Try next alternative
+                    console.log(chalk.gray(`[.js→${alt.ext}] ${basePath + alt.ext} not found, trying next...`));
+                }
+            }
+            // No alternatives found, throw error
+            console.error(chalk.red(`[.js] File not found: ${url} (tried .js, .ts, .ui, .uix)`));
+            console.error(chalk.red(`[.js] filePath was: ${filePath}`));
+            console.error(chalk.red(`[.js] basePath was: ${basePath}`));
+            throw new Error(`File not found: ${url} (tried .js, .ts, .ui, .uix)`);
+        }
+        // .js file exists, process it normally
+        const source = await fs.readFile(filePath, "utf-8");
+        // Debug: Check for bare imports (including simple npm packages like bcryptjs)
+        const bareImportPattern = /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)[^'"]*['"]/;
+        const simpleNpmPattern = /(?:import|from|export).*['"]([a-zA-Z][a-zA-Z0-9_-]*)[^'"]*['"]/;
+        if (bareImportPattern.test(source) || simpleNpmPattern.test(source)) {
+            console.log(chalk.yellow(`[.js] Found imports in ${url}, rewriting...`));
+            // Log the actual imports found
+            const importMatches = source.matchAll(/(?:import|from)\s+['"]([^'"]+)['"]/g);
+            for (const match of importMatches) {
+                console.log(chalk.cyan(`[.js] Found import: ${match[1]}`));
+            }
+        }
+        const rewritten = await rewriteImports(source, filePath, this.context.resolver);
+        // Debug: Verify no bare imports remain after rewriting
+        if (bareImportPattern.test(rewritten)) {
+            console.error(chalk.red(`[.js] WARNING: Bare imports still present in ${url} after rewriting!`));
+            const matches = Array.from(rewritten.matchAll(/(?:import|from|export).*['"](@[^'"]+\/[^'"]+)[^'"]*['"]/g));
+            for (const match of matches.slice(0, 3)) {
+                console.error(chalk.red(`[.js] Unresolved: ${match[1]}`));
+            }
+        }
+        setDevHeaders(res);
+        res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+        res.send(rewritten);
+    }
+}

package/dist/handlers/mjs-handler.d.ts

@@ -0,0 +1,8 @@
+import type { Response } from "express";
+import { BaseHandler, type HandlerContext } from "./base-handler.js";
+export declare class MJSHandler extends BaseHandler {
+    private jsHandler;
+    constructor(context: HandlerContext);
+    handle(url: string, res: Response): Promise<void>;
+}
+//# sourceMappingURL=mjs-handler.d.ts.map

package/dist/handlers/mjs-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mjs-handler.d.ts","sourceRoot":"","sources":["../../src/handlers/mjs-handler.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC,OAAO,EACL,WAAW,EAEX,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAG3B,qBAAa,UAAW,SAAQ,WAAW;IACzC,OAAO,CAAC,SAAS,CAAY;gBAEjB,OAAO,EAAE,cAAc;IAK7B,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAuCxD"}

package/dist/handlers/mjs-handler.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import chalk from "chalk";
+import { rewriteImports } from "../import-rewriter.js";
+import { BaseHandler, setDevHeaders, } from "./base-handler.js";
+import { JSHandler } from "./js-handler.js";
+export class MJSHandler extends BaseHandler {
+    constructor(context) {
+        super(context);
+        this.jsHandler = new JSHandler(context);
+    }
+    async handle(url, res) {
+        const filePath = await this.resolveFilePath(url);
+        // Check if .mjs file exists
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            // .mjs doesn't exist, try .js as fallback
+            const jsPath = filePath.replace(/\.mjs$/, ".js");
+            try {
+                await fs.access(jsPath);
+                console.log(chalk.yellow(`[.mjs→.js] ${url} → ${url.replace(/\.mjs$/, ".js")} (file: ${jsPath})`));
+                return await this.jsHandler.handle(url.replace(/\.mjs$/, ".js"), res);
+            }
+            catch {
+                console.error(chalk.red(`[.mjs] File not found: ${url} (tried .mjs, .js)`));
+                throw new Error(`File not found: ${url} (tried .mjs, .js)`);
+            }
+        }
+        // .mjs file exists, process it normally
+        const source = await fs.readFile(filePath, "utf-8");
+        const rewritten = await rewriteImports(source, filePath, this.context.resolver);
+        // Set proper MIME type for ES modules (.mjs)
+        // According to MDN Web Standards: .mjs files should use "application/javascript"
+        setDevHeaders(res);
+        res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+        res.send(rewritten);
+    }
+}

package/dist/handlers/node-module-handler.d.ts

@@ -0,0 +1,16 @@
+import type { Response } from "express";
+import { BaseHandler, type HandlerContext } from "./base-handler.js";
+export declare class NodeModuleHandler extends BaseHandler {
+    private uiHandler;
+    private uixHandler;
+    private tsHandler;
+    constructor(context: HandlerContext);
+    handle(url: string, res: Response): Promise<void>;
+    /**
+     * Get CDN URL for a /node_modules/... request when the file is not found locally.
+     * Uses jsDelivr (+esm) for reliable ESM delivery; esm.sh can return 500 for some packages.
+     * e.g. /node_modules/reflect-metadata/Reflect.js -> https://cdn.jsdelivr.net/npm/reflect-metadata/+esm
+     */
+    private getNodeModuleCdnRedirect;
+}
+//# sourceMappingURL=node-module-handler.d.ts.map

package/dist/handlers/node-module-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-module-handler.d.ts","sourceRoot":"","sources":["../../src/handlers/node-module-handler.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAKxC,OAAO,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAOrE,qBAAa,iBAAkB,SAAQ,WAAW;IAChD,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,SAAS,CAAY;gBAEjB,OAAO,EAAE,cAAc;IAO7B,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAqRvD;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;CA0BjC"}

package/dist/handlers/node-module-handler.js

@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import chalk from "chalk";
+import { rewriteImports } from "../import-rewriter.js";
+import { BaseHandler } from "./base-handler.js";
+import { UIHandler } from "./ui-handler.js";
+import { UIXHandler } from "./uix-handler.js";
+import { TSHandler } from "./ts-handler.js";
+import { findWorkspaceRoot } from "../utils/workspace.js";
+import { shouldUseCdnFallback } from "../utils/cdn-fallback.js";
+export class NodeModuleHandler extends BaseHandler {
+    constructor(context) {
+        super(context);
+        this.uiHandler = new UIHandler(context);
+        this.uixHandler = new UIXHandler(context);
+        this.tsHandler = new TSHandler(context);
+    }
+    async handle(url, res) {
+        try {
+            // Special case: reflect-metadata/reflect.js -> Reflect.js (case fix)
+            if (url.includes("/reflect-metadata/reflect.js")) {
+                url = url.replace("/reflect.js", "/Reflect.js");
+            }
+            // Handle node_modules paths - try multiple locations
+            // URL is like /node_modules/reflect-metadata/Reflect.js
+            // We need to remove the leading / and join with the appropriate root
+            const urlPath = url.startsWith("/") ? url.slice(1) : url;
+            let filePath = null;
+            const workspaceRoot = this.context.workspaceRoot ||
+                (await findWorkspaceRoot(this.context.root));
+            console.log(chalk.blue(`[node_modules] Processing: ${url}`));
+            console.log(chalk.blue(`[node_modules] App root: ${this.context.root}`));
+            console.log(chalk.blue(`[node_modules] Workspace root: ${workspaceRoot || "none"}`));
+            // Walk up directory tree from app root to find node_modules at any level
+            // (handles pnpm isolated AND hoisted workspace layouts)
+            {
+                let current = path.resolve(this.context.root);
+                const visited = new Set();
+                for (let i = 0; i < 8; i++) {
+                    const candidate = path.join(current, urlPath);
+                    if (!visited.has(candidate)) {
+                        visited.add(candidate);
+                        console.log(chalk.blue(`[node_modules] Trying path: ${candidate}`));
+                        try {
+                            const resolvedPath = await fs.realpath(candidate);
+                            console.log(chalk.blue(`[node_modules] Resolved to: ${resolvedPath}`));
+                            await fs.access(resolvedPath);
+                            filePath = resolvedPath;
+                            console.log(chalk.green(`[node_modules] ✓ Found: ${urlPath}`));
+                            break;
+                        }
+                        catch (err) {
+                            console.log(chalk.yellow(`[node_modules] Path failed: ${err instanceof Error ? err.message : String(err)}`));
+                        }
+                    }
+                    const parent = path.dirname(current);
+                    if (parent === current)
+                        break;
+                    current = parent;
+                }
+            }
+            if (!filePath) {
+                // Try workspace root node_modules
+                if (workspaceRoot) {
+                    const workspaceNodeModulesPath = path.join(workspaceRoot, urlPath);
+                    console.log(chalk.blue(`[node_modules] Trying workspace path: ${workspaceNodeModulesPath}`));
+                    try {
+                        // Try to resolve symlinks first (realpath works even if path is a symlink)
+                        const resolvedPath = await fs.realpath(workspaceNodeModulesPath);
+                        console.log(chalk.blue(`[node_modules] Resolved to: ${resolvedPath}`));
+                        // Verify the resolved path exists
+                        await fs.access(resolvedPath);
+                        filePath = resolvedPath;
+                        console.log(chalk.green(`[node_modules] ✓ Found in workspace: ${urlPath}`));
+                    }
+                    catch (err2) {
+                        console.log(chalk.yellow(`[node_modules] Workspace path failed: ${err2 instanceof Error ? err2.message : String(err2)}`));
+                        // Try swiss-lib monorepo node_modules (dynamically found)
+                        const { findSwissLibMonorepo } = await import("../utils/package-finder.js");
+                        const swissLib = await findSwissLibMonorepo(this.context.root);
+                        if (swissLib) {
+                            const swissNodeModulesPath = path.join(swissLib, urlPath);
+                            console.log(chalk.blue(`[node_modules] Trying swiss-lib path: ${swissNodeModulesPath}`));
+                            try {
+                                // Try to resolve symlinks first (realpath works even if path is a symlink)
+                                const resolvedPath = await fs.realpath(swissNodeModulesPath);
+                                console.log(chalk.blue(`[node_modules] Resolved to: ${resolvedPath}`));
+                                // Verify the resolved path exists
+                                await fs.access(resolvedPath);
+                                filePath = resolvedPath;
+                                console.log(chalk.green(`[node_modules] ✓ Found in swiss-lib monorepo: ${urlPath}`));
+                            }
+                            catch (err3) {
+                                console.log(chalk.yellow(`[node_modules] swiss-lib path failed: ${err3 instanceof Error ? err3.message : String(err3)}`));
+                                // File not found in any location, will trigger case-insensitive search below
+                                filePath = path.join(this.context.root, urlPath);
+                            }
+                        }
+                        else {
+                            // File not found in any location, will trigger case-insensitive search below
+                            filePath = path.join(this.context.root, urlPath);
+                        }
+                    }
+                }
+                else {
+                    filePath = path.join(this.context.root, urlPath);
+                }
+            }
+            console.log(chalk.gray(`[node_modules] Resolving: ${url} -> ${filePath}`));
+            // File path is already resolved from above, no need to resolve again
+            // Check if file exists, if .js doesn't exist try case-insensitive match and alternatives
+            try {
+                await fs.access(filePath);
+            }
+            catch (error) {
+                console.log(chalk.yellow(`[node_modules] File not found at ${filePath}, trying case-insensitive match...`));
+                // File doesn't exist with exact case, try case-insensitive match (for Reflect.js vs reflect.js)
+                if (url.endsWith(".js")) {
+                    const dir = path.dirname(filePath);
+                    const requestedName = path.basename(filePath);
+                    try {
+                        // Resolve directory symlink (for pnpm)
+                        const resolvedDir = await fs.realpath(dir).catch(() => dir);
+                        // Check if directory exists first
+                        await fs.access(resolvedDir);
+                        const files = await fs.readdir(resolvedDir);
+                        const caseInsensitiveMatch = files.find((f) => f.toLowerCase() === requestedName.toLowerCase());
+                        if (caseInsensitiveMatch) {
+                            filePath = path.join(resolvedDir, caseInsensitiveMatch);
+                            console.log(chalk.yellow(`[node_modules] Case-insensitive match: ${requestedName} -> ${caseInsensitiveMatch}`));
+                            // Verify the file exists with the correct case
+                            await fs.access(filePath);
+                            // File found, continue to serve it below
+                        }
+                        else {
+                            throw new Error("No case-insensitive match found");
+                        }
+                    }
+                    catch {
+                        // Directory doesn't exist or no case-insensitive match, try alternatives
+                        console.log(chalk.gray(`[node_modules] Case-insensitive match failed for ${url}, trying alternatives...`));
+                        const basePath = filePath.slice(0, -3); // Remove .js
+                        const alternatives = [
+                            {
+                                ext: ".ts",
+                                handler: () => this.tsHandler.handle(url.replace(/\.js$/, ".ts"), res),
+                            },
+                            {
+                                ext: ".ui",
+                                handler: () => this.uiHandler.handle(url.replace(/\.js$/, ".ui"), res),
+                            },
+                            {
+                                ext: ".uix",
+                                handler: () => this.uixHandler.handle(url.replace(/\.js$/, ".uix"), res),
+                            },
+                        ];
+                        for (const alt of alternatives) {
+                            try {
+                                await fs.access(basePath + alt.ext);
+                                console.log(chalk.yellow(`[.js→${alt.ext}] ${url} → ${url.replace(/\.js$/, alt.ext)}`));
+                                return await alt.handler();
+                            }
+                            catch {
+                                // Try next alternative
+                            }
+                        }
+                        // No alternatives found - redirect to CDN instead of 500
+                        const cdnRedirect = this.getNodeModuleCdnRedirect(url);
+                        if (cdnRedirect) {
+                            console.log(chalk.yellow(`[node_modules] Not found locally, redirecting to CDN: ${cdnRedirect}`));
+                            res.redirect(302, cdnRedirect);
+                            return;
+                        }
+                        res.status(404).send(`Module not found: ${url}`);
+                        return;
+                    }
+                }
+                else {
+                    // Not a .js file and doesn't exist - try CDN redirect or 404
+                    const cdnRedirect = this.getNodeModuleCdnRedirect(url);
+                    if (cdnRedirect) {
+                        res.redirect(302, cdnRedirect);
+                        return;
+                    }
+                    res.status(404).send(`Module not found: ${url}`);
+                    return;
+                }
+            }
+            // File exists, process it normally
+            // For node_modules files, skip import rewriting - they should work as-is
+            // and rewriting can cause issues with package internals
+            try {
+                console.log(chalk.blue(`[node_modules] Reading file: ${filePath}`));
+                const source = await fs.readFile(filePath, "utf-8");
+                console.log(chalk.green(`[node_modules] ✓ File read successfully, length: ${source.length}`));
+                // Skip import rewriting for node_modules - serve as-is
+                // This is safer and faster for third-party packages
+                res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+                res.send(source);
+                console.log(chalk.green(`[node_modules] ✓ Served ${url} successfully`));
+            }
+            catch (error) {
+                console.error(chalk.red(`[node_modules] Error processing ${url} at ${filePath}:`));
+                console.error(chalk.red(`[node_modules] Error details:`), error);
+                if (error instanceof Error) {
+                    console.error(chalk.red(`[node_modules] Error stack:`), error.stack);
+                }
+                throw error;
+            }
+        }
+        catch (outerError) {
+            console.error(chalk.red(`[node_modules] FATAL ERROR handling ${url}:`));
+            console.error(chalk.red(`[node_modules] Error type: ${outerError instanceof Error ? outerError.constructor.name : typeof outerError}`));
+            console.error(chalk.red(`[node_modules] Error message: ${outerError instanceof Error ? outerError.message : String(outerError)}`));
+            if (outerError instanceof Error && outerError.stack) {
+                console.error(chalk.red(`[node_modules] Stack trace:`));
+                console.error(outerError.stack);
+            }
+            // Try CDN redirect before giving up with 500
+            const cdnRedirect = this.getNodeModuleCdnRedirect(url);
+            if (cdnRedirect) {
+                console.log(chalk.yellow(`[node_modules] Error handling locally, redirecting to CDN: ${cdnRedirect}`));
+                res.redirect(302, cdnRedirect);
+                return;
+            }
+            res.status(404).setHeader("Content-Type", "text/plain").send(`Module not found: ${url}. ${outerError instanceof Error ? outerError.message : String(outerError)}`);
+        }
+    }
+    /**
+     * Get CDN URL for a /node_modules/... request when the file is not found locally.
+     * Uses jsDelivr (+esm) for reliable ESM delivery; esm.sh can return 500 for some packages.
+     * e.g. /node_modules/reflect-metadata/Reflect.js -> https://cdn.jsdelivr.net/npm/reflect-metadata/+esm
+     */
+    getNodeModuleCdnRedirect(url) {
+        const prefix = "/node_modules/";
+        if (!url.startsWith(prefix))
+            return null;
+        // For nested paths like /node_modules/@scope/pkg/node_modules/dep/file.js,
+        // find the LAST node_modules segment and extract the package name from there.
+        const lastNodeModulesIdx = url.lastIndexOf("/node_modules/");
+        const after = url.slice(lastNodeModulesIdx + prefix.length);
+        if (!after)
+            return null;
+        // Extract package name: handle @scope/name and plain-name
+        let pkgName;
+        if (after.startsWith("@")) {
+            // Scoped package: need TWO path segments — @scope/name
+            const secondSlash = after.indexOf("/", after.indexOf("/") + 1);
+            pkgName = secondSlash === -1 ? after : after.slice(0, secondSlash);
+        }
+        else {
+            const firstSlash = after.indexOf("/");
+            pkgName = firstSlash === -1 ? after : after.slice(0, firstSlash);
+        }
+        if (!pkgName || pkgName === "." || pkgName === "..")
+            return null;
+        if (!shouldUseCdnFallback(pkgName))
+            return null;
+        // jsDelivr +esm serves ESM build; works for reflect-metadata and most npm packages
+        return `https://cdn.jsdelivr.net/npm/${pkgName}/+esm`;
+    }
+}

package/dist/handlers/ts-handler.d.ts

@@ -0,0 +1,11 @@
+import type { Response } from "express";
+import { BaseHandler, type HandlerContext } from "./base-handler.js";
+export declare class TSHandler extends BaseHandler {
+    constructor(context: HandlerContext);
+    /**
+     * Extract dependencies from compiled code (import paths)
+     */
+    private getDependencies;
+    handle(url: string, res: Response): Promise<void>;
+}
+//# sourceMappingURL=ts-handler.d.ts.map

package/dist/handlers/ts-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-handler.d.ts","sourceRoot":"","sources":["../../src/handlers/ts-handler.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAKxC,OAAO,EACL,WAAW,EAEX,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,SAAU,SAAQ,WAAW;gBAC5B,OAAO,EAAE,cAAc;IAInC;;OAEG;YACW,eAAe;IAwBvB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAuHxD"}

package/dist/handlers/ts-handler.js

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import chalk from "chalk";
+import { rewriteImports } from "../import-rewriter.js";
+import { compilationCache } from "../cache/compilation-cache.js";
+import { BaseHandler, setDevHeaders, } from "./base-handler.js";
+export class TSHandler extends BaseHandler {
+    constructor(context) {
+        super(context);
+    }
+    /**
+     * Extract dependencies from compiled code (import paths)
+     */
+    async getDependencies(compiled) {
+        const deps = [];
+        const importPattern = /(?:import|from|export).*['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = importPattern.exec(compiled)) !== null) {
+            const specifier = match[1];
+            // Only track absolute paths and workspace paths (not relative)
+            if (specifier.startsWith("/") || specifier.startsWith("@")) {
+                try {
+                    const resolved = await this.context.resolver.resolve(specifier, "");
+                    if (resolved && !resolved.startsWith("http")) {
+                        deps.push(resolved);
+                    }
+                }
+                catch {
+                    // Ignore resolution errors
+                }
+            }
+        }
+        return deps;
+    }
+    async handle(url, res) {
+        const filePath = await this.resolveFilePath(url);
+        console.log(chalk.gray(`[.ts] ${url}`));
+        // Check if .ts file exists, if not try .ui, .uix
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            // .ts doesn't exist, try alternatives
+            const basePath = filePath.slice(0, -3); // Remove .ts
+            const alternatives = [
+                {
+                    ext: ".ui",
+                    url: url.replace(/\.ts$/, ".ui"),
+                },
+                {
+                    ext: ".uix",
+                    url: url.replace(/\.ts$/, ".uix"),
+                },
+            ];
+            for (const alt of alternatives) {
+                try {
+                    const altPath = basePath + alt.ext;
+                    await fs.access(altPath);
+                    console.log(chalk.yellow(`[.ts→${alt.ext}] ${url} → ${alt.url} (file: ${altPath})`));
+                    // Import and use the appropriate handler
+                    if (alt.ext === ".ui") {
+                        const { UIHandler } = await import("./ui-handler.js");
+                        const uiHandler = new UIHandler(this.context);
+                        return await uiHandler.handle(alt.url, res);
+                    }
+                    else if (alt.ext === ".uix") {
+                        const { UIXHandler } = await import("./uix-handler.js");
+                        const uixHandler = new UIXHandler(this.context);
+                        return await uixHandler.handle(alt.url, res);
+                    }
+                }
+                catch {
+                    // Try next alternative
+                    console.log(chalk.gray(`[.ts→${alt.ext}] ${basePath + alt.ext} not found, trying next...`));
+                }
+            }
+            // No alternatives found, throw error
+            console.error(chalk.red(`[.ts] File not found: ${filePath} (and no alternatives found)`));
+            res.status(404).send(`File not found: ${url}`);
+            return;
+        }
+        // Check cache first
+        const cached = await compilationCache.get(filePath, (compiled) => this.getDependencies(compiled));
+        if (cached) {
+            setDevHeaders(res);
+            res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+            res.send(cached);
+            return;
+        }
+        // Cache miss - compile
+        const source = await fs.readFile(filePath, "utf-8");
+        // Use esbuild for fast TS transformation
+        const esbuild = await import("esbuild");
+        const result = await esbuild.transform(source, {
+            loader: "ts",
+            format: "esm",
+            target: "esnext",
+            sourcefile: filePath,
+        });
+        const rewritten = await rewriteImports(result.code, filePath, this.context.resolver);
+        // Store in cache (use result.code as "compiled" for dependency tracking)
+        await compilationCache.set(filePath, result.code, rewritten, (compiled) => this.getDependencies(compiled));
+        // Debug: Check for bare imports after rewriting
+        const bareImportPattern = /(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/;
+        if (bareImportPattern.test(rewritten)) {
+            console.log(chalk.red(`[.ts] ERROR: Bare imports still present after rewriting: ${url}`));
+            const matches = Array.from(rewritten.matchAll(/(?:import|from|export).*['"](@[^'"]+\/[^'"]+)(?!\/)[^'"]*['"]/g));
+            for (const match of matches.slice(0, 3)) {
+                console.log(chalk.red(`[.ts] Unresolved import: ${match[1]}`));
+            }
+        }
+        setDevHeaders(res);
+        res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+        res.send(rewritten);
+    }
+}

package/dist/handlers/ui-handler.d.ts

@@ -0,0 +1,12 @@
+import type { Response } from "express";
+import { BaseHandler, type HandlerContext } from "./base-handler.js";
+export declare class UIHandler extends BaseHandler {
+    private compiler;
+    constructor(context: HandlerContext);
+    /**
+     * Extract dependencies from compiled code (import paths)
+     */
+    private getDependencies;
+    handle(url: string, res: Response): Promise<void>;
+}
+//# sourceMappingURL=ui-handler.d.ts.map

package/dist/handlers/ui-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-handler.d.ts","sourceRoot":"","sources":["../../src/handlers/ui-handler.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAMxC,OAAO,EACL,WAAW,EAEX,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,SAAU,SAAQ,WAAW;IACxC,OAAO,CAAC,QAAQ,CAAoB;gBAExB,OAAO,EAAE,cAAc;IAInC;;OAEG;YACW,eAAe;IAyBvB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAwLxD"}