@hypen-space/core 0.4.1 → 0.4.3

package/dist/index.js

@@ -895,7 +895,11 @@ class BaseRenderer {
 
 class ConsoleRenderer {
   applyPatches(patches) {
-    log3.debug("Patches:", patches);
+    console.group("Hypen Patches");
+    for (const patch of patches) {
+      console.log(patch);
+    }
+    console.groupEnd();
   }
 }
 
@@ -1796,113 +1800,258 @@ class RemoteEngine {
   }
 }
 
-// src/engine.ts
-init_logger();
-import { WasmEngine } from "../wasm-node/hypen_engine.js";
-var log9 = frameworkLoggers.engine;
-function unwrapForWasm(value) {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (typeof value.__getSnapshot === "function") {
-    return value.__getSnapshot();
+// src/resolver.ts
+class ComponentResolver {
+  cache = new Map;
+  options;
+  moduleRegistry;
+  constructor(options = {}) {
+    this.options = {
+      baseDir: options.baseDir || process.cwd(),
+      cache: options.cache ?? true,
+      customFetch: options.customFetch || this.defaultFetch.bind(this),
+      moduleRegistry: options.moduleRegistry
+    };
+    this.moduleRegistry = options.moduleRegistry;
   }
-  try {
-    return structuredClone(value);
-  } catch {
-    return JSON.parse(JSON.stringify(value));
+  async resolve(importStmt) {
+    if (this.moduleRegistry) {
+      const names = importStmt.clause.type === "named" ? importStmt.clause.names : [importStmt.clause.name];
+      const allFound = names.every((name) => this.moduleRegistry.has(name));
+      if (allFound) {
+        const result = {};
+        for (const name of names) {
+          const def = this.moduleRegistry.get(name);
+          result[name] = {
+            module: def,
+            template: def?.template || ""
+          };
+        }
+        return result;
+      }
+    }
+    const sourcePath = this.getSourcePath(importStmt.source);
+    if (this.options.cache && this.cache.has(sourcePath)) {
+      const cached = this.cache.get(sourcePath);
+      return this.extractComponents(importStmt.clause, cached);
+    }
+    let component;
+    if (importStmt.source.type === "local") {
+      component = await this.resolveLocal(importStmt.source.path);
+    } else {
+      component = await this.resolveUrl(importStmt.source.url);
+    }
+    if (this.options.cache) {
+      this.cache.set(sourcePath, component);
+    }
+    return this.extractComponents(importStmt.clause, component);
   }
-}
-
-class Engine {
-  wasmEngine = null;
-  initialized = false;
-  async init() {
-    if (this.initialized)
-      return;
-    this.wasmEngine = new WasmEngine;
-    this.initialized = true;
+  async resolveLocal(path) {
+    const { resolve, join } = await import("path");
+    const { readFile } = await import("fs/promises");
+    const basePath = resolve(this.options.baseDir, path);
+    const hypenPath = basePath.endsWith(".hypen") ? basePath : `${basePath}.hypen`;
+    const template = await readFile(hypenPath, "utf-8");
+    const modulePath = hypenPath.replace(/\.hypen$/, ".ts");
+    let module = {};
+    try {
+      module = await import(modulePath);
+    } catch {}
+    return { module, template };
   }
-  ensureInitialized() {
-    if (!this.wasmEngine) {
-      throw new Error("Engine not initialized. Call init() first.");
+  async resolveUrl(url) {
+    try {
+      const response = await this.options.customFetch(url);
+      const data = JSON.parse(response);
+      if (!data.module || !data.template) {
+        throw new Error(`Invalid component format from ${url}. Expected { module, template }`);
+      }
+      return data;
+    } catch (error) {
+      throw new Error(`Failed to resolve component from ${url}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    return this.wasmEngine;
   }
-  setRenderCallback(callback) {
-    const engine = this.ensureInitialized();
-    engine.setRenderCallback((patches) => {
-      callback(patches);
-    });
+  async defaultFetch(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return response.text();
   }
-  setComponentResolver(resolver) {
-    const engine = this.ensureInitialized();
-    engine.setComponentResolver((componentName, contextPath) => {
-      const result = resolver(componentName, contextPath);
+  extractComponents(clause, component) {
+    if (clause.type === "default") {
+      return {
+        [clause.name]: component
+      };
+    } else {
+      const result = {};
+      for (const name of clause.names) {
+        result[name] = component;
+      }
       return result;
-    });
-  }
-  renderSource(source) {
-    const engine = this.ensureInitialized();
-    engine.renderSource(source);
+    }
   }
-  renderLazyComponent(source) {
-    const engine = this.ensureInitialized();
-    engine.renderLazyComponent(source);
+  getSourcePath(source) {
+    return source.type === "local" ? source.path : source.url;
   }
-  renderInto(source, parentNodeId, state) {
-    const engine = this.ensureInitialized();
-    engine.renderInto(source, parentNodeId, unwrapForWasm(state));
+  clearCache() {
+    this.cache.clear();
   }
-  notifyStateChange(paths, values) {
-    const engine = this.ensureInitialized();
-    if (paths.length === 0) {
-      return;
+  static parseImports(text) {
+    const imports = [];
+    const importRegex = /import\s+(?:(\{[^}]*\})|(\w+))\s+from\s+["']([^"']+)["']/g;
+    let match2;
+    while ((match2 = importRegex.exec(text)) !== null) {
+      const [, namedImports, defaultImport, source] = match2;
+      if (!source)
+        continue;
+      let clause;
+      if (namedImports) {
+        const names = namedImports.slice(1, -1).split(",").map((n) => n.trim()).filter((n) => n.length > 0);
+        clause = { type: "named", names };
+      } else if (defaultImport) {
+        clause = { type: "default", name: defaultImport };
+      } else {
+        continue;
+      }
+      const sourceObj = source.startsWith("http://") || source.startsWith("https://") ? { type: "url", url: source } : { type: "local", path: source };
+      imports.push({ clause, source: sourceObj });
     }
-    engine.updateStateSparse(paths, unwrapForWasm(values));
-    log9.debug("State changed (sparse):", paths);
+    return imports;
   }
-  notifyStateChangeFull(paths, currentState) {
-    const engine = this.ensureInitialized();
-    engine.updateState(unwrapForWasm(currentState));
-    if (paths.length > 0) {
-      log9.debug("State changed (full):", paths);
-    }
+}
+
+// src/components/builtin.ts
+init_app();
+init_logger();
+var log9 = frameworkLoggers.router;
+var Router = app.defineState({
+  currentPath: "/",
+  matchedRoute: null,
+  routeParams: {}
+}, { name: "__Router" }).onCreated((state, context) => {
+  if (!context) {
+    log9.error("Requires global context");
+    return;
   }
-  updateState(statePatch) {
-    const engine = this.ensureInitialized();
-    engine.updateState(unwrapForWasm(statePatch));
+  const router = context.__router;
+  if (!router) {
+    log9.error("Router not found in context");
+    return;
   }
-  dispatchAction(name, payload) {
-    const engine = this.ensureInitialized();
-    engine.dispatchAction(name, payload ?? null);
+  const hypenEngine = context.__hypenEngine;
+  const updateRouteVisibility = async (currentPath) => {
+    const routeElements = document.querySelectorAll('[data-hypen-type="route"]');
+    let matchFound = false;
+    for (let index = 0;index < routeElements.length; index++) {
+      const routeEl = routeElements[index];
+      const htmlEl = routeEl;
+      const routePath = htmlEl.dataset.routePath || "/";
+      const isMatch = routePath === currentPath;
+      htmlEl.style.display = isMatch ? "flex" : "none";
+      if (isMatch) {
+        matchFound = true;
+        const componentName = htmlEl.dataset.routeComponent;
+        const isLazy = htmlEl.dataset.routeLazy === "true";
+        const hasContent = htmlEl.children.length > 0;
+        if (componentName && !hasContent && hypenEngine) {
+          try {
+            await hypenEngine.renderLazyRoute(routePath, componentName, htmlEl);
+          } catch (err) {
+            log9.error(`Failed to render route ${routePath}:`, err);
+          }
+        }
+      }
+    }
+    if (!matchFound) {
+      log9.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
+    }
+  };
+  setTimeout(() => {
+    updateRouteVisibility(state.currentPath);
+  }, 100);
+  router.onNavigate((routeState) => {
+    state.currentPath = routeState.currentPath;
+    state.routeParams = routeState.params;
+    updateRouteVisibility(routeState.currentPath);
+  });
+}).build();
+var Route = app.defineState({}, { name: "__Route" }).build();
+var Link = app.defineState({
+  to: "/",
+  isActive: false
+}, { name: "__Link" }).onAction("navigate", ({ state, context }) => {
+  const router = context?.__router;
+  if (!router) {
+    log9.error("Link requires router context");
+    return;
   }
-  onAction(actionName, handler) {
-    const engine = this.ensureInitialized();
-    engine.onAction(actionName, (action) => {
-      Promise.resolve(handler(action)).catch((err) => log9.error("Action handler error:", err));
+  const targetPath = state.to;
+  router.push(targetPath);
+}).onCreated((state, context) => {
+  if (!context)
+    return;
+  const router = context.__router;
+  if (router) {
+    router.onNavigate((routeState) => {
+      state.isActive = routeState.currentPath === state.to;
     });
   }
-  setModule(name, actions, stateKeys, initialState) {
-    const engine = this.ensureInitialized();
-    engine.setModule(name, actions, stateKeys, initialState);
-  }
-  getRevision() {
-    const engine = this.ensureInitialized();
-    return Number(engine.getRevision());
-  }
-  clearTree() {
-    const engine = this.ensureInitialized();
-    engine.clearTree();
-  }
-  debugParseComponent(source) {
-    const engine = this.ensureInitialized();
-    return engine.debugParseComponent(source);
+}).build();
+
+// src/index.ts
+init_app();
+
+// src/hypen.ts
+function createBindingProxy(root) {
+  const handler = {
+    get(_, prop) {
+      if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
+        return () => `\${${root}}`;
+      }
+      if (typeof prop === "symbol") {
+        return;
+      }
+      if (prop === "toJSON") {
+        return () => `\${${root}}`;
+      }
+      return createBindingProxy(`${root}.${prop}`);
+    },
+    has() {
+      return true;
+    },
+    ownKeys() {
+      return [];
+    },
+    getOwnPropertyDescriptor() {
+      return {
+        configurable: true,
+        enumerable: true
+      };
+    }
+  };
+  return new Proxy({}, handler);
+}
+var state = createBindingProxy("state");
+var item = createBindingProxy("item");
+var index = {
+  [Symbol.toPrimitive]: () => "${index}",
+  toString: () => "${index}",
+  valueOf: () => "${index}",
+  toJSON: () => "${index}"
+};
+function hypen(strings, ...expressions) {
+  let result = strings[0];
+  for (let i = 0;i < expressions.length; i++) {
+    const expr = expressions[i];
+    result += String(expr);
+    result += strings[i + 1];
   }
+  return result.trim();
 }
 
-// src/remote/server.ts
-init_app();
+// src/index.ts
+init_state();
 
 // src/remote/session.ts
 class SessionManager {
@@ -2028,1108 +2177,11 @@ class SessionManager {
   }
 }
 
-// src/remote/server.ts
-init_logger();
-var log10 = frameworkLoggers.remote;
-
-class RemoteServer {
-  _module = null;
-  _moduleName = "App";
-  _ui = "";
-  _config = {};
-  _sessionConfig = {};
-  _onConnectionCallbacks = [];
-  _onDisconnectionCallbacks = [];
-  clients = new Map;
-  nextClientId = 1;
-  server = null;
-  sessionManager = null;
-  module(name, module) {
-    this._moduleName = name;
-    this._module = module;
-    return this;
-  }
-  ui(dsl) {
-    this._ui = dsl;
-    return this;
-  }
-  config(config2) {
-    this._config = { ...this._config, ...config2 };
-    return this;
-  }
-  session(config2) {
-    this._sessionConfig = config2;
-    return this;
-  }
-  onConnection(callback) {
-    this._onConnectionCallbacks.push(callback);
-    return this;
-  }
-  onDisconnection(callback) {
-    this._onDisconnectionCallbacks.push(callback);
-    return this;
-  }
-  listen(port) {
-    if (!this._module) {
-      throw new Error("Module not set. Call .module() before .listen()");
-    }
-    if (!this._ui) {
-      throw new Error("UI not set. Call .ui() before .listen()");
-    }
-    this.sessionManager = new SessionManager(this._sessionConfig);
-    const finalPort = port ?? this._config.port ?? 3000;
-    const hostname = this._config.hostname ?? "0.0.0.0";
-    this.server = Bun.serve({
-      port: finalPort,
-      hostname,
-      websocket: {
-        open: (ws) => this.handleOpen(ws),
-        message: (ws, message) => this.handleMessage(ws, message),
-        close: (ws) => this.handleClose(ws)
-      },
-      fetch: (req, server) => {
-        const url = new URL(req.url);
-        if (server.upgrade(req, { data: undefined })) {
-          return;
-        }
-        if (url.pathname === "/health") {
-          return new Response("OK", { status: 200 });
-        }
-        if (url.pathname === "/stats") {
-          const stats = this.sessionManager?.getStats() ?? {
-            activeSessions: 0,
-            pendingSessions: 0,
-            totalConnections: 0
-          };
-          return new Response(JSON.stringify(stats), {
-            headers: { "Content-Type": "application/json" }
-          });
-        }
-        return new Response("Hypen Remote Server", { status: 200 });
-      }
-    });
-    log10.info(`Hypen app streaming on ws://${hostname}:${finalPort}`);
-    return this;
-  }
-  stop() {
-    if (this.server) {
-      this.server.stop();
-      this.server = null;
-    }
-    if (this.sessionManager) {
-      this.sessionManager.destroy();
-      this.sessionManager = null;
-    }
-  }
-  get url() {
-    if (!this.server)
-      return null;
-    const hostname = this._config.hostname ?? "localhost";
-    const port = this._config.port ?? 3000;
-    return `ws://${hostname}:${port}`;
-  }
-  async handleOpen(ws) {
-    try {
-      const clientId = `client_${this.nextClientId++}`;
-      const connectedAt = new Date;
-      const engine = new Engine;
-      await engine.init();
-      const moduleInstance = new HypenModuleInstance(engine, this._module);
-      const clientData = {
-        id: clientId,
-        engine,
-        moduleInstance,
-        revision: 0,
-        connectedAt,
-        sessionId: "",
-        helloReceived: false
-      };
-      this.clients.set(ws, clientData);
-      clientData.helloTimeout = setTimeout(() => {
-        if (!clientData.helloReceived) {
-          this.initializeSession(ws, clientData, undefined, undefined);
-        }
-      }, 1000);
-    } catch (error) {
-      log10.error("Error handling WebSocket open:", error);
-      ws.close(1011, "Internal server error");
-    }
-  }
-  async initializeSession(ws, clientData, requestedSessionId, props) {
-    if (clientData.helloReceived)
-      return;
-    clientData.helloReceived = true;
-    if (clientData.helloTimeout) {
-      clearTimeout(clientData.helloTimeout);
-      clientData.helloTimeout = undefined;
-    }
-    let session;
-    let isNew = true;
-    let isRestored = false;
-    let restoredState = null;
-    if (requestedSessionId && this.sessionManager) {
-      const resumed = this.sessionManager.resumeSession(requestedSessionId);
-      if (resumed) {
-        session = resumed.session;
-        restoredState = resumed.savedState;
-        isNew = false;
-        isRestored = true;
-        await this.triggerReconnect(clientData, session, restoredState);
-      } else {
-        const activeSession = this.sessionManager.getActiveSession(requestedSessionId);
-        if (activeSession) {
-          const handled = await this.handleConcurrentConnection(ws, clientData, activeSession, props);
-          if (!handled)
-            return;
-          session = activeSession;
-          isNew = false;
-        } else {
-          session = this.sessionManager.createSession(props);
-        }
-      }
-    } else if (this.sessionManager) {
-      session = this.sessionManager.createSession(props);
-    } else {
-      session = {
-        id: crypto.randomUUID(),
-        ttl: 3600,
-        createdAt: new Date,
-        lastConnectedAt: new Date,
-        props
-      };
-    }
-    clientData.sessionId = session.id;
-    this.sessionManager?.trackConnection(session.id, ws);
-    const sessionAck = {
-      type: "sessionAck",
-      sessionId: session.id,
-      isNew,
-      isRestored
-    };
-    ws.send(JSON.stringify(sessionAck));
-    this.setupRenderCallback(ws, clientData);
-    const initialPatches = [];
-    clientData.engine.setRenderCallback((patches) => {
-      initialPatches.push(...patches);
-    });
-    clientData.engine.renderSource(this._ui);
-    this.setupRenderCallback(ws, clientData);
-    const initialMessage = {
-      type: "initialTree",
-      module: this._moduleName,
-      state: clientData.moduleInstance.getState(),
-      patches: initialPatches,
-      revision: 0
-    };
-    ws.send(JSON.stringify(initialMessage));
-    const client = {
-      id: clientData.id,
-      socket: ws,
-      connectedAt: clientData.connectedAt
-    };
-    this._onConnectionCallbacks.forEach((cb) => cb(client));
-  }
-  setupRenderCallback(ws, clientData) {
-    clientData.engine.setRenderCallback((patches) => {
-      const data = this.clients.get(ws);
-      if (!data)
-        return;
-      data.revision++;
-      const message = {
-        type: "patch",
-        module: this._moduleName,
-        patches,
-        revision: data.revision
-      };
-      ws.send(JSON.stringify(message));
-      if (this.sessionManager?.getConcurrentPolicy() === "allow-multiple" && data.sessionId) {
-        const connections = this.sessionManager.getConnections(data.sessionId);
-        if (connections) {
-          for (const conn of connections) {
-            if (conn !== ws) {
-              conn.send(JSON.stringify(message));
-            }
-          }
-        }
-      }
-    });
-  }
-  async handleConcurrentConnection(ws, clientData, existingSession, props) {
-    const policy = this.sessionManager?.getConcurrentPolicy() ?? "kick-old";
-    switch (policy) {
-      case "kick-old": {
-        const existingConnections = this.sessionManager?.getConnections(existingSession.id);
-        if (existingConnections) {
-          for (const conn of existingConnections) {
-            const oldWs = conn;
-            const expiredMsg = {
-              type: "sessionExpired",
-              sessionId: existingSession.id,
-              reason: "kicked"
-            };
-            oldWs.send(JSON.stringify(expiredMsg));
-            oldWs.close(1000, "Session taken by new connection");
-          }
-        }
-        return true;
-      }
-      case "reject-new": {
-        const expiredMsg = {
-          type: "sessionExpired",
-          sessionId: existingSession.id,
-          reason: "kicked"
-        };
-        ws.send(JSON.stringify(expiredMsg));
-        ws.close(1000, "Session already active");
-        return false;
-      }
-      case "allow-multiple": {
-        return true;
-      }
-      default:
-        return true;
-    }
-  }
-  async triggerReconnect(clientData, session, savedState) {
-    const handler = this._module?.handlers.onReconnect;
-    if (!handler)
-      return;
-    let restored = false;
-    const restore = (state) => {
-      restored = true;
-      clientData.moduleInstance.updateState(state);
-    };
-    await handler({ session, restore });
-  }
-  handleMessage(ws, message) {
-    try {
-      const clientData = this.clients.get(ws);
-      if (!clientData)
-        return;
-      const msg = JSON.parse(message.toString());
-      switch (msg.type) {
-        case "hello": {
-          const helloMsg = msg;
-          this.initializeSession(ws, clientData, helloMsg.sessionId, helloMsg.props);
-          break;
-        }
-        case "dispatchAction": {
-          const actionMsg = msg;
-          clientData.engine.dispatchAction(actionMsg.action, actionMsg.payload);
-          break;
-        }
-        default:
-          break;
-      }
-    } catch (error) {
-      log10.error("Error handling WebSocket message:", error);
-    }
-  }
-  async handleClose(ws) {
-    const clientData = this.clients.get(ws);
-    if (!clientData)
-      return;
-    if (clientData.helloTimeout) {
-      clearTimeout(clientData.helloTimeout);
-    }
-    const currentState = clientData.moduleInstance.getState();
-    if (clientData.sessionId && this._module?.handlers.onDisconnect) {
-      const session = this.sessionManager?.getActiveSession(clientData.sessionId);
-      if (session) {
-        await this._module.handlers.onDisconnect({
-          state: currentState,
-          session
-        });
-      }
-    }
-    if (clientData.sessionId && this.sessionManager) {
-      this.sessionManager.untrackConnection(clientData.sessionId, ws);
-      if (this.sessionManager.getConnectionCount(clientData.sessionId) === 0) {
-        const session = this.sessionManager.getActiveSession(clientData.sessionId);
-        if (session) {
-          this.sessionManager.suspendSession(clientData.sessionId, currentState, async (expiredSession) => {
-            if (this._module?.handlers.onExpire) {
-              await this._module.handlers.onExpire({ session: expiredSession });
-            }
-          });
-        }
-      }
-    }
-    await clientData.moduleInstance.destroy();
-    this.clients.delete(ws);
-    const client = {
-      id: clientData.id,
-      socket: ws,
-      connectedAt: clientData.connectedAt
-    };
-    this._onDisconnectionCallbacks.forEach((cb) => cb(client));
-  }
-  getClientCount() {
-    return this.clients.size;
-  }
-  getSessionStats() {
-    return this.sessionManager?.getStats() ?? {
-      activeSessions: 0,
-      pendingSessions: 0,
-      totalConnections: 0
-    };
-  }
-  broadcast(message) {
-    const json = JSON.stringify(message);
-    this.clients.forEach((_, ws) => {
-      ws.send(json);
-    });
-  }
-}
-function serve(options) {
-  const server = new RemoteServer().module(options.moduleName ?? "App", options.module).ui(options.ui);
-  if (options.port || options.hostname) {
-    server.config({
-      port: options.port,
-      hostname: options.hostname
-    });
-  }
-  if (options.session) {
-    server.session(options.session);
-  }
-  if (options.onConnection) {
-    server.onConnection(options.onConnection);
-  }
-  if (options.onDisconnection) {
-    server.onDisconnection(options.onDisconnection);
-  }
-  return server.listen(options.port);
-}
-
-// src/loader.ts
-init_logger();
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { join } from "path";
-var log11 = frameworkLoggers.loader;
-
-class ComponentLoader {
-  components = new Map;
-  register(name, module, template, path) {
-    this.components.set(name, {
-      name,
-      module,
-      template,
-      path: path || name
-    });
-  }
-  get(name) {
-    return this.components.get(name);
-  }
-  has(name) {
-    return this.components.has(name);
-  }
-  getNames() {
-    return Array.from(this.components.keys());
-  }
-  getAll() {
-    return Array.from(this.components.values());
-  }
-  clear() {
-    this.components.clear();
-  }
-  async loadFromDirectory(name, dirPath) {
-    try {
-      const modulePath = join(dirPath, "component.ts");
-      const moduleExport = await import(modulePath);
-      const module = moduleExport.default;
-      const templatePath = join(dirPath, "component.hypen");
-      const template = readFileSync(templatePath, "utf-8");
-      this.register(name, module, template, dirPath);
-      log11.debug(`Loaded component: ${name} from ${dirPath}`);
-    } catch (error) {
-      log11.error(`Failed to load component ${name} from ${dirPath}:`, error);
-      throw error;
-    }
-  }
-  async loadFromComponentsDir(baseDir) {
-    try {
-      if (!existsSync(baseDir)) {
-        log11.warn(`Components directory not found: ${baseDir}`);
-        return;
-      }
-      const entries = readdirSync(baseDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory())
-          continue;
-        const componentDir = join(baseDir, entry.name);
-        const hypenPath = join(componentDir, "component.hypen");
-        if (existsSync(hypenPath)) {
-          await this.loadFromDirectory(entry.name, componentDir);
-        }
-      }
-      log11.debug(`Loaded ${this.components.size} components from ${baseDir}`);
-    } catch (error) {
-      log11.error(`Failed to load components from ${baseDir}:`, error);
-      throw error;
-    }
-  }
-}
-var componentLoader = new ComponentLoader;
-
-// src/resolver.ts
-class ComponentResolver {
-  cache = new Map;
-  options;
-  moduleRegistry;
-  constructor(options = {}) {
-    this.options = {
-      baseDir: options.baseDir || process.cwd(),
-      cache: options.cache ?? true,
-      customFetch: options.customFetch || this.defaultFetch.bind(this),
-      moduleRegistry: options.moduleRegistry
-    };
-    this.moduleRegistry = options.moduleRegistry;
-  }
-  async resolve(importStmt) {
-    if (this.moduleRegistry) {
-      const names = importStmt.clause.type === "named" ? importStmt.clause.names : [importStmt.clause.name];
-      const allFound = names.every((name) => this.moduleRegistry.has(name));
-      if (allFound) {
-        const result = {};
-        for (const name of names) {
-          const def = this.moduleRegistry.get(name);
-          result[name] = {
-            module: def,
-            template: def?.template || ""
-          };
-        }
-        return result;
-      }
-    }
-    const sourcePath = this.getSourcePath(importStmt.source);
-    if (this.options.cache && this.cache.has(sourcePath)) {
-      const cached = this.cache.get(sourcePath);
-      return this.extractComponents(importStmt.clause, cached);
-    }
-    let component;
-    if (importStmt.source.type === "local") {
-      component = await this.resolveLocal(importStmt.source.path);
-    } else {
-      component = await this.resolveUrl(importStmt.source.url);
-    }
-    if (this.options.cache) {
-      this.cache.set(sourcePath, component);
-    }
-    return this.extractComponents(importStmt.clause, component);
-  }
-  async resolveLocal(path) {
-    const { resolve, join: join2 } = await import("path");
-    const { readFile } = await import("fs/promises");
-    const basePath = resolve(this.options.baseDir, path);
-    const hypenPath = basePath.endsWith(".hypen") ? basePath : `${basePath}.hypen`;
-    const template = await readFile(hypenPath, "utf-8");
-    const modulePath = hypenPath.replace(/\.hypen$/, ".ts");
-    let module = {};
-    try {
-      module = await import(modulePath);
-    } catch {}
-    return { module, template };
-  }
-  async resolveUrl(url) {
-    try {
-      const response = await this.options.customFetch(url);
-      const data = JSON.parse(response);
-      if (!data.module || !data.template) {
-        throw new Error(`Invalid component format from ${url}. Expected { module, template }`);
-      }
-      return data;
-    } catch (error) {
-      throw new Error(`Failed to resolve component from ${url}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async defaultFetch(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    return response.text();
-  }
-  extractComponents(clause, component) {
-    if (clause.type === "default") {
-      return {
-        [clause.name]: component
-      };
-    } else {
-      const result = {};
-      for (const name of clause.names) {
-        result[name] = component;
-      }
-      return result;
-    }
-  }
-  getSourcePath(source) {
-    return source.type === "local" ? source.path : source.url;
-  }
-  clearCache() {
-    this.cache.clear();
-  }
-  static parseImports(text) {
-    const imports = [];
-    const importRegex = /import\s+(?:(\{[^}]*\})|(\w+))\s+from\s+["']([^"']+)["']/g;
-    let match2;
-    while ((match2 = importRegex.exec(text)) !== null) {
-      const [, namedImports, defaultImport, source] = match2;
-      if (!source)
-        continue;
-      let clause;
-      if (namedImports) {
-        const names = namedImports.slice(1, -1).split(",").map((n) => n.trim()).filter((n) => n.length > 0);
-        clause = { type: "named", names };
-      } else if (defaultImport) {
-        clause = { type: "default", name: defaultImport };
-      } else {
-        continue;
-      }
-      const sourceObj = source.startsWith("http://") || source.startsWith("https://") ? { type: "url", url: source } : { type: "local", path: source };
-      imports.push({ clause, source: sourceObj });
-    }
-    return imports;
-  }
-}
-
-// src/discovery.ts
-init_logger();
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, watch } from "fs";
-import { join as join2, basename, resolve } from "path";
-async function discoverComponents(baseDir, options = {}) {
-  const {
-    patterns = ["single-file", "folder", "sibling", "index"],
-    recursive = false,
-    debug = false
-  } = options;
-  const log12 = debug ? (...args) => frameworkLoggers.discovery.debug(...args) : () => {};
-  const resolvedDir = resolve(baseDir);
-  const components = [];
-  const seen = new Set;
-  log12("Scanning directory:", resolvedDir);
-  log12("Patterns:", patterns);
-  const addTwoFileComponent = (name, hypenPath, modulePath) => {
-    if (seen.has(name)) {
-      log12(`Skipping duplicate: ${name}`);
-      return;
-    }
-    seen.add(name);
-    const templateRaw = readFileSync2(hypenPath, "utf-8");
-    const template = templateRaw.trim();
-    components.push({
-      name,
-      hypenPath,
-      modulePath,
-      template,
-      hasModule: modulePath !== null,
-      isSingleFile: false
-    });
-    log12(`Found: ${name} (two-file, ${modulePath ? "with module" : "stateless"})`);
-  };
-  const addSingleFileComponent = (name, modulePath, template) => {
-    if (seen.has(name)) {
-      log12(`Skipping duplicate: ${name}`);
-      return;
-    }
-    seen.add(name);
-    components.push({
-      name,
-      hypenPath: null,
-      modulePath,
-      template,
-      hasModule: true,
-      isSingleFile: true
-    });
-    log12(`Found: ${name} (single-file with inline template)`);
-  };
-  const scanForFolderComponents = (dir) => {
-    if (!existsSync2(dir))
-      return;
-    const entries = readdirSync2(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      const folderPath = join2(dir, entry.name);
-      const componentName = entry.name;
-      if (patterns.includes("folder")) {
-        const hypenPath = join2(folderPath, "component.hypen");
-        if (existsSync2(hypenPath)) {
-          const modulePath = join2(folderPath, "component.ts");
-          addTwoFileComponent(componentName, hypenPath, existsSync2(modulePath) ? modulePath : null);
-          continue;
-        }
-      }
-      if (patterns.includes("index")) {
-        const hypenPath = join2(folderPath, "index.hypen");
-        if (existsSync2(hypenPath)) {
-          const modulePath = join2(folderPath, "index.ts");
-          addTwoFileComponent(componentName, hypenPath, existsSync2(modulePath) ? modulePath : null);
-          continue;
-        }
-      }
-      if (recursive) {
-        scanForFolderComponents(folderPath);
-      }
-    }
-  };
-  const scanForSiblingComponents = (dir) => {
-    if (!existsSync2(dir))
-      return;
-    const entries = readdirSync2(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        if (recursive) {
-          scanForSiblingComponents(join2(dir, entry.name));
-        }
-        continue;
-      }
-      if (!entry.name.endsWith(".hypen"))
-        continue;
-      const hypenPath = join2(dir, entry.name);
-      const baseName = basename(entry.name, ".hypen");
-      if (baseName === "component" || baseName === "index")
-        continue;
-      const modulePath = join2(dir, `${baseName}.ts`);
-      addTwoFileComponent(baseName, hypenPath, existsSync2(modulePath) ? modulePath : null);
-    }
-  };
-  const scanForSingleFileComponents = async (dir) => {
-    if (!existsSync2(dir))
-      return;
-    const entries = readdirSync2(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        if (recursive) {
-          await scanForSingleFileComponents(join2(dir, entry.name));
-        }
-        continue;
-      }
-      if (!entry.name.endsWith(".ts"))
-        continue;
-      if (entry.name.startsWith(".") || entry.name.includes(".test.") || entry.name.includes(".spec."))
-        continue;
-      const baseName = basename(entry.name, ".ts");
-      if (baseName === "component" || baseName === "index")
-        continue;
-      const hypenPath = join2(dir, `${baseName}.hypen`);
-      if (existsSync2(hypenPath))
-        continue;
-      const modulePath = join2(dir, entry.name);
-      const content = readFileSync2(modulePath, "utf-8");
-      if (content.includes(".ui(") || content.includes(".ui(hypen")) {
-        try {
-          const moduleExport = await import(modulePath);
-          const module = moduleExport.default;
-          if (module && typeof module === "object" && module.template) {
-            addSingleFileComponent(baseName, modulePath, module.template);
-          }
-        } catch (e) {
-          log12(`Failed to import potential single-file component: ${entry.name}`, e);
-        }
-      }
-    }
-  };
-  if (patterns.includes("folder") || patterns.includes("index")) {
-    scanForFolderComponents(resolvedDir);
-  }
-  if (patterns.includes("sibling")) {
-    scanForSiblingComponents(resolvedDir);
-  }
-  if (patterns.includes("single-file")) {
-    await scanForSingleFileComponents(resolvedDir);
-  }
-  log12(`Discovered ${components.length} components`);
-  return components;
-}
-async function loadDiscoveredComponents(components) {
-  const { app: app2 } = await Promise.resolve().then(() => (init_app(), exports_app));
-  const loaded = new Map;
-  for (const component of components) {
-    let module;
-    let template = component.template;
-    if (component.modulePath) {
-      const moduleExport = await import(component.modulePath);
-      module = moduleExport.default;
-      if (component.isSingleFile && module.template) {
-        template = module.template;
-      }
-    } else {
-      module = app2.defineState({}).build();
-    }
-    loaded.set(component.name, {
-      name: component.name,
-      module,
-      template
-    });
-  }
-  return loaded;
-}
-function watchComponents(baseDir, options = {}) {
-  const resolvedDir = resolve(baseDir);
-  const {
-    onChange,
-    onAdd,
-    onRemove,
-    onUpdate,
-    debug = false,
-    ...discoveryOptions
-  } = options;
-  const log12 = debug ? (...args) => frameworkLoggers.discovery.debug("[watch]", ...args) : () => {};
-  let currentComponents = new Map;
-  let debounceTimer = null;
-  const initialScan = async () => {
-    const components = await discoverComponents(resolvedDir, discoveryOptions);
-    currentComponents = new Map(components.map((c) => [c.name, c]));
-    onChange?.(components);
-  };
-  const rescan = async () => {
-    if (debounceTimer) {
-      clearTimeout(debounceTimer);
-    }
-    debounceTimer = setTimeout(async () => {
-      log12("Rescanning...");
-      const newComponents = await discoverComponents(resolvedDir, discoveryOptions);
-      const newMap = new Map(newComponents.map((c) => [c.name, c]));
-      for (const [name, component] of newMap) {
-        const existing = currentComponents.get(name);
-        if (!existing) {
-          log12("Added:", name);
-          onAdd?.(component);
-        } else if (existing.template !== component.template || existing.modulePath !== component.modulePath) {
-          log12("Updated:", name);
-          onUpdate?.(component);
-        }
-      }
-      for (const name of currentComponents.keys()) {
-        if (!newMap.has(name)) {
-          log12("Removed:", name);
-          onRemove?.(name);
-        }
-      }
-      currentComponents = newMap;
-      onChange?.(newComponents);
-    }, 100);
-  };
-  const watcher = watch(resolvedDir, { recursive: true }, (event, filename) => {
-    if (!filename)
-      return;
-    if (filename.endsWith(".hypen") || filename.endsWith(".ts")) {
-      log12("File changed:", filename);
-      rescan();
-    }
-  });
-  initialScan();
-  return {
-    stop: () => {
-      watcher.close();
-      if (debounceTimer) {
-        clearTimeout(debounceTimer);
-      }
-    }
-  };
-}
-async function generateComponentsCode(baseDir, options = {}) {
-  const components = await discoverComponents(baseDir, options);
-  const resolvedDir = resolve(baseDir);
-  let code = `/**
- * Auto-generated component imports
- * Generated by @hypen-space/core discovery
- */
-
-`;
-  for (const component of components) {
-    const relativePath = component.modulePath ? "./" + component.modulePath.replace(resolvedDir + "/", "").replace(/\.ts$/, ".js") : null;
-    if (relativePath) {
-      code += `import ${component.name}Module from "${relativePath}";
-`;
-    }
-  }
-  code += `
-import { app } from "@hypen-space/core";
-
-`;
-  for (const component of components) {
-    if (component.isSingleFile) {
-      code += `export const ${component.name} = {
-  module: ${component.name}Module,
-  template: ${component.name}Module.template,
-};
-
-`;
-    } else if (component.hasModule) {
-      const templateJson = JSON.stringify(component.template);
-      code += `export const ${component.name} = {
-  module: ${component.name}Module,
-  template: ${templateJson},
-};
-
-`;
-    } else {
-      const templateJson = JSON.stringify(component.template);
-      code += `const ${component.name}Module = app.defineState({}).build();
-export const ${component.name} = {
-  module: ${component.name}Module,
-  template: ${templateJson},
-};
-
-`;
-    }
-  }
-  return code;
-}
-
-// src/plugin.ts
-init_logger();
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
-import { dirname, basename as basename2, join as join3, resolve as resolve2 } from "path";
-function findModulePath(hypenPath, patterns) {
-  const dir = dirname(hypenPath);
-  const baseName = basename2(hypenPath, ".hypen");
-  const parentDir = dirname(dir);
-  const folderName = basename2(dir);
-  for (const pattern of patterns) {
-    let candidatePath = null;
-    switch (pattern) {
-      case "sibling":
-        candidatePath = join3(dir, `${baseName}.ts`);
-        break;
-      case "component":
-        if (baseName === "component") {
-          candidatePath = join3(dir, "component.ts");
-        }
-        break;
-      case "index":
-        if (baseName === "index") {
-          candidatePath = join3(dir, "index.ts");
-        }
-        break;
-    }
-    if (candidatePath && existsSync3(candidatePath)) {
-      return candidatePath;
-    }
-  }
-  return null;
-}
-function getComponentName(hypenPath) {
-  const baseName = basename2(hypenPath, ".hypen");
-  if (baseName === "component" || baseName === "index") {
-    return basename2(dirname(hypenPath));
-  }
-  return baseName;
-}
-function parseImports(text) {
-  const imports = [];
-  const importRegex = /import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+["']([^"']+)["']/g;
-  let match2;
-  while ((match2 = importRegex.exec(text)) !== null) {
-    const [, namedImports, defaultImport, source] = match2;
-    if (!source)
-      continue;
-    let names;
-    if (namedImports) {
-      names = namedImports.split(",").map((n) => n.trim()).filter((n) => n.length > 0);
-    } else if (defaultImport) {
-      names = [defaultImport];
-    } else {
-      continue;
-    }
-    imports.push({ names, source });
-  }
-  return imports;
-}
-function removeImports(text) {
-  return text.replace(/import\s+(?:\{[^}]+\}|\w+)\s+from\s+["'][^"']+["']\s*/g, "");
-}
-function hypenPlugin(options = {}) {
-  const { debug = false, patterns = ["sibling", "component", "index"] } = options;
-  const log12 = debug ? (...args) => frameworkLoggers.plugin.debug(...args) : () => {};
-  return {
-    name: "hypen-loader",
-    async setup(build) {
-      build.onLoad({ filter: /\.hypen$/ }, async (args) => {
-        const hypenPath = resolve2(args.path);
-        log12("Loading:", hypenPath);
-        const templateRaw = readFileSync3(hypenPath, "utf-8");
-        const imports = parseImports(templateRaw);
-        const template = removeImports(templateRaw).trim();
-        if (imports.length > 0) {
-          log12("Found imports:", imports);
-        }
-        const componentName = getComponentName(hypenPath);
-        log12("Component name:", componentName);
-        const modulePath = findModulePath(hypenPath, patterns);
-        log12("Module path:", modulePath);
-        let contents;
-        if (modulePath) {
-          const relativeModulePath = modulePath.replace(/\.ts$/, ".js");
-          contents = `
-import _module from "${relativeModulePath}";
-export const module = _module;
-export const template = ${JSON.stringify(template)};
-export const name = ${JSON.stringify(componentName)};
-export default { module: _module, template: ${JSON.stringify(template)}, name: ${JSON.stringify(componentName)} };
-`;
-        } else {
-          log12("No module found, creating stateless component");
-          contents = `
-import { app } from "@hypen-space/core";
-const _module = app.defineState({}).build();
-export const module = _module;
-export const template = ${JSON.stringify(template)};
-export const name = ${JSON.stringify(componentName)};
-export default { module: _module, template: ${JSON.stringify(template)}, name: ${JSON.stringify(componentName)} };
-`;
-        }
-        return {
-          contents,
-          loader: "js"
-        };
-      });
-    }
-  };
-}
-var defaultHypenPlugin = hypenPlugin();
-function registerHypenPlugin(options) {
-  Bun.plugin(hypenPlugin(options));
-}
-var plugin_default = hypenPlugin;
-
-// src/components/builtin.ts
-init_app();
-init_logger();
-var log12 = frameworkLoggers.router;
-var Router = app.defineState({
-  currentPath: "/",
-  matchedRoute: null,
-  routeParams: {}
-}, { name: "__Router" }).onCreated((state, context) => {
-  if (!context) {
-    log12.error("Requires global context");
-    return;
-  }
-  const router = context.__router;
-  if (!router) {
-    log12.error("Router not found in context");
-    return;
-  }
-  const hypenEngine = context.__hypenEngine;
-  const updateRouteVisibility = async (currentPath) => {
-    const routeElements = document.querySelectorAll('[data-hypen-type="route"]');
-    let matchFound = false;
-    for (let index = 0;index < routeElements.length; index++) {
-      const routeEl = routeElements[index];
-      const htmlEl = routeEl;
-      const routePath = htmlEl.dataset.routePath || "/";
-      const isMatch = routePath === currentPath;
-      htmlEl.style.display = isMatch ? "flex" : "none";
-      if (isMatch) {
-        matchFound = true;
-        const componentName = htmlEl.dataset.routeComponent;
-        const isLazy = htmlEl.dataset.routeLazy === "true";
-        const hasContent = htmlEl.children.length > 0;
-        if (componentName && !hasContent && hypenEngine) {
-          try {
-            await hypenEngine.renderLazyRoute(routePath, componentName, htmlEl);
-          } catch (err) {
-            log12.error(`Failed to render route ${routePath}:`, err);
-          }
-        }
-      }
-    }
-    if (!matchFound) {
-      log12.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
-    }
-  };
-  setTimeout(() => {
-    updateRouteVisibility(state.currentPath);
-  }, 100);
-  router.onNavigate((routeState) => {
-    state.currentPath = routeState.currentPath;
-    state.routeParams = routeState.params;
-    updateRouteVisibility(routeState.currentPath);
-  });
-}).build();
-var Route = app.defineState({}, { name: "__Route" }).build();
-var Link = app.defineState({
-  to: "/",
-  isActive: false
-}, { name: "__Link" }).onAction("navigate", ({ state, context }) => {
-  const router = context?.__router;
-  if (!router) {
-    log12.error("Link requires router context");
-    return;
-  }
-  const targetPath = state.to;
-  router.push(targetPath);
-}).onCreated((state, context) => {
-  if (!context)
-    return;
-  const router = context.__router;
-  if (router) {
-    router.onNavigate((routeState) => {
-      state.isActive = routeState.currentPath === state.to;
-    });
-  }
-}).build();
-
 // src/index.ts
-init_app();
-
-// src/hypen.ts
-function createBindingProxy(root) {
-  const handler = {
-    get(_, prop) {
-      if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
-        return () => `\${${root}}`;
-      }
-      if (typeof prop === "symbol") {
-        return;
-      }
-      if (prop === "toJSON") {
-        return () => `\${${root}}`;
-      }
-      return createBindingProxy(`${root}.${prop}`);
-    },
-    has() {
-      return true;
-    },
-    ownKeys() {
-      return [];
-    },
-    getOwnPropertyDescriptor() {
-      return {
-        configurable: true,
-        enumerable: true
-      };
-    }
-  };
-  return new Proxy({}, handler);
-}
-var state = createBindingProxy("state");
-var item = createBindingProxy("item");
-var index = {
-  [Symbol.toPrimitive]: () => "${index}",
-  toString: () => "${index}",
-  valueOf: () => "${index}",
-  toJSON: () => "${index}"
-};
-function hypen(strings, ...expressions) {
-  let result = strings[0];
-  for (let i = 0;i < expressions.length; i++) {
-    const expr = expressions[i];
-    result += String(expr);
-    result += strings[i + 1];
-  }
-  return result.trim();
-}
-
-// src/index.ts
-init_state();
 init_result();
 init_logger();
 export {
   withRetry,
-  watchComponents,
   usingSync,
   using,
   unwrapProxy,
@@ -3139,16 +2191,13 @@ export {
   state,
   setLogLevel,
   setDebugMode,
-  serve,
   retryResult,
   retry,
-  registerHypenPlugin,
   match,
   mapErr,
   map,
   logger,
   log,
-  loadDiscoveredComponents,
   item,
   isStateProxy,
   isOk,
@@ -3156,13 +2205,11 @@ export {
   isDisposable,
   isDebugMode,
   index,
-  hypenPlugin,
   hypen,
   hasElementDisposables,
   getStateSnapshot,
   getLogLevel,
   getElementDisposables,
-  generateComponentsCode,
   fromTry,
   fromPromise,
   frameworkLoggers,
@@ -3175,15 +2222,12 @@ export {
   disposableListener,
   disposableInterval,
   disposableAbortController,
-  discoverComponents,
   disableLogging,
-  defaultHypenPlugin,
   createObservableState,
   createLogger,
   createEventEmitter,
   configureLogger,
   compositeDisposable,
-  componentLoader,
   batchStateUpdates,
   app,
   all,
@@ -3194,7 +2238,6 @@ export {
   Route,
   RetryPresets,
   RetryConditions,
-  RemoteServer,
   RemoteEngine,
   Ok,
   Logger,
@@ -3211,9 +2254,8 @@ export {
   ConsoleRenderer,
   ConnectionError,
   ComponentResolver,
-  ComponentLoader,
   BaseRenderer,
   ActionError
 };
 
-//# debugId=C03FB9EC8278859464756E2164756E21
+//# debugId=27843E67245517FE64756E2164756E21