@hypen-space/core 0.3.9 → 0.3.11

package/dist/{src/index.js → index.js}

@@ -10,6 +10,205 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// src/logger.ts
+function isProduction() {
+  if (typeof process !== "undefined" && process.env) {
+    return false;
+  }
+  return false;
+}
+function setLogLevel(level) {
+  config.level = level;
+}
+function getLogLevel() {
+  return config.level;
+}
+function configureLogger(options) {
+  config = { ...config, ...options };
+}
+function enableLogging() {
+  config.level = "debug";
+}
+function disableLogging() {
+  config.level = "none";
+}
+function setDebugMode(enabled) {
+  config.level = enabled ? "debug" : "error";
+}
+function isDebugMode() {
+  return config.level === "debug";
+}
+function shouldLog(level) {
+  return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[config.level];
+}
+function formatTag(tag, level) {
+  const timestamp = config.timestamps ? `${new Date().toISOString()} ` : "";
+  if (config.colors && level !== "none") {
+    const color = LOG_LEVEL_COLORS[level];
+    return `${timestamp}${color}[${tag}]${RESET_COLOR}`;
+  }
+  return `${timestamp}[${tag}]`;
+}
+
+class Logger {
+  tag;
+  constructor(tag) {
+    this.tag = tag;
+  }
+  debug(...args) {
+    if (!shouldLog("debug"))
+      return;
+    if (config.handler) {
+      config.handler.debug(this.tag, ...args);
+    } else {
+      console.log(formatTag(this.tag, "debug"), ...args);
+    }
+  }
+  info(...args) {
+    if (!shouldLog("info"))
+      return;
+    if (config.handler) {
+      config.handler.info(this.tag, ...args);
+    } else {
+      console.info(formatTag(this.tag, "info"), ...args);
+    }
+  }
+  warn(...args) {
+    if (!shouldLog("warn"))
+      return;
+    if (config.handler) {
+      config.handler.warn(this.tag, ...args);
+    } else {
+      console.warn(formatTag(this.tag, "warn"), ...args);
+    }
+  }
+  error(...args) {
+    if (!shouldLog("error"))
+      return;
+    if (config.handler) {
+      config.handler.error(this.tag, ...args);
+    } else {
+      console.error(formatTag(this.tag, "error"), ...args);
+    }
+  }
+  time(label, fn) {
+    if (!shouldLog("debug")) {
+      return fn();
+    }
+    const start = performance.now();
+    try {
+      return fn();
+    } finally {
+      const duration = performance.now() - start;
+      this.debug(`${label}: ${duration.toFixed(2)}ms`);
+    }
+  }
+  async timeAsync(label, fn) {
+    if (!shouldLog("debug")) {
+      return fn();
+    }
+    const start = performance.now();
+    try {
+      return await fn();
+    } finally {
+      const duration = performance.now() - start;
+      this.debug(`${label}: ${duration.toFixed(2)}ms`);
+    }
+  }
+  child(subTag) {
+    return new Logger(`${this.tag}:${subTag}`);
+  }
+  debugIf(condition, ...args) {
+    if (condition)
+      this.debug(...args);
+  }
+  warnIf(condition, ...args) {
+    if (condition)
+      this.warn(...args);
+  }
+  errorIf(condition, ...args) {
+    if (condition)
+      this.error(...args);
+  }
+  loggedOnce = new Set;
+  warnOnce(key, ...args) {
+    if (this.loggedOnce.has(key))
+      return;
+    this.loggedOnce.add(key);
+    this.warn(...args);
+  }
+  debugOnce(key, ...args) {
+    if (this.loggedOnce.has(key))
+      return;
+    this.loggedOnce.add(key);
+    this.debug(...args);
+  }
+}
+function createLogger(tag) {
+  return new Logger(tag);
+}
+var LOG_LEVEL_ORDER, LOG_LEVEL_COLORS, RESET_COLOR = "\x1B[0m", config, logger, log, frameworkLoggers;
+var init_logger = __esm(() => {
+  LOG_LEVEL_ORDER = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    none: 4
+  };
+  LOG_LEVEL_COLORS = {
+    debug: "\x1B[36m",
+    info: "\x1B[32m",
+    warn: "\x1B[33m",
+    error: "\x1B[31m"
+  };
+  config = {
+    level: isProduction() ? "error" : "debug",
+    colors: true,
+    timestamps: false
+  };
+  logger = createLogger("Hypen");
+  log = {
+    debug: (tag, ...args) => {
+      if (!shouldLog("debug"))
+        return;
+      console.log(formatTag(tag, "debug"), ...args);
+    },
+    info: (tag, ...args) => {
+      if (!shouldLog("info"))
+        return;
+      console.info(formatTag(tag, "info"), ...args);
+    },
+    warn: (tag, ...args) => {
+      if (!shouldLog("warn"))
+        return;
+      console.warn(formatTag(tag, "warn"), ...args);
+    },
+    error: (tag, ...args) => {
+      if (!shouldLog("error"))
+        return;
+      console.error(formatTag(tag, "error"), ...args);
+    }
+  };
+  frameworkLoggers = {
+    hypen: createLogger("Hypen"),
+    engine: createLogger("Engine"),
+    router: createLogger("Router"),
+    state: createLogger("State"),
+    events: createLogger("Events"),
+    remote: createLogger("Remote"),
+    renderer: createLogger("Renderer"),
+    module: createLogger("Module"),
+    lifecycle: createLogger("Lifecycle"),
+    loader: createLogger("Loader"),
+    context: createLogger("Context"),
+    discovery: createLogger("Discovery"),
+    plugin: createLogger("Plugin"),
+    canvas: createLogger("Canvas"),
+    debug: createLogger("Debug")
+  };
+});
+
 // src/state.ts
 function deepClone(obj) {
   if (obj === null || typeof obj !== "object") {
@@ -396,223 +595,37 @@ var init_result = __esm(() => {
   };
 });
 
-// src/logger.ts
-function isProduction() {
-  if (typeof process !== "undefined" && process.env) {
-    return false;
+// src/app.ts
+var exports_app = {};
+__export(exports_app, {
+  app: () => app,
+  HypenModuleInstance: () => HypenModuleInstance,
+  HypenAppBuilder: () => HypenAppBuilder,
+  HypenApp: () => HypenApp
+});
+
+class HypenAppBuilder {
+  initialState;
+  options;
+  createdHandler;
+  actionHandlers = new Map;
+  destroyedHandler;
+  disconnectHandler;
+  reconnectHandler;
+  expireHandler;
+  errorHandler;
+  template;
+  constructor(initialState, options) {
+    this.initialState = initialState;
+    this.options = options || {};
   }
-  return false;
-}
-function setLogLevel(level) {
-  config.level = level;
-}
-function getLogLevel() {
-  return config.level;
-}
-function configureLogger(options) {
-  config = { ...config, ...options };
-}
-function enableLogging() {
-  config.level = "debug";
-}
-function disableLogging() {
-  config.level = "none";
-}
-function shouldLog(level) {
-  return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[config.level];
-}
-function formatTag(tag, level) {
-  const timestamp = config.timestamps ? `${new Date().toISOString()} ` : "";
-  if (config.colors && level !== "none") {
-    const color = LOG_LEVEL_COLORS[level];
-    return `${timestamp}${color}[${tag}]${RESET_COLOR}`;
+  onCreated(fn) {
+    this.createdHandler = fn;
+    return this;
   }
-  return `${timestamp}[${tag}]`;
-}
-
-class Logger {
-  tag;
-  constructor(tag) {
-    this.tag = tag;
-  }
-  debug(...args) {
-    if (!shouldLog("debug"))
-      return;
-    if (config.handler) {
-      config.handler.debug(this.tag, ...args);
-    } else {
-      console.log(formatTag(this.tag, "debug"), ...args);
-    }
-  }
-  info(...args) {
-    if (!shouldLog("info"))
-      return;
-    if (config.handler) {
-      config.handler.info(this.tag, ...args);
-    } else {
-      console.info(formatTag(this.tag, "info"), ...args);
-    }
-  }
-  warn(...args) {
-    if (!shouldLog("warn"))
-      return;
-    if (config.handler) {
-      config.handler.warn(this.tag, ...args);
-    } else {
-      console.warn(formatTag(this.tag, "warn"), ...args);
-    }
-  }
-  error(...args) {
-    if (!shouldLog("error"))
-      return;
-    if (config.handler) {
-      config.handler.error(this.tag, ...args);
-    } else {
-      console.error(formatTag(this.tag, "error"), ...args);
-    }
-  }
-  time(label, fn) {
-    if (!shouldLog("debug")) {
-      return fn();
-    }
-    const start = performance.now();
-    try {
-      return fn();
-    } finally {
-      const duration = performance.now() - start;
-      this.debug(`${label}: ${duration.toFixed(2)}ms`);
-    }
-  }
-  async timeAsync(label, fn) {
-    if (!shouldLog("debug")) {
-      return fn();
-    }
-    const start = performance.now();
-    try {
-      return await fn();
-    } finally {
-      const duration = performance.now() - start;
-      this.debug(`${label}: ${duration.toFixed(2)}ms`);
-    }
-  }
-  child(subTag) {
-    return new Logger(`${this.tag}:${subTag}`);
-  }
-  debugIf(condition, ...args) {
-    if (condition)
-      this.debug(...args);
-  }
-  warnIf(condition, ...args) {
-    if (condition)
-      this.warn(...args);
-  }
-  errorIf(condition, ...args) {
-    if (condition)
-      this.error(...args);
-  }
-  loggedOnce = new Set;
-  warnOnce(key, ...args) {
-    if (this.loggedOnce.has(key))
-      return;
-    this.loggedOnce.add(key);
-    this.warn(...args);
-  }
-  debugOnce(key, ...args) {
-    if (this.loggedOnce.has(key))
-      return;
-    this.loggedOnce.add(key);
-    this.debug(...args);
-  }
-}
-function createLogger(tag) {
-  return new Logger(tag);
-}
-var LOG_LEVEL_ORDER, LOG_LEVEL_COLORS, RESET_COLOR = "\x1B[0m", config, logger, log, frameworkLoggers;
-var init_logger = __esm(() => {
-  LOG_LEVEL_ORDER = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-    none: 4
-  };
-  LOG_LEVEL_COLORS = {
-    debug: "\x1B[36m",
-    info: "\x1B[32m",
-    warn: "\x1B[33m",
-    error: "\x1B[31m"
-  };
-  config = {
-    level: isProduction() ? "error" : "debug",
-    colors: true,
-    timestamps: false
-  };
-  logger = createLogger("Hypen");
-  log = {
-    debug: (tag, ...args) => {
-      if (!shouldLog("debug"))
-        return;
-      console.log(formatTag(tag, "debug"), ...args);
-    },
-    info: (tag, ...args) => {
-      if (!shouldLog("info"))
-        return;
-      console.info(formatTag(tag, "info"), ...args);
-    },
-    warn: (tag, ...args) => {
-      if (!shouldLog("warn"))
-        return;
-      console.warn(formatTag(tag, "warn"), ...args);
-    },
-    error: (tag, ...args) => {
-      if (!shouldLog("error"))
-        return;
-      console.error(formatTag(tag, "error"), ...args);
-    }
-  };
-  frameworkLoggers = {
-    engine: createLogger("Engine"),
-    router: createLogger("Router"),
-    state: createLogger("State"),
-    events: createLogger("Events"),
-    remote: createLogger("Remote"),
-    renderer: createLogger("Renderer"),
-    module: createLogger("Module"),
-    lifecycle: createLogger("Lifecycle")
-  };
-});
-
-// src/app.ts
-var exports_app = {};
-__export(exports_app, {
-  app: () => app,
-  HypenModuleInstance: () => HypenModuleInstance,
-  HypenAppBuilder: () => HypenAppBuilder,
-  HypenApp: () => HypenApp
-});
-
-class HypenAppBuilder {
-  initialState;
-  options;
-  createdHandler;
-  actionHandlers = new Map;
-  destroyedHandler;
-  disconnectHandler;
-  reconnectHandler;
-  expireHandler;
-  errorHandler;
-  template;
-  constructor(initialState, options) {
-    this.initialState = initialState;
-    this.options = options || {};
-  }
-  onCreated(fn) {
-    this.createdHandler = fn;
-    return this;
-  }
-  onAction(name, fn) {
-    this.actionHandlers.set(name, fn);
-    return this;
+  onAction(name, fn) {
+    this.actionHandlers.set(name, fn);
+    return this;
   }
   onDestroyed(fn) {
     this.destroyedHandler = fn;
@@ -688,9 +701,9 @@ class HypenModuleInstance {
     });
     this.engine.setModule(definition.name || "AnonymousModule", definition.actions, definition.stateKeys, getStateSnapshot(this.state));
     for (const [actionName, handler] of definition.handlers.onAction) {
-      log2.debug(`Registering action handler: ${actionName} for module ${definition.name}`);
+      log4.debug(`Registering action handler: ${actionName} for module ${definition.name}`);
       this.engine.onAction(actionName, async (action) => {
-        log2.debug(`Action handler fired: ${actionName}`, action);
+        log4.debug(`Action handler fired: ${actionName}`, action);
         const actionCtx = {
           name: action.name,
           payload: action.payload,
@@ -712,7 +725,7 @@ class HypenModuleInstance {
             throw result.error;
           }
         } else {
-          log2.debug(`Action handler completed: ${actionName}`);
+          log4.debug(`Action handler completed: ${actionName}`);
         }
       });
     }
@@ -767,7 +780,7 @@ class HypenModuleInstance {
           }
         }
       } catch (handlerError) {
-        log2.error("Error in onError handler:", handlerError);
+        log4.error("Error in onError handler:", handlerError);
       }
     }
     if (this.globalContext) {
@@ -778,7 +791,7 @@ class HypenModuleInstance {
         context: eventContext
       });
     }
-    log2.error(`${context.actionName ? `Action "${context.actionName}"` : `Lifecycle "${context.lifecycle}"`} error:`, error);
+    log4.error(`${context.actionName ? `Action "${context.actionName}"` : `Lifecycle "${context.lifecycle}"`} error:`, error);
     return false;
   }
   async callCreatedHandler() {
@@ -808,17 +821,19 @@ class HypenModuleInstance {
     Object.assign(this.state, patch);
   }
 }
