@hypen-space/core 0.3.12 → 0.4.1

package/dist/index.js

@@ -27,205 +27,6 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// 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") {
@@ -612,60 +413,259 @@ var init_result = __esm(() => {
   };
 });
 
-// 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;
-  }
-  onDestroyed(fn) {
-    this.destroyedHandler = fn;
-    return this;
-  }
-  onDisconnect(fn) {
-    this.disconnectHandler = fn;
-    return this;
-  }
-  onReconnect(fn) {
-    this.reconnectHandler = fn;
-    return this;
-  }
-  onExpire(fn) {
-    this.expireHandler = fn;
-    return this;
-  }
-  onError(fn) {
-    this.errorHandler = fn;
-    return this;
+// src/logger.ts
+function isProduction() {
+  if (typeof process !== "undefined" && process.env) {
+    return false;
   }
-  ui(template) {
-    this.template = template;
+  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/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;
+  }
+  onDestroyed(fn) {
+    this.destroyedHandler = fn;
+    return this;
+  }
+  onDisconnect(fn) {
+    this.disconnectHandler = fn;
+    return this;
+  }
+  onReconnect(fn) {
+    this.reconnectHandler = fn;
+    return this;
+  }
+  onExpire(fn) {
+    this.expireHandler = fn;
+    return this;
+  }
+  onError(fn) {
+    this.errorHandler = fn;
+    return this;
+  }
+  ui(template) {
+    this.template = template;
     return this.build();
   }
   build() {
@@ -710,17 +710,21 @@ class HypenModuleInstance {
     this.definition = definition;
     this.routerContext = routerContext;
     this.globalContext = globalContext;
+    const statePrefix = (definition.name || "").toLowerCase();
     this.state = createObservableState(definition.initialState, {
       onChange: (change) => {
         this.engine.notifyStateChange(change.paths, change.newValues);
         this.stateChangeCallbacks.forEach((cb) => cb());
-      }
+      },
+      pathPrefix: statePrefix || undefined
     });
-    this.engine.setModule(definition.name || "AnonymousModule", definition.actions, definition.stateKeys, getStateSnapshot(this.state));
+    const snapshot = getStateSnapshot(this.state);
+    const prefixedState = statePrefix ? { [statePrefix]: snapshot } : snapshot;
+    this.engine.setModule(definition.name || "AnonymousModule", definition.actions, definition.stateKeys, prefixedState);
     for (const [actionName, handler] of definition.handlers.onAction) {
-      log4.debug(`Registering action handler: ${actionName} for module ${definition.name}`);
+      log2.debug(`Registering action handler: ${actionName} for module ${definition.name}`);
       this.engine.onAction(actionName, async (action) => {
-        log4.debug(`Action handler fired: ${actionName}`, action);
+        log2.debug(`Action handler fired: ${actionName}`, action);
         const actionCtx = {
           name: action.name,
           payload: action.payload,
@@ -742,355 +746,114 @@ class HypenModuleInstance {
             throw result.error;
           }
         } else {
-          log4.debug(`Action handler completed: ${actionName}`);
+          log2.debug(`Action handler completed: ${actionName}`);
         }
       });
     }
     this.callCreatedHandler();
   }
   createGlobalContextAPI() {
-    if (!this.globalContext) {
-      throw new Error("Global context not available");
-    }
-    const ctx = this.globalContext;
-    const api = {
-      getModule: (id) => ctx.getModule(id),
-      hasModule: (id) => ctx.hasModule(id),
-      getModuleIds: () => ctx.getModuleIds(),
-      getGlobalState: () => ctx.getGlobalState(),
-      emit: (event, payload) => ctx.emit(event, payload),
-      on: (event, handler) => ctx.on(event, handler)
-    };
-    if (ctx.__router) {
-      api.__router = ctx.__router;
-    }
-    if (ctx.__hypenEngine) {
-      api.__hypenEngine = ctx.__hypenEngine;
-    }
-    return api;
-  }
-  async executeAction(actionName, handler, ctx) {
-    try {
-      const result = handler(ctx);
-      await result;
-      return Ok(undefined);
-    } catch (e) {
-      return Err(new ActionError(actionName, e));
-    }
-  }
-  async handleError(error, context) {
-    const errorCtx = {
-      error,
-      state: this.state,
-      actionName: context.actionName,
-      lifecycle: context.lifecycle
-    };
-    if (this.definition.handlers.onError) {
-      try {
-        const result = await this.definition.handlers.onError(errorCtx);
-        if (result && typeof result === "object") {
-          if ("handled" in result && result.handled) {
-            return false;
-          }
-          if ("rethrow" in result && result.rethrow) {
-            return true;
-          }
-        }
-      } catch (handlerError) {
-        log4.error("Error in onError handler:", handlerError);
-      }
-    }
-    if (this.globalContext) {
-      const eventContext = context.actionName ? `action:${context.actionName}` : context.lifecycle ? `lifecycle:${context.lifecycle}` : "unknown";
-      this.globalContext.emit("error", {
-        message: error.message,
-        error,
-        context: eventContext
-      });
-    }
-    log4.error(`${context.actionName ? `Action "${context.actionName}"` : `Lifecycle "${context.lifecycle}"`} error:`, error);
-    return false;
-  }
-  async callCreatedHandler() {
-    if (this.definition.handlers.onCreated) {
-      const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
-      await this.definition.handlers.onCreated(this.state, context);
-    }
-  }
-  onStateChange(callback) {
-    this.stateChangeCallbacks.push(callback);
-  }
-  async destroy() {
-    if (this.isDestroyed)
-      return;
-    if (this.definition.handlers.onDestroyed) {
-      await this.definition.handlers.onDestroyed(this.state);
-    }
-    this.isDestroyed = true;
-  }
-  getState() {
-    return getStateSnapshot(this.state);
-  }
-  getLiveState() {
-    return this.state;
-  }
-  updateState(patch) {
-    Object.assign(this.state, patch);
-  }
-}
-var log4, app;
-var init_app = __esm(() => {
-  init_result();
-  init_state();
-  init_logger();
-  log4 = createLogger("ModuleInstance");
-  app = new HypenApp;
-});
-
-// src/engine.ts
-init_logger();
-var WasmEngineClass = null;
-var log2 = frameworkLoggers.engine;
-function unwrapForWasm(value) {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (typeof value.__getSnapshot === "function") {
-    return value.__getSnapshot();
-  }
-  try {
-    return structuredClone(value);
-  } catch {
-    return JSON.parse(JSON.stringify(value));
-  }
-}
-
-class Engine {
-  wasmEngine = null;
-  initialized = false;
-  async init() {
-    if (this.initialized)
-      return;
-    if (!WasmEngineClass) {
-      const wasm = await import("../wasm-node/hypen_engine.js");
-      WasmEngineClass = wasm.WasmEngine;
-    }
-    this.wasmEngine = new WasmEngineClass;
-    this.initialized = true;
-  }
-  ensureInitialized() {
-    if (!this.wasmEngine) {
-      throw new Error("Engine not initialized. Call init() first.");
-    }
-    return this.wasmEngine;
-  }
-  setRenderCallback(callback) {
-    const engine = this.ensureInitialized();
-    engine.setRenderCallback((patches) => {
-      callback(patches);
-    });
-  }
-  setComponentResolver(resolver) {
-    const engine = this.ensureInitialized();
-    engine.setComponentResolver((componentName, contextPath) => {
-      const result = resolver(componentName, contextPath);
-      return result;
-    });
-  }
-  renderSource(source) {
-    const engine = this.ensureInitialized();
-    engine.renderSource(source);
-  }
-  renderLazyComponent(source) {
-    const engine = this.ensureInitialized();
-    engine.renderLazyComponent(source);
-  }
-  renderInto(source, parentNodeId, state) {
-    const engine = this.ensureInitialized();
-    engine.renderInto(source, parentNodeId, unwrapForWasm(state));
-  }
-  notifyStateChange(paths, values) {
-    const engine = this.ensureInitialized();
-    if (paths.length === 0) {
-      return;
-    }
-    engine.updateStateSparse(paths, unwrapForWasm(values));
-    log2.debug("State changed (sparse):", paths);
-  }
-  notifyStateChangeFull(paths, currentState) {
-    const engine = this.ensureInitialized();
-    engine.updateState(unwrapForWasm(currentState));
-    if (paths.length > 0) {
-      log2.debug("State changed (full):", paths);
-    }
-  }
-  updateState(statePatch) {
-    const engine = this.ensureInitialized();
-    engine.updateState(unwrapForWasm(statePatch));
-  }
-  dispatchAction(name, payload) {
-    const engine = this.ensureInitialized();
-    engine.dispatchAction(name, payload ?? null);
-  }
-  onAction(actionName, handler) {
-    const engine = this.ensureInitialized();
-    engine.onAction(actionName, (action) => {
-      Promise.resolve(handler(action)).catch((err) => log2.error("Action handler error:", err));
-    });
-  }
-  setModule(name, actions, stateKeys, initialState) {
-    const engine = this.ensureInitialized();
-    engine.setModule(name, actions, stateKeys, initialState);
-  }
-  getRevision() {
-    const engine = this.ensureInitialized();
-    return Number(engine.getRevision());
-  }
-  clearTree() {
-    const engine = this.ensureInitialized();
-    engine.clearTree();
-  }
-  debugParseComponent(source) {
-    const engine = this.ensureInitialized();
-    return engine.debugParseComponent(source);
-  }
-}
-
-// src/engine.browser.ts
-init_logger();
-var log3 = frameworkLoggers.engine;
-var wasmInit = null;
-var WasmEngineClass2 = null;
-function mapToObject(value) {
-  if (value instanceof Map) {
-    const obj = {};
-    for (const [key, val] of value.entries()) {
-      obj[key] = mapToObject(val);
+    if (!this.globalContext) {
+      throw new Error("Global context not available");
     }
-    return obj;
-  } else if (Array.isArray(value)) {
-    return value.map(mapToObject);
-  } else if (value && typeof value === "object" && value.constructor === Object) {
-    const obj = {};
-    for (const [key, val] of Object.entries(value)) {
-      obj[key] = mapToObject(val);
+    const ctx = this.globalContext;
+    const api = {
+      getModule: (id) => ctx.getModule(id),
+      hasModule: (id) => ctx.hasModule(id),
+      getModuleIds: () => ctx.getModuleIds(),
+      getGlobalState: () => ctx.getGlobalState(),
+      emit: (event, payload) => ctx.emit(event, payload),
+      on: (event, handler) => ctx.on(event, handler)
+    };
+    if (ctx.__router) {
+      api.__router = ctx.__router;
     }
-    return obj;
+    if (ctx.__hypenEngine) {
+      api.__hypenEngine = ctx.__hypenEngine;
+    }
+    return api;
   }
-  return value;
-}
-
-class Engine2 {
-  wasmEngine = null;
-  initialized = false;
-  async init(options = {}) {
-    if (this.initialized)
-      return;
-    const cdnBase = "https://unpkg.com/@hypen-space/core@latest/wasm-browser";
-    const jsUrl = options.jsUrl ?? `${cdnBase}/hypen_engine.js`;
-    const wasmUrl = options.wasmUrl ?? `${cdnBase}/hypen_engine_bg.wasm`;
+  async executeAction(actionName, handler, ctx) {
     try {
-      const wasmModule = await import(jsUrl);
-      wasmInit = wasmModule.default;
-      WasmEngineClass2 = wasmModule.WasmEngine;
-      await wasmInit(wasmUrl);
-      this.wasmEngine = new WasmEngineClass2;
-      this.initialized = true;
-    } catch (error) {
-      log3.error("Failed to initialize WASM engine:", error);
-      throw error;
+      const result = handler(ctx);
+      await result;
+      return Ok(undefined);
+    } catch (e) {
+      return Err(new ActionError(actionName, e));
     }
   }
-  ensureInitialized() {
-    if (!this.wasmEngine) {
-      throw new Error("Engine not initialized. Call init() first.");
+  async handleError(error, context) {
+    const errorCtx = {
+      error,
+      state: this.state,
+      actionName: context.actionName,
+      lifecycle: context.lifecycle
+    };
+    if (this.definition.handlers.onError) {
+      try {
+        const result = await this.definition.handlers.onError(errorCtx);
+        if (result && typeof result === "object") {
+          if ("handled" in result && result.handled) {
+            return false;
+          }
+          if ("rethrow" in result && result.rethrow) {
+            return true;
+          }
+        }
+      } catch (handlerError) {
+        log2.error("Error in onError handler:", handlerError);
+      }
     }
-    return this.wasmEngine;
-  }
-  setRenderCallback(callback) {
-    const engine = this.ensureInitialized();
-    engine.setRenderCallback((patches) => {
-      callback(patches);
-    });
-  }
-  setComponentResolver(resolver) {
-    const engine = this.ensureInitialized();
-    engine.setComponentResolver((componentName, contextPath) => {
-      const result = resolver(componentName, contextPath);
-      return result;
-    });
-  }
-  renderSource(source) {
-    const engine = this.ensureInitialized();
-    engine.renderSource(source);
-  }
-  renderLazyComponent(source) {
-    const engine = this.ensureInitialized();
-    engine.renderLazyComponent(source);
-  }
-  renderInto(source, parentNodeId, state) {
-    const engine = this.ensureInitialized();
-    const safeState = JSON.parse(JSON.stringify(state));
-    engine.renderInto(source, parentNodeId, safeState);
-  }
-  notifyStateChange(paths, values) {
-    const engine = this.ensureInitialized();
-    if (paths.length === 0) {
-      return;
+    if (this.globalContext) {
+      const eventContext = context.actionName ? `action:${context.actionName}` : context.lifecycle ? `lifecycle:${context.lifecycle}` : "unknown";
+      this.globalContext.emit("error", {
+        message: error.message,
+        error,
+        context: eventContext
+      });
     }
-    const plainValues = JSON.parse(JSON.stringify(values));
-    engine.updateStateSparse(paths, plainValues);
-    log3.debug("State changed (sparse):", paths);
+    log2.error(`${context.actionName ? `Action "${context.actionName}"` : `Lifecycle "${context.lifecycle}"`} error:`, error);
+    return false;
   }
-  notifyStateChangeFull(paths, currentState) {
-    const engine = this.ensureInitialized();
-    const plainObject = JSON.parse(JSON.stringify(currentState));
-    engine.updateState(plainObject);
-    if (paths.length > 0) {
-      log3.debug("State changed (full):", paths);
+  async callCreatedHandler() {
+    if (this.definition.handlers.onCreated) {
+      const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
+      await this.definition.handlers.onCreated(this.state, context);
     }
   }
-  updateState(statePatch) {
-    const engine = this.ensureInitialized();
-    const plainObject = JSON.parse(JSON.stringify(statePatch));
-    engine.updateState(plainObject);
-  }
-  dispatchAction(name, payload) {
-    const engine = this.ensureInitialized();
-    log3.debug(`Action dispatched: ${name}`);
-    engine.dispatchAction(name, payload ?? null);
-  }
-  onAction(actionName, handler) {
-    const engine = this.ensureInitialized();
-    engine.onAction(actionName, (action) => {
-      const normalizedAction = {
-        ...action,
-        payload: action.payload ? mapToObject(action.payload) : action.payload
-      };
-      Promise.resolve(handler(normalizedAction)).catch((err) => log3.error("Action handler error:", err));
-    });
+  onStateChange(callback) {
+    this.stateChangeCallbacks.push(callback);
   }
-  setModule(name, actions, stateKeys, initialState) {
-    const engine = this.ensureInitialized();
-    engine.setModule(name, actions, stateKeys, initialState);
+  async destroy() {
+    if (this.isDestroyed)
+      return;
+    if (this.definition.handlers.onDestroyed) {
+      await this.definition.handlers.onDestroyed(this.state);
+    }
+    this.isDestroyed = true;
   }
-  getRevision() {
-    const engine = this.ensureInitialized();
-    return engine.getRevision();
+  getState() {
+    return getStateSnapshot(this.state);
   }
-  clearTree() {
-    const engine = this.ensureInitialized();
-    engine.clearTree();
+  getLiveState() {
+    return this.state;
   }
-  debugParseComponent(source) {
-    const engine = this.ensureInitialized();
-    return engine.debugParseComponent(source);
+  updateState(patch) {
+    Object.assign(this.state, patch);
   }
 }
+var log2, app;
+var init_app = __esm(() => {
+  init_result();
+  init_state();
+  init_logger();
+  log2 = createLogger("ModuleInstance");
+  app = new HypenApp;
+});
 
 // src/renderer.ts
 init_logger();
-var log5 = frameworkLoggers.renderer;
+var log3 = frameworkLoggers.renderer;
 
 class BaseRenderer {
   nodes = new Map;
@@ -1132,14 +895,14 @@ class BaseRenderer {
 
 class ConsoleRenderer {
   applyPatches(patches) {
-    log5.debug("Patches:", patches);
+    log3.debug("Patches:", patches);
   }
 }
 
 // src/router.ts
 init_state();
 init_logger();
-var log6 = frameworkLoggers.router;
+var log4 = frameworkLoggers.router;
 
 class HypenRouter {
   state;
@@ -1177,7 +940,7 @@ class HypenRouter {
       this.updatePath(newPath, false);
     });
     this.isInitialized = true;
-    log6.debug("Router initialized at:", initialPath);
+    log4.debug("Router initialized at:", initialPath);
   }
   getPathFromBrowser() {
     if (typeof window === "undefined")
@@ -1198,21 +961,21 @@ class HypenRouter {
     return query;
   }
   push(path) {
-    log6.debug("push:", path);
+    log4.debug("push:", path);
     this.updatePath(path, true);
   }
   replace(path) {
-    log6.debug("replace:", path);
+    log4.debug("replace:", path);
     this.updatePath(path, true, true);
   }
   back() {
-    log6.debug("back");
+    log4.debug("back");
     if (typeof window !== "undefined") {
       window.history.back();
     }
   }
   forward() {
-    log6.debug("forward");
+    log4.debug("forward");
     if (typeof window !== "undefined") {
       window.history.forward();
     }
@@ -1308,7 +1071,7 @@ class HypenRouter {
     try {
       callback(this.getState());
     } catch (error) {
-      log6.error("Error in route subscriber:", error);
+      log4.error("Error in route subscriber:", error);
     }
     return () => {
       this.subscribers.delete(callback);
@@ -1320,7 +1083,7 @@ class HypenRouter {
       try {
         callback(routeState);
       } catch (error) {
-        log6.error("Error in route subscriber:", error);
+        log4.error("Error in route subscriber:", error);
       }
     });
   }
@@ -1338,7 +1101,7 @@ class HypenRouter {
 
 // src/events.ts
 init_logger();
-var log7 = frameworkLoggers.events;
+var log5 = frameworkLoggers.events;
 
 class TypedEventEmitter {
   eventBus = new Map;
@@ -1351,7 +1114,7 @@ class TypedEventEmitter {
       try {
         handler(payload);
       } catch (error) {
-        log7.error(`Error in event handler for "${String(event)}":`, error);
+        log5.error(`Error in event handler for "${String(event)}":`, error);
       }
     });
   }
@@ -1404,7 +1167,7 @@ function createEventEmitter() {
 
 // src/context.ts
 init_logger();
-var log8 = frameworkLoggers.context;
+var log6 = frameworkLoggers.context;
 
 class HypenGlobalContext {
   modules = new Map;
@@ -1418,14 +1181,14 @@ class HypenGlobalContext {
   }
   registerModule(id, instance) {
     if (this.modules.has(id)) {
-      log8.warn(`Module "${id}" is already registered. Overwriting.`);
+      log6.warn(`Module "${id}" is already registered. Overwriting.`);
     }
     this.modules.set(id, instance);
-    log8.debug(`Registered module: ${id}`);
+    log6.debug(`Registered module: ${id}`);
   }
   unregisterModule(id) {
     this.modules.delete(id);
-    log8.debug(`Unregistered module: ${id}`);
+    log6.debug(`Unregistered module: ${id}`);
   }
   getModule(id) {
     const module = this.modules.get(id);
@@ -1454,14 +1217,14 @@ class HypenGlobalContext {
   emit(event, payload) {
     const handlers = this.legacyEventBus.get(event);
     if (!handlers || handlers.size === 0) {
-      log8.debug(`Event "${event}" emitted but no listeners`);
+      log6.debug(`Event "${event}" emitted but no listeners`);
     } else {
-      log8.debug(`Emitting event: ${event}`, payload);
+      log6.debug(`Emitting event: ${event}`, payload);
       handlers.forEach((handler) => {
         try {
           handler(payload);
         } catch (error) {
-          log8.error(`Error in event handler for "${event}":`, error);
+          log6.error(`Error in event handler for "${event}":`, error);
         }
       });
     }
@@ -1475,7 +1238,7 @@ class HypenGlobalContext {
     }
     const handlers = this.legacyEventBus.get(event);
     handlers.add(handler);
-    log8.debug(`Listening to event: ${event}`);
+    log6.debug(`Listening to event: ${event}`);
     return () => {
       handlers.delete(handler);
       if (handlers.size === 0) {
@@ -1510,7 +1273,7 @@ class HypenGlobalContext {
 
 // src/disposable.ts
 init_logger();
-var log9 = frameworkLoggers.lifecycle;
+var log7 = frameworkLoggers.lifecycle;
 function isDisposable(obj) {
   return obj !== null && typeof obj === "object" && "dispose" in obj && typeof obj.dispose === "function";
 }
@@ -1542,7 +1305,7 @@ class DisposableStack {
       try {
         item.dispose();
       } catch (error) {
-        log9.error("Error during dispose:", error);
+        log7.error("Error during dispose:", error);
       }
     }
   }
@@ -1633,7 +1396,7 @@ function compositeDisposable(...disposables) {
         try {
           d.dispose();
         } catch (error) {
-          log9.error("Error during dispose:", error);
+          log7.error("Error during dispose:", error);
         }
       }
     }
@@ -1787,7 +1550,7 @@ var RetryPresets = {
 
 // src/remote/client.ts
 init_logger();
-var log10 = frameworkLoggers.remote;
+var log8 = frameworkLoggers.remote;
 
 class RemoteEngine {
   ws = null;
@@ -1895,7 +1658,7 @@ class RemoteEngine {
   }
   dispatchAction(action, payload) {
     if (this.state !== "connected" || !this.ws) {
-      log10.warn("Cannot dispatch action: not connected");
+      log8.warn("Cannot dispatch action: not connected");
       return;
     }
     const message = {
@@ -1968,7 +1731,7 @@ class RemoteEngine {
           break;
       }
     } catch (e) {
-      log10.error("Error handling remote message:", e);
+      log8.error("Error handling remote message:", e);
       const error = e instanceof Error ? e : new Error(String(e));
       this.errorCallbacks.forEach((cb) => cb(error));
     }
@@ -1997,7 +1760,7 @@ class RemoteEngine {
   }
   handlePatch(message) {
     if (message.revision <= this.currentRevision) {
-      log10.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
+      log8.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
       return;
     }
     this.currentRevision = message.revision;
@@ -2023,16 +1786,121 @@ class RemoteEngine {
         maxDelayMs: 30000,
         jitter: 0.1,
         onRetry: (attempt, error) => {
-          log10.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
+          log8.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
         }
       }).catch((error) => {
-        log10.error("Max reconnection attempts reached:", error.message);
+        log8.error("Max reconnection attempts reached:", error.message);
         this.errorCallbacks.forEach((cb) => cb(new ConnectionError(this.url, error, this.options.maxReconnectAttempts)));
       });
     }, this.options.reconnectInterval);
   }
 }
 
+// src/engine.ts
+init_logger();
+import { WasmEngine } from "../wasm-node/hypen_engine.js";
+var log9 = frameworkLoggers.engine;
+function unwrapForWasm(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (typeof value.__getSnapshot === "function") {
+    return value.__getSnapshot();
+  }
+  try {
+    return structuredClone(value);
+  } catch {
+    return JSON.parse(JSON.stringify(value));
+  }
+}
+
+class Engine {
+  wasmEngine = null;
+  initialized = false;
+  async init() {
+    if (this.initialized)
+      return;
+    this.wasmEngine = new WasmEngine;
+    this.initialized = true;
+  }
+  ensureInitialized() {
+    if (!this.wasmEngine) {
+      throw new Error("Engine not initialized. Call init() first.");
+    }
+    return this.wasmEngine;
+  }
+  setRenderCallback(callback) {
+    const engine = this.ensureInitialized();
+    engine.setRenderCallback((patches) => {
+      callback(patches);
+    });
+  }
+  setComponentResolver(resolver) {
+    const engine = this.ensureInitialized();
+    engine.setComponentResolver((componentName, contextPath) => {
+      const result = resolver(componentName, contextPath);
+      return result;
+    });
+  }
+  renderSource(source) {
+    const engine = this.ensureInitialized();
+    engine.renderSource(source);
+  }
+  renderLazyComponent(source) {
+    const engine = this.ensureInitialized();
+    engine.renderLazyComponent(source);
+  }
+  renderInto(source, parentNodeId, state) {
+    const engine = this.ensureInitialized();
+    engine.renderInto(source, parentNodeId, unwrapForWasm(state));
+  }
+  notifyStateChange(paths, values) {
+    const engine = this.ensureInitialized();
+    if (paths.length === 0) {
+      return;
+    }
+    engine.updateStateSparse(paths, unwrapForWasm(values));
+    log9.debug("State changed (sparse):", paths);
+  }
+  notifyStateChangeFull(paths, currentState) {
+    const engine = this.ensureInitialized();
+    engine.updateState(unwrapForWasm(currentState));
+    if (paths.length > 0) {
+      log9.debug("State changed (full):", paths);
+    }
+  }
+  updateState(statePatch) {
+    const engine = this.ensureInitialized();
+    engine.updateState(unwrapForWasm(statePatch));
+  }
+  dispatchAction(name, payload) {
+    const engine = this.ensureInitialized();
+    engine.dispatchAction(name, payload ?? null);
+  }
+  onAction(actionName, handler) {
+    const engine = this.ensureInitialized();
+    engine.onAction(actionName, (action) => {
+      Promise.resolve(handler(action)).catch((err) => log9.error("Action handler error:", err));
+    });
+  }
+  setModule(name, actions, stateKeys, initialState) {
+    const engine = this.ensureInitialized();
+    engine.setModule(name, actions, stateKeys, initialState);
+  }
+  getRevision() {
+    const engine = this.ensureInitialized();
+    return Number(engine.getRevision());
+  }
+  clearTree() {
+    const engine = this.ensureInitialized();
+    engine.clearTree();
+  }
+  debugParseComponent(source) {
+    const engine = this.ensureInitialized();
+    return engine.debugParseComponent(source);
+  }
+}
+
 // src/remote/server.ts
 init_app();
 
@@ -2162,7 +2030,7 @@ class SessionManager {
 
 // src/remote/server.ts
 init_logger();
-var log11 = frameworkLoggers.remote;
+var log10 = frameworkLoggers.remote;
 
 class RemoteServer {
   _module = null;
@@ -2240,7 +2108,7 @@ class RemoteServer {
         return new Response("Hypen Remote Server", { status: 200 });
       }
     });
-    log11.info(`Hypen app streaming on ws://${hostname}:${finalPort}`);
+    log10.info(`Hypen app streaming on ws://${hostname}:${finalPort}`);
     return this;
   }
   stop() {
@@ -2283,7 +2151,7 @@ class RemoteServer {
         }
       }, 1000);
     } catch (error) {
-      log11.error("Error handling WebSocket open:", error);
+      log10.error("Error handling WebSocket open:", error);
       ws.close(1011, "Internal server error");
     }
   }
@@ -2454,7 +2322,7 @@ class RemoteServer {
           break;
       }
     } catch (error) {
-      log11.error("Error handling WebSocket message:", error);
+      log10.error("Error handling WebSocket message:", error);
     }
   }
   async handleClose(ws) {
@@ -2537,7 +2405,7 @@ function serve(options) {
 init_logger();
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { join } from "path";
-var log12 = frameworkLoggers.loader;
+var log11 = frameworkLoggers.loader;
 
 class ComponentLoader {
   components = new Map;
@@ -2572,16 +2440,16 @@ class ComponentLoader {
       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}`);
+      log11.debug(`Loaded component: ${name} from ${dirPath}`);
     } catch (error) {
-      log12.error(`Failed to load component ${name} from ${dirPath}:`, error);
+      log11.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}`);
+        log11.warn(`Components directory not found: ${baseDir}`);
         return;
       }
       const entries = readdirSync(baseDir, { withFileTypes: true });
@@ -2594,9 +2462,9 @@ class ComponentLoader {
           await this.loadFromDirectory(entry.name, componentDir);
         }
       }
-      log12.debug(`Loaded ${this.components.size} components from ${baseDir}`);
+      log11.debug(`Loaded ${this.components.size} components from ${baseDir}`);
     } catch (error) {
-      log12.error(`Failed to load components from ${baseDir}:`, error);
+      log11.error(`Failed to load components from ${baseDir}:`, error);
       throw error;
     }
   }
@@ -2607,14 +2475,32 @@ var componentLoader = new ComponentLoader;
 class ComponentResolver {
   cache = new Map;
   options;
+  moduleRegistry;
   constructor(options = {}) {
     this.options = {
       baseDir: options.baseDir || process.cwd(),
       cache: options.cache ?? true,
-      customFetch: options.customFetch || this.defaultFetch.bind(this)
+      customFetch: options.customFetch || this.defaultFetch.bind(this),
+      moduleRegistry: options.moduleRegistry
     };
+    this.moduleRegistry = options.moduleRegistry;
   }
   async resolve(importStmt) {
+    if (this.moduleRegistry) {
+      const names = importStmt.clause.type === "named" ? importStmt.clause.names : [importStmt.clause.name];
+      const allFound = names.every((name) => this.moduleRegistry.has(name));
+      if (allFound) {
+        const result = {};
+        for (const name of names) {
+          const def = this.moduleRegistry.get(name);
+          result[name] = {
+            module: def,
+            template: def?.template || ""
+          };
+        }
+        return result;
+      }
+    }
     const sourcePath = this.getSourcePath(importStmt.source);
     if (this.options.cache && this.cache.has(sourcePath)) {
       const cached = this.cache.get(sourcePath);
@@ -2632,8 +2518,17 @@ class ComponentResolver {
     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.`);
+    const { resolve, join: join2 } = await import("path");
+    const { readFile } = await import("fs/promises");
+    const basePath = resolve(this.options.baseDir, path);
+    const hypenPath = basePath.endsWith(".hypen") ? basePath : `${basePath}.hypen`;
+    const template = await readFile(hypenPath, "utf-8");
+    const modulePath = hypenPath.replace(/\.hypen$/, ".ts");
+    let module = {};
+    try {
+      module = await import(modulePath);
+    } catch {}
+    return { module, template };
   }
   async resolveUrl(url) {
     try {
@@ -2701,29 +2596,26 @@ class ComponentResolver {
 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 log12 = debug ? (...args) => frameworkLoggers.discovery.debug(...args) : () => {};
   const resolvedDir = resolve(baseDir);
   const components = [];
   const seen = new Set;
-  log13("Scanning directory:", resolvedDir);
-  log13("Patterns:", patterns);
+  log12("Scanning directory:", resolvedDir);
+  log12("Patterns:", patterns);
   const addTwoFileComponent = (name, hypenPath, modulePath) => {
     if (seen.has(name)) {
-      log13(`Skipping duplicate: ${name}`);
+      log12(`Skipping duplicate: ${name}`);
       return;
     }
     seen.add(name);
     const templateRaw = readFileSync2(hypenPath, "utf-8");
-    const template = removeImports(templateRaw).trim();
+    const template = templateRaw.trim();
     components.push({
       name,
       hypenPath,
@@ -2732,11 +2624,11 @@ async function discoverComponents(baseDir, options = {}) {
       hasModule: modulePath !== null,
       isSingleFile: false
     });
-    log13(`Found: ${name} (two-file, ${modulePath ? "with module" : "stateless"})`);
+    log12(`Found: ${name} (two-file, ${modulePath ? "with module" : "stateless"})`);
   };
   const addSingleFileComponent = (name, modulePath, template) => {
     if (seen.has(name)) {
-      log13(`Skipping duplicate: ${name}`);
+      log12(`Skipping duplicate: ${name}`);
       return;
     }
     seen.add(name);
@@ -2748,7 +2640,7 @@ async function discoverComponents(baseDir, options = {}) {
       hasModule: true,
       isSingleFile: true
     });
-    log13(`Found: ${name} (single-file with inline template)`);
+    log12(`Found: ${name} (single-file with inline template)`);
   };
   const scanForFolderComponents = (dir) => {
     if (!existsSync2(dir))
@@ -2832,7 +2724,7 @@ async function discoverComponents(baseDir, options = {}) {
             addSingleFileComponent(baseName, modulePath, module.template);
           }
         } catch (e) {
-          log13(`Failed to import potential single-file component: ${entry.name}`, e);
+          log12(`Failed to import potential single-file component: ${entry.name}`, e);
         }
       }
     }
@@ -2846,7 +2738,7 @@ async function discoverComponents(baseDir, options = {}) {
   if (patterns.includes("single-file")) {
     await scanForSingleFileComponents(resolvedDir);
   }
-  log13(`Discovered ${components.length} components`);
+  log12(`Discovered ${components.length} components`);
   return components;
 }
 async function loadDiscoveredComponents(components) {
@@ -2882,7 +2774,7 @@ function watchComponents(baseDir, options = {}) {
     debug = false,
     ...discoveryOptions
   } = options;
-  const log13 = debug ? (...args) => frameworkLoggers.discovery.debug("[watch]", ...args) : () => {};
+  const log12 = debug ? (...args) => frameworkLoggers.discovery.debug("[watch]", ...args) : () => {};
   let currentComponents = new Map;
   let debounceTimer = null;
   const initialScan = async () => {
@@ -2895,22 +2787,22 @@ function watchComponents(baseDir, options = {}) {
       clearTimeout(debounceTimer);
     }
     debounceTimer = setTimeout(async () => {
-      log13("Rescanning...");
+      log12("Rescanning...");
       const newComponents = await discoverComponents(resolvedDir, discoveryOptions);
       const newMap = new Map(newComponents.map((c) => [c.name, c]));
       for (const [name, component] of newMap) {
         const existing = currentComponents.get(name);
         if (!existing) {
-          log13("Added:", name);
+          log12("Added:", name);
           onAdd?.(component);
         } else if (existing.template !== component.template || existing.modulePath !== component.modulePath) {
-          log13("Updated:", name);
+          log12("Updated:", name);
           onUpdate?.(component);
         }
       }
       for (const name of currentComponents.keys()) {
         if (!newMap.has(name)) {
-          log13("Removed:", name);
+          log12("Removed:", name);
           onRemove?.(name);
         }
       }
@@ -2922,7 +2814,7 @@ function watchComponents(baseDir, options = {}) {
     if (!filename)
       return;
     if (filename.endsWith(".hypen") || filename.endsWith(".ts")) {
-      log13("File changed:", filename);
+      log12("File changed:", filename);
       rescan();
     }
   });
@@ -3045,28 +2937,28 @@ function parseImports(text) {
   }
   return imports;
 }
-function removeImports2(text) {
+function removeImports(text) {
   return text.replace(/import\s+(?:\{[^}]+\}|\w+)\s+from\s+["'][^"']+["']\s*/g, "");
 }
 function hypenPlugin(options = {}) {
   const { debug = false, patterns = ["sibling", "component", "index"] } = options;
-  const log13 = debug ? (...args) => frameworkLoggers.plugin.debug(...args) : () => {};
+  const log12 = debug ? (...args) => frameworkLoggers.plugin.debug(...args) : () => {};
   return {
     name: "hypen-loader",
     async setup(build) {
       build.onLoad({ filter: /\.hypen$/ }, async (args) => {
         const hypenPath = resolve2(args.path);
-        log13("Loading:", hypenPath);
+        log12("Loading:", hypenPath);
         const templateRaw = readFileSync3(hypenPath, "utf-8");
         const imports = parseImports(templateRaw);
-        const template = removeImports2(templateRaw).trim();
+        const template = removeImports(templateRaw).trim();
         if (imports.length > 0) {
-          log13("Found imports:", imports);
+          log12("Found imports:", imports);
         }
         const componentName = getComponentName(hypenPath);
-        log13("Component name:", componentName);
+        log12("Component name:", componentName);
         const modulePath = findModulePath(hypenPath, patterns);
-        log13("Module path:", modulePath);
+        log12("Module path:", modulePath);
         let contents;
         if (modulePath) {
           const relativeModulePath = modulePath.replace(/\.ts$/, ".js");
@@ -3078,7 +2970,7 @@ 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");
+          log12("No module found, creating stateless component");
           contents = `
 import { app } from "@hypen-space/core";
 const _module = app.defineState({}).build();
@@ -3105,19 +2997,19 @@ var plugin_default = hypenPlugin;
 // src/components/builtin.ts
 init_app();
 init_logger();
-var log13 = frameworkLoggers.router;
+var log12 = frameworkLoggers.router;
 var Router = app.defineState({
   currentPath: "/",
   matchedRoute: null,
   routeParams: {}
 }, { name: "__Router" }).onCreated((state, context) => {
   if (!context) {
-    log13.error("Requires global context");
+    log12.error("Requires global context");
     return;
   }
   const router = context.__router;
   if (!router) {
-    log13.error("Router not found in context");
+    log12.error("Router not found in context");
     return;
   }
   const hypenEngine = context.__hypenEngine;
@@ -3139,13 +3031,13 @@ var Router = app.defineState({
           try {
             await hypenEngine.renderLazyRoute(routePath, componentName, htmlEl);
           } catch (err) {
-            log13.error(`Failed to render route ${routePath}:`, err);
+            log12.error(`Failed to render route ${routePath}:`, err);
           }
         }
       }
     }
     if (!matchFound) {
-      log13.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
+      log12.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
     }
   };
   setTimeout(() => {
@@ -3164,7 +3056,7 @@ var Link = app.defineState({
 }, { name: "__Link" }).onAction("navigate", ({ state, context }) => {
   const router = context?.__router;
   if (!router) {
-    log13.error("Link requires router context");
+    log12.error("Link requires router context");
     return;
   }
   const targetPath = state.to;
@@ -3314,16 +3206,14 @@ export {
   HypenAppBuilder,
   HypenApp,
   Err,
-  Engine,
   DisposableStack,
   DisposableMixin,
   ConsoleRenderer,
   ConnectionError,
   ComponentResolver,
   ComponentLoader,
-  Engine2 as BrowserEngine,
   BaseRenderer,
   ActionError
 };
 
-//# debugId=202EDC5229AA5FFA64756E2164756E21
+//# debugId=C03FB9EC8278859464756E2164756E21