@swissjs/swite 0.3.0

package/dist/cache/compilation-cache.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Compilation cache with dependency tracking
+ * Invalidates when source file or dependencies change
+ */
+export declare class CompilationCache {
+    private cache;
+    private readonly maxSize;
+    /**
+     * Get cached compilation result if valid
+     */
+    get(filePath: string, getDependencies: (compiled: string) => Promise<string[]>): Promise<string | null>;
+    /**
+     * Store compilation result in cache
+     */
+    set(filePath: string, compiled: string, rewritten: string, getDependencies: (compiled: string) => Promise<string[]>): Promise<void>;
+    /**
+     * Clear cache for a specific file
+     */
+    clear(filePath: string): void;
+    /**
+     * Clear entire cache
+     */
+    clearAll(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+    };
+}
+export declare const compilationCache: CompilationCache;
+//# sourceMappingURL=compilation-cache.d.ts.map

package/dist/cache/compilation-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilation-cache.d.ts","sourceRoot":"","sources":["../../src/cache/compilation-cache.ts"],"names":[],"mappings":"AAmBA;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAEhC;;OAEG;IACG,GAAG,CACP,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,GACvD,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IA+EzB;;OAEG;IACG,GAAG,CACP,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,GACvD,OAAO,CAAC,IAAI,CAAC;IAiChB;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAI7B;;OAEG;IACH,QAAQ,IAAI,IAAI;IAKhB;;OAEG;IACH,QAAQ,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAM9C;AAGD,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}