-var log2, app;
+var log4, app;
 var init_app = __esm(() => {
   init_result();
   init_state();
   init_logger();
-  log2 = createLogger("ModuleInstance");
+  log4 = createLogger("ModuleInstance");
   app = new HypenApp;
 });
 
 // src/engine.ts
+init_logger();
 import { WasmEngine } from "../wasm-node/hypen_engine.js";
+var log2 = frameworkLoggers.engine;
 function unwrapForWasm(value) {
   if (value === null || typeof value !== "object") {
     return value;
@@ -879,13 +894,13 @@ class Engine {
       return;
     }
     engine.updateStateSparse(paths, unwrapForWasm(values));
-    console.debug("[Hypen] State changed (sparse):", paths);
+    log2.debug("State changed (sparse):", paths);
   }
   notifyStateChangeFull(paths, currentState) {
     const engine = this.ensureInitialized();
     engine.updateState(unwrapForWasm(currentState));
     if (paths.length > 0) {
-      console.debug("[Hypen] State changed (full):", paths);
+      log2.debug("State changed (full):", paths);
     }
   }
   updateState(statePatch) {
@@ -899,7 +914,7 @@ class Engine {
   onAction(actionName, handler) {
     const engine = this.ensureInitialized();
     engine.onAction(actionName, (action) => {
-      Promise.resolve(handler(action)).catch(console.error);
+      Promise.resolve(handler(action)).catch((err) => log2.error("Action handler error:", err));
     });
   }
   setModule(name, actions, stateKeys, initialState) {
@@ -921,6 +936,8 @@ class Engine {
 }
 
 // src/engine.browser.ts
+init_logger();
+var log3 = frameworkLoggers.engine;
 var wasmInit = null;
 var WasmEngineClass = null;
 function mapToObject(value) {
@@ -959,7 +976,7 @@ class Engine2 {
       this.wasmEngine = new WasmEngineClass;
       this.initialized = true;
     } catch (error) {
-      console.error("[Hypen] Failed to initialize WASM engine:", error);
+      log3.error("Failed to initialize WASM engine:", error);
       throw error;
     }
   }
@@ -995,12 +1012,21 @@ class Engine2 {
     const safeState = JSON.parse(JSON.stringify(state));
     engine.renderInto(source, parentNodeId, safeState);
   }
-  notifyStateChange(paths, currentState) {
+  notifyStateChange(paths, values) {
+    const engine = this.ensureInitialized();
+    if (paths.length === 0) {
+      return;
+    }
+    const plainValues = JSON.parse(JSON.stringify(values));
+    engine.updateStateSparse(paths, plainValues);
+    log3.debug("State changed (sparse):", paths);
+  }
+  notifyStateChangeFull(paths, currentState) {
     const engine = this.ensureInitialized();
     const plainObject = JSON.parse(JSON.stringify(currentState));
     engine.updateState(plainObject);
     if (paths.length > 0) {
-      console.debug("[Hypen] State changed:", paths);
+      log3.debug("State changed (full):", paths);
     }
   }
   updateState(statePatch) {
@@ -1010,7 +1036,7 @@ class Engine2 {
   }
   dispatchAction(name, payload) {
     const engine = this.ensureInitialized();
-    console.log(`[Engine] Action dispatched: ${name}`);
+    log3.debug(`Action dispatched: ${name}`);
     engine.dispatchAction(name, payload ?? null);
   }
   onAction(actionName, handler) {
@@ -1020,7 +1046,7 @@ class Engine2 {
         ...action,
         payload: action.payload ? mapToObject(action.payload) : action.payload
       };
-      Promise.resolve(handler(normalizedAction)).catch(console.error);
+      Promise.resolve(handler(normalizedAction)).catch((err) => log3.error("Action handler error:", err));
     });
   }
   setModule(name, actions, stateKeys, initialState) {
@@ -1042,6 +1068,9 @@ class Engine2 {
 }
 
 // src/renderer.ts
+init_logger();
+var log5 = frameworkLoggers.renderer;
+
 class BaseRenderer {
   nodes = new Map;
   getNode(id) {
@@ -1082,16 +1111,14 @@ class BaseRenderer {
 
 class ConsoleRenderer {
   applyPatches(patches) {
-    console.group("Patches:");
-    for (const patch of patches) {
-      console.log(patch);
-    }
-    console.groupEnd();
+    log5.debug("Patches:", patches);
   }
 }
 
 // src/router.ts
 init_state();
+init_logger();
+var log6 = frameworkLoggers.router;
 
 class HypenRouter {
   state;
@@ -1129,7 +1156,7 @@ class HypenRouter {
       this.updatePath(newPath, false);
     });
     this.isInitialized = true;
-    console.log("Router initialized at:", initialPath);
+    log6.debug("Router initialized at:", initialPath);
   }
   getPathFromBrowser() {
     if (typeof window === "undefined")
@@ -1150,21 +1177,21 @@ class HypenRouter {
     return query;
   }
   push(path) {
-    console.log("Router.push:", path);
+    log6.debug("push:", path);
     this.updatePath(path, true);
   }
   replace(path) {
-    console.log("Router.replace:", path);
+    log6.debug("replace:", path);
     this.updatePath(path, true, true);
   }
   back() {
-    console.log("Router.back");
+    log6.debug("back");
     if (typeof window !== "undefined") {
       window.history.back();
     }
   }
   forward() {
-    console.log("Router.forward");
+    log6.debug("forward");
     if (typeof window !== "undefined") {
       window.history.forward();
     }
@@ -1260,7 +1287,7 @@ class HypenRouter {
     try {
       callback(this.getState());
     } catch (error) {
-      console.error("[HypenRouter] Error in route subscriber:", error);
+      log6.error("Error in route subscriber:", error);
     }
     return () => {
       this.subscribers.delete(callback);
@@ -1272,7 +1299,7 @@ class HypenRouter {
       try {
         callback(routeState);
       } catch (error) {
-        console.error("[HypenRouter] Error in route subscriber:", error);
+        log6.error("Error in route subscriber:", error);
       }
     });
   }
@@ -1289,6 +1316,9 @@ class HypenRouter {
 }
 
 // src/events.ts
+init_logger();
+var log7 = frameworkLoggers.events;
+
 class TypedEventEmitter {
   eventBus = new Map;
   emit(event, payload) {
@@ -1300,7 +1330,7 @@ class TypedEventEmitter {
       try {
         handler(payload);
       } catch (error) {
-        console.error(`Error in event handler for "${String(event)}":`, error);
+        log7.error(`Error in event handler for "${String(event)}":`, error);
       }
     });
   }
@@ -1352,6 +1382,9 @@ function createEventEmitter() {
 }
 
 // src/context.ts
+init_logger();
+var log8 = frameworkLoggers.context;
+
 class HypenGlobalContext {
   modules = new Map;
   typedEvents;
@@ -1364,14 +1397,14 @@ class HypenGlobalContext {
   }
   registerModule(id, instance) {
     if (this.modules.has(id)) {
-      console.warn(`Module "${id}" is already registered. Overwriting.`);
+      log8.warn(`Module "${id}" is already registered. Overwriting.`);
     }
     this.modules.set(id, instance);
-    console.log(`Registered module: ${id}`);
+    log8.debug(`Registered module: ${id}`);
   }
   unregisterModule(id) {
     this.modules.delete(id);
-    console.log(`Unregistered module: ${id}`);
+    log8.debug(`Unregistered module: ${id}`);
   }
   getModule(id) {
     const module = this.modules.get(id);
@@ -1400,14 +1433,14 @@ class HypenGlobalContext {
   emit(event, payload) {
     const handlers = this.legacyEventBus.get(event);
     if (!handlers || handlers.size === 0) {
-      console.log(`Event "${event}" emitted but no listeners`);
+      log8.debug(`Event "${event}" emitted but no listeners`);
     } else {
-      console.log(`Emitting event: ${event}`, payload);
+      log8.debug(`Emitting event: ${event}`, payload);
       handlers.forEach((handler) => {
         try {
           handler(payload);
         } catch (error) {
-          console.error(`Error in event handler for "${event}":`, error);
+          log8.error(`Error in event handler for "${event}":`, error);
         }
       });
     }
@@ -1421,7 +1454,7 @@ class HypenGlobalContext {
     }
     const handlers = this.legacyEventBus.get(event);
     handlers.add(handler);
-    console.log(`Listening to event: ${event}`);
+    log8.debug(`Listening to event: ${event}`);
     return () => {
       handlers.delete(handler);
       if (handlers.size === 0) {
@@ -1454,10 +1487,9 @@ class HypenGlobalContext {
   }
 }
 
-// src/remote/client.ts
-init_result();
-
 // src/disposable.ts
+init_logger();
+var log9 = frameworkLoggers.lifecycle;
 function isDisposable(obj) {
   return obj !== null && typeof obj === "object" && "dispose" in obj && typeof obj.dispose === "function";
 }
@@ -1489,7 +1521,7 @@ class DisposableStack {
       try {
         item.dispose();
       } catch (error) {
-        console.error("[DisposableStack] Error during dispose:", error);
+        log9.error("Error during dispose:", error);
       }
     }
   }
@@ -1580,7 +1612,7 @@ function compositeDisposable(...disposables) {
         try {
           d.dispose();
         } catch (error) {
-          console.error("[compositeDisposable] Error during dispose:", error);
+          log9.error("Error during dispose:", error);
         }
       }
     }
@@ -1603,6 +1635,9 @@ function usingSync(resource, fn) {
   }
 }
 
+// src/remote/client.ts
+init_result();
+
 // src/retry.ts
 init_result();
 var DEFAULT_OPTIONS = {
@@ -1730,6 +1765,9 @@ var RetryPresets = {
 };
 
 // src/remote/client.ts
+init_logger();
+var log10 = frameworkLoggers.remote;
+
 class RemoteEngine {
   ws = null;
   url;
@@ -1836,7 +1874,7 @@ class RemoteEngine {
   }
   dispatchAction(action, payload) {
     if (this.state !== "connected" || !this.ws) {
-      console.warn("Cannot dispatch action: not connected");
+      log10.warn("Cannot dispatch action: not connected");
       return;
     }
     const message = {
@@ -1909,7 +1947,7 @@ class RemoteEngine {
           break;
       }
     } catch (e) {
-      console.error("Error handling remote message:", e);
+      log10.error("Error handling remote message:", e);
       const error = e instanceof Error ? e : new Error(String(e));
       this.errorCallbacks.forEach((cb) => cb(error));
     }
@@ -1938,7 +1976,7 @@ class RemoteEngine {
   }
   handlePatch(message) {
     if (message.revision <= this.currentRevision) {
-      console.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
+      log10.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
       return;
     }
     this.currentRevision = message.revision;
@@ -1964,1209 +2002,1216 @@ class RemoteEngine {
         maxDelayMs: 30000,
         jitter: 0.1,
         onRetry: (attempt, error) => {
-          console.log(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
+          log10.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
         }
       }).catch((error) => {
-        console.error("Max reconnection attempts reached:", error.message);
+        log10.error("Max reconnection attempts reached:", error.message);
         this.errorCallbacks.forEach((cb) => cb(new ConnectionError(this.url, error, this.options.maxReconnectAttempts)));
       });
     }, this.options.reconnectInterval);
   }
 }
 
-// src/loader.ts
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { join } from "path";
+// src/remote/server.ts
+init_app();
 
-class ComponentLoader {
-  components = new Map;
-  register(name, module, template, path) {
-    this.components.set(name, {
-      name,
-      module,
-      template,
-      path: path || name
-    });
+// src/remote/session.ts
+class SessionManager {
+  activeSessions = new Map;
+  pendingSessions = new Map;
+  sessionConnections = new Map;
+  config;
+  constructor(config2 = {}) {
+    this.config = {
+      ttl: config2.ttl ?? 3600,
+      concurrent: config2.concurrent ?? "kick-old",
+      generateId: config2.generateId ?? (() => crypto.randomUUID())
+    };
   }
-  get(name) {
-    return this.components.get(name);
+  getTtl() {
+    return this.config.ttl;
   }
-  has(name) {
-    return this.components.has(name);
+  getConcurrentPolicy() {
+    return this.config.concurrent;
   }
-  getNames() {
-    return Array.from(this.components.keys());
+  createSession(props) {
+    const now = new Date;
+    const session = {
+      id: this.config.generateId(),
+      ttl: this.config.ttl,
+      createdAt: now,
+      lastConnectedAt: now,
+      props
+    };
+    this.activeSessions.set(session.id, session);
+    return session;
   }
-  getAll() {
-    return Array.from(this.components.values());
+  getActiveSession(id) {
+    return this.activeSessions.get(id) ?? null;
   }
-  clear() {
-    this.components.clear();
+  getPendingSession(id) {
+    return this.pendingSessions.get(id) ?? null;
   }
-  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);
-      console.log(`✓ Loaded component: ${name} from ${dirPath}`);
-    } catch (error) {
-      console.error(`✗ Failed to load component ${name} from ${dirPath}:`, error);
-      throw error;
-    }
+  hasSession(id) {
+    return this.activeSessions.has(id) || this.pendingSessions.has(id);
   }
-  async loadFromComponentsDir(baseDir) {
-    try {
-      if (!existsSync(baseDir)) {
-        console.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);
-        }
+  suspendSession(sessionId, savedState, onExpire) {
+    const session = this.activeSessions.get(sessionId);
+    if (!session)
+      return;
+    this.activeSessions.delete(sessionId);
+    const expiryTimer = setTimeout(async () => {
+      const pending = this.pendingSessions.get(sessionId);
+      if (pending) {
+        this.pendingSessions.delete(sessionId);
+        await onExpire(pending.session);
       }
-      console.log(`✓ Loaded ${this.components.size} components from ${baseDir}`);
-    } catch (error) {
-      console.error(`✗ Failed to load components from ${baseDir}:`, error);
-      throw error;
-    }
+    }, session.ttl * 1000);
+    this.pendingSessions.set(sessionId, {
+      session,
+      savedState,
+      expiryTimer
+    });
   }
-}
-var componentLoader = new ComponentLoader;
-
-// src/resolver.ts
-class ComponentResolver {
-  cache = new Map;
-  options;
-  constructor(options = {}) {
-    this.options = {
-      baseDir: options.baseDir || process.cwd(),
-      cache: options.cache ?? true,
-      customFetch: options.customFetch || this.defaultFetch.bind(this)
+  resumeSession(sessionId) {
+    const pending = this.pendingSessions.get(sessionId);
+    if (!pending)
+      return null;
+    clearTimeout(pending.expiryTimer);
+    this.pendingSessions.delete(sessionId);
+    pending.session.lastConnectedAt = new Date;
+    this.activeSessions.set(sessionId, pending.session);
+    return {
+      session: pending.session,
+      savedState: pending.savedState
     };
   }
-  async resolve(importStmt) {
-    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) {
-    throw new Error(`Dynamic local component resolution not yet implemented: ${path}
-` + `Please use the build-components.ts script to generate component imports.`);
-  }
-  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)}`);
+  destroySession(sessionId) {
+    this.activeSessions.delete(sessionId);
+    const pending = this.pendingSessions.get(sessionId);
+    if (pending) {
+      clearTimeout(pending.expiryTimer);
+      this.pendingSessions.delete(sessionId);
     }
+    this.sessionConnections.delete(sessionId);
   }
-  async defaultFetch(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  trackConnection(sessionId, ws) {
+    let connections = this.sessionConnections.get(sessionId);
+    if (!connections) {
+      connections = new Set;
+      this.sessionConnections.set(sessionId, connections);
     }
-    return response.text();
+    connections.add(ws);
   }
-  extractComponents(clause, component) {
-    if (clause.type === "default") {
-      return {
-        [clause.name]: component
-      };
-    } else {
-      const result = {};
-      for (const name of clause.names) {
-        result[name] = component;
+  untrackConnection(sessionId, ws) {
+    const connections = this.sessionConnections.get(sessionId);
+    if (connections) {
+      connections.delete(ws);
+      if (connections.size === 0) {
+        this.sessionConnections.delete(sessionId);
       }
-      return result;
     }
   }
-  getSourcePath(source) {
-    return source.type === "local" ? source.path : source.url;
+  getConnections(sessionId) {
+    return this.sessionConnections.get(sessionId);
   }
-  clearCache() {
-    this.cache.clear();
+  getConnectionCount(sessionId) {
+    return this.sessionConnections.get(sessionId)?.size ?? 0;
   }
-  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 });
+  getStats() {
+    let totalConnections = 0;
+    for (const connections of this.sessionConnections.values()) {
+      totalConnections += connections.size;
     }
-    return imports;
+    return {
+      activeSessions: this.activeSessions.size,
+      pendingSessions: this.pendingSessions.size,
+      totalConnections
+    };
+  }
+  destroy() {
+    for (const pending of this.pendingSessions.values()) {
+      clearTimeout(pending.expiryTimer);
+    }
+    this.activeSessions.clear();
+    this.pendingSessions.clear();
+    this.sessionConnections.clear();
   }
 }
 
-// src/discovery.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, watch } from "fs";
-import { join as join2, basename, resolve } from "path";
-function removeImports(text) {
-  return text.replace(/import\s+(?:\{[^}]+\}|\w+)\s+from\s+["'][^"']+["']\s*/g, "");
-}
-async function discoverComponents(baseDir, options = {}) {
-  const {
-    patterns = ["single-file", "folder", "sibling", "index"],
-    recursive = false,
-    debug = false
-  } = options;
-  const log3 = debug ? (...args) => console.log("[discovery]", ...args) : () => {};
-  const resolvedDir = resolve(baseDir);
-  const components = [];
-  const seen = new Set;
-  log3("Scanning directory:", resolvedDir);
-  log3("Patterns:", patterns);
-  const addTwoFileComponent = (name, hypenPath, modulePath) => {
-    if (seen.has(name)) {
-      log3(`Skipping duplicate: ${name}`);
-      return;
+// src/remote/server.ts
+init_logger();
+var log11 = 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()");
     }
-    seen.add(name);
-    const templateRaw = readFileSync2(hypenPath, "utf-8");
-    const template = removeImports(templateRaw).trim();
-    components.push({
-      name,
-      hypenPath,
-      modulePath,
-      template,
-      hasModule: modulePath !== null,
-      isSingleFile: false
-    });
-    log3(`Found: ${name} (two-file, ${modulePath ? "with module" : "stateless"})`);
-  };
-  const addSingleFileComponent = (name, modulePath, template) => {
-    if (seen.has(name)) {
-      log3(`Skipping duplicate: ${name}`);
-      return;
+    if (!this._ui) {
+      throw new Error("UI not set. Call .ui() before .listen()");
     }
-    seen.add(name);
-    components.push({
-      name,
-      hypenPath: null,
-      modulePath,
-      template,
-      hasModule: true,
-      isSingleFile: true
-    });
-    log3(`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;
+    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 (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 (url.pathname === "/health") {
+          return new Response("OK", { status: 200 });
         }
-      }
-      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));
+        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" }
+          });
         }
-        continue;
+        return new Response("Hypen Remote Server", { status: 200 });
       }
-      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);
+    });
+    log11.info(`Hypen app streaming on ws://${hostname}:${finalPort}`);
+    return this;
+  }
+  stop() {
+    if (this.server) {
+      this.server.stop();
+      this.server = 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) {
-          log3(`Failed to import potential single-file component: ${entry.name}`, e);
-        }
-      }
+    if (this.sessionManager) {
+      this.sessionManager.destroy();
+      this.sessionManager = null;
     }
-  };
-  if (patterns.includes("folder") || patterns.includes("index")) {
-    scanForFolderComponents(resolvedDir);
   }
-  if (patterns.includes("sibling")) {
-    scanForSiblingComponents(resolvedDir);
+  get url() {
+    if (!this.server)
+      return null;
+    const hostname = this._config.hostname ?? "localhost";
+    const port = this._config.port ?? 3000;
+    return `ws://${hostname}:${port}`;
   }
-  if (patterns.includes("single-file")) {
-    await scanForSingleFileComponents(resolvedDir);
+  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) {
+      log11.error("Error handling WebSocket open:", error);
+      ws.close(1011, "Internal server error");
+    }
   }
-  log3(`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;
+  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 {
-      module = app2.defineState({}).build();
+      session = {
+        id: crypto.randomUUID(),
+        ttl: 3600,
+        createdAt: new Date,
+        lastConnectedAt: new Date,
+        props
+      };
     }
-    loaded.set(component.name, {
-      name: component.name,
-      module,
-      template
+    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));
   }
-  return loaded;
-}
-function watchComponents(baseDir, options = {}) {
-  const resolvedDir = resolve(baseDir);
-  const {
-    onChange,
-    onAdd,
-    onRemove,
-    onUpdate,
-    debug = false,
-    ...discoveryOptions
-  } = options;
-  const log3 = debug ? (...args) => console.log("[discovery: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 () => {
-      log3("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) {
-          log3("Added:", name);
-          onAdd?.(component);
-        } else if (existing.template !== component.template || existing.modulePath !== component.modulePath) {
-          log3("Updated:", name);
-          onUpdate?.(component);
+  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));
+            }
+          }
         }
       }
-      for (const name of currentComponents.keys()) {
-        if (!newMap.has(name)) {
-          log3("Removed:", name);
-          onRemove?.(name);
+    });
+  }
+  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;
       }
-      currentComponents = newMap;
-      onChange?.(newComponents);
-    }, 100);
-  };
-  const watcher = watch(resolvedDir, { recursive: true }, (event, filename) => {
-    if (!filename)
-      return;
-    if (filename.endsWith(".hypen") || filename.endsWith(".ts")) {
-      log3("File changed:", filename);
-      rescan();
-    }
-  });
-  initialScan();
-  return {
-    stop: () => {
-      watcher.close();
-      if (debounceTimer) {
-        clearTimeout(debounceTimer);
+      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;
       }
-    }
-  };
-}
-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}";
-`;
+      case "allow-multiple": {
+        return true;
+      }
+      default:
+        return true;
     }
   }
-  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},
-};
-
-`;
-    }
+  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 });
   }
-  return code;
-}
-
-// src/plugin.ts
-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");
+  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;
         }
-        break;
-      case "index":
-        if (baseName === "index") {
-          candidatePath = join3(dir, "index.ts");
+        case "dispatchAction": {
+          const actionMsg = msg;
+          clientData.engine.dispatchAction(actionMsg.action, actionMsg.payload);
+          break;
         }
-        break;
+        default:
+          break;
+      }
+    } catch (error) {
+      log11.error("Error handling WebSocket message:", error);
     }
-    if (candidatePath && existsSync3(candidatePath)) {
-      return candidatePath;
+  }
+  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));
   }
-  return null;
-}
-function getComponentName(hypenPath) {
-  const baseName = basename2(hypenPath, ".hypen");
-  if (baseName === "component" || baseName === "index") {
-    return basename2(dirname(hypenPath));
+  getClientCount() {
+    return this.clients.size;
   }
-  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 });
+  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);
+    });
   }
-  return imports;
-}
-function removeImports2(text) {
-  return text.replace(/import\s+(?:\{[^}]+\}|\w+)\s+from\s+["'][^"']+["']\s*/g, "");
-}
-function hypenPlugin(options = {}) {
-  const { debug = false, patterns = ["sibling", "component", "index"] } = options;
-  const log3 = debug ? (...args) => console.log("[hypen-plugin]", ...args) : () => {};
-  return {
-    name: "hypen-loader",
-    async setup(build) {
-      build.onLoad({ filter: /\.hypen$/ }, async (args) => {
-        const hypenPath = resolve2(args.path);
-        log3("Loading:", hypenPath);
-        const templateRaw = readFileSync3(hypenPath, "utf-8");
-        const imports = parseImports(templateRaw);
-        const template = removeImports2(templateRaw).trim();
-        if (imports.length > 0) {
-          log3("Found imports:", imports);
-        }
-        const componentName = getComponentName(hypenPath);
-        log3("Component name:", componentName);
-        const modulePath = findModulePath(hypenPath, patterns);
-        log3("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 {
-          log3("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();
-var Router = app.defineState({
-  currentPath: "/",
-  matchedRoute: null,
-  routeParams: {}
-}, { name: "__Router" }).onCreated((state, context) => {
-  if (!context) {
-    console.error("[Router] Requires global context");
-    return;
+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
+    });
   }
-  const router = context.__router;
-  if (!router) {
-    console.error("[Router] Router not found in context");
-    return;
+  if (options.session) {
+    server.session(options.session);
   }
-  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) {
-            console.error(`[Router] Failed to render route ${routePath}:`, err);
-          }
-        }
-      }
-    }
-    if (!matchFound) {
-      console.warn(`[Router] 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) {
-    console.error("[Link] Requires router context");
-    return;
+  if (options.onConnection) {
+    server.onConnection(options.onConnection);
   }
-  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;
-    });
+  if (options.onDisconnection) {
+    server.onDisconnection(options.onDisconnection);
   }
-}).build();
+  return server.listen(options.port);
+}
 
