@coherent.js/runtime 1.0.0-beta.2

package/dist/coherent-universal.js

@@ -0,0 +1,3254 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/runtimes/browser.js
+var browser_exports = {};
+__export(browser_exports, {
+  BrowserRuntime: () => BrowserRuntime
+});
+import { render, withState, memo } from "@coherent.js/core";
+import { hydrate, autoHydrate, makeHydratable } from "@coherent.js/client";
+import { integrateWithWebComponents, defineCoherentElement } from "@coherent.js/web-components";
+var BrowserRuntime;
+var init_browser = __esm({
+  "src/runtimes/browser.js"() {
+    "use strict";
+    BrowserRuntime = class _BrowserRuntime {
+      constructor(options = {}) {
+        this.options = {
+          autoHydrate: true,
+          enableWebComponents: true,
+          enablePerformanceMonitoring: true,
+          routingMode: "hash",
+          // 'hash', 'history', or 'memory'
+          ...options
+        };
+        this.componentRegistry = /* @__PURE__ */ new Map();
+        this.routeRegistry = /* @__PURE__ */ new Map();
+        this.currentRoute = null;
+        this.isInitialized = false;
+        this.renderMetrics = [];
+        this.startTime = Date.now();
+      }
+      async initialize() {
+        if (this.isInitialized) return;
+        if (document.readyState === "loading") {
+          await new Promise((resolve) => {
+            document.addEventListener("DOMContentLoaded", resolve);
+          });
+        }
+        if (this.options.enableWebComponents) {
+          await this.initializeWebComponents();
+        }
+        if (this.options.routingMode !== "none") {
+          this.initializeRouting();
+        }
+        if (this.options.autoHydrate) {
+          await this.autoHydrate();
+        }
+        if (this.options.enablePerformanceMonitoring) {
+          this.initializePerformanceMonitoring();
+        }
+        this.isInitialized = true;
+      }
+      async initializeWebComponents() {
+        try {
+          await integrateWithWebComponents(
+            Object.fromEntries(this.componentRegistry),
+            this.options.webComponents || {}
+          );
+        } catch (error) {
+          console.warn("Failed to initialize Web Components:", error);
+        }
+      }
+      initializeRouting() {
+        const handleRouteChange = () => {
+          const newRoute = this.getCurrentRoute();
+          if (newRoute !== this.currentRoute) {
+            this.handleRouteChange(this.currentRoute, newRoute);
+            this.currentRoute = newRoute;
+          }
+        };
+        if (this.options.routingMode === "hash") {
+          window.addEventListener("hashchange", handleRouteChange);
+        } else if (this.options.routingMode === "history") {
+          window.addEventListener("popstate", handleRouteChange);
+        }
+        this.currentRoute = this.getCurrentRoute();
+        handleRouteChange();
+      }
+      getCurrentRoute() {
+        if (this.options.routingMode === "hash") {
+          return window.location.hash.slice(1) || "/";
+        } else if (this.options.routingMode === "history") {
+          return window.location.pathname;
+        }
+        return "/";
+      }
+      handleRouteChange(oldRoute, newRoute) {
+        const handler = this.routeRegistry.get(newRoute) || this.routeRegistry.get("*");
+        if (handler) {
+          try {
+            handler({ route: newRoute, oldRoute, params: this.parseRouteParams(newRoute) });
+          } catch (error) {
+            console.error("Route handler error:", error);
+          }
+        }
+      }
+      parseRouteParams(route) {
+        const params = {};
+        const parts = route.split("/").filter(Boolean);
+        parts.forEach((part, index) => {
+          if (part.startsWith(":")) {
+            const key = part.slice(1);
+            const value = parts[index];
+            if (value && !value.startsWith(":")) {
+              params[key] = value;
+            }
+          }
+        });
+        return params;
+      }
+      initializePerformanceMonitoring() {
+        if (typeof window === "undefined" || typeof window.PerformanceObserver === "undefined") return;
+        const observer = new window.PerformanceObserver((list) => {
+          for (const entry of list.getEntries()) {
+            if (entry.name.includes("coherent")) {
+              this.renderMetrics.push({
+                name: entry.name,
+                duration: entry.duration,
+                startTime: entry.startTime,
+                timestamp: Date.now()
+              });
+            }
+          }
+        });
+        try {
+          observer.observe({ entryTypes: ["measure", "mark"] });
+        } catch (error) {
+          console.warn("Performance monitoring not available:", error);
+        }
+        setInterval(() => {
+          const cutoff = Date.now() - 3e5;
+          this.renderMetrics = this.renderMetrics.filter((m) => m.timestamp > cutoff);
+        }, 6e4);
+      }
+      // Component management
+      registerComponent(name, component, options = {}) {
+        const hydratableComponent = makeHydratable(component, {
+          componentName: name,
+          ...options
+        });
+        this.componentRegistry.set(name, hydratableComponent);
+        if (this.options.enableWebComponents && this.isInitialized) {
+          try {
+            defineCoherentElement(name, hydratableComponent, options);
+          } catch (error) {
+            console.warn(`Failed to register Web Component ${name}:`, error);
+          }
+        }
+        return hydratableComponent;
+      }
+      getComponent(name) {
+        return this.componentRegistry.get(name);
+      }
+      // Routing
+      addRoute(path, handler) {
+        this.routeRegistry.set(path, handler);
+      }
+      navigate(path) {
+        if (this.options.routingMode === "hash") {
+          window.location.hash = path;
+        } else if (this.options.routingMode === "history") {
+          window.history.pushState({}, "", path);
+          this.handleRouteChange(this.currentRoute, path);
+          this.currentRoute = path;
+        }
+      }
+      // Rendering
+      async render(component, props = {}, target = null) {
+        const startMark = `coherent-render-start-${Date.now()}`;
+        const endMark = `coherent-render-end-${Date.now()}`;
+        try {
+          performance.mark(startMark);
+          const resolvedComponent = typeof component === "string" ? this.getComponent(component) : component;
+          if (!resolvedComponent) {
+            throw new Error(`Component not found: ${component}`);
+          }
+          const vdom = resolvedComponent(props);
+          const html = render(vdom);
+          let targetElement = target;
+          if (typeof target === "string") {
+            targetElement = document.querySelector(target);
+          }
+          if (!targetElement) {
+            targetElement = document.body;
+          }
+          targetElement.innerHTML = html;
+          const instance = await hydrate(targetElement.firstElementChild, resolvedComponent, props);
+          performance.mark(endMark);
+          performance.measure(`coherent-render-${resolvedComponent.name || "anonymous"}`, startMark, endMark);
+          return instance;
+        } catch (error) {
+          performance.mark(endMark);
+          console.error("Render error:", error);
+          throw error;
+        }
+      }
+      // Create a complete app
+      async createApp(_options = {}) {
+        await this.initialize();
+        return {
+          // Component management
+          component: (name, component, opts) => this.registerComponent(name, component, opts),
+          // Routing
+          route: (path, handler) => this.addRoute(path, handler),
+          navigate: (path) => this.navigate(path),
+          // Rendering
+          render: (component, props, target) => this.render(component, props, target),
+          // State management
+          state: withState,
+          memo,
+          // Hydration
+          hydrate: (element, component, props) => hydrate(element, component, props),
+          // Utilities
+          getRuntime: () => this,
+          getCurrentRoute: () => this.currentRoute,
+          getPerformanceMetrics: () => [...this.renderMetrics],
+          // Lifecycle
+          mount: async (component, target = "#app") => {
+            const app = await this.render(component, {}, target);
+            return app;
+          },
+          unmount: (target = "#app") => {
+            const element = typeof target === "string" ? document.querySelector(target) : target;
+            if (element) {
+              element.innerHTML = "";
+            }
+          }
+        };
+      }
+      // Auto-hydration
+      async autoHydrate() {
+        const componentMap = Object.fromEntries(this.componentRegistry);
+        await autoHydrate(componentMap);
+      }
+      // Static methods for quick setup
+      static async createQuickApp(components = {}, options = {}) {
+        const runtime = new _BrowserRuntime(options);
+        Object.entries(components).forEach(([name, component]) => {
+          runtime.registerComponent(name, component);
+        });
+        return await runtime.createApp(options);
+      }
+      static async renderToPage(component, props = {}, target = "#app") {
+        const runtime = new _BrowserRuntime({ autoHydrate: false });
+        await runtime.initialize();
+        return await runtime.render(component, props, target);
+      }
+      // Performance utilities
+      getPerformanceReport() {
+        const now = Date.now();
+        const uptime = now - this.startTime;
+        const recentMetrics = this.renderMetrics.filter((m) => m.timestamp >= now - 6e4);
+        const averageRenderTime = recentMetrics.length > 0 ? recentMetrics.reduce((sum, m) => sum + m.duration, 0) / recentMetrics.length : 0;
+        return {
+          uptime,
+          totalRenders: this.renderMetrics.length,
+          recentRenders: recentMetrics.length,
+          averageRenderTime: Math.round(averageRenderTime * 100) / 100,
+          registeredComponents: this.componentRegistry.size,
+          registeredRoutes: this.routeRegistry.size,
+          currentRoute: this.currentRoute,
+          memoryUsage: this.getMemoryUsage()
+        };
+      }
+      getMemoryUsage() {
+        if (typeof performance !== "undefined" && performance.memory) {
+          return {
+            used: Math.round(performance.memory.usedJSHeapSize / 1024 / 1024),
+            total: Math.round(performance.memory.totalJSHeapSize / 1024 / 1024),
+            limit: Math.round(performance.memory.jsHeapSizeLimit / 1024 / 1024)
+          };
+        }
+        return null;
+      }
+      // Development utilities
+      debug() {
+        return {
+          runtime: this,
+          components: Array.from(this.componentRegistry.keys()),
+          routes: Array.from(this.routeRegistry.keys()),
+          performance: this.getPerformanceReport(),
+          options: this.options
+        };
+      }
+    };
+  }
+});
+
+// src/runtimes/edge.js
+var edge_exports = {};
+__export(edge_exports, {
+  EdgeRuntime: () => EdgeRuntime2,
+  createBunHandler: () => createBunHandler,
+  createCloudflareWorker: () => createCloudflareWorker,
+  createDenoHandler: () => createDenoHandler
+});
+import { render as render2 } from "@coherent.js/core";
+function createCloudflareWorker(app) {
+  return {
+    async fetch(request, _env, _ctx) {
+      return await app.fetch(request);
+    }
+  };
+}
+function createDenoHandler(app) {
+  return async (request) => {
+    return await app.fetch(request);
+  };
+}
+function createBunHandler(app) {
+  return {
+    async fetch(request) {
+      return await app.fetch(request);
+    },
+    port: 3e3
+  };
+}
+var EdgeRuntime2;
+var init_edge = __esm({
+  "src/runtimes/edge.js"() {
+    "use strict";
+    EdgeRuntime2 = class _EdgeRuntime {
+      constructor(options = {}) {
+        this.options = {
+          caching: true,
+          streaming: false,
+          headers: {
+            "Content-Type": "text/html; charset=utf-8",
+            "Cache-Control": "public, max-age=3600",
+            ...options.headers
+          },
+          ...options
+        };
+        this.componentRegistry = /* @__PURE__ */ new Map();
+        this.routeRegistry = /* @__PURE__ */ new Map();
+        this.cache = /* @__PURE__ */ new Map();
+        this.middleware = [];
+        this.renderCount = 0;
+        if (this.options.caching) {
+          this.initializeCacheCleanup();
+        }
+      }
+      initializeCacheCleanup() {
+        if (typeof setInterval !== "undefined") {
+          setInterval(() => {
+            if (this.cache.size > 1e3) {
+              const entries = Array.from(this.cache.entries());
+              const toDelete = entries.slice(0, entries.length - 500);
+              toDelete.forEach(([key]) => this.cache.delete(key));
+            }
+          }, 3e5);
+        }
+      }
+      // Component management
+      registerComponent(name, component) {
+        this.componentRegistry.set(name, component);
+        return component;
+      }
+      getComponent(name) {
+        return this.componentRegistry.get(name);
+      }
+      // Route management
+      addRoute(pattern, handler) {
+        this.routeRegistry.set(pattern, handler);
+      }
+      matchRoute(pathname) {
+        for (const [pattern, handler] of this.routeRegistry) {
+          const match = this.matchPattern(pattern, pathname);
+          if (match) {
+            return { handler, params: match.params };
+          }
+        }
+        return null;
+      }
+      matchPattern(pattern, pathname) {
+        if (pattern === "*" || pattern === pathname) {
+          return { params: {} };
+        }
+        const patternParts = pattern.split("/").filter(Boolean);
+        const pathParts = pathname.split("/").filter(Boolean);
+        if (patternParts.length !== pathParts.length) {
+          return null;
+        }
+        const params = {};
+        for (let i = 0; i < patternParts.length; i++) {
+          const patternPart = patternParts[i];
+          const pathPart = pathParts[i];
+          if (patternPart.startsWith(":")) {
+            params[patternPart.slice(1)] = pathPart;
+          } else if (patternPart !== pathPart) {
+            return null;
+          }
+        }
+        return { params };
+      }
+      // Rendering
+      async renderComponent(component, props = {}, options = {}) {
+        const _startTime = Date.now();
+        try {
+          const resolvedComponent = typeof component === "string" ? this.getComponent(component) : component;
+          if (!resolvedComponent) {
+            throw new Error(`Component not found: ${component}`);
+          }
+          const cacheKey = this.generateCacheKey(resolvedComponent, props);
+          if (this.options.caching && this.cache.has(cacheKey)) {
+            const cached = this.cache.get(cacheKey);
+            if (Date.now() - cached.timestamp < (options.cacheMaxAge || 3e5)) {
+              return cached.html;
+            }
+            this.cache.delete(cacheKey);
+          }
+          const vdom = resolvedComponent(props);
+          const html = render2(vdom);
+          if (this.options.caching && options.cacheable !== false) {
+            this.cache.set(cacheKey, {
+              html,
+              timestamp: Date.now()
+            });
+          }
+          this.renderCount++;
+          return html;
+        } catch (error) {
+          console.error("Edge render error:", error);
+          throw error;
+        } finally {
+          if (typeof performance !== "undefined" && performance.mark) {
+            performance.mark(`coherent-edge-render-${Date.now()}`);
+          }
+        }
+      }
+      generateCacheKey(component, props) {
+        const componentName = component.name || "anonymous";
+        const propsHash = this.hashObject(props);
+        return `${componentName}-${propsHash}`;
+      }
+      hashObject(obj) {
+        const str = JSON.stringify(obj, Object.keys(obj).sort());
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+          const char = str.charCodeAt(i);
+          hash = (hash << 5) - hash + char;
+          hash = hash & hash;
+        }
+        return hash.toString(36);
+      }
+      // HTTP Request handling
+      async handleRequest(request) {
+        try {
+          const url = new URL(request.url);
+          const pathname = url.pathname;
+          const context = {
+            request,
+            url,
+            pathname,
+            params: {},
+            searchParams: Object.fromEntries(url.searchParams),
+            method: request.method,
+            headers: Object.fromEntries(request.headers),
+            runtime: this,
+            state: {}
+            // Shared state for middleware
+          };
+          let middlewareIndex = 0;
+          const next = async () => {
+            if (middlewareIndex < this.middleware.length) {
+              const middleware = this.middleware[middlewareIndex++];
+              return await middleware(context, next);
+            }
+          };
+          if (this.middleware.length > 0) {
+            await next();
+          }
+          if (context.response) {
+            return context.response;
+          }
+          const match = this.matchRoute(pathname);
+          if (!match) {
+            return this.createErrorResponse(404, "Not Found");
+          }
+          context.params = match.params;
+          const result = await match.handler(context);
+          if (result instanceof Response) {
+            return result;
+          }
+          if (typeof result === "string") {
+            return this.createHtmlResponse(result);
+          }
+          if (result && typeof result === "object") {
+            if (result.component) {
+              const html = await this.renderComponent(
+                result.component,
+                result.props || {},
+                result.options || {}
+              );
+              return this.createHtmlResponse(html, result.status, result.headers);
+            }
+            if (result.json) {
+              return this.createJsonResponse(result.json, result.status, result.headers);
+            }
+            if (result.redirect) {
+              return Response.redirect(result.redirect, result.status || 302);
+            }
+          }
+          return this.createJsonResponse(result);
+        } catch (error) {
+          console.error("Request handling error:", error);
+          return this.createErrorResponse(500, "Internal Server Error");
+        }
+      }
+      createHtmlResponse(html, status = 200, customHeaders = {}) {
+        return new Response(html, {
+          status,
+          headers: {
+            ...this.options.headers,
+            ...customHeaders
+          }
+        });
+      }
+      createJsonResponse(data, status = 200, customHeaders = {}) {
+        return new Response(JSON.stringify(data), {
+          status,
+          headers: {
+            "Content-Type": "application/json",
+            ...customHeaders
+          }
+        });
+      }
+      createErrorResponse(status, message) {
+        const errorHtml = `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>Error ${status}</title>
+          <style>
+            body { font-family: Arial, sans-serif; text-align: center; padding: 50px; }
+            h1 { color: #e74c3c; }
+          </style>
+        </head>
+        <body>
+          <h1>Error ${status}</h1>
+          <p>${message}</p>
+        </body>
+      </html>
+    `;
+        return new Response(errorHtml, {
+          status,
+          headers: { "Content-Type": "text/html; charset=utf-8" }
+        });
+      }
+      // API Routes
+      async handleApiRequest(request, handler) {
+        try {
+          const url = new URL(request.url);
+          const context = {
+            request,
+            url,
+            method: request.method,
+            headers: Object.fromEntries(request.headers),
+            searchParams: Object.fromEntries(url.searchParams),
+            runtime: this
+          };
+          if (request.method === "POST" || request.method === "PUT") {
+            const contentType = request.headers.get("content-type") || "";
+            if (contentType.includes("application/json")) {
+              context.body = await request.json();
+            } else if (contentType.includes("application/x-www-form-urlencoded")) {
+              const formData = await request.formData();
+              context.body = Object.fromEntries(formData);
+            } else {
+              context.body = await request.text();
+            }
+          }
+          const result = await handler(context);
+          if (result instanceof Response) {
+            return result;
+          }
+          return this.createJsonResponse(result);
+        } catch (error) {
+          console.error("API request error:", error);
+          return this.createJsonResponse({ error: error.message }, 500);
+        }
+      }
+      // Streaming support (for environments that support it)
+      async renderStream(component, props = {}) {
+        if (!this.options.streaming) {
+          return await this.renderComponent(component, props);
+        }
+        const encoder = new TextEncoder();
+        let buffer = "";
+        const chunkSize = this.options.streamChunkSize || 1024;
+        const stream = new ReadableStream({
+          async start(controller) {
+            try {
+              const flush = () => {
+                if (buffer.length > 0) {
+                  controller.enqueue(encoder.encode(buffer));
+                  buffer = "";
+                }
+              };
+              const renderNode = async (node) => {
+                if (!node || typeof node !== "object") {
+                  if (node !== null && node !== void 0) {
+                    buffer += String(node);
+                    if (buffer.length >= chunkSize) {
+                      flush();
+                    }
+                  }
+                  return;
+                }
+                if (Array.isArray(node)) {
+                  for (const child of node) {
+                    await renderNode(child);
+                  }
+                  return;
+                }
+                for (const [tag, content] of Object.entries(node)) {
+                  if (typeof content === "object" && content !== null) {
+                    buffer += `<${tag}`;
+                    for (const [key, value] of Object.entries(content)) {
+                      if (key !== "children" && key !== "text" && value !== void 0) {
+                        buffer += ` ${key}="${String(value)}"`;
+                      }
+                    }
+                    buffer += ">";
+                    if (buffer.length >= chunkSize) {
+                      flush();
+                    }
+                    if (content.text) {
+                      buffer += String(content.text);
+                      if (buffer.length >= chunkSize) {
+                        flush();
+                      }
+                    }
+                    if (content.children) {
+                      await renderNode(content.children);
+                    }
+                    buffer += `</${tag}>`;
+                    if (buffer.length >= chunkSize) {
+                      flush();
+                    }
+                  } else {
+                    buffer += `<${tag}>${String(content)}</${tag}>`;
+                    if (buffer.length >= chunkSize) {
+                      flush();
+                    }
+                  }
+                }
+              };
+              await renderNode(component);
+              flush();
+              controller.close();
+            } catch (error) {
+              controller.error(error);
+            }
+          }
+        });
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/html; charset=utf-8",
+            "Transfer-Encoding": "chunked"
+          }
+        });
+      }
+      // Create app factory
+      createApp() {
+        const app = {
+          // Component registration
+          component: (name, component, opts) => this.registerComponent(name, component, opts),
+          // Routing
+          get: (pattern, handler) => this.addRoute(pattern, handler),
+          post: (pattern, handler) => this.addRoute(pattern, handler),
+          put: (pattern, handler) => this.addRoute(pattern, handler),
+          delete: (pattern, handler) => this.addRoute(pattern, handler),
+          route: (pattern, handler) => this.addRoute(pattern, handler),
+          // API endpoints
+          api: (pattern, handler) => {
+            this.addRoute(pattern, (context) => this.handleApiRequest(context.request, handler));
+          },
+          // Static file serving (basic)
+          static: (pattern) => {
+            this.addRoute(pattern, async () => {
+              return this.createErrorResponse(404, "Static file serving not implemented");
+            });
+          },
+          // Middleware support
+          use: (middleware) => {
+            if (typeof middleware !== "function") {
+              throw new Error("Middleware must be a function");
+            }
+            this.middleware.push(middleware);
+            return app;
+          },
+          // Request handler
+          fetch: (request) => this.handleRequest(request),
+          // Utilities
+          render: (component, props, options) => this.renderComponent(component, props, options),
+          getRuntime: () => this,
+          getStats: () => ({
+            renderCount: this.renderCount,
+            cacheSize: this.cache.size,
+            componentCount: this.componentRegistry.size,
+            routeCount: this.routeRegistry.size
+          })
+        };
+        return app;
+      }
+      // Static factory methods
+      static createApp(options = {}) {
+        const runtime = new _EdgeRuntime(options);
+        return runtime.createApp(options);
+      }
+      static async handleRequest(request, components = {}, routes = {}) {
+        const runtime = new _EdgeRuntime();
+        Object.entries(components).forEach(([name, component]) => {
+          runtime.registerComponent(name, component);
+        });
+        Object.entries(routes).forEach(([pattern, handler]) => {
+          runtime.addRoute(pattern, handler);
+        });
+        return await runtime.handleRequest(request);
+      }
+    };
+  }
+});
+
+// src/runtimes/static.js
+var static_exports = {};
+__export(static_exports, {
+  StaticRuntime: () => StaticRuntime
+});
+import { render as render3 } from "@coherent.js/core";
+var StaticRuntime;
+var init_static = __esm({
+  "src/runtimes/static.js"() {
+    "use strict";
+    StaticRuntime = class _StaticRuntime {
+      constructor(options = {}) {
+        this.options = {
+          outputDir: "dist",
+          baseUrl: "",
+          generateSitemap: true,
+          generateManifest: true,
+          minifyHtml: true,
+          inlineCSS: false,
+          ...options
+        };
+        this.componentRegistry = /* @__PURE__ */ new Map();
+        this.pageRegistry = /* @__PURE__ */ new Map();
+        this.staticAssets = /* @__PURE__ */ new Map();
+        this.generatedPages = /* @__PURE__ */ new Map();
+        this.buildStats = {
+          startTime: Date.now(),
+          pagesGenerated: 0,
+          assetsProcessed: 0,
+          totalSize: 0,
+          errors: []
+        };
+      }
+      // Component management
+      registerComponent(name, component, options = {}) {
+        this.componentRegistry.set(name, {
+          component,
+          options
+        });
+        return component;
+      }
+      getComponent(name) {
+        const registration = this.componentRegistry.get(name);
+        return registration ? registration.component : null;
+      }
+      // Page registration
+      addPage(route, component, options = {}) {
+        this.pageRegistry.set(route, {
+          component: typeof component === "string" ? this.getComponent(component) : component,
+          options: {
+            title: options.title || "Page",
+            description: options.description || "",
+            keywords: options.keywords || "",
+            generatePath: options.generatePath || this.routeToPath(route),
+            props: options.props || {},
+            ...options
+          }
+        });
+      }
+      routeToPath(route) {
+        if (route === "/") return "/index.html";
+        if (route.includes(":")) {
+          console.warn(`Dynamic route ${route} requires explicit generatePath`);
+          return null;
+        }
+        return route.endsWith("/") ? `${route}index.html` : `${route}.html`;
+      }
+      // Static asset management
+      addAsset(path, content, options = {}) {
+        this.staticAssets.set(path, {
+          content,
+          type: options.type || this.inferContentType(path),
+          minify: options.minify !== false,
+          ...options
+        });
+      }
+      inferContentType(path) {
+        const ext = path.split(".").pop().toLowerCase();
+        const contentTypes = {
+          "html": "text/html",
+          "css": "text/css",
+          "js": "application/javascript",
+          "json": "application/json",
+          "png": "image/png",
+          "jpg": "image/jpeg",
+          "jpeg": "image/jpeg",
+          "gif": "image/gif",
+          "svg": "image/svg+xml",
+          "ico": "image/x-icon"
+        };
+        return contentTypes[ext] || "text/plain";
+      }
+      // HTML template generation
+      generateHtmlDocument(content, options = {}) {
+        const {
+          title = "Coherent.js App",
+          description = "",
+          keywords = "",
+          lang = "en",
+          charset = "utf-8",
+          viewport = "width=device-width, initial-scale=1",
+          favicon = "/favicon.ico",
+          styles = [],
+          scripts = [],
+          meta = [],
+          bodyClass = "",
+          hydrate: hydrate2 = false,
+          componentName = null,
+          componentProps = {}
+        } = options;
+        const metaTags = [
+          `<meta charset="${charset}">`,
+          `<meta name="viewport" content="${viewport}">`,
+          description && `<meta name="description" content="${description}">`,
+          keywords && `<meta name="keywords" content="${keywords}">`,
+          ...meta.map((m) => typeof m === "string" ? m : `<meta ${Object.entries(m).map(([k, v]) => `${k}="${v}"`).join(" ")}>`)
+        ].filter(Boolean).join("\n  ");
+        const styleTags = styles.map(
+          (style) => typeof style === "string" ? style.startsWith("<") ? style : `<link rel="stylesheet" href="${style}">` : `<style>${style.content}</style>`
+        ).join("\n  ");
+        const scriptTags = [
+          ...scripts.map(
+            (script) => typeof script === "string" ? script.startsWith("<") ? script : `<script src="${script}"></script>` : `<script>${script.content}</script>`
+          ),
+          // Add hydration script if enabled
+          hydrate2 && this.generateHydrationScript(componentName, componentProps)
+        ].filter(Boolean).join("\n  ");
+        return `<!DOCTYPE html>
+<html lang="${lang}">
+<head>
+  ${metaTags}
+  <title>${this.escapeHtml(title)}</title>
+  <link rel="icon" href="${favicon}">
+  ${styleTags}
+</head>
+<body${bodyClass ? ` class="${bodyClass}"` : ""}>
+  ${content}
+  ${scriptTags}
+</body>
+</html>`;
+      }
+      generateHydrationScript(componentName) {
+        if (!componentName) return "";
+        return `
+  <script type="module">
+    import { autoHydrate } from '/coherent-client.js';
+    
+    // Auto-hydrate on page load
+    document.addEventListener('DOMContentLoaded', () => {
+      autoHydrate({
+        '${componentName}': window.components?.['${componentName}']
+      });
+    });
+  </script>`;
+      }
+      escapeHtml(text) {
+        if (typeof text !== "string") return text;
+        return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+      }
+      // Build process
+      async build() {
+        this.buildStats.startTime = Date.now();
+        console.log("\u{1F3D7}\uFE0F  Starting static site generation...");
+        try {
+          await this.generatePages();
+          await this.processAssets();
+          if (this.options.generateSitemap) {
+            await this.generateSitemap();
+          }
+          if (this.options.generateManifest) {
+            await this.generateManifest();
+          }
+          const buildTime = Date.now() - this.buildStats.startTime;
+          console.log(`\u2705 Build completed in ${buildTime}ms`);
+          console.log(`\u{1F4C4} Generated ${this.buildStats.pagesGenerated} pages`);
+          console.log(`\u{1F4E6} Processed ${this.buildStats.assetsProcessed} assets`);
+          return this.getBuildResult();
+        } catch (error) {
+          this.buildStats.errors.push(error);
+          console.error("\u274C Build failed:", error);
+          throw error;
+        }
+      }
+      async generatePages() {
+        for (const [route, pageConfig] of this.pageRegistry) {
+          try {
+            await this.generatePage(route, pageConfig);
+            this.buildStats.pagesGenerated++;
+          } catch (error) {
+            console.error(`Failed to generate page ${route}:`, error);
+            this.buildStats.errors.push({ route, error });
+          }
+        }
+      }
+      async generatePage(route, pageConfig) {
+        const { component, options } = pageConfig;
+        if (!component) {
+          throw new Error(`No component found for route: ${route}`);
+        }
+        const vdom = component(options.props || {});
+        const content = render3(vdom);
+        const html = this.generateHtmlDocument(content, {
+          title: options.title,
+          description: options.description,
+          keywords: options.keywords,
+          styles: options.styles || [],
+          scripts: options.scripts || [],
+          meta: options.meta || [],
+          hydrate: options.hydrate,
+          componentName: options.componentName,
+          componentProps: options.props || {},
+          ...options.htmlOptions
+        });
+        const finalHtml = this.options.minifyHtml ? this.minifyHtml(html) : html;
+        const outputPath = options.generatePath || this.routeToPath(route);
+        if (outputPath) {
+          this.generatedPages.set(outputPath, {
+            html: finalHtml,
+            size: finalHtml.length,
+            route,
+            options
+          });
+          this.buildStats.totalSize += finalHtml.length;
+        }
+      }
+      minifyHtml(html) {
+        return html.replace(/\s+/g, " ").replace(/>\s+</g, "><").replace(/\s+>/g, ">").replace(/<\s+/g, "<").trim();
+      }
+      async processAssets() {
+        for (const [path, asset] of this.staticAssets) {
+          try {
+            let content = asset.content;
+            if (asset.minify) {
+              content = this.minifyAsset(content, asset.type);
+            }
+            this.generatedPages.set(path, {
+              content,
+              type: asset.type,
+              size: content.length
+            });
+            this.buildStats.assetsProcessed++;
+            this.buildStats.totalSize += content.length;
+          } catch (error) {
+            console.error(`Failed to process asset ${path}:`, error);
+            this.buildStats.errors.push({ path, error });
+          }
+        }
+      }
+      minifyAsset(content, type) {
+        switch (type) {
+          case "text/css":
+            return content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/;\s*}/g, "}").replace(/\s*{\s*/g, "{").replace(/;\s*/g, ";").trim();
+          case "application/javascript":
+            return content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").replace(/\s+/g, " ").replace(/\s*([{}();,])\s*/g, "$1").trim();
+          default:
+            return content;
+        }
+      }
+      async generateSitemap() {
+        const pages = Array.from(this.generatedPages.keys()).filter((path) => path.endsWith(".html"));
+        const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${pages.map((path) => `  <url>
+    <loc>${this.options.baseUrl}${path.replace("/index.html", "/")}</loc>
+    <lastmod>${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}</lastmod>
+  </url>`).join("\n")}
+</urlset>`;
+        this.generatedPages.set("/sitemap.xml", {
+          content: sitemap,
+          type: "application/xml",
+          size: sitemap.length
+        });
+      }
+      async generateManifest() {
+        const manifest = {
+          name: this.options.name || "Coherent.js App",
+          short_name: this.options.shortName || "App",
+          description: this.options.description || "",
+          start_url: "/",
+          display: "standalone",
+          theme_color: this.options.themeColor || "#000000",
+          background_color: this.options.backgroundColor || "#ffffff",
+          icons: this.options.icons || []
+        };
+        const manifestJson = JSON.stringify(manifest, null, 2);
+        this.generatedPages.set("/manifest.json", {
+          content: manifestJson,
+          type: "application/json",
+          size: manifestJson.length
+        });
+      }
+      getBuildResult() {
+        return {
+          pages: this.generatedPages,
+          stats: {
+            ...this.buildStats,
+            buildTime: Date.now() - this.buildStats.startTime
+          },
+          success: this.buildStats.errors.length === 0
+        };
+      }
+      // Create static app factory
+      createApp() {
+        return {
+          // Component registration
+          component: (name, component, opts) => this.registerComponent(name, component, opts),
+          // Page registration
+          page: (route, component, opts) => this.addPage(route, component, opts),
+          // Asset management
+          asset: (path, content, opts) => this.addAsset(path, content, opts),
+          // Build process
+          build: () => this.build(),
+          // Utilities
+          getRuntime: () => this,
+          getStats: () => this.buildStats,
+          getPages: () => Array.from(this.pageRegistry.keys()),
+          getAssets: () => Array.from(this.staticAssets.keys())
+        };
+      }
+      // Static factory methods
+      static createApp(options = {}) {
+        const runtime = new _StaticRuntime(options);
+        return runtime.createApp(options);
+      }
+      static async buildSite(pages = {}, components = {}, options = {}) {
+        const runtime = new _StaticRuntime(options);
+        Object.entries(components).forEach(([name, component]) => {
+          runtime.registerComponent(name, component);
+        });
+        Object.entries(pages).forEach(([route, config]) => {
+          runtime.addPage(route, config.component, config.options);
+        });
+        return await runtime.build();
+      }
+    };
+  }
+});
+
+// src/runtimes/node.js
+var node_exports = {};
+__export(node_exports, {
+  NodeRuntime: () => NodeRuntime,
+  createNodeRuntime: () => createNodeRuntime,
+  default: () => node_default
+});
+import { render as render4 } from "@coherent.js/core";
+import { createServer } from "http";
+function createNodeRuntime(options = {}) {
+  return new NodeRuntime(options);
+}
+var NodeRuntime, node_default;
+var init_node = __esm({
+  "src/runtimes/node.js"() {
+    "use strict";
+    NodeRuntime = class {
+      constructor(options = {}) {
+        this.options = {
+          port: 3e3,
+          host: "localhost",
+          caching: true,
+          framework: null,
+          // 'express', 'fastify', 'koa', or null for standalone
+          headers: {
+            "Content-Type": "text/html; charset=utf-8",
+            "Cache-Control": "public, max-age=3600",
+            ...options.headers
+          },
+          ...options
+        };
+        this.componentRegistry = /* @__PURE__ */ new Map();
+        this.routeRegistry = /* @__PURE__ */ new Map();
+        this.middleware = [];
+        this.cache = /* @__PURE__ */ new Map();
+        this.renderCount = 0;
+        this.server = null;
+        if (this.options.caching) {
+          this.initializeCacheCleanup();
+        }
+      }
+      initializeCacheCleanup() {
+        setInterval(() => {
+          if (this.cache.size > 1e3) {
+            const entries = Array.from(this.cache.entries());
+            const toDelete = entries.slice(0, entries.length - 500);
+            toDelete.forEach(([key]) => this.cache.delete(key));
+          }
+        }, 3e5);
+      }
+      // Component management
+      registerComponent(name, component) {
+        this.componentRegistry.set(name, component);
+        return component;
+      }
+      getComponent(name) {
+        return this.componentRegistry.get(name);
+      }
+      // Route management
+      addRoute(pattern, handler) {
+        this.routeRegistry.set(pattern, handler);
+      }
+      matchRoute(pathname) {
+        for (const [pattern, handler] of this.routeRegistry.entries()) {
+          const match = this.matchPattern(pattern, pathname);
+          if (match) {
+            return { handler, params: match.params };
+          }
+        }
+        return null;
+      }
+      matchPattern(pattern, pathname) {
+        const patternParts = pattern.split("/").filter(Boolean);
+        const pathParts = pathname.split("/").filter(Boolean);
+        if (patternParts.length !== pathParts.length) {
+          return null;
+        }
+        const params = {};
+        for (let i = 0; i < patternParts.length; i++) {
+          const patternPart = patternParts[i];
+          const pathPart = pathParts[i];
+          if (patternPart.startsWith(":")) {
+            params[patternPart.slice(1)] = pathPart;
+          } else if (patternPart !== pathPart) {
+            return null;
+          }
+        }
+        return { params };
+      }
+      // Rendering
+      async renderComponent(component, props = {}, options = {}) {
+        try {
+          const resolvedComponent = typeof component === "string" ? this.getComponent(component) : component;
+          if (!resolvedComponent) {
+            throw new Error(`Component not found: ${component}`);
+          }
+          const cacheKey = this.generateCacheKey(resolvedComponent, props);
+          if (this.options.caching && this.cache.has(cacheKey)) {
+            const cached = this.cache.get(cacheKey);
+            if (Date.now() - cached.timestamp < (options.cacheMaxAge || 3e5)) {
+              return cached.html;
+            }
+            this.cache.delete(cacheKey);
+          }
+          const vdom = resolvedComponent(props);
+          const html = render4(vdom);
+          if (this.options.caching && options.cacheable !== false) {
+            this.cache.set(cacheKey, {
+              html,
+              timestamp: Date.now()
+            });
+          }
+          this.renderCount++;
+          return html;
+        } catch (error) {
+          console.error("Node render error:", error);
+          throw error;
+        }
+      }
+      generateCacheKey(component, props) {
+        const componentName = component.name || "anonymous";
+        const propsHash = this.hashObject(props);
+        return `${componentName}-${propsHash}`;
+      }
+      hashObject(obj) {
+        const str = JSON.stringify(obj, Object.keys(obj).sort());
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+          const char = str.charCodeAt(i);
+          hash = (hash << 5) - hash + char;
+          hash = hash & hash;
+        }
+        return hash.toString(36);
+      }
+      // HTTP Request handling (for standalone mode)
+      async handleRequest(req, res) {
+        try {
+          const url = new URL(req.url, `http://${req.headers.host}`);
+          const pathname = url.pathname;
+          const context = {
+            req,
+            res,
+            url,
+            pathname,
+            params: {},
+            query: Object.fromEntries(url.searchParams),
+            method: req.method,
+            headers: req.headers,
+            runtime: this,
+            state: {}
+          };
+          let middlewareIndex = 0;
+          const next = async () => {
+            if (middlewareIndex < this.middleware.length) {
+              const middleware = this.middleware[middlewareIndex++];
+              return await middleware(context, next);
+            }
+          };
+          if (this.middleware.length > 0) {
+            await next();
+          }
+          if (res.headersSent) {
+            return;
+          }
+          const match = this.matchRoute(pathname);
+          if (!match) {
+            res.writeHead(404, { "Content-Type": "text/html" });
+            res.end("<h1>404 Not Found</h1>");
+            return;
+          }
+          context.params = match.params;
+          const result = await match.handler(context);
+          if (res.headersSent) {
+            return;
+          }
+          if (typeof result === "string") {
+            res.writeHead(200, this.options.headers);
+            res.end(result);
+            return;
+          }
+          if (result && typeof result === "object") {
+            if (result.component) {
+              const html = await this.renderComponent(
+                result.component,
+                result.props || {},
+                result.options || {}
+              );
+              res.writeHead(result.status || 200, {
+                ...this.options.headers,
+                ...result.headers
+              });
+              res.end(html);
+              return;
+            }
+            if (result.json !== void 0) {
+              res.writeHead(result.status || 200, {
+                "Content-Type": "application/json",
+                ...result.headers
+              });
+              res.end(JSON.stringify(result.json));
+              return;
+            }
+            if (result.redirect) {
+              res.writeHead(result.status || 302, {
+                "Location": result.redirect
+              });
+              res.end();
+              return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(result));
+            return;
+          }
+          res.writeHead(200, this.options.headers);
+          res.end(String(result));
+        } catch (error) {
+          console.error("Request handling error:", error);
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: error.message }));
+          }
+        }
+      }
+      // Create app factory
+      createApp() {
+        const app = {
+          // Component registration
+          component: (name, component) => this.registerComponent(name, component),
+          // Routing
+          get: (pattern, handler) => this.addRoute(pattern, handler),
+          post: (pattern, handler) => this.addRoute(pattern, handler),
+          put: (pattern, handler) => this.addRoute(pattern, handler),
+          delete: (pattern, handler) => this.addRoute(pattern, handler),
+          route: (pattern, handler) => this.addRoute(pattern, handler),
+          // Middleware support
+          use: (middleware) => {
+            if (typeof middleware !== "function") {
+              throw new Error("Middleware must be a function");
+            }
+            this.middleware.push(middleware);
+            return app;
+          },
+          // Server control
+          listen: (port, callback) => {
+            const serverPort = port || this.options.port;
+            this.server = createServer((req, res) => this.handleRequest(req, res));
+            this.server.listen(serverPort, this.options.host, () => {
+              console.log(`Coherent.js Node runtime listening on http://${this.options.host}:${serverPort}`);
+              if (callback) callback();
+            });
+            return this.server;
+          },
+          close: (callback) => {
+            if (this.server) {
+              this.server.close(callback);
+            }
+          },
+          // Utilities
+          render: (component, props, options) => this.renderComponent(component, props, options),
+          getRuntime: () => this,
+          getStats: () => ({
+            renderCount: this.renderCount,
+            cacheSize: this.cache.size,
+            componentCount: this.componentRegistry.size,
+            routeCount: this.routeRegistry.size,
+            middlewareCount: this.middleware.length
+          })
+        };
+        return app;
+      }
+      // Framework integration helpers
+      expressMiddleware() {
+        return async (req, res, next) => {
+          req.coherent = {
+            render: async (component, props, options) => {
+              const html = await this.renderComponent(component, props, options);
+              res.send(html);
+            },
+            runtime: this
+          };
+          next();
+        };
+      }
+      fastifyPlugin() {
+        return async (fastify) => {
+          fastify.decorate("coherent", {
+            render: async (component, props, renderOptions) => {
+              return await this.renderComponent(component, props, renderOptions);
+            },
+            runtime: this
+          });
+        };
+      }
+      koaMiddleware() {
+        return async (ctx, next) => {
+          ctx.coherent = {
+            render: async (component, props, options) => {
+              const html = await this.renderComponent(component, props, options);
+              ctx.type = "html";
+              ctx.body = html;
+            },
+            runtime: this
+          };
+          await next();
+        };
+      }
+    };
+    node_default = NodeRuntime;
+  }
+});
+
+// src/index.js
+init_browser();
+init_edge();
+init_static();
+export * from "@coherent.js/core";
+export * from "@coherent.js/client";
+export * from "@coherent.js/web-components";
+
+// src/runtimes/desktop.js
+init_browser();
+var DesktopRuntime = class _DesktopRuntime extends BrowserRuntime {
+  constructor(options = {}) {
+    super({
+      enableFileSystem: true,
+      enableNativeAPIs: true,
+      ...options
+    });
+    this.desktopAPI = null;
+    this.isElectron = typeof window !== "undefined" && !!window.require;
+    this.isTauri = typeof window !== "undefined" && !!window.__TAURI__;
+  }
+  async initialize() {
+    await super.initialize();
+    if (this.isElectron) {
+      this.initializeElectron();
+    } else if (this.isTauri) {
+      this.initializeTauri();
+    }
+  }
+  initializeElectron() {
+    try {
+      this.desktopAPI = {
+        platform: "electron",
+        fs: window.require ? window.require("fs") : null,
+        path: window.require ? window.require("path") : null,
+        ipcRenderer: window.require ? window.require("electron").ipcRenderer : null
+      };
+    } catch (error) {
+      console.warn("Failed to initialize Electron APIs:", error);
+    }
+  }
+  async initializeTauri() {
+    try {
+      if (window.__TAURI__) {
+        this.desktopAPI = {
+          platform: "tauri",
+          fs: window.__TAURI__.fs,
+          path: window.__TAURI__.path,
+          invoke: window.__TAURI__.invoke
+        };
+      }
+    } catch (error) {
+      console.warn("Failed to initialize Tauri APIs:", error);
+    }
+  }
+  // Desktop-specific methods
+  async readFile(path) {
+    if (this.desktopAPI?.fs) {
+      return await this.desktopAPI.fs.readTextFile(path);
+    }
+    throw new Error("File system access not available");
+  }
+  async writeFile(path, content) {
+    if (this.desktopAPI?.fs) {
+      return await this.desktopAPI.fs.writeTextFile(path, content);
+    }
+    throw new Error("File system access not available");
+  }
+  async showDialog(options) {
+    if (this.isElectron && this.desktopAPI?.ipcRenderer) {
+      return await this.desktopAPI.ipcRenderer.invoke("show-dialog", options);
+    } else if (this.isTauri && this.desktopAPI?.invoke) {
+      return await this.desktopAPI.invoke("show_dialog", options);
+    }
+    console.warn("Desktop dialog not available, rejecting by default");
+    return Promise.resolve(false);
+  }
+  static createApp(options = {}) {
+    const runtime = new _DesktopRuntime(options);
+    return runtime.createApp(options);
+  }
+};
+
+// src/loaders/universal-loader.js
+var UniversalLoader = class _UniversalLoader {
+  constructor(options = {}) {
+    this.options = {
+      baseUrl: "",
+      moduleMap: {},
+      fallbackUrls: [],
+      cache: true,
+      ...options
+    };
+    this.moduleCache = /* @__PURE__ */ new Map();
+    this.loadingPromises = /* @__PURE__ */ new Map();
+    this.environment = this.detectEnvironment();
+  }
+  detectEnvironment() {
+    if (typeof Deno !== "undefined") return "deno";
+    if (typeof Bun !== "undefined") return "bun";
+    if (typeof window !== "undefined") return "browser";
+    if (typeof global !== "undefined" && typeof __require !== "undefined") return "node";
+    if (typeof WorkerGlobalScope !== "undefined") return "worker";
+    return "unknown";
+  }
+  // Universal module loading
+  async load(modulePath, options = {}) {
+    const resolvedPath = this.resolvePath(modulePath, options);
+    const cacheKey = resolvedPath + JSON.stringify(options);
+    if (this.options.cache && this.moduleCache.has(cacheKey)) {
+      return this.moduleCache.get(cacheKey);
+    }
+    if (this.loadingPromises.has(cacheKey)) {
+      return this.loadingPromises.get(cacheKey);
+    }
+    const loadingPromise = this.loadModule(resolvedPath, options);
+    this.loadingPromises.set(cacheKey, loadingPromise);
+    try {
+      const module = await loadingPromise;
+      if (this.options.cache) {
+        this.moduleCache.set(cacheKey, module);
+      }
+      return module;
+    } finally {
+      this.loadingPromises.delete(cacheKey);
+    }
+  }
+  async loadModule(modulePath, options = {}) {
+    switch (this.environment) {
+      case "browser":
+        return await this.loadBrowserModule(modulePath, options);
+      case "node":
+        return await this.loadNodeModule(modulePath, options);
+      case "deno":
+        return await this.loadDenoModule(modulePath, options);
+      case "bun":
+        return await this.loadBunModule(modulePath, options);
+      case "worker":
+        return await this.loadWorkerModule(modulePath, options);
+      default:
+        return await this.loadGenericModule(modulePath, options);
+    }
+  }
+  async loadBrowserModule(modulePath, options = {}) {
+    if (modulePath.startsWith("http") || modulePath.startsWith("/")) {
+      try {
+        return await import(modulePath);
+      } catch {
+        return await this.loadScript(modulePath, options);
+      }
+    } else {
+      const cdnUrl = this.toCdnUrl(modulePath);
+      return await import(cdnUrl);
+    }
+  }
+  async loadNodeModule(modulePath) {
+    if (typeof __require !== "undefined") {
+      try {
+        return __require(modulePath);
+      } catch {
+        return await import(modulePath);
+      }
+    } else {
+      return await import(modulePath);
+    }
+  }
+  async loadDenoModule(modulePath) {
+    if (modulePath.startsWith("npm:")) {
+      return await import(modulePath);
+    } else if (modulePath.startsWith("http")) {
+      return await import(modulePath);
+    } else {
+      return await import(`npm:${modulePath}`);
+    }
+  }
+  async loadBunModule(modulePath) {
+    try {
+      return await import(modulePath);
+    } catch (error) {
+      if (typeof __require !== "undefined") {
+        return __require(modulePath);
+      }
+      throw error;
+    }
+  }
+  async loadWorkerModule(modulePath) {
+    return await import(modulePath);
+  }
+  async loadGenericModule(modulePath) {
+    return await import(modulePath);
+  }
+  async loadScript(src, options = {}) {
+    return new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.type = "module";
+      script.src = src;
+      script.onload = () => {
+        const moduleName = options.globalName || this.getModuleNameFromPath(src);
+        const module = window[moduleName] || {};
+        resolve(module);
+      };
+      script.onerror = () => reject(new Error(`Failed to load script: ${src}`));
+      document.head.appendChild(script);
+    });
+  }
+  resolvePath(modulePath, options = {}) {
+    if (modulePath.startsWith("http://") || modulePath.startsWith("https://")) {
+      return modulePath;
+    }
+    if (modulePath.startsWith("./") || modulePath.startsWith("../")) {
+      return this.resolveRelativePath(modulePath, options.baseUrl || this.options.baseUrl);
+    }
+    if (this.options.moduleMap[modulePath]) {
+      return this.options.moduleMap[modulePath];
+    }
+    return this.options.baseUrl + modulePath;
+  }
+  resolveRelativePath(relativePath, baseUrl) {
+    if (!baseUrl) return relativePath;
+    const base = new URL(baseUrl, location?.href || "file:///");
+    const resolved = new URL(relativePath, base);
+    return resolved.href;
+  }
+  toCdnUrl(packageName, version = "latest") {
+    const _cleanName = packageName.replace(/^@/, "").replace("/", "-");
+    return `https://unpkg.com/${packageName}@${version}/dist/index.js`;
+  }
+  getModuleNameFromPath(path) {
+    const filename = path.split("/").pop().split(".")[0];
+    return filename.replace(/[-_]/g, "");
+  }
+  // Batch loading
+  async loadAll(modulePaths, options = {}) {
+    const loadPromises = modulePaths.map(
+      (path) => this.load(path, options).catch((error) => ({ error, path }))
+    );
+    return await Promise.all(loadPromises);
+  }
+  // Preloading
+  async preload(modulePaths, options = {}) {
+    const preloadPromises = modulePaths.map(async (path) => {
+      try {
+        await this.load(path, { ...options, preload: true });
+        return { success: true, path };
+      } catch (error) {
+        return { success: false, path, error };
+      }
+    });
+    return await Promise.all(preloadPromises);
+  }
+  // Cache management
+  clearCache() {
+    this.moduleCache.clear();
+  }
+  getCacheStats() {
+    return {
+      size: this.moduleCache.size,
+      modules: Array.from(this.moduleCache.keys())
+    };
+  }
+  // Environment detection helpers
+  static isSupported() {
+    return (() => {
+      try {
+        return typeof Function('return import("")') === "function";
+      } catch {
+        return false;
+      }
+    })() || typeof __require !== "undefined";
+  }
+  static getCapabilities() {
+    return {
+      dynamicImport: (() => {
+        try {
+          return typeof Function('return import("")') === "function";
+        } catch {
+          return false;
+        }
+      })(),
+      require: typeof __require !== "undefined",
+      fetch: typeof fetch !== "undefined",
+      worker: typeof Worker !== "undefined",
+      environment: new _UniversalLoader().environment
+    };
+  }
+};
+var universalLoader = new UniversalLoader();
+
+// src/loaders/component-loader.js
+var ComponentLoader = class {
+  constructor(options = {}) {
+    this.options = {
+      componentRegistry: /* @__PURE__ */ new Map(),
+      lazyLoad: true,
+      preloadComponents: [],
+      componentPaths: {},
+      ...options
+    };
+    this.loader = universalLoader;
+    this.loadingQueue = /* @__PURE__ */ new Map();
+    this.dependencyGraph = /* @__PURE__ */ new Map();
+    this.loadedComponents = /* @__PURE__ */ new Set();
+  }
+  // Register a component with its metadata
+  registerComponent(name, componentOrPath, options = {}) {
+    const registration = {
+      name,
+      path: typeof componentOrPath === "string" ? componentOrPath : null,
+      component: typeof componentOrPath === "function" ? componentOrPath : null,
+      loaded: typeof componentOrPath === "function",
+      dependencies: options.dependencies || [],
+      lazy: options.lazy !== false,
+      preload: options.preload || false,
+      metadata: options.metadata || {},
+      ...options
+    };
+    this.options.componentRegistry.set(name, registration);
+    if (registration.dependencies.length > 0) {
+      this.dependencyGraph.set(name, registration.dependencies);
+    }
+    if (!registration.lazy && registration.path && !registration.loaded) {
+      this.loadComponent(name);
+    }
+    return registration;
+  }
+  // Load a component by name
+  async loadComponent(name, options = {}) {
+    const registration = this.options.componentRegistry.get(name);
+    if (!registration) {
+      throw new Error(`Component '${name}' not found in registry`);
+    }
+    if (registration.loaded && registration.component) {
+      return registration.component;
+    }
+    if (this.loadingQueue.has(name)) {
+      return this.loadingQueue.get(name);
+    }
+    const loadingPromise = this.doLoadComponent(registration, options);
+    this.loadingQueue.set(name, loadingPromise);
+    try {
+      const component = await loadingPromise;
+      registration.component = component;
+      registration.loaded = true;
+      this.loadedComponents.add(name);
+      return component;
+    } finally {
+      this.loadingQueue.delete(name);
+    }
+  }
+  async doLoadComponent(registration, options = {}) {
+    const { name, path, dependencies } = registration;
+    try {
+      if (dependencies.length > 0) {
+        await this.loadDependencies(dependencies, options);
+      }
+      let component;
+      if (path) {
+        const module = await this.loader.load(path, options);
+        component = this.extractComponent(module, name);
+      } else if (registration.component) {
+        component = registration.component;
+      } else {
+        throw new Error(`No component or path specified for '${name}'`);
+      }
+      return this.processComponent(component, registration, options);
+    } catch (error) {
+      console.error(`Failed to load component '${name}':`, error);
+      throw error;
+    }
+  }
+  extractComponent(module, componentName) {
+    if (module.default && typeof module.default === "function") {
+      return module.default;
+    }
+    if (module[componentName] && typeof module[componentName] === "function") {
+      return module[componentName];
+    }
+    for (const [key, value] of Object.entries(module)) {
+      if (typeof value === "function" && key !== "default") {
+        return value;
+      }
+    }
+    throw new Error(`No valid component function found in module for '${componentName}'`);
+  }
+  processComponent(component, registration, options = {}) {
+    if (registration.metadata) {
+      Object.assign(component, {
+        $meta: registration.metadata,
+        $name: registration.name
+      });
+    }
+    if (options.wrapper) {
+      return options.wrapper(component, registration);
+    }
+    return component;
+  }
+  async loadDependencies(dependencies, options = {}) {
+    const dependencyPromises = dependencies.map((depName) => {
+      return this.loadComponent(depName, options);
+    });
+    await Promise.all(dependencyPromises);
+  }
+  // Batch component loading
+  async loadComponents(componentNames, options = {}) {
+    const loadPromises = componentNames.map(
+      (name) => this.loadComponent(name, options).catch((error) => ({ error, name }))
+    );
+    const results = await Promise.all(loadPromises);
+    const loaded = {};
+    const errors = [];
+    results.forEach((result, index) => {
+      const name = componentNames[index];
+      if (result && result.error) {
+        errors.push({ name, error: result.error });
+      } else {
+        loaded[name] = result;
+      }
+    });
+    return { loaded, errors };
+  }
+  // Preload components
+  async preloadComponents(componentNames = null) {
+    const toPreload = componentNames || this.getPreloadableComponents();
+    const preloadResults = await Promise.allSettled(
+      toPreload.map((name) => this.loadComponent(name, { preload: true }))
+    );
+    const results = {
+      successful: [],
+      failed: []
+    };
+    preloadResults.forEach((result, index) => {
+      const name = toPreload[index];
+      if (result.status === "fulfilled") {
+        results.successful.push(name);
+      } else {
+        results.failed.push({ name, error: result.reason });
+      }
+    });
+    return results;
+  }
+  getPreloadableComponents() {
+    return Array.from(this.options.componentRegistry.values()).filter((reg) => reg.preload && !reg.loaded).map((reg) => reg.name);
+  }
+  // Component discovery
+  async discoverComponents(basePath, options = {}) {
+    const discovered = [];
+    try {
+      if (typeof fetch !== "undefined") {
+        discovered.push(...await this.discoverFromManifest(basePath, options));
+      } else if (typeof __require !== "undefined") {
+        discovered.push(...await this.discoverFromFileSystem(basePath, options));
+      }
+    } catch (error) {
+      console.warn("Component discovery failed:", error);
+    }
+    return discovered;
+  }
+  async discoverFromManifest(basePath, _options = {}) {
+    try {
+      const manifestUrl = `${basePath}/components.json`;
+      const response = await fetch(manifestUrl);
+      const manifest = await response.json();
+      return manifest.components || [];
+    } catch {
+      return [];
+    }
+  }
+  async discoverFromFileSystem(basePath, _options = {}) {
+    return [];
+  }
+  // Auto-registration from patterns
+  registerComponentPattern(pattern, options = {}) {
+    this.componentPatterns = this.componentPatterns || [];
+    this.componentPatterns.push({ pattern, options });
+  }
+  // Dependency analysis
+  analyzeDependencies() {
+    const analysis = {
+      circular: [],
+      missing: [],
+      unused: [],
+      depth: /* @__PURE__ */ new Map()
+    };
+    analysis.circular = this.findCircularDependencies();
+    analysis.missing = this.findMissingDependencies();
+    analysis.unused = this.findUnusedComponents();
+    analysis.depth = this.calculateDependencyDepths();
+    return analysis;
+  }
+  findCircularDependencies() {
+    const circular = [];
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const visit = (componentName, path = []) => {
+      if (recursionStack.has(componentName)) {
+        circular.push([...path, componentName]);
+        return;
+      }
+      if (visited.has(componentName)) return;
+      visited.add(componentName);
+      recursionStack.add(componentName);
+      const dependencies = this.dependencyGraph.get(componentName) || [];
+      dependencies.forEach((dep) => {
+        visit(dep, [...path, componentName]);
+      });
+      recursionStack.delete(componentName);
+    };
+    Array.from(this.dependencyGraph.keys()).forEach(visit);
+    return circular;
+  }
+  findMissingDependencies() {
+    const missing = [];
+    for (const [component, dependencies] of this.dependencyGraph) {
+      for (const dep of dependencies) {
+        if (!this.options.componentRegistry.has(dep)) {
+          missing.push({ component, dependency: dep });
+        }
+      }
+    }
+    return missing;
+  }
+  findUnusedComponents() {
+    const used = /* @__PURE__ */ new Set();
+    for (const dependencies of this.dependencyGraph.values()) {
+      dependencies.forEach((dep) => used.add(dep));
+    }
+    const unused = [];
+    for (const name of this.options.componentRegistry.keys()) {
+      if (!used.has(name)) {
+        unused.push(name);
+      }
+    }
+    return unused;
+  }
+  calculateDependencyDepths() {
+    const depths = /* @__PURE__ */ new Map();
+    const calculateDepth = (componentName, visited = /* @__PURE__ */ new Set()) => {
+      if (depths.has(componentName)) {
+        return depths.get(componentName);
+      }
+      if (visited.has(componentName)) {
+        return Infinity;
+      }
+      visited.add(componentName);
+      const dependencies = this.dependencyGraph.get(componentName) || [];
+      const maxDepth = dependencies.length === 0 ? 0 : Math.max(...dependencies.map((dep) => calculateDepth(dep, new Set(visited)))) + 1;
+      depths.set(componentName, maxDepth);
+      return maxDepth;
+    };
+    for (const componentName of this.options.componentRegistry.keys()) {
+      calculateDepth(componentName);
+    }
+    return depths;
+  }
+  // Utilities
+  getRegisteredComponents() {
+    return Array.from(this.options.componentRegistry.keys());
+  }
+  getLoadedComponents() {
+    return Array.from(this.loadedComponents);
+  }
+  getComponentInfo(name) {
+    return this.options.componentRegistry.get(name);
+  }
+  isComponentLoaded(name) {
+    return this.loadedComponents.has(name);
+  }
+  clearCache() {
+    this.loader.clearCache();
+    this.loadingQueue.clear();
+  }
+  getStats() {
+    return {
+      registered: this.options.componentRegistry.size,
+      loaded: this.loadedComponents.size,
+      loading: this.loadingQueue.size,
+      dependencies: this.dependencyGraph.size
+    };
+  }
+};
+var componentLoader = new ComponentLoader();
+
+// src/runtime-factory.js
+var RuntimeEnvironment = {
+  BROWSER: "browser",
+  NODE: "node",
+  EDGE: "edge",
+  CLOUDFLARE: "cloudflare",
+  DENO: "deno",
+  BUN: "bun",
+  ELECTRON: "electron",
+  TAURI: "tauri",
+  STATIC: "static"
+};
+function detectRuntime() {
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    if (typeof window.require !== "undefined" || typeof window.process !== "undefined" && window.process.versions?.electron) {
+      return RuntimeEnvironment.ELECTRON;
+    }
+    if (typeof window.__TAURI__ !== "undefined") {
+      return RuntimeEnvironment.TAURI;
+    }
+    return RuntimeEnvironment.BROWSER;
+  }
+  if (typeof process !== "undefined") {
+    if (process.versions?.node) {
+      return RuntimeEnvironment.NODE;
+    }
+  }
+  if (typeof EdgeRuntime !== "undefined") {
+    return RuntimeEnvironment.EDGE;
+  }
+  if (typeof caches !== "undefined" && typeof Request !== "undefined" && typeof Response !== "undefined" && typeof addEventListener !== "undefined") {
+    return RuntimeEnvironment.CLOUDFLARE;
+  }
+  if (typeof Deno !== "undefined") {
+    return RuntimeEnvironment.DENO;
+  }
+  if (typeof Bun !== "undefined") {
+    return RuntimeEnvironment.BUN;
+  }
+  return RuntimeEnvironment.BROWSER;
+}
+async function createRuntime(options = {}) {
+  const environment = options.environment || detectRuntime();
+  switch (environment) {
+    case RuntimeEnvironment.BROWSER:
+    case RuntimeEnvironment.ELECTRON:
+    case RuntimeEnvironment.TAURI: {
+      const { BrowserRuntime: BrowserRuntime2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
+      return new BrowserRuntime2(options);
+    }
+    case RuntimeEnvironment.EDGE:
+    case RuntimeEnvironment.CLOUDFLARE:
+    case RuntimeEnvironment.DENO:
+    case RuntimeEnvironment.BUN: {
+      const { EdgeRuntime: EdgeRuntime3 } = await Promise.resolve().then(() => (init_edge(), edge_exports));
+      return new EdgeRuntime3(options);
+    }
+    case RuntimeEnvironment.NODE: {
+      const { NodeRuntime: NodeRuntime2 } = await Promise.resolve().then(() => (init_node(), node_exports));
+      return new NodeRuntime2(options);
+    }
+    case RuntimeEnvironment.STATIC: {
+      const { StaticRuntime: StaticRuntime2 } = await Promise.resolve().then(() => (init_static(), static_exports));
+      return new StaticRuntime2(options);
+    }
+    default:
+      throw new Error(`Unsupported runtime environment: ${environment}`);
+  }
+}
+
+// src/utils/runtime-detector.js
+var RuntimeEnvironment2 = {
+  BROWSER: "browser",
+  NODE: "node",
+  DENO: "deno",
+  BUN: "bun",
+  EDGE: "edge",
+  CLOUDFLARE: "cloudflare",
+  ELECTRON: "electron",
+  TAURI: "tauri",
+  WEBVIEW: "webview",
+  STATIC: "static",
+  UNKNOWN: "unknown"
+};
+var RuntimeDetector = class _RuntimeDetector {
+  constructor() {
+    this.detectionResult = null;
+    this.capabilities = null;
+  }
+  // Reset detection cache (useful for testing)
+  reset() {
+    this.detectionResult = null;
+    this.capabilities = null;
+  }
+  // Main detection method
+  detect() {
+    if (this.detectionResult) {
+      return this.detectionResult;
+    }
+    this.detectionResult = this.performDetection();
+    return this.detectionResult;
+  }
+  performDetection() {
+    if (this.isTauri()) return RuntimeEnvironment2.TAURI;
+    if (this.isElectron()) return RuntimeEnvironment2.ELECTRON;
+    if (this.isWebView()) return RuntimeEnvironment2.WEBVIEW;
+    if (this.isDeno()) return RuntimeEnvironment2.DENO;
+    if (this.isBun()) return RuntimeEnvironment2.BUN;
+    if (this.isCloudflareWorkers()) return RuntimeEnvironment2.CLOUDFLARE;
+    if (this.isEdgeRuntime()) return RuntimeEnvironment2.EDGE;
+    if (this.isBrowser()) return RuntimeEnvironment2.BROWSER;
+    if (this.isNodeJS()) return RuntimeEnvironment2.NODE;
+    return RuntimeEnvironment2.UNKNOWN;
+  }
+  // Environment-specific detection methods
+  isBrowser() {
+    return typeof window !== "undefined" && typeof document !== "undefined" && typeof navigator !== "undefined";
+  }
+  isNodeJS() {
+    return typeof process !== "undefined" && process.versions && process.versions.node && typeof __require !== "undefined";
+  }
+  isDeno() {
+    return typeof Deno !== "undefined" && typeof Deno.version !== "undefined";
+  }
+  isBun() {
+    return typeof Bun !== "undefined" || typeof process !== "undefined" && process.versions && process.versions.bun;
+  }
+  isElectron() {
+    return typeof window !== "undefined" && typeof window.require !== "undefined" && typeof window.require("electron") !== "undefined";
+  }
+  isTauri() {
+    return typeof window !== "undefined" && typeof window.__TAURI__ !== "undefined";
+  }
+  isWebView() {
+    return typeof window !== "undefined" && (typeof window.webkit !== "undefined" || typeof window.external !== "undefined") && !this.isElectron() && !this.isTauri();
+  }
+  isCloudflareWorkers() {
+    return typeof caches !== "undefined" && typeof fetch !== "undefined" && typeof Response !== "undefined" && typeof addEventListener !== "undefined" && typeof window === "undefined";
+  }
+  isEdgeRuntime() {
+    return typeof EdgeRuntime !== "undefined" || typeof globalThis !== "undefined" && typeof globalThis.EdgeRuntime !== "undefined" || this.isVercelEdge() || this.isNetlifyEdge();
+  }
+  isVercelEdge() {
+    return typeof process !== "undefined" && process.env && process.env.VERCEL === "1" && typeof EdgeRuntime !== "undefined";
+  }
+  isNetlifyEdge() {
+    return typeof Netlify !== "undefined" || typeof process !== "undefined" && process.env && process.env.NETLIFY === "true";
+  }
+  // Detailed capability analysis
+  getCapabilities(environment = null) {
+    const env = environment || this.detect();
+    if (this.capabilities && !environment) {
+      return this.capabilities;
+    }
+    const capabilities = this.analyzeCapabilities(env);
+    if (!environment) {
+      this.capabilities = capabilities;
+    }
+    return capabilities;
+  }
+  analyzeCapabilities(environment) {
+    const base = {
+      environment,
+      dom: false,
+      ssr: false,
+      filesystem: false,
+      fetch: false,
+      websockets: false,
+      workers: false,
+      storage: false,
+      crypto: false,
+      streams: false,
+      modules: {
+        esm: false,
+        commonjs: false,
+        dynamicImport: false
+      },
+      apis: {
+        console: false,
+        timers: false,
+        events: false,
+        url: false,
+        base64: false
+      }
+    };
+    switch (environment) {
+      case RuntimeEnvironment2.BROWSER:
+        return {
+          ...base,
+          dom: true,
+          fetch: typeof fetch !== "undefined",
+          websockets: typeof WebSocket !== "undefined",
+          workers: typeof Worker !== "undefined",
+          storage: typeof localStorage !== "undefined",
+          crypto: typeof crypto !== "undefined",
+          streams: typeof ReadableStream !== "undefined",
+          modules: {
+            esm: true,
+            commonjs: false,
+            dynamicImport: (() => {
+              try {
+                return typeof Function('return import("")') === "function";
+              } catch {
+                return false;
+              }
+            })()
+          },
+          apis: {
+            console: typeof console !== "undefined",
+            timers: typeof setTimeout !== "undefined",
+            events: typeof EventTarget !== "undefined",
+            url: typeof URL !== "undefined",
+            base64: typeof btoa !== "undefined"
+          }
+        };
+      case RuntimeEnvironment2.NODE:
+        return {
+          ...base,
+          ssr: true,
+          filesystem: true,
+          fetch: typeof fetch !== "undefined",
+          websockets: true,
+          crypto: true,
+          streams: true,
+          modules: {
+            esm: true,
+            commonjs: true,
+            dynamicImport: (() => {
+              try {
+                return typeof Function('return import("")') === "function";
+              } catch {
+                return false;
+              }
+            })()
+          },
+          apis: {
+            console: true,
+            timers: true,
+            events: true,
+            url: typeof URL !== "undefined",
+            base64: typeof Buffer !== "undefined"
+          }
+        };
+      case RuntimeEnvironment2.DENO:
+        return {
+          ...base,
+          ssr: true,
+          filesystem: typeof Deno.readTextFile !== "undefined",
+          fetch: typeof fetch !== "undefined",
+          websockets: typeof WebSocket !== "undefined",
+          crypto: typeof crypto !== "undefined",
+          streams: typeof ReadableStream !== "undefined",
+          modules: {
+            esm: true,
+            commonjs: false,
+            dynamicImport: true
+          },
+          apis: {
+            console: true,
+            timers: true,
+            events: true,
+            url: typeof URL !== "undefined",
+            base64: typeof btoa !== "undefined"
+          }
+        };
+      case RuntimeEnvironment2.BUN:
+        return {
+          ...base,
+          ssr: true,
+          filesystem: true,
+          fetch: typeof fetch !== "undefined",
+          websockets: typeof WebSocket !== "undefined",
+          crypto: typeof crypto !== "undefined",
+          streams: typeof ReadableStream !== "undefined",
+          modules: {
+            esm: true,
+            commonjs: true,
+            dynamicImport: true
+          },
+          apis: {
+            console: true,
+            timers: true,
+            events: true,
+            url: typeof URL !== "undefined",
+            base64: typeof btoa !== "undefined"
+          }
+        };
+      case RuntimeEnvironment2.CLOUDFLARE:
+        return {
+          ...base,
+          ssr: true,
+          fetch: typeof fetch !== "undefined",
+          websockets: typeof WebSocket !== "undefined",
+          storage: typeof caches !== "undefined",
+          crypto: typeof crypto !== "undefined",
+          streams: typeof ReadableStream !== "undefined",
+          modules: {
+            esm: true,
+            commonjs: false,
+            dynamicImport: true
+          },
+          apis: {
+            console: true,
+            timers: true,
+            events: true,
+            url: typeof URL !== "undefined",
+            base64: typeof btoa !== "undefined"
+          }
+        };
+      case RuntimeEnvironment2.ELECTRON:
+        return {
+          ...base,
+          dom: true,
+          ssr: true,
+          filesystem: true,
+          fetch: typeof fetch !== "undefined",
+          websockets: typeof WebSocket !== "undefined",
+          workers: typeof Worker !== "undefined",
+          storage: typeof localStorage !== "undefined",
+          crypto: typeof crypto !== "undefined",
+          streams: typeof ReadableStream !== "undefined",
+          modules: {
+            esm: true,
+            commonjs: true,
+            dynamicImport: true
+          },
+          apis: {
+            console: true,
+            timers: true,
+            events: true,
+            url: typeof URL !== "undefined",
+            base64: typeof btoa !== "undefined"
+          }
+        };
+      case RuntimeEnvironment2.TAURI:
+        return {
+          ...base,
+          dom: true,
+          ssr: true,
+          filesystem: typeof window !== "undefined" && typeof window.__TAURI__ !== "undefined",
+          fetch: typeof fetch !== "undefined",
+          websockets: typeof WebSocket !== "undefined",
+          storage: typeof localStorage !== "undefined",
+          crypto: typeof crypto !== "undefined",
+          streams: typeof ReadableStream !== "undefined",
+          modules: {
+            esm: true,
+            commonjs: false,
+            dynamicImport: true
+          },
+          apis: {
+            console: true,
+            timers: true,
+            events: true,
+            url: typeof URL !== "undefined",
+            base64: typeof btoa !== "undefined"
+          }
+        };
+      default:
+        return base;
+    }
+  }
+  // Get detailed runtime information
+  getRuntimeInfo() {
+    const environment = this.detect();
+    const capabilities = this.getCapabilities(environment);
+    return {
+      environment,
+      capabilities,
+      version: this.getRuntimeVersion(environment),
+      features: this.getAvailableFeatures(),
+      userAgent: this.getUserAgent(),
+      platform: this.getPlatformInfo()
+    };
+  }
+  // Alias method for backward compatibility
+  getEnvironmentInfo() {
+    return this.getRuntimeInfo();
+  }
+  getRuntimeVersion(environment) {
+    switch (environment) {
+      case RuntimeEnvironment2.NODE:
+        return typeof process !== "undefined" ? process.version : null;
+      case RuntimeEnvironment2.DENO:
+        return typeof Deno !== "undefined" ? Deno.version.deno : null;
+      case RuntimeEnvironment2.BUN:
+        return typeof Bun !== "undefined" ? Bun.version : typeof process !== "undefined" ? process.versions.bun : null;
+      case RuntimeEnvironment2.BROWSER:
+        return typeof navigator !== "undefined" ? navigator.userAgent : null;
+      default:
+        return null;
+    }
+  }
+  getAvailableFeatures() {
+    const features = [];
+    if (typeof fetch !== "undefined") features.push("fetch");
+    if (typeof WebSocket !== "undefined") features.push("websockets");
+    if (typeof Worker !== "undefined") features.push("workers");
+    if (typeof crypto !== "undefined") features.push("crypto");
+    if (typeof localStorage !== "undefined") features.push("localStorage");
+    if (typeof sessionStorage !== "undefined") features.push("sessionStorage");
+    if (typeof IndexedDB !== "undefined") features.push("indexedDB");
+    if (typeof WebAssembly !== "undefined") features.push("webassembly");
+    if (typeof SharedArrayBuffer !== "undefined") features.push("sharedArrayBuffer");
+    if (typeof BigInt !== "undefined") features.push("bigint");
+    if ((() => {
+      try {
+        return typeof Function('return import("")') === "function";
+      } catch {
+        return false;
+      }
+    })()) features.push("dynamicImport");
+    return features;
+  }
+  getUserAgent() {
+    if (typeof navigator !== "undefined" && navigator.userAgent) {
+      return navigator.userAgent;
+    }
+    return null;
+  }
+  getPlatformInfo() {
+    if (typeof navigator !== "undefined") {
+      return {
+        platform: navigator.platform,
+        language: navigator.language,
+        cookieEnabled: navigator.cookieEnabled,
+        onLine: navigator.onLine
+      };
+    }
+    if (typeof process !== "undefined") {
+      return {
+        platform: process.platform,
+        arch: process.arch,
+        version: process.version,
+        pid: process.pid
+      };
+    }
+    if (typeof Deno !== "undefined") {
+      return {
+        os: Deno.build.os,
+        arch: Deno.build.arch,
+        version: Deno.version
+      };
+    }
+    return null;
+  }
+  // Compatibility checking
+  isCompatible(requirements) {
+    const capabilities = this.getCapabilities();
+    for (const [feature, required] of Object.entries(requirements)) {
+      if (required && !capabilities[feature]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getIncompatibilities(requirements) {
+    const capabilities = this.getCapabilities();
+    const incompatibilities = [];
+    for (const [feature, required] of Object.entries(requirements)) {
+      if (required && !capabilities[feature]) {
+        incompatibilities.push(feature);
+      }
+    }
+    return incompatibilities;
+  }
+  // Static methods for quick access
+  static detect() {
+    return new _RuntimeDetector().detect();
+  }
+  static getCapabilities(environment = null) {
+    return new _RuntimeDetector().getCapabilities(environment);
+  }
+  static getRuntimeInfo() {
+    return new _RuntimeDetector().getRuntimeInfo();
+  }
+  static isCompatible(requirements) {
+    return new _RuntimeDetector().isCompatible(requirements);
+  }
+};
+function detectRuntime2() {
+  return RuntimeDetector.detect();
+}
+var runtimeDetector = new RuntimeDetector();
+
+// src/utils/module-resolver.js
+var ModuleResolver = class {
+  constructor(options = {}) {
+    this.options = {
+      baseUrl: "",
+      paths: {},
+      aliases: {},
+      extensions: [".js", ".mjs", ".cjs", ".ts", ".jsx", ".tsx"],
+      moduleMap: {},
+      cdnTemplate: "https://unpkg.com/{name}@{version}/{path}",
+      fallbacks: [],
+      ...options
+    };
+    this.environment = detectRuntime2();
+    this.resolutionCache = /* @__PURE__ */ new Map();
+  }
+  // Main resolution method
+  resolve(modulePath, context = {}) {
+    const cacheKey = this.getCacheKey(modulePath, context);
+    if (this.resolutionCache.has(cacheKey)) {
+      return this.resolutionCache.get(cacheKey);
+    }
+    const resolved = this.doResolve(modulePath, context);
+    this.resolutionCache.set(cacheKey, resolved);
+    return resolved;
+  }
+  doResolve(modulePath, context = {}) {
+    const pathInfo = this.analyzePath(modulePath);
+    switch (pathInfo.type) {
+      case "absolute":
+        return this.resolveAbsolute(pathInfo, context);
+      case "relative":
+        return this.resolveRelative(pathInfo, context);
+      case "package":
+        return this.resolvePackage(pathInfo, context);
+      case "alias":
+        return this.resolveAlias(pathInfo, context);
+      case "mapped":
+        return this.resolveMapped(pathInfo, context);
+      default:
+        throw new Error(`Unable to resolve module: ${modulePath}`);
+    }
+  }
+  analyzePath(modulePath) {
+    if (/^https?:\/\//.test(modulePath)) {
+      return { type: "absolute", path: modulePath, original: modulePath };
+    }
+    if (modulePath.startsWith("file://")) {
+      return { type: "absolute", path: modulePath, original: modulePath };
+    }
+    if (modulePath.startsWith("./") || modulePath.startsWith("../")) {
+      return { type: "relative", path: modulePath, original: modulePath };
+    }
+    if (this.options.moduleMap[modulePath]) {
+      return {
+        type: "mapped",
+        path: modulePath,
+        mapped: this.options.moduleMap[modulePath],
+        original: modulePath
+      };
+    }
+    const aliasKey = Object.keys(this.options.aliases).find(
+      (alias) => modulePath.startsWith(`${alias}/`) || modulePath === alias
+    );
+    if (aliasKey) {
+      return {
+        type: "alias",
+        path: modulePath,
+        alias: aliasKey,
+        remainder: modulePath.slice(aliasKey.length + 1),
+        original: modulePath
+      };
+    }
+    return { type: "package", path: modulePath, original: modulePath };
+  }
+  resolveAbsolute(pathInfo) {
+    return {
+      resolved: pathInfo.path,
+      type: "absolute",
+      original: pathInfo.original
+    };
+  }
+  resolveRelative(pathInfo, context) {
+    let baseUrl = context.baseUrl || this.options.baseUrl || "";
+    if (this.environment === RuntimeEnvironment2.BROWSER && !baseUrl) {
+      baseUrl = window.location.href;
+    }
+    if (!baseUrl) {
+      throw new Error(`Cannot resolve relative path "${pathInfo.path}" without base URL`);
+    }
+    const resolved = new URL(pathInfo.path, baseUrl).href;
+    return {
+      resolved,
+      type: "relative",
+      original: pathInfo.original,
+      baseUrl
+    };
+  }
+  resolvePackage(pathInfo, context) {
+    const packageName = this.parsePackageName(pathInfo.path);
+    switch (this.environment) {
+      case RuntimeEnvironment2.BROWSER:
+        return this.resolveBrowserPackage(packageName, context);
+      case RuntimeEnvironment2.NODE:
+        return this.resolveNodePackage(packageName, context);
+      case RuntimeEnvironment2.DENO:
+        return this.resolveDenoPackage(packageName, context);
+      case RuntimeEnvironment2.BUN:
+        return this.resolveBunPackage(packageName, context);
+      case RuntimeEnvironment2.CLOUDFLARE:
+      case RuntimeEnvironment2.EDGE:
+        return this.resolveEdgePackage(packageName, context);
+      default:
+        return this.resolveGenericPackage(packageName, context);
+    }
+  }
+  parsePackageName(modulePath) {
+    const parts = modulePath.split("/");
+    if (modulePath.startsWith("@")) {
+      return {
+        name: `${parts[0]}/${parts[1]}`,
+        subpath: parts.slice(2).join("/"),
+        scope: parts[0],
+        packageName: parts[1]
+      };
+    } else {
+      return {
+        name: parts[0],
+        subpath: parts.slice(1).join("/"),
+        scope: null,
+        packageName: parts[0]
+      };
+    }
+  }
+  resolveBrowserPackage(packageInfo, context) {
+    const cdnUrl = this.resolveToCdn(packageInfo, context);
+    return {
+      resolved: cdnUrl,
+      type: "package",
+      strategy: "cdn",
+      original: packageInfo.name + (packageInfo.subpath ? `/${packageInfo.subpath}` : ""),
+      package: packageInfo
+    };
+  }
+  resolveNodePackage(packageInfo) {
+    const modulePath = packageInfo.name + (packageInfo.subpath ? `/${packageInfo.subpath}` : "");
+    return {
+      resolved: modulePath,
+      type: "package",
+      strategy: "node",
+      original: modulePath,
+      package: packageInfo
+    };
+  }
+  resolveDenoPackage(packageInfo) {
+    const modulePath = `npm:${packageInfo.name}${packageInfo.subpath ? `/${packageInfo.subpath}` : ""}`;
+    return {
+      resolved: modulePath,
+      type: "package",
+      strategy: "deno-npm",
+      original: packageInfo.name + (packageInfo.subpath ? `/${packageInfo.subpath}` : ""),
+      package: packageInfo
+    };
+  }
+  resolveBunPackage(packageInfo) {
+    const modulePath = packageInfo.name + (packageInfo.subpath ? `/${packageInfo.subpath}` : "");
+    return {
+      resolved: modulePath,
+      type: "package",
+      strategy: "bun",
+      original: modulePath,
+      package: packageInfo
+    };
+  }
+  resolveEdgePackage(packageInfo, context) {
+    const cdnUrl = this.resolveToCdn(packageInfo, context);
+    return {
+      resolved: cdnUrl,
+      type: "package",
+      strategy: "edge-cdn",
+      original: packageInfo.name + (packageInfo.subpath ? `/${packageInfo.subpath}` : ""),
+      package: packageInfo
+    };
+  }
+  resolveGenericPackage(packageInfo) {
+    const modulePath = packageInfo.name + (packageInfo.subpath ? `/${packageInfo.subpath}` : "");
+    return {
+      resolved: modulePath,
+      type: "package",
+      strategy: "generic",
+      original: modulePath,
+      package: packageInfo
+    };
+  }
+  resolveToCdn(packageInfo, context = {}) {
+    const version = context.version || "latest";
+    const subpath = packageInfo.subpath || "dist/index.js";
+    return this.options.cdnTemplate.replace("{name}", packageInfo.name).replace("{version}", version).replace("{path}", subpath);
+  }
+  resolveAlias(pathInfo, context) {
+    const aliasTarget = this.options.aliases[pathInfo.alias];
+    const resolvedPath = pathInfo.remainder ? `${aliasTarget}/${pathInfo.remainder}` : aliasTarget;
+    const resolved = this.doResolve(resolvedPath, context);
+    return {
+      ...resolved,
+      type: "alias",
+      alias: pathInfo.alias,
+      aliasTarget,
+      original: pathInfo.original
+    };
+  }
+  resolveMapped(pathInfo, context) {
+    const mapped = pathInfo.mapped;
+    if (typeof mapped === "function") {
+      const result = mapped(pathInfo.path, context);
+      return {
+        resolved: result,
+        type: "mapped",
+        original: pathInfo.original,
+        mapFunction: true
+      };
+    }
+    return {
+      resolved: mapped,
+      type: "mapped",
+      original: pathInfo.original
+    };
+  }
+  // Path utilities
+  addExtension(path, extensions = null) {
+    const exts = extensions || this.options.extensions;
+    if (exts.some((ext) => path.endsWith(ext))) {
+      return path;
+    }
+    return path + exts[0];
+  }
+  stripExtension(path) {
+    const ext = this.options.extensions.find((e) => path.endsWith(e));
+    return ext ? path.slice(0, -ext.length) : path;
+  }
+  isRelative(path) {
+    return path.startsWith("./") || path.startsWith("../");
+  }
+  isAbsolute(path) {
+    return /^https?:\/\//.test(path) || path.startsWith("file://");
+  }
+  // Configuration methods
+  addAlias(alias, target) {
+    this.options.aliases[alias] = target;
+    this.clearCache();
+  }
+  addMapping(from, to) {
+    this.options.moduleMap[from] = to;
+    this.clearCache();
+  }
+  setBaseUrl(baseUrl) {
+    this.options.baseUrl = baseUrl;
+    this.clearCache();
+  }
+  setCdnTemplate(template) {
+    this.options.cdnTemplate = template;
+    this.clearCache();
+  }
+  // Path patterns and wildcards
+  resolvePattern(pattern, replacements = {}) {
+    let resolved = pattern;
+    Object.entries(replacements).forEach(([key, value]) => {
+      resolved = resolved.replace(new RegExp(`\\{${key}\\}`, "g"), value);
+    });
+    return resolved;
+  }
+  // Batch resolution
+  resolveAll(modulePaths, context = {}) {
+    return modulePaths.map((path) => {
+      try {
+        return { path, resolution: this.resolve(path, context), success: true };
+      } catch (error) {
+        return { path, error, success: false };
+      }
+    });
+  }
+  // Cache management
+  getCacheKey(modulePath, context) {
+    return `${modulePath}::${JSON.stringify(context)}`;
+  }
+  clearCache() {
+    this.resolutionCache.clear();
+  }
+  getCacheStats() {
+    return {
+      size: this.resolutionCache.size,
+      keys: Array.from(this.resolutionCache.keys())
+    };
+  }
+  // Validation
+  validateResolution(resolution) {
+    if (!resolution || !resolution.resolved) {
+      return { valid: false, error: "Invalid resolution object" };
+    }
+    switch (resolution.type) {
+      case "absolute":
+        if (!this.isAbsolute(resolution.resolved)) {
+          return { valid: false, error: "Absolute resolution must be a valid URL" };
+        }
+        break;
+      case "relative":
+        if (!resolution.baseUrl) {
+          return { valid: false, error: "Relative resolution must include baseUrl" };
+        }
+        break;
+    }
+    return { valid: true };
+  }
+  // Debug utilities
+  debug(modulePath, context = {}) {
+    const pathInfo = this.analyzePath(modulePath);
+    const resolution = this.resolve(modulePath, context);
+    const validation = this.validateResolution(resolution);
+    return {
+      input: modulePath,
+      context,
+      pathInfo,
+      resolution,
+      validation,
+      environment: this.environment,
+      options: this.options
+    };
+  }
+};
+var moduleResolver = new ModuleResolver();
+
+// src/utils/asset-manager.js
+var AssetManager = class {
+  constructor(options = {}) {
+    this.options = {
+      baseUrl: "",
+      assetPaths: {},
+      preloadAssets: [],
+      lazyLoad: true,
+      cacheAssets: true,
+      optimizeImages: true,
+      inlineThreshold: 1024,
+      // Inline assets smaller than this (bytes)
+      supportedFormats: {
+        images: ["png", "jpg", "jpeg", "gif", "svg", "webp", "avif"],
+        styles: ["css"],
+        fonts: ["woff", "woff2", "ttf", "otf"],
+        scripts: ["js", "mjs"]
+      },
+      ...options
+    };
+    this.environment = detectRuntime2();
+    this.loadedAssets = /* @__PURE__ */ new Map();
+    this.loadingAssets = /* @__PURE__ */ new Map();
+    this.assetCache = /* @__PURE__ */ new Map();
+  }
+  // Main asset loading method
+  async loadAsset(assetPath, options = {}) {
+    const resolvedPath = this.resolvePath(assetPath, options);
+    const assetType = this.getAssetType(resolvedPath);
+    const cacheKey = this.getCacheKey(resolvedPath, options);
+    if (this.options.cacheAssets && this.loadedAssets.has(cacheKey)) {
+      return this.loadedAssets.get(cacheKey);
+    }
+    if (this.loadingAssets.has(cacheKey)) {
+      return this.loadingAssets.get(cacheKey);
+    }
+    const loadingPromise = this.doLoadAsset(resolvedPath, assetType, options);
+    this.loadingAssets.set(cacheKey, loadingPromise);
+    try {
+      const asset = await loadingPromise;
+      if (this.options.cacheAssets) {
+        this.loadedAssets.set(cacheKey, asset);
+      }
+      return asset;
+    } finally {
+      this.loadingAssets.delete(cacheKey);
+    }
+  }
+  async doLoadAsset(assetPath, assetType, options = {}) {
+    switch (assetType) {
+      case "css":
+        return await this.loadStylesheet(assetPath, options);
+      case "image":
+        return await this.loadImage(assetPath, options);
+      case "font":
+        return await this.loadFont(assetPath, options);
+      case "script":
+        return await this.loadScript(assetPath, options);
+      case "data":
+        return await this.loadData(assetPath, options);
+      default:
+        return await this.loadGeneric(assetPath, options);
+    }
+  }
+  // CSS loading
+  async loadStylesheet(cssPath, options = {}) {
+    if (this.environment === RuntimeEnvironment2.BROWSER) {
+      return await this.loadBrowserStylesheet(cssPath, options);
+    } else {
+      return await this.loadServerStylesheet(cssPath, options);
+    }
+  }
+  async loadBrowserStylesheet(cssPath, options = {}) {
+    return new Promise((resolve, reject) => {
+      const existing = document.querySelector(`link[href="${cssPath}"]`);
+      if (existing) {
+        resolve({ element: existing, cached: true });
+        return;
+      }
+      const link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = cssPath;
+      if (options.media) link.media = options.media;
+      if (options.crossorigin) link.crossOrigin = options.crossorigin;
+      link.onload = () => {
+        resolve({ element: link, loaded: true });
+      };
+      link.onerror = () => {
+        reject(new Error(`Failed to load stylesheet: ${cssPath}`));
+      };
+      document.head.appendChild(link);
+    });
+  }
+  async loadServerStylesheet(cssPath) {
+    try {
+      const response = await fetch(cssPath);
+      const content = await response.text();
+      return {
+        content,
+        path: cssPath,
+        inline: true
+      };
+    } catch (error) {
+      throw new Error(`Failed to load stylesheet: ${cssPath} - ${error.message}`);
+    }
+  }
+  // Image loading
+  async loadImage(imagePath, options = {}) {
+    if (this.environment === RuntimeEnvironment2.BROWSER) {
+      return await this.loadBrowserImage(imagePath, options);
+    } else {
+      return await this.loadServerImage(imagePath, options);
+    }
+  }
+  async loadBrowserImage(imagePath, options = {}) {
+    return new Promise((resolve, reject) => {
+      const img = new Image();
+      if (options.crossorigin) img.crossOrigin = options.crossorigin;
+      if (options.loading) img.loading = options.loading;
+      if (options.sizes) img.sizes = options.sizes;
+      if (options.srcset) img.srcset = options.srcset;
+      img.onload = () => {
+        resolve({
+          element: img,
+          width: img.naturalWidth,
+          height: img.naturalHeight,
+          path: imagePath
+        });
+      };
+      img.onerror = () => {
+        reject(new Error(`Failed to load image: ${imagePath}`));
+      };
+      img.src = imagePath;
+    });
+  }
+  async loadServerImage(imagePath) {
+    try {
+      const response = await fetch(imagePath);
+      const blob = await response.blob();
+      return {
+        blob,
+        size: blob.size,
+        type: blob.type,
+        path: imagePath
+      };
+    } catch (error) {
+      throw new Error(`Failed to load image: ${imagePath} - ${error.message}`);
+    }
+  }
+  // Font loading
+  async loadFont(fontPath, options = {}) {
+    if (this.environment === RuntimeEnvironment2.BROWSER && "fonts" in document) {
+      return await this.loadBrowserFont(fontPath, options);
+    } else {
+      return await this.loadGeneric(fontPath, options);
+    }
+  }
+  async loadBrowserFont(fontPath, options = {}) {
+    try {
+      const fontFace = new FontFace(
+        options.family || "CustomFont",
+        `url(${fontPath})`,
+        {
+          style: options.style || "normal",
+          weight: options.weight || "normal",
+          stretch: options.stretch || "normal"
+        }
+      );
+      await fontFace.load();
+      document.fonts.add(fontFace);
+      return {
+        fontFace,
+        family: options.family,
+        loaded: true
+      };
+    } catch (error) {
+      throw new Error(`Failed to load font: ${fontPath} - ${error.message}`);
+    }
+  }
+  // Script loading
+  async loadScript(scriptPath, options = {}) {
+    if (this.environment === RuntimeEnvironment2.BROWSER) {
+      return await this.loadBrowserScript(scriptPath, options);
+    } else {
+      return await this.loadServerScript(scriptPath, options);
+    }
+  }
+  async loadBrowserScript(scriptPath, options = {}) {
+    return new Promise((resolve, reject) => {
+      const existing = document.querySelector(`script[src="${scriptPath}"]`);
+      if (existing) {
+        resolve({ element: existing, cached: true });
+        return;
+      }
+      const script = document.createElement("script");
+      script.src = scriptPath;
+      if (options.type) script.type = options.type;
+      if (options.async !== void 0) script.async = options.async;
+      if (options.defer !== void 0) script.defer = options.defer;
+      if (options.crossorigin) script.crossOrigin = options.crossorigin;
+      script.onload = () => {
+        resolve({ element: script, loaded: true });
+      };
+      script.onerror = () => {
+        reject(new Error(`Failed to load script: ${scriptPath}`));
+      };
+      document.head.appendChild(script);
+    });
+  }
+  async loadServerScript(scriptPath, options = {}) {
+    try {
+      const response = await fetch(scriptPath);
+      const content = await response.text();
+      return {
+        content,
+        path: scriptPath,
+        type: options.type || "text/javascript"
+      };
+    } catch (error) {
+      throw new Error(`Failed to load script: ${scriptPath} - ${error.message}`);
+    }
+  }
+  // Data loading (JSON, XML, etc.)
+  async loadData(dataPath) {
+    try {
+      const response = await fetch(dataPath);
+      const contentType = response.headers.get("content-type") || "";
+      let data;
+      if (contentType.includes("application/json")) {
+        data = await response.json();
+      } else if (contentType.includes("text/xml") || contentType.includes("application/xml")) {
+        const text = await response.text();
+        data = this.parseXML(text);
+      } else {
+        data = await response.text();
+      }
+      return {
+        data,
+        contentType,
+        path: dataPath
+      };
+    } catch (error) {
+      throw new Error(`Failed to load data: ${dataPath} - ${error.message}`);
+    }
+  }
+  parseXML(xmlString) {
+    if (typeof DOMParser !== "undefined") {
+      const parser = new DOMParser();
+      return parser.parseFromString(xmlString, "text/xml");
+    }
+    return xmlString;
+  }
+  // Generic loading
+  async loadGeneric(assetPath) {
+    try {
+      const response = await fetch(assetPath);
+      const blob = await response.blob();
+      return {
+        blob,
+        size: blob.size,
+        type: blob.type,
+        path: assetPath
+      };
+    } catch (error) {
+      throw new Error(`Failed to load asset: ${assetPath} - ${error.message}`);
+    }
+  }
+  // Path resolution
+  resolvePath(assetPath, options = {}) {
+    if (typeof assetPath !== "string") {
+      throw new Error(`Expected string path, got ${typeof assetPath}: ${assetPath}`);
+    }
+    if (assetPath.startsWith("http://") || assetPath.startsWith("https://")) {
+      return assetPath;
+    }
+    if (assetPath.startsWith("data:")) {
+      return assetPath;
+    }
+    if (assetPath.startsWith("blob:")) {
+      return assetPath;
+    }
+    if (this.options.assetPaths[assetPath]) {
+      return this.options.assetPaths[assetPath];
+    }
+    const baseUrl = options.baseUrl || this.options.baseUrl;
+    if (baseUrl) {
+      return new URL(assetPath, baseUrl).href;
+    }
+    return assetPath;
+  }
+  // Asset type detection
+  getAssetType(assetPath) {
+    const extension = this.getFileExtension(assetPath).toLowerCase();
+    if (this.options.supportedFormats.images.includes(extension)) {
+      return "image";
+    }
+    if (this.options.supportedFormats.styles.includes(extension)) {
+      return "css";
+    }
+    if (this.options.supportedFormats.fonts.includes(extension)) {
+      return "font";
+    }
+    if (this.options.supportedFormats.scripts.includes(extension)) {
+      return "script";
+    }
+    if (["json", "xml"].includes(extension)) {
+      return "data";
+    }
+    return "generic";
+  }
+  getFileExtension(path) {
+    const cleanPath = path.split("?")[0].split("#")[0];
+    const parts = cleanPath.split(".");
+    return parts.length > 1 ? parts.pop() : "";
+  }
+  // Batch operations
+  async loadAssets(assetPaths, options = {}) {
+    const loadPromises = assetPaths.map(
+      (path) => this.loadAsset(path, options).catch((error) => ({ error, path }))
+    );
+    const results = await Promise.all(loadPromises);
+    return {
+      successful: results.filter((r) => !r.error),
+      failed: results.filter((r) => r.error)
+    };
+  }
+  // Preloading
+  async preloadAssets(assetPaths = null) {
+    const toPreload = assetPaths || this.options.preloadAssets;
+    if (this.environment === RuntimeEnvironment2.BROWSER) {
+      return await this.preloadBrowserAssets(toPreload);
+    } else {
+      return await this.loadAssets(toPreload, { preload: true });
+    }
+  }
+  async preloadBrowserAssets(assetPaths) {
+    const preloadPromises = assetPaths.map(async (assetPath) => {
+      try {
+        const link = document.createElement("link");
+        link.rel = "preload";
+        link.href = this.resolvePath(assetPath);
+        const assetType = this.getAssetType(assetPath);
+        switch (assetType) {
+          case "css":
+            link.as = "style";
+            break;
+          case "script":
+            link.as = "script";
+            break;
+          case "font":
+            link.as = "font";
+            link.crossOrigin = "anonymous";
+            break;
+          case "image":
+            link.as = "image";
+            break;
+        }
+        document.head.appendChild(link);
+        return { success: true, path: assetPath };
+      } catch (error) {
+        return { success: false, path: assetPath, error };
+      }
+    });
+    return await Promise.all(preloadPromises);
+  }
+  // Cache management
+  getCacheKey(assetPath, options) {
+    return `${assetPath}::${JSON.stringify(options)}`;
+  }
+  clearCache() {
+    this.loadedAssets.clear();
+    this.assetCache.clear();
+  }
+  getCacheStats() {
+    return {
+      loaded: this.loadedAssets.size,
+      loading: this.loadingAssets.size,
+      cached: this.assetCache.size
+    };
+  }
+  // Asset optimization
+  shouldInline(assetPath, size = null) {
+    if (size && size <= this.options.inlineThreshold) {
+      return true;
+    }
+    return false;
+  }
+  async optimizeImage(imagePath, options = {}) {
+    return await this.loadImage(imagePath, options);
+  }
+  // Utilities
+  addAssetPath(alias, path) {
+    this.options.assetPaths[alias] = path;
+  }
+  setBaseUrl(baseUrl) {
+    this.options.baseUrl = baseUrl;
+  }
+  isAssetLoaded(assetPath) {
+    const resolvedPath = this.resolvePath(assetPath);
+    return this.loadedAssets.has(this.getCacheKey(resolvedPath, {}));
+  }
+  getLoadedAssets() {
+    return Array.from(this.loadedAssets.keys());
+  }
+};
+var assetManager = new AssetManager();
+
+// src/index.js
+async function createCoherentApp(options = {}) {
+  const runtime = await createRuntime(options);
+  return runtime.createApp(options);
+}
+function renderApp(component, props = {}, target = null) {
+  const runtime = detectRuntime();
+  if (typeof runtime === "object" && runtime.renderApp) {
+    return runtime.renderApp(component, props, target);
+  }
+  throw new Error("renderApp requires a proper runtime implementation");
+}
+if (typeof window !== "undefined") {
+  window.Coherent = {
+    // Core functionality
+    render: async (obj) => {
+      const { render: render5 } = await import("@coherent.js/core");
+      return render5(obj);
+    },
+    // Hydration
+    hydrate: async (element, component, props) => {
+      const { hydrate: hydrate2 } = await import("@coherent.js/client");
+      return hydrate2(element, component, props);
+    },
+    // Web Components
+    defineComponent: async (name, component, options) => {
+      const { defineComponent } = await import("@coherent.js/web-components");
+      return defineComponent(name, component, options);
+    },
+    // Universal app creation
+    createApp: createCoherentApp,
+    renderApp,
+    // Version info
+    VERSION: "1.1.1"
+  };
+  if (document.querySelector("[data-coherent-auto]")) {
+    document.addEventListener("DOMContentLoaded", async () => {
+      const { autoHydrate: autoHydrate2 } = await import("@coherent.js/client");
+      autoHydrate2(window.componentRegistry || {});
+    });
+  }
+}
+var VERSION = "1.1.1";
+export {
+  AssetManager,
+  BrowserRuntime,
+  ComponentLoader,
+  DesktopRuntime,
+  EdgeRuntime2 as EdgeRuntime,
+  ModuleResolver,
+  RuntimeDetector,
+  RuntimeEnvironment,
+  StaticRuntime,
+  UniversalLoader,
+  VERSION,
+  createCoherentApp,
+  createRuntime,
+  detectRuntime,
+  renderApp
+};
+//# sourceMappingURL=coherent-universal.js.map