package/dist/cache/compilation-cache.js

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Compilation Cache for .ui, .uix, .ts files
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+/**
+ * Compilation cache with dependency tracking
+ * Invalidates when source file or dependencies change
+ */
+export class CompilationCache {
+    constructor() {
+        this.cache = new Map();
+        this.maxSize = 1000; // Prevent memory leaks
+    }
+    /**
+     * Get cached compilation result if valid
+     */
+    async get(filePath, getDependencies) {
+        const entry = this.cache.get(filePath);
+        if (!entry) {
+            return null;
+        }
+        // Check if source file changed
+        try {
+            const stats = await fs.stat(filePath);
+            if (stats.mtimeMs !== entry.mtime) {
+                console.log(chalk.yellow(`[Cache] Invalidating ${filePath}: file modified`));
+                this.cache.delete(filePath);
+                return null;
+            }
+        }
+        catch (error) {
+            // File deleted or inaccessible
+            this.cache.delete(filePath);
+            return null;
+        }
+        // Check if dependencies changed
+        const currentDeps = await getDependencies(entry.compiled);
+        const depsChanged = currentDeps.length !== entry.dependencies.length ||
+            currentDeps.some((dep, i) => dep !== entry.dependencies[i]);
+        if (depsChanged) {
+            console.log(chalk.yellow(`[Cache] Invalidating ${filePath}: dependencies changed`));
+            this.cache.delete(filePath);
+            return null;
+        }
+        // Check if dependencies still exist and haven't changed
+        for (const dep of entry.dependencies) {
+            try {
+                const depStats = await fs.stat(dep);
+                // If dependency was modified after cache entry, invalidate
+                if (depStats.mtimeMs > entry.timestamp) {
+                    console.log(chalk.yellow(`[Cache] Invalidating ${filePath}: dependency ${dep} modified`));
+                    this.cache.delete(filePath);
+                    return null;
+                }
+            }
+            catch {
+                // Dependency deleted or inaccessible
+                console.log(chalk.yellow(`[Cache] Invalidating ${filePath}: dependency ${dep} not found`));
+                this.cache.delete(filePath);
+                return null;
+            }
+        }
+        // Check if cached content has stale CDN URLs (from before import rewriter fix)
+        if (entry.rewritten.includes("cdn.jsdelivr.net") || entry.rewritten.includes("esm.sh")) {
+            console.log(chalk.yellow(`[Cache] Invalidating ${filePath}: contains stale CDN URLs`));
+            this.cache.delete(filePath);
+            return null;
+        }
+        console.log(chalk.green(`[Cache] ✅ Cache hit for ${filePath}`));
+        return entry.rewritten;
+    }
+    /**
+     * Store compilation result in cache
+     */
+    async set(filePath, compiled, rewritten, getDependencies) {
+        // Enforce max size (LRU eviction)
+        if (this.cache.size >= this.maxSize) {
+            // Remove oldest entry (simple FIFO)
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+                console.log(chalk.gray(`[Cache] Evicted ${firstKey} (cache full)`));
+            }
+        }
+        try {
+            const stats = await fs.stat(filePath);
+            const dependencies = await getDependencies(compiled);
+            this.cache.set(filePath, {
+                compiled,
+                rewritten,
+                mtime: stats.mtimeMs,
+                dependencies,
+                timestamp: Date.now(),
+            });
+            console.log(chalk.green(`[Cache] ✅ Cached ${filePath} (${dependencies.length} deps)`));
+        }
+        catch (error) {
+            console.warn(chalk.yellow(`[Cache] Failed to cache ${filePath}:`, error));
+        }
+    }
+    /**
+     * Clear cache for a specific file
+     */
+    clear(filePath) {
+        this.cache.delete(filePath);
+    }
+    /**
+     * Clear entire cache
+     */
+    clearAll() {
+        this.cache.clear();
+        console.log(chalk.gray("[Cache] Cleared all entries"));
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+        };
+    }
+}
+// Singleton instance
+export const compilationCache = new CompilationCache();

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import chalk from "chalk";
+import { SwiteServer } from "./server.js";
+import { loadUserConfig } from "./config-loader.js";
+import { startPythonDevService, stopPythonDevService, } from "./dev/pythonDevManager.js";
+import { setProductionMode } from "./proxy/proxyToPython.js";
+const [, , command, ...args] = process.argv;
+const root = resolve(process.cwd());
+async function dev() {
+    const config = await loadUserConfig(root);
+    const python = config.services?.python;
+    if (python?.autoStart) {
+        await startPythonDevService(python, root);
+    }
+    // Relay SIGINT: kill Python, then exit cleanly
+    process.on("SIGINT", () => {
+        stopPythonDevService();
+        process.exit(0);
+    });
+    // Ensure Python is killed if Node crashes
+    process.on("exit", () => {
+        stopPythonDevService();
+    });
+    const server = new SwiteServer({
+        root,
+        port: config.server?.port ?? 3000,
+        host: config.server?.host ?? "localhost",
+        publicDir: "public",
+        open: false,
+    });
+    await server.start();
+}
+async function start() {
+    const config = await loadUserConfig(root);
+    const python = config.services?.python;
+    setProductionMode();
+    if (python && !process.env["PYTHON_SERVICE_URL"]) {
+        console.warn(chalk.yellow("[swite] WARNING: services.python is configured but PYTHON_SERVICE_URL is not set.\n" +
+            "        Proxy calls to Python will fail. Set PYTHON_SERVICE_URL to the running service URL."));
+    }
+    const server = new SwiteServer({
+        root,
+        port: config.server?.port ?? 3000,
+        host: config.server?.host ?? "localhost",
+        publicDir: "public",
+        open: false,
+    });
+    await server.start();
+}
+async function build() {
+    const { SwiteBuilder } = await import("./builder.js");
+    const config = await loadUserConfig(root);
+    const builder = new SwiteBuilder({
+        root,
+        entry: resolve(root, "src/index.ui"),
+        outDir: resolve(root, "dist"),
+    });
+    await builder.build();
+}
+switch (command) {
+    case "dev":
+        dev().catch((err) => {
+            console.error(chalk.red("[swite] fatal:"), err);
+            stopPythonDevService();
+            process.exit(1);
+        });
+        break;
+    case "start":
+        start().catch((err) => {
+            console.error(chalk.red("[swite] fatal:"), err);
+            process.exit(1);
+        });
+        break;
+    case "build":
+        build().catch((err) => {
+            console.error(chalk.red("[swite] build failed:"), err);
+            process.exit(1);
+        });
+        break;
+    default:
+        console.error(chalk.red(`[swite] unknown command: ${command ?? "(none)"}`));
+        console.error("Usage: swite <dev|build|start>");
+        process.exit(1);
+}

package/dist/config-loader.d.ts

@@ -0,0 +1,8 @@
+import type { SwiteUserConfig } from "./config.js";
+/**
+ * Load swiss.config.ts from the project root.
+ * Transpiles to a temp ESM file via esbuild, imports it, then cleans up.
+ * Returns empty config if no config file found.
+ */
+export declare function loadUserConfig(root: string): Promise<SwiteUserConfig>;
+//# sourceMappingURL=config-loader.d.ts.map