-// src/index.ts
-init_app();
+// src/loader.ts
+init_logger();
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+var log12 = frameworkLoggers.loader;
 
-// src/hypen.ts
-function createBindingProxy(root) {
-  const handler = {
-    get(_, prop) {
-      if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
-        return () => `\${${root}}`;
-      }
-      if (typeof prop === "symbol") {
+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);
+      log12.debug(`Loaded component: ${name} from ${dirPath}`);
+    } catch (error) {
+      log12.error(`Failed to load component ${name} from ${dirPath}:`, error);
+      throw error;
+    }
+  }
+  async loadFromComponentsDir(baseDir) {
+    try {
+      if (!existsSync(baseDir)) {
+        log12.warn(`Components directory not found: ${baseDir}`);
         return;
       }
-      if (prop === "toJSON") {
-        return () => `\${${root}}`;
+      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);
+        }
       }
-      return createBindingProxy(`${root}.${prop}`);
-    },
-    has() {
-      return true;
-    },
-    ownKeys() {
-      return [];
-    },
-    getOwnPropertyDescriptor() {
-      return {
-        configurable: true,
-        enumerable: true
-      };
+      log12.debug(`Loaded ${this.components.size} components from ${baseDir}`);
+    } catch (error) {
+      log12.error(`Failed to load components from ${baseDir}:`, error);
+      throw error;
     }
