@hypen-space/core 0.4.37 → 0.4.39

package/dist/index.js

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -14,7 +13,353 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// node:path
+var exports_path = {};
+__export(exports_path, {
+  sep: () => sep,
+  resolve: () => resolve,
+  relative: () => relative,
+  posix: () => posix,
+  parse: () => parse,
+  normalize: () => normalize,
+  join: () => join,
+  isAbsolute: () => isAbsolute,
+  format: () => format,
+  extname: () => extname,
+  dirname: () => dirname,
+  delimiter: () => delimiter,
+  default: () => path_default,
+  basename: () => basename,
+  _makeLong: () => _makeLong
+});
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/", delimiter = ":", posix, path_default;
+var init_path = __esm(() => {
+  posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+  path_default = posix;
+});
 
 // src/result.ts
 function Ok(value) {
@@ -102,7 +447,95 @@ function all(results) {
   }
   return Ok(values);
 }
+
+class HypenError extends Error {
+  code;
+  context;
+  cause;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "HypenError";
+    this.code = code;
+    this.context = options?.context;
+    this.cause = options?.cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class ActionError extends HypenError {
+  actionName;
+  constructor(actionName, cause) {
+    super("ACTION_ERROR", `Action handler "${actionName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
+      context: { actionName },
+      cause: cause instanceof Error ? cause : undefined
+    });
+    this.name = "ActionError";
+    this.actionName = actionName;
+  }
+}
+
+class ConnectionError extends HypenError {
+  url;
+  attempt;
+  constructor(url, cause, attempt) {
+    super("CONNECTION_ERROR", `Connection to "${url}" failed${attempt ? ` (attempt ${attempt})` : ""}: ${cause instanceof Error ? cause.message : String(cause)}`, {
+      context: { url, attempt },
+      cause: cause instanceof Error ? cause : undefined
+    });
+    this.name = "ConnectionError";
+    this.url = url;
+    this.attempt = attempt;
+  }
+}
+
+class StateError extends HypenError {
+  path;
+  constructor(message, path, cause) {
+    super("STATE_ERROR", message, {
+      context: { path },
+      cause: cause instanceof Error ? cause : undefined
+    });
+    this.name = "StateError";
+    this.path = path;
+  }
+}
+
+class ParseError extends HypenError {
+  source;
+  constructor(message, source, cause) {
+    super("PARSE_ERROR", message, {
+      context: { source },
+      cause: cause instanceof Error ? cause : undefined
+    });
+    this.name = "ParseError";
+    this.source = source;
+  }
+}
+
+class RenderError extends HypenError {
+  constructor(message, cause) {
+    super("RENDER_ERROR", message, {
+      cause: cause instanceof Error ? cause : undefined
+    });
+    this.name = "RenderError";
+  }
+}
 function classifyEngineError(err) {
+  if (err && typeof err === "object" && "message" in err && "type" in err) {
+    const structured = err;
+    switch (structured.type) {
+      case "parseError":
+        return new ParseError(structured.message);
+      case "stateError":
+        return new StateError(structured.message);
+      case "renderError":
+        return new RenderError(structured.message);
+      case "actionError":
+        return new HypenError("ACTION_ERROR", structured.message);
+      default:
+        return new HypenError("UNKNOWN_ERROR", structured.message);
+    }
+  }
   const message = err instanceof Error ? err.message : String(err);
   if (message.startsWith("Parse error:")) {
     return new ParseError(message);
@@ -115,76 +548,6 @@ function classifyEngineError(err) {
   }
   return new RenderError(message);
 }
-var HypenError, ActionError, ConnectionError, StateError, ParseError, RenderError;
-var init_result = __esm(() => {
-  HypenError = class HypenError extends Error {
-    code;
-    context;
-    cause;
-    constructor(code, message, options) {
-      super(message);
-      this.name = "HypenError";
-      this.code = code;
-      this.context = options?.context;
-      this.cause = options?.cause;
-      Object.setPrototypeOf(this, new.target.prototype);
-    }
-  };
-  ActionError = class ActionError extends HypenError {
-    actionName;
-    constructor(actionName, cause) {
-      super("ACTION_ERROR", `Action handler "${actionName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
-        context: { actionName },
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "ActionError";
-      this.actionName = actionName;
-    }
-  };
-  ConnectionError = class ConnectionError extends HypenError {
-    url;
-    attempt;
-    constructor(url, cause, attempt) {
-      super("CONNECTION_ERROR", `Connection to "${url}" failed${attempt ? ` (attempt ${attempt})` : ""}: ${cause instanceof Error ? cause.message : String(cause)}`, {
-        context: { url, attempt },
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "ConnectionError";
-      this.url = url;
-      this.attempt = attempt;
-    }
-  };
-  StateError = class StateError extends HypenError {
-    path;
-    constructor(message, path, cause) {
-      super("STATE_ERROR", message, {
-        context: { path },
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "StateError";
-      this.path = path;
-    }
-  };
-  ParseError = class ParseError extends HypenError {
-    source;
-    constructor(message, source, cause) {
-      super("PARSE_ERROR", message, {
-        context: { source },
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "ParseError";
-      this.source = source;
-    }
-  };
-  RenderError = class RenderError extends HypenError {
-    constructor(message, cause) {
-      super("RENDER_ERROR", message, {
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "RenderError";
-    }
-  };
-});
 
 // src/datasource.ts
 class DataSourceManager {
@@ -240,6 +603,8 @@ class DataSourceManager {
 }
 
 // src/state.ts
+var IS_PROXY = Symbol.for("hypen.isProxy");
+var RAW_TARGET = Symbol.for("hypen.rawTarget");
 function deepClone(obj) {
   if (obj === null || typeof obj !== "object") {
     return obj;
@@ -484,19 +849,33 @@ function unwrapProxy(value) {
   }
   return value;
 }
-var IS_PROXY, RAW_TARGET;
-var init_state = __esm(() => {
-  IS_PROXY = Symbol.for("hypen.isProxy");
-  RAW_TARGET = Symbol.for("hypen.rawTarget");
-});
 
 // src/logger.ts
+var LOG_LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  none: 4
+};
+var LOG_LEVEL_COLORS = {
+  debug: "\x1B[36m",
+  info: "\x1B[32m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m"
+};
+var RESET_COLOR = "\x1B[0m";
 function isProduction() {
   if (typeof process !== "undefined" && process.env) {
     return false;
   }
   return false;
 }
+var config = {
+  level: isProduction() ? "error" : "info",
+  colors: true,
+  timestamps: false
+};
 function setLogLevel(level) {
   config.level = level;
 }
@@ -627,76 +1006,49 @@ class Logger {
 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" : "info",
-    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")
-  };
-});
+var logger = createLogger("Hypen");
+var 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);
+  }
+};
+var 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
-});
+var log2 = createLogger("ModuleInstance");
 
 class HypenAppBuilder {
   initialState;
@@ -753,7 +1105,7 @@ class HypenAppBuilder {
     return this.build();
   }
   uiFile(path) {
-    const fs = __require("fs");
+    const fs = (() => ({}));
     this.template = fs.readFileSync(path, "utf-8").trim();
     return this.build();
   }
@@ -820,6 +1172,7 @@ class HypenApp {
     this._registry.clear();
   }
 }
+var app = new HypenApp;
 
 class HypenModuleInstance {
   engine;
@@ -1023,17 +1376,6 @@ class HypenModuleInstance {
     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/index.ts
-init_app();
 
 // src/hypen.ts
 function createBindingProxy(root) {
@@ -1083,11 +1425,7 @@ function hypen(strings, ...expressions) {
   return result.trim();
 }
 
-// src/index.ts
-init_state();
-
 // src/renderer.ts
-init_logger();
 var log3 = frameworkLoggers.renderer;
 
 class BaseRenderer {
@@ -1137,11 +1475,8 @@ class ConsoleRenderer {
     console.groupEnd();
   }
 }
-// src/router.ts
-init_state();
 
 // src/disposable.ts
-init_logger();
 var log4 = frameworkLoggers.lifecycle;
 function isDisposable(obj) {
   return obj !== null && typeof obj === "object" && "dispose" in obj && typeof obj.dispose === "function";
@@ -1289,7 +1624,6 @@ function usingSync(resource, fn) {
 }
 
 // src/router.ts
-init_logger();
 var log5 = frameworkLoggers.router;
 
 class HypenRouter {
@@ -1499,8 +1833,8 @@ class HypenRouter {
     this.dispose();
   }
 }
+
 // src/events.ts
-init_logger();
 var log6 = frameworkLoggers.events;
 
 class TypedEventEmitter {
@@ -1564,14 +1898,13 @@ class TypedEventEmitter {
 function createEventEmitter() {
   return new TypedEventEmitter;
 }
+
 // src/context.ts
-init_logger();
 var log7 = frameworkLoggers.context;
 
 class HypenGlobalContext {
   modules = new Map;
   typedEvents;
-  legacyEventBus = new Map;
   constructor() {
     this.typedEvents = new TypedEventEmitter;
   }
@@ -1614,66 +1947,36 @@ class HypenGlobalContext {
     return state2;
   }
   emit(event, payload) {
-    const handlers = this.legacyEventBus.get(event);
-    if (!handlers || handlers.size === 0) {
+    if (this.typedEvents.listenerCount(event) === 0) {
       log7.debug(`Event "${event}" emitted but no listeners`);
-    } else {
-      log7.debug(`Emitting event: ${event}`, payload);
-      handlers.forEach((handler) => {
-        try {
-          handler(payload);
-        } catch (error) {
-          log7.error(`Error in event handler for "${event}":`, error);
-        }
-      });
-    }
-    if (this.typedEvents.listenerCount(event) > 0) {
-      this.typedEvents.emit(event, payload);
+      return;
     }
+    log7.debug(`Emitting event: ${event}`, payload);
+    this.typedEvents.emit(event, payload);
   }
   on(event, handler) {
-    if (!this.legacyEventBus.has(event)) {
-      this.legacyEventBus.set(event, new Set);
-    }
-    const handlers = this.legacyEventBus.get(event);
-    handlers.add(handler);
     log7.debug(`Listening to event: ${event}`);
-    return () => {
-      handlers.delete(handler);
-      if (handlers.size === 0) {
-        this.legacyEventBus.delete(event);
-      }
-    };
+    return this.typedEvents.on(event, handler);
   }
   off(event, handler) {
-    const handlers = this.legacyEventBus.get(event);
-    if (handlers) {
-      handlers.delete(handler);
-      if (handlers.size === 0) {
-        this.legacyEventBus.delete(event);
-      }
-    }
+    this.typedEvents.off(event, handler);
   }
   clearEvent(event) {
-    this.legacyEventBus.delete(event);
+    this.typedEvents.removeAllListeners(event);
   }
   clearAllEvents() {
-    this.legacyEventBus.clear();
+    this.typedEvents.clearAll();
   }
   debug() {
     return {
       modules: this.getModuleIds(),
-      events: Array.from(this.legacyEventBus.keys()),
-      typedEvents: this.typedEvents.eventNames(),
+      events: this.typedEvents.eventNames(),
       state: this.getGlobalState()
     };
   }
 }
-// src/remote/client.ts
-init_result();
 
 // src/retry.ts
-init_result();
 var DEFAULT_OPTIONS = {
   maxAttempts: 3,
   delayMs: 1000,
@@ -1799,7 +2102,6 @@ var RetryPresets = {
 };
 
 // src/remote/client.ts
-init_logger();
 var log8 = frameworkLoggers.remote;
 
 class RemoteEngine {
@@ -2065,6 +2367,7 @@ class RemoteEngine {
     }, this.options.reconnectInterval);
   }
 }
+
 // src/remote/session.ts
 class SessionManager {
   activeSessions = new Map;
@@ -2188,6 +2491,7 @@ class SessionManager {
     this.sessionConnections.clear();
   }
 }
+
 // src/resolver.ts
 class ComponentResolver {
   cache = new Map;
@@ -2235,9 +2539,9 @@ class ComponentResolver {
     return this.extractComponents(importStmt.clause, component);
   }
   async resolveLocal(path) {
-    const { resolve, join } = await import("path");
+    const { resolve: resolve2, join: join2 } = await Promise.resolve().then(() => (init_path(), exports_path));
     const { readFile } = await import("fs/promises");
-    const basePath = resolve(this.options.baseDir, path);
+    const basePath = resolve2(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");
@@ -2308,10 +2612,38 @@ class ComponentResolver {
     return imports;
   }
 }
+
 // src/components/builtin.ts
-init_app();
-init_logger();
 var log9 = frameworkLoggers.router;
+async function updateRouteVisibility(currentPath, engine, doc) {
+  const targetDoc = doc ?? document;
+  const routeElements = targetDoc.querySelectorAll('[data-hypen-type="route"]');
+  let matchFound = false;
+  for (let index2 = 0;index2 < routeElements.length; index2++) {
+    const routeEl = routeElements[index2];
+    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;
+      const shouldRender = componentName && engine && (isLazy || !hasContent);
+      if (shouldRender) {
+        try {
+          await engine.renderLazyRoute(routePath, componentName, htmlEl);
+        } catch (err) {
+          log9.error(`Failed to render route ${routePath}:`, err);
+        }
+      }
+    }
+  }
+  if (!matchFound) {
+    log9.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
+  }
+}
 var Router = app.defineState({
   currentPath: "/",
   matchedRoute: null,
@@ -2327,40 +2659,13 @@ var Router = app.defineState({
     return;
   }
   const hypenEngine = context.__hypenEngine;
-  const updateRouteVisibility = async (currentPath) => {
-    const routeElements = document.querySelectorAll('[data-hypen-type="route"]');
-    let matchFound = false;
-    for (let index2 = 0;index2 < routeElements.length; index2++) {
-      const routeEl = routeElements[index2];
-      const htmlEl = routeEl;
-      const routePath = htmlEl.dataset.routePath || "/";
-      const isMatch = routePath === currentPath;
-      htmlEl.style.display = isMatch ? "flex" : "none";
-      if (isMatch) {
-        matchFound = true;
-        const componentName = htmlEl.dataset.routeComponent;
-        const isLazy = htmlEl.dataset.routeLazy === "true";
-        const hasContent = htmlEl.children.length > 0;
-        if (componentName && !hasContent && hypenEngine) {
-          try {
-            await hypenEngine.renderLazyRoute(routePath, componentName, htmlEl);
-          } catch (err) {
-            log9.error(`Failed to render route ${routePath}:`, err);
-          }
-        }
-      }
-    }
-    if (!matchFound) {
-      log9.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
-    }
-  };
   setTimeout(() => {
-    updateRouteVisibility(state2.currentPath);
+    updateRouteVisibility(state2.currentPath, hypenEngine);
   }, 100);
   router.onNavigate((routeState) => {
     state2.currentPath = routeState.currentPath;
     state2.routeParams = routeState.params;
-    updateRouteVisibility(routeState.currentPath);
+    updateRouteVisibility(routeState.currentPath, hypenEngine);
   });
 }).build();
 var Route = app.defineState({}, { name: "__Route" }).build();
@@ -2385,10 +2690,6 @@ var Link = app.defineState({
     });
   }
 }).build();
-
-// src/index.ts
-init_result();
-init_logger();
 export {
   withRetry,
   usingSync,
@@ -2471,4 +2772,4 @@ export {
   ActionError
 };
 
-//# debugId=D4B51C3A115B4AA664756E2164756E21
+//# debugId=9FB52584D73FE77364756E2164756E21