package/dist/config-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../src/config-loader.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAgC3E"}

package/dist/config-loader.js

@@ -0,0 +1,40 @@
+import { build } from "esbuild";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
+/**
+ * Load swiss.config.ts from the project root.
+ * Transpiles to a temp ESM file via esbuild, imports it, then cleans up.
+ * Returns empty config if no config file found.
+ */
+export async function loadUserConfig(root) {
+    const tsConfig = join(root, "swiss.config.ts");
+    const jsConfig = join(root, "swiss.config.js");
+    const configPath = existsSync(tsConfig)
+        ? tsConfig
+        : existsSync(jsConfig)
+            ? jsConfig
+            : null;
+    if (!configPath) {
+        return {};
+    }
+    const tempDir = await mkdtemp(join(tmpdir(), "swite-config-"));
+    const outFile = join(tempDir, "swiss.config.mjs");
+    try {
+        await build({
+            entryPoints: [configPath],
+            bundle: false,
+            format: "esm",
+            outfile: outFile,
+            platform: "node",
+            logLevel: "silent",
+        });
+        const mod = await import(pathToFileURL(outFile).href);
+        return (mod.default ?? {});
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,29 @@
+export interface PythonServiceConfig {
+    /** Path to the Python entry file, relative to project root */
+    entry: string;
+    /** Port the Python service listens on */
+    port: number;
+    /** Whether swite dev should spawn the Python process automatically */
+    autoStart: boolean;
+    /** Health check endpoint polled before Node server starts */
+    healthCheck: string;
+    /** Additional environment variables passed to the Python process */
+    env?: Record<string, string>;
+}
+export interface ServicesConfig {
+    python?: PythonServiceConfig;
+}
+export interface ServerConfig {
+    port?: number;
+    host?: string;
+}
+export interface SwiteUserConfig {
+    server?: ServerConfig;
+    services?: ServicesConfig;
+}
+/**
+ * Define swite configuration with full TypeScript validation.
+ * Unknown fields are rejected at compile time.
+ */
+export declare function defineConfig(config: SwiteUserConfig): SwiteUserConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,SAAS,EAAE,OAAO,CAAC;IACnB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,mBAAmB,CAAC;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAErE"}

package/dist/config.js

@@ -0,0 +1,7 @@
+/**
+ * Define swite configuration with full TypeScript validation.
+ * Unknown fields are rejected at compile time.
+ */
+export function defineConfig(config) {
+    return config;
+}

package/dist/dev/pythonDevManager.d.ts

@@ -0,0 +1,12 @@
+import type { PythonServiceConfig } from "../config.js";
+/**
+ * Spawn the Python service and wait until its health endpoint responds 200.
+ * Streams stdout/stderr line-buffered, prefixed with [python].
+ * Also calls initPythonProxy so proxyToPython works without PYTHON_SERVICE_URL.
+ */
+export declare function startPythonDevService(config: PythonServiceConfig, projectRoot: string): Promise<void>;
+/**
+ * Send SIGTERM to the Python child process if running.
+ */
+export declare function stopPythonDevService(): void;
+//# sourceMappingURL=pythonDevManager.d.ts.map

package/dist/dev/pythonDevManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pythonDevManager.d.ts","sourceRoot":"","sources":["../../src/dev/pythonDevManager.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAQxD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,mBAAmB,EAC3B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAuCf;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAM3C"}

package/dist/dev/pythonDevManager.js

@@ -0,0 +1,85 @@
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+import chalk from "chalk";
+import { initPythonProxy } from "../proxy/proxyToPython.js";
+const POLL_INTERVAL_MS = 500;
+const HEALTH_TIMEOUT_MS = 15000;
+const BACKOFF_THRESHOLD = 5;
+let _child = null;
+/**
+ * Spawn the Python service and wait until its health endpoint responds 200.
+ * Streams stdout/stderr line-buffered, prefixed with [python].
+ * Also calls initPythonProxy so proxyToPython works without PYTHON_SERVICE_URL.
+ */
+export async function startPythonDevService(config, projectRoot) {
+    const entryPath = resolve(projectRoot, config.entry);
+    const healthUrl = `http://localhost:${config.port}${config.healthCheck}`;
+    const pythonCmd = process.platform === "win32" ? "python" : "python3";
+    console.log(chalk.blue(`[python] spawning: ${pythonCmd} ${config.entry} (port ${config.port})`));
+    const env = {
+        ...process.env,
+        ...config.env,
+        PORT: String(config.port),
+    };
+    _child = spawn(pythonCmd, [entryPath], {
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    pipeLines(_child.stdout, chalk.cyan("[python] "));
+    pipeLines(_child.stderr, chalk.yellow("[python] "));
+    _child.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+            console.error(chalk.red(`\n[python] process exited with code ${code} — Node server continuing in degraded mode\n`));
+        }
+        _child = null;
+    });
+    initPythonProxy(config);
+    await pollHealth(healthUrl);
+    console.log(chalk.green(`[python] healthy — ${healthUrl}`));
+}
+/**
+ * Send SIGTERM to the Python child process if running.
+ */
+export function stopPythonDevService() {
+    if (_child) {
+        console.log(chalk.gray("[python] shutting down..."));
+        _child.kill("SIGTERM");
+        _child = null;
+    }
+}
+// ── internals ────────────────────────────────────────────────────────────────
+function pipeLines(stream, prefix) {
+    if (!stream)
+        return;
+    let buffer = "";
+    stream.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line.trim())
+                process.stdout.write(prefix + line + "\n");
+        }
+    });
+}
+async function pollHealth(url) {
+    const deadline = Date.now() + HEALTH_TIMEOUT_MS;
+    let attempt = 0;
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(url, { signal: AbortSignal.timeout(1000) });
+            if (res.ok)
+                return;
+        }
+        catch {
+            // not ready yet
+        }
+        attempt++;
+        const delay = attempt <= BACKOFF_THRESHOLD
+            ? POLL_INTERVAL_MS
+            : Math.min(POLL_INTERVAL_MS * Math.pow(2, attempt - BACKOFF_THRESHOLD), 3000);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    stopPythonDevService();
+    throw new Error(`[python] health check timed out after ${HEALTH_TIMEOUT_MS}ms — is ${url} reachable?`);
+}