-  };
-  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();
 }
+var componentLoader = new ComponentLoader;
 
-// src/index.ts
-init_state();
-
-// src/remote/server.ts
-init_app();
-
-// src/remote/session.ts
-class SessionManager {
-  activeSessions = new Map;
-  pendingSessions = new Map;
-  sessionConnections = new Map;
-  config;
-  constructor(config2 = {}) {
-    this.config = {
-      ttl: config2.ttl ?? 3600,
-      concurrent: config2.concurrent ?? "kick-old",
-      generateId: config2.generateId ?? (() => crypto.randomUUID())
-    };
-  }
-  getTtl() {
-    return this.config.ttl;
-  }
-  getConcurrentPolicy() {
-    return this.config.concurrent;
-  }
-  createSession(props) {
-    const now = new Date;
-    const session = {
-      id: this.config.generateId(),
-      ttl: this.config.ttl,
-      createdAt: now,
-      lastConnectedAt: now,
-      props
+// src/resolver.ts
+class ComponentResolver {
+  cache = new Map;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      baseDir: options.baseDir || process.cwd(),
+      cache: options.cache ?? true,
+      customFetch: options.customFetch || this.defaultFetch.bind(this)
     };
-    this.activeSessions.set(session.id, session);
-    return session;
-  }
-  getActiveSession(id) {
-    return this.activeSessions.get(id) ?? null;
   }
-  getPendingSession(id) {
-    return this.pendingSessions.get(id) ?? null;
+  async resolve(importStmt) {
+    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);
   }
-  hasSession(id) {
-    return this.activeSessions.has(id) || this.pendingSessions.has(id);
+  async resolveLocal(path) {
+    throw new Error(`Dynamic local component resolution not yet implemented: ${path}
+` + `Please use the build-components.ts script to generate component imports.`);
   }
-  suspendSession(sessionId, savedState, onExpire) {
-    const session = this.activeSessions.get(sessionId);
-    if (!session)
-      return;
-    this.activeSessions.delete(sessionId);
-    const expiryTimer = setTimeout(async () => {
-      const pending = this.pendingSessions.get(sessionId);
-      if (pending) {
-        this.pendingSessions.delete(sessionId);
-        await onExpire(pending.session);
+  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 }`);
       }
-    }, session.ttl * 1000);
-    this.pendingSessions.set(sessionId, {
-      session,
-      savedState,
-      expiryTimer
-    });
-  }
-  resumeSession(sessionId) {
-    const pending = this.pendingSessions.get(sessionId);
-    if (!pending)
-      return null;
-    clearTimeout(pending.expiryTimer);
-    this.pendingSessions.delete(sessionId);
-    pending.session.lastConnectedAt = new Date;
-    this.activeSessions.set(sessionId, pending.session);
-    return {
-      session: pending.session,
-      savedState: pending.savedState
-    };
-  }
-  destroySession(sessionId) {
-    this.activeSessions.delete(sessionId);
-    const pending = this.pendingSessions.get(sessionId);
-    if (pending) {
-      clearTimeout(pending.expiryTimer);
-      this.pendingSessions.delete(sessionId);
+      return data;
+    } catch (error) {
+      throw new Error(`Failed to resolve component from ${url}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    this.sessionConnections.delete(sessionId);
   }
-  trackConnection(sessionId, ws) {
-    let connections = this.sessionConnections.get(sessionId);
-    if (!connections) {
-      connections = new Set;
-      this.sessionConnections.set(sessionId, connections);
+  async defaultFetch(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    connections.add(ws);
+    return response.text();
   }
-  untrackConnection(sessionId, ws) {
-    const connections = this.sessionConnections.get(sessionId);
-    if (connections) {
-      connections.delete(ws);
-      if (connections.size === 0) {
-        this.sessionConnections.delete(sessionId);
+  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;
     }
   }
-  getConnections(sessionId) {
-    return this.sessionConnections.get(sessionId);
-  }
-  getConnectionCount(sessionId) {
-    return this.sessionConnections.get(sessionId)?.size ?? 0;
+  getSourcePath(source) {
+    return source.type === "local" ? source.path : source.url;
   }
-  getStats() {
-    let totalConnections = 0;
-    for (const connections of this.sessionConnections.values()) {
-      totalConnections += connections.size;
-    }
-    return {
-      activeSessions: this.activeSessions.size,
-      pendingSessions: this.pendingSessions.size,
-      totalConnections
-    };
+  clearCache() {
+    this.cache.clear();
   }
-  destroy() {
-    for (const pending of this.pendingSessions.values()) {
-      clearTimeout(pending.expiryTimer);
+  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 });
     }
-    this.activeSessions.clear();
-    this.pendingSessions.clear();
-    this.sessionConnections.clear();
+    return imports;
   }
 }
 
-// src/remote/server.ts
-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()");
+// 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";
+function removeImports(text) {
+  return text.replace(/import\s+(?:\{[^}]+\}|\w+)\s+from\s+["'][^"']+["']\s*/g, "");
+}
+async function discoverComponents(baseDir, options = {}) {
+  const {
+    patterns = ["single-file", "folder", "sibling", "index"],
+    recursive = false,
+    debug = false
+  } = options;
+  const log13 = debug ? (...args) => frameworkLoggers.discovery.debug(...args) : () => {};
+  const resolvedDir = resolve(baseDir);
+  const components = [];
+  const seen = new Set;
+  log13("Scanning directory:", resolvedDir);
+  log13("Patterns:", patterns);
+  const addTwoFileComponent = (name, hypenPath, modulePath) => {
+    if (seen.has(name)) {
+      log13(`Skipping duplicate: ${name}`);
+      return;
     }
-    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;
+    seen.add(name);
+    const templateRaw = readFileSync2(hypenPath, "utf-8");
+    const template = removeImports(templateRaw).trim();
+    components.push({
+      name,
+      hypenPath,
+      modulePath,
+      template,
+      hasModule: modulePath !== null,
+      isSingleFile: false
+    });
+    log13(`Found: ${name} (two-file, ${modulePath ? "with module" : "stateless"})`);
+  };
+  const addSingleFileComponent = (name, modulePath, template) => {
+    if (seen.has(name)) {
+      log13(`Skipping duplicate: ${name}`);
+      return;
+    }
+    seen.add(name);
+    components.push({
+      name,
+      hypenPath: null,
+      modulePath,
+      template,
+      hasModule: true,
+      isSingleFile: true
+    });
+    log13(`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 (url.pathname === "/health") {
-          return new Response("OK", { status: 200 });
+      }
+      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 (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" }
-          });
+      }
+      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));
         }
-        return new Response("Hypen Remote Server", { status: 200 });
+        continue;
       }
-    });
-    console.log(`\uD83D\uDE80 Hypen app streaming on ws://${hostname}:${finalPort}`);
-    return this;
-  }
-  stop() {
-    if (this.server) {
-      this.server.stop();
-      this.server = null;
+      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);
     }
-    if (this.sessionManager) {
-      this.sessionManager.destroy();
-      this.sessionManager = 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) {
+          log13(`Failed to import potential single-file component: ${entry.name}`, e);
+        }
+      }
     }
+  };
+  if (patterns.includes("folder") || patterns.includes("index")) {
+    scanForFolderComponents(resolvedDir);
   }
-  get url() {
-    if (!this.server)
-      return null;
-    const hostname = this._config.hostname ?? "localhost";
-    const port = this._config.port ?? 3000;
-    return `ws://${hostname}:${port}`;
+  if (patterns.includes("sibling")) {
+    scanForSiblingComponents(resolvedDir);
   }
-  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) {
-      console.error("Error handling WebSocket open:", error);
-      ws.close(1011, "Internal server error");
+  if (patterns.includes("single-file")) {
+    await scanForSingleFileComponents(resolvedDir);
+  }
+  log13(`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
+    });
   }
-  async initializeSession(ws, clientData, requestedSessionId, props) {
-    if (clientData.helloReceived)
-      return;
-    clientData.helloReceived = true;
-    if (clientData.helloTimeout) {
-      clearTimeout(clientData.helloTimeout);
-      clientData.helloTimeout = undefined;
+  return loaded;
+}
+function watchComponents(baseDir, options = {}) {
+  const resolvedDir = resolve(baseDir);
+  const {
+    onChange,
+    onAdd,
+    onRemove,
+    onUpdate,
+    debug = false,
+    ...discoveryOptions
+  } = options;
+  const log13 = 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);
     }
-    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);
+    debounceTimer = setTimeout(async () => {
+      log13("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) {
+          log13("Added:", name);
+          onAdd?.(component);
+        } else if (existing.template !== component.template || existing.modulePath !== component.modulePath) {
+          log13("Updated:", name);
+          onUpdate?.(component);
         }
       }
-    } else if (this.sessionManager) {
-      session = this.sessionManager.createSession(props);
+      for (const name of currentComponents.keys()) {
+        if (!newMap.has(name)) {
+          log13("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")) {
+      log13("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 {
-      session = {
-        id: crypto.randomUUID(),
-        ttl: 3600,
-        createdAt: new Date,
-        lastConnectedAt: new Date,
-        props
-      };
+      const templateJson = JSON.stringify(component.template);
+      code += `const ${component.name}Module = app.defineState({}).build();
+export const ${component.name} = {
+  module: ${component.name}Module,
+  template: ${templateJson},
+};
+
+`;
     }
-    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));
-            }
-          }
+  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;
+    }
   }
-  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 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 removeImports2(text) {
+  return text.replace(/import\s+(?:\{[^}]+\}|\w+)\s+from\s+["'][^"']+["']\s*/g, "");
+}
+function hypenPlugin(options = {}) {
+  const { debug = false, patterns = ["sibling", "component", "index"] } = options;
+  const log13 = debug ? (...args) => frameworkLoggers.plugin.debug(...args) : () => {};
+  return {
+    name: "hypen-loader",
+    async setup(build) {
+      build.onLoad({ filter: /\.hypen$/ }, async (args) => {
+        const hypenPath = resolve2(args.path);
+        log13("Loading:", hypenPath);
+        const templateRaw = readFileSync3(hypenPath, "utf-8");
+        const imports = parseImports(templateRaw);
+        const template = removeImports2(templateRaw).trim();
+        if (imports.length > 0) {
+          log13("Found imports:", imports);
+        }
+        const componentName = getComponentName(hypenPath);
+        log13("Component name:", componentName);
+        const modulePath = findModulePath(hypenPath, patterns);
+        log13("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 {
+          log13("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 true;
-      }
-      case "reject-new": {
-        const expiredMsg = {
-          type: "sessionExpired",
-          sessionId: existingSession.id,
-          reason: "kicked"
+        return {
+          contents,
+          loader: "js"
         };
-        ws.send(JSON.stringify(expiredMsg));
-        ws.close(1000, "Session already active");
-        return false;
-      }
-      case "allow-multiple": {
-        return true;
-      }
-      default:
-        return true;
+      });
     }
+  };
+}
+var defaultHypenPlugin = hypenPlugin();
+function registerHypenPlugin(options) {
+  Bun.plugin(hypenPlugin(options));
+}
+var plugin_default = hypenPlugin;
+
+// src/components/builtin.ts
+init_app();
+init_logger();
+var log13 = frameworkLoggers.router;
+var Router = app.defineState({
+  currentPath: "/",
+  matchedRoute: null,
+  routeParams: {}
+}, { name: "__Router" }).onCreated((state, context) => {
+  if (!context) {
+    log13.error("Requires global context");
+    return;
   }
-  async triggerReconnect(clientData, session, savedState) {
-    const handler = this._module?.handlers.onReconnect;
-    if (!handler)
-      return;
-    let restored = false;
-    const restore = (state2) => {
-      restored = true;
-      clientData.moduleInstance.updateState(state2);
-    };
-    await handler({ session, restore });
+  const router = context.__router;
+  if (!router) {
+    log13.error("Router not found in context");
+    return;
   }
-  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;
+  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) {
+            log13.error(`Failed to render route ${routePath}:`, err);
+          }
         }
-        default:
-          break;
-      }
-    } catch (error) {
-      console.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 });
-            }
-          });
-        }
-      }
+    if (!matchFound) {
+      log13.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
     }
-    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
-    };
+  };
+  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) {
+    log13.error("Link requires router context");
+    return;
   }
-  broadcast(message) {
-    const json = JSON.stringify(message);
-    this.clients.forEach((_, ws) => {
-      ws.send(json);
+  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);
 }
-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);
+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 server.listen(options.port);
+  return result.trim();
 }
 
 // src/index.ts
+init_state();
 init_result();
 init_logger();
 export {
@@ -3180,6 +3225,7 @@ export {
   unwrap,
   state,
   setLogLevel,
+  setDebugMode,
   serve,
   retryResult,
   retry,
@@ -3195,6 +3241,7 @@ export {
   isOk,
   isErr,
   isDisposable,
+  isDebugMode,
   index,
   hypenPlugin,
   hypen,
@@ -3258,4 +3305,4 @@ export {
   ActionError
 };
 
-//# debugId=5FEDED160A511C9E64756E2164756E21
+//# debugId=1C99977DF3016DFC64756E2164756E21