package/dist/env.d.ts

@@ -0,0 +1,19 @@
+export interface EnvConfig {
+    mode?: "development" | "production";
+    prefix?: string;
+}
+/**
+ * Load environment variables from .env files
+ * Supports .env, .env.local, .env.[mode], .env.[mode].local
+ */
+export declare function loadEnv(root: string, mode?: string): Record<string, string>;
+/**
+ * Generate import.meta.env replacement code
+ * Injects environment variables as a module that can be imported
+ */
+export declare function generateEnvModule(env: Record<string, string>, prefix?: string): string;
+/**
+ * Inject import.meta.env polyfill into code
+ */
+export declare function injectEnvPolyfill(code: string): string;
+//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,EAAE,aAAa,GAAG,YAAY,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,MAAsB,GAC3B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAwBxB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,MAAM,GAAE,MAAiB,GACxB,MAAM,CAwCR;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqCtD"}

package/dist/env.js

@@ -0,0 +1,112 @@
+/*
+ * Environment Variable Support for SWITE
+ * Provides import.meta.env replacement for SWITE
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Load environment variables from .env files
+ * Supports .env, .env.local, .env.[mode], .env.[mode].local
+ */
+export function loadEnv(root, mode = "development") {
+    const env = {};
+    const envFiles = [`.env.${mode}.local`, `.env.${mode}`, `.env.local`, `.env`];
+    for (const file of envFiles) {
+        const envPath = join(root, file);
+        if (existsSync(envPath)) {
+            const content = readFileSync(envPath, "utf-8");
+            for (const line of content.split("\n")) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith("#")) {
+                    const match = trimmed.match(/^([^=]+)=(.*)$/);
+                    if (match) {
+                        const [, key, value] = match;
+                        // Remove quotes if present
+                        const cleanValue = value.replace(/^["']|["']$/g, "");
+                        env[key.trim()] = cleanValue;
+                    }
+                }
+            }
+        }
+    }
+    return env;
+}
+/**
+ * Generate import.meta.env replacement code
+ * Injects environment variables as a module that can be imported
+ */
+export function generateEnvModule(env, prefix = "SWITE_") {
+    // Filter env vars by prefix and expose them
+    const switeEnv = {};
+    const publicEnv = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (key.startsWith(prefix)) {
+            // Remove prefix for SWITE_ prefixed vars
+            const cleanKey = key.slice(prefix.length);
+            switeEnv[cleanKey] = value;
+            publicEnv[key] = value;
+        }
+        else if (key.startsWith("PUBLIC_")) {
+            // PUBLIC_ vars are always exposed
+            publicEnv[key] = value;
+        }
+    }
+    // Build env object with all variables
+    const allEnvEntries = [
+        ...Object.entries(switeEnv).map(([key, value]) => [key, value]),
+        ...Object.entries(publicEnv).map(([key, value]) => [key, value]),
+        ["MODE", process.env.NODE_ENV || "development"],
+        ["DEV", process.env.NODE_ENV !== "production"],
+        ["PROD", process.env.NODE_ENV === "production"],
+    ];
+    return `
+// SWITE Environment Variables
+// Generated at runtime - do not edit manually
+export const env = {
+  ${allEnvEntries
+        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+        .join(",\n  ")},
+};
+
+// For import.meta.env compatibility
+if (typeof globalThis !== 'undefined') {
+  globalThis.__swite_env__ = env;
+}
+`;
+}
+/**
+ * Inject import.meta.env polyfill into code
+ */
+export function injectEnvPolyfill(code) {
+    // Check if import.meta.env is used
+    if (!code.includes("import.meta.env") && !code.includes("__swite_env__")) {
+        return code;
+    }
+    // Inject polyfill at the top - load env module first
+    const polyfill = `
+// SWITE import.meta.env polyfill
+import { env as switeEnv } from '/__swite_env';
+if (typeof globalThis !== 'undefined') {
+  globalThis.__swite_env__ = switeEnv;
+}
+if (typeof import !== 'undefined' && import.meta) {
+  import.meta.env = switeEnv;
+} else if (typeof globalThis !== 'undefined') {
+  // Fallback for environments without import.meta
+  if (!globalThis.import) {
+    globalThis.import = { meta: {} };
+  }
+  if (!globalThis.import.meta) {
+    globalThis.import.meta = {};
+  }
+  globalThis.import.meta.env = switeEnv;
+}
+`;
+    // Find the first import statement or start of file
+    const firstImport = code.match(/^import\s+/m);
+    if (firstImport) {
+        const insertIndex = firstImport.index;
+        return (code.slice(0, insertIndex) + polyfill + "\n" + code.slice(insertIndex));
+    }
+    return polyfill + "\n" + code;
+}

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

@@ -0,0 +1,21 @@
+import type { Response } from "express";
+import { ModuleResolver } from "../resolver.js";
+export interface HandlerContext {
+    resolver: ModuleResolver;
+    root: string;
+    workspaceRoot: string | null;
+}
+/**
+ * Set cache-busting headers for development
+ */
+export declare function setDevHeaders(res: Response): void;
+/**
+ * Base handler utilities
+ */
+export declare class BaseHandler {
+    protected context: HandlerContext;
+    constructor(context: HandlerContext);
+    protected resolveFilePath(url: string): Promise<string>;
+    protected fileExists(filePath: string): Promise<boolean>;
+}
+//# sourceMappingURL=base-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"base-handler.d.ts","sourceRoot":"","sources":["../../src/handlers/base-handler.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGhD,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,cAAc,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAMjD;AAED;;GAEG;AACH,qBAAa,WAAW;IACV,SAAS,CAAC,OAAO,EAAE,cAAc;gBAAvB,OAAO,EAAE,cAAc;cAE7B,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;cAI7C,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAQ/D"}

package/dist/handlers/base-handler.js

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2024 Themba Mzumara
+ * SWITE - SWISS Development Server
+ * Licensed under the MIT License.
+ */
+import { promises as fs } from "node:fs";
+import { ModuleResolver } from "../resolver.js";
+import { resolveFilePath } from "../utils/file-path-resolver.js";
+/**
+ * Set cache-busting headers for development
+ */
+export function setDevHeaders(res) {
+    // Prevent all caching during development
+    res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+    res.setHeader("Pragma", "no-cache");
+    res.setHeader("Expires", "0");
+    res.setHeader("Surrogate-Control", "no-store");
+}
+/**
+ * Base handler utilities
+ */
+export class BaseHandler {
+    constructor(context) {
+        this.context = context;
+    }
+    async resolveFilePath(url) {
+        return resolveFilePath(url, this.context.root, this.context.workspaceRoot);
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

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

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