@hypen-space/core 0.4.956 → 0.5.2

package/dist/index.js

@@ -1,3066 +1,140 @@
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-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;
-      }
+import {
+  ComponentResolver
+} from "./chunk-mbqqsz6r.js";
+import {
+  Link,
+  Route,
+  Router
+} from "./chunk-x4qv4jm9.js";
+import {
+  SessionManager
+} from "./chunk-gtwh1sg7.js";
+import {
+  HypenGlobalContext
+} from "./chunk-3zvyth50.js";
+import {
+  TypedEventEmitter,
+  createEventEmitter
+} from "./chunk-k12cwfst.js";
+import {
+  RemoteEngine
+} from "./chunk-g7g3jxty.js";
+import {
+  RetryConditions,
+  RetryPresets,
+  retry,
+  retryResult,
+  withRetry
+} from "./chunk-g2gz9pgg.js";
+import {
+  hypen,
+  index,
+  item,
+  state
+} from "./chunk-wp2ebn2m.js";
+import {
+  BaseRenderer,
+  ConsoleRenderer
+} from "./chunk-00zt3w6e.js";
+import {
+  HypenRouter
+} from "./chunk-p3pj1bax.js";
+import {
+  DisposableMixin,
+  DisposableStack,
+  compositeDisposable,
+  disposableAbortController,
+  disposableInterval,
+  disposableListener,
+  disposableSubscription,
+  disposableTimeout,
+  disposableWebSocket,
+  disposeElement,
+  getElementDisposables,
+  hasElementDisposables,
+  isDisposable,
+  using,
+  usingSync
+} from "./chunk-ec0tgy9a.js";
+import {
+  ManagedRouter
+} from "./chunk-ne632swm.js";
+import {
+  HypenApp,
+  HypenAppBuilder,
+  HypenModuleInstance,
+  app
+} from "./chunk-fnss4dm2.js";
+import {
+  DataSourceManager
+} from "./chunk-vshdk2pw.js";
+import {
+  ActionError,
+  ConnectionError,
+  Err,
+  HypenError,
+  Ok,
+  ParseError,
+  RenderError,
+  StateError,
+  all,
+  classifyEngineError,
+  flatMap,
+  fromPromise,
+  fromTry,
+  isErr,
+  isOk,
+  map,
+  mapErr,
+  match,
+  unwrap,
+  unwrapOr,
+  unwrapOrElse
+} from "./chunk-7222131a.js";
+import {
+  batchStateUpdates,
+  createObservableState,
+  getStateSnapshot,
+  isStateProxy,
+  unwrapProxy
+} from "./chunk-ycxp4drd.js";
+import {
+  portable,
+  setPortableImpl
+} from "./chunk-g830re2c.js";
+import {
+  Logger,
+  configureLogger,
+  createLogger,
+  disableLogging,
+  enableLogging,
+  frameworkLoggers,
+  getLogLevel,
+  isDebugMode,
+  log,
+  logger,
+  setDebugMode,
+  setLogLevel
+} from "./chunk-avchpwhf.js";
+import"./chunk-5gtx3pza.js";
+// src/validate.ts
+function validatePatches(patches, knownTypes) {
+  const known = knownTypes instanceof Set ? knownTypes : new Set(knownTypes);
+  const unknown = new Set;
+  for (const patch of patches) {
+    if (patch.type !== "create")
       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;
-      }
+    const elementType = patch.elementType;
+    if (typeof elementType !== "string")
       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) {
-  return { ok: true, value };
-}
-function Err(error) {
-  return { ok: false, error };
-}
-function isOk(result) {
-  return result.ok;
-}
-function isErr(result) {
-  return !result.ok;
-}
-async function fromPromise(promise, mapError) {
-  try {
-    const value = await promise;
-    return Ok(value);
-  } catch (e) {
-    if (mapError) {
-      return Err(mapError(e));
-    }
-    return Err(e);
-  }
-}
-function fromTry(fn, mapError) {
-  try {
-    return Ok(fn());
-  } catch (e) {
-    if (mapError) {
-      return Err(mapError(e));
-    }
-    return Err(e);
-  }
-}
-function map(result, fn) {
-  if (result.ok) {
-    return Ok(fn(result.value));
-  }
-  return result;
-}
-function mapErr(result, fn) {
-  if (!result.ok) {
-    return Err(fn(result.error));
-  }
-  return result;
-}
-function flatMap(result, fn) {
-  if (result.ok) {
-    return fn(result.value);
-  }
-  return result;
-}
-function unwrap(result) {
-  if (result.ok) {
-    return result.value;
-  }
-  throw result.error;
-}
-function unwrapOr(result, defaultValue) {
-  if (result.ok) {
-    return result.value;
-  }
-  return defaultValue;
-}
-function unwrapOrElse(result, fn) {
-  if (result.ok) {
-    return result.value;
-  }
-  return fn(result.error);
-}
-function match(result, handlers) {
-  if (result.ok) {
-    return handlers.ok(result.value);
-  }
-  return handlers.err(result.error);
-}
-function all(results) {
-  const values = [];
-  for (const result of results) {
-    if (!result.ok) {
-      return result;
-    }
-    values.push(result.value);
-  }
-  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);
-  }
-  if (message.startsWith("Invalid state:") || message.startsWith("Invalid state patch:")) {
-    return new StateError(message);
-  }
-  if (message.startsWith("Parent node not found:")) {
-    return new RenderError(message);
-  }
-  return new RenderError(message);
-}
-
-// src/datasource.ts
-class DataSourceManager {
-  plugins = new Map;
-  configs = new Map;
-  state = new Map;
-  engine;
-  constructor(engine) {
-    this.engine = engine;
-  }
-  async use(plugin, config) {
-    const { name } = plugin;
-    this.state.set(name, {});
-    this.plugins.set(name, plugin);
-    this.configs.set(name, config);
-    await plugin.connect(config, (change) => {
-      const current = this.state.get(name) ?? {};
-      for (const path of change.paths) {
-        if (path in change.values) {
-          current[path] = change.values[path];
-        }
-      }
-      this.state.set(name, current);
-      this.engine.setContext(name, current);
-    });
-  }
-  get(name) {
-    return this.plugins.get(name);
-  }
-  has(name) {
-    return this.plugins.has(name);
-  }
-  getNames() {
-    return Array.from(this.plugins.keys());
-  }
-  getStatus(name) {
-    return this.plugins.get(name)?.status;
-  }
-  async remove(name) {
-    const plugin = this.plugins.get(name);
-    if (plugin) {
-      await plugin.disconnect();
-      this.plugins.delete(name);
-      this.configs.delete(name);
-      this.state.delete(name);
-      this.engine.removeContext(name);
-    }
-  }
-  async disconnectAll() {
-    const names = Array.from(this.plugins.keys());
-    await Promise.all(names.map((name) => this.remove(name)));
-  }
-}
-
-// src/portable.ts
-function notInstalled(name) {
-  throw new Error(`[@hypen-space/core] Portable helper "${name}" called before the engine was installed. ` + `Import @hypen-space/server, @hypen-space/web-engine, or call setPortableImpl() before use.`);
-}
-var current = {
-  diffState: () => notInstalled("diffState"),
-  matchPath: () => notInstalled("matchPath"),
-  pathGet: () => notInstalled("pathGet"),
-  pathHas: () => notInstalled("pathHas"),
-  pathSet: () => notInstalled("pathSet"),
-  pathDelete: () => notInstalled("pathDelete"),
-  encodeUriComponent: () => notInstalled("encodeUriComponent"),
-  decodeUriComponent: () => notInstalled("decodeUriComponent"),
-  parseQuery: () => notInstalled("parseQuery"),
-  buildUrl: () => notInstalled("buildUrl")
-};
-function setPortableImpl(impl) {
-  if (impl === null) {
-    current = {
-      diffState: () => notInstalled("diffState"),
-      matchPath: () => notInstalled("matchPath"),
-      pathGet: () => notInstalled("pathGet"),
-      pathHas: () => notInstalled("pathHas"),
-      pathSet: () => notInstalled("pathSet"),
-      pathDelete: () => notInstalled("pathDelete"),
-      encodeUriComponent: () => notInstalled("encodeUriComponent"),
-      decodeUriComponent: () => notInstalled("decodeUriComponent"),
-      parseQuery: () => notInstalled("parseQuery"),
-      buildUrl: () => notInstalled("buildUrl")
-    };
-    return;
-  }
-  current = impl;
-}
-var portable = {
-  diffState: (o, n, b) => current.diffState(o, n, b),
-  matchPath: (p, path) => current.matchPath(p, path),
-  pathGet: (v, p) => current.pathGet(v, p),
-  pathHas: (v, p) => current.pathHas(v, p),
-  pathSet: (v, p, nv) => current.pathSet(v, p, nv),
-  pathDelete: (v, p) => current.pathDelete(v, p),
-  encodeUriComponent: (s) => current.encodeUriComponent(s),
-  decodeUriComponent: (s) => current.decodeUriComponent(s),
-  parseQuery: (f) => current.parseQuery(f),
-  buildUrl: (p, q) => current.buildUrl(p, q)
-};
-
-// 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;
-  }
-  if (typeof obj === "function") {
-    return obj;
-  }
-  if (typeof obj.__getSnapshot === "function") {
-    return obj.__getSnapshot();
-  }
-  if (obj instanceof WeakMap || obj instanceof WeakSet) {
-    return obj;
-  }
-  const visited = new WeakMap;
-  function cloneInternal(value) {
-    if (value === null || typeof value !== "object") {
-      return value;
-    }
-    if (typeof value === "function") {
-      return value;
-    }
-    if (visited.has(value)) {
-      return visited.get(value);
-    }
-    if (value instanceof WeakMap || value instanceof WeakSet) {
-      return value;
-    }
-    if (value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
-      try {
-        return structuredClone(value);
-      } catch {}
-    }
-    if (Array.isArray(value)) {
-      const arrClone = [];
-      visited.set(value, arrClone);
-      for (let i = 0;i < value.length; i++) {
-        arrClone[i] = cloneInternal(value[i]);
-      }
-      return arrClone;
-    }
-    const objClone = {};
-    visited.set(value, objClone);
-    for (const key in value) {
-      if (Object.prototype.hasOwnProperty.call(value, key)) {
-        objClone[key] = cloneInternal(value[key]);
-      }
-    }
-    const symbolKeys = Object.getOwnPropertySymbols(value);
-    for (const sym of symbolKeys) {
-      objClone[sym] = cloneInternal(value[sym]);
-    }
-    return objClone;
-  }
-  return cloneInternal(obj);
-}
-function diffState(oldState, newState, basePath = "") {
-  return portable.diffState(oldState, newState, basePath);
-}
-function createObservableState(initialState, options) {
-  const opts = options || { onChange: () => {} };
-  if (initialState === null || initialState === undefined) {
-    initialState = {};
-  }
-  if (initialState instanceof Number || initialState instanceof String || initialState instanceof Boolean) {
-    throw new TypeError("Cannot create observable state from primitive wrapper objects (Number, String, Boolean). " + "Use plain primitives or regular objects instead.");
-  }
-  initialState = deepClone(initialState);
-  let lastSnapshot = deepClone(initialState);
-  const pathPrefix = opts.pathPrefix || "";
-  let batchDepth = 0;
-  let pendingChange = null;
-  function notifyChange() {
-    if (batchDepth > 0)
-      return;
-    const change = diffState(lastSnapshot, state, pathPrefix);
-    if (change.paths.length > 0) {
-      lastSnapshot = deepClone(state);
-      if (pendingChange) {
-        change.paths.push(...pendingChange.paths);
-        Object.assign(change.newValues, pendingChange.newValues);
-        pendingChange = null;
-      }
-      opts.onChange(change);
-    }
-  }
-  let notificationPending = false;
-  function scheduleBatch() {
-    if (batchDepth === 0) {
-      if (!notificationPending) {
-        notificationPending = true;
-        queueMicrotask(() => {
-          notificationPending = false;
-          if (batchDepth === 0) {
-            notifyChange();
-          } else {}
-        });
-      }
-    } else {
-      pendingChange = pendingChange || { paths: [], newValues: {} };
-    }
-  }
-  const proxyCache = new WeakMap;
-  function createProxy(target, basePath) {
-    const cached = proxyCache.get(target);
-    if (cached)
-      return cached;
-    const proxy = new Proxy(target, {
-      get(obj, prop) {
-        if (prop === IS_PROXY)
-          return true;
-        if (prop === RAW_TARGET)
-          return obj;
-        if (prop === "__beginBatch") {
-          return () => {
-            batchDepth++;
-          };
-        }
-        if (prop === "__endBatch") {
-          return () => {
-            batchDepth--;
-            if (batchDepth === 0) {
-              notifyChange();
-            }
-          };
-        }
-        if (prop === "__getSnapshot") {
-          return () => deepClone(obj);
-        }
-        const value = obj[prop];
-        if (value && typeof value === "object") {
-          if (value[IS_PROXY]) {
-            return value;
-          }
-          if (value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet) {
-            return value;
-          }
-          const cachedNested = proxyCache.get(value);
-          if (cachedNested) {
-            return cachedNested;
-          }
-          const nestedProxy = createProxy(value, basePath ? `${basePath}.${String(prop)}` : String(prop));
-          return nestedProxy;
-        }
-        return value;
-      },
-      set(obj, prop, value) {
-        const oldValue = obj[prop];
-        if (value && typeof value === "object" && value[IS_PROXY]) {
-          value = value[RAW_TARGET];
-        }
-        obj[prop] = value;
-        if (oldValue !== value) {
-          scheduleBatch();
-        }
-        return true;
-      },
-      deleteProperty(obj, prop) {
-        const existed = Object.prototype.hasOwnProperty.call(obj, prop);
-        const result = delete obj[prop];
-        if (existed) {
-          scheduleBatch();
-        }
-        return result;
-      }
-    });
-    proxyCache.set(target, proxy);
-    return proxy;
-  }
-  const state = createProxy(initialState, pathPrefix);
-  return state;
-}
-function batchStateUpdates(state, fn) {
-  const s = state;
-  if (s.__beginBatch && s.__endBatch) {
-    s.__beginBatch();
-    try {
-      fn();
-    } finally {
-      s.__endBatch();
-    }
-  } else {
-    fn();
-  }
-}
-function getStateSnapshot(state) {
-  const s = state;
-  if (s.__getSnapshot) {
-    return s.__getSnapshot();
-  }
-  return deepClone(state);
-}
-function isStateProxy(value) {
-  return value !== null && typeof value === "object" && value[IS_PROXY] === true;
-}
-function unwrapProxy(value) {
-  if (value !== null && typeof value === "object" && value[IS_PROXY]) {
-    return value[RAW_TARGET];
-  }
-  return value;
-}
-
-// 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;
-}
-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 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 log2 = createLogger("ModuleInstance");
-
-class HypenAppBuilder {
-  initialState;
-  options;
-  createdHandler;
-  activatedHandler;
-  deactivatedHandler;
-  actionHandlers = new Map;
-  destroyedHandler;
-  disconnectHandler;
-  reconnectHandler;
-  expireHandler;
-  errorHandler;
-  template;
-  _registry;
-  dataSourceEntries = [];
-  _stateStore;
-  constructor(initialState, options, registry) {
-    this.initialState = initialState;
-    this.options = options || {};
-    this._registry = registry;
-  }
-  onCreated(fn) {
-    this.createdHandler = fn;
-    return this;
-  }
-  onAction(name, fn) {
-    this.actionHandlers.set(name, fn);
-    return this;
-  }
-  onActivated(fn) {
-    this.activatedHandler = fn;
-    return this;
-  }
-  onDeactivated(fn) {
-    this.deactivatedHandler = 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;
-  }
-  persist(store) {
-    this._stateStore = store;
-    return this;
-  }
-  useDataSource(plugin, config2) {
-    this.dataSourceEntries.push({ plugin, config: config2 });
-    return this;
-  }
-  ui(template) {
-    this.template = template;
-    return this.build();
-  }
-  uiFile(path) {
-    const fs = (() => ({}));
-    this.template = fs.readFileSync(path, "utf-8").trim();
-    return this.build();
+    if (!known.has(elementType))
+      unknown.add(elementType);
   }
-  build() {
-    const stateKeys = this.initialState !== null && typeof this.initialState === "object" ? Object.keys(this.initialState) : [];
-    const definition = {
-      name: this.options.name,
-      actions: Array.from(this.actionHandlers.keys()),
-      stateKeys,
-      persist: this.options.persist,
-      version: this.options.version,
-      initialState: this.initialState,
-      template: this.template,
-      dataSources: this.dataSourceEntries.length > 0 ? this.dataSourceEntries : undefined,
-      stateStore: this._stateStore,
-      handlers: {
-        onCreated: this.createdHandler,
-        onActivated: this.activatedHandler,
-        onDeactivated: this.deactivatedHandler,
-        onAction: this.actionHandlers,
-        onDestroyed: this.destroyedHandler,
-        onDisconnect: this.disconnectHandler,
-        onReconnect: this.reconnectHandler,
-        onExpire: this.expireHandler,
-        onError: this.errorHandler
-      }
-    };
-    if (this.options.name && this._registry) {
-      this._registry.set(this.options.name, definition);
-    }
-    return definition;
-  }
-}
-
-class HypenApp {
-  _registry = new Map;
-  defineState(initial, options) {
-    return new HypenAppBuilder(initial, options, this._registry);
-  }
-  module(name) {
-    const registry = this._registry;
-    return {
-      defineState: (initial, options) => {
-        return new HypenAppBuilder(initial, { ...options, name }, registry);
-      }
-    };
-  }
-  get(name) {
-    return this._registry.get(name);
-  }
-  has(name) {
-    return this._registry.has(name);
-  }
-  get components() {
-    return this._registry;
-  }
-  getNames() {
-    return Array.from(this._registry.keys());
-  }
-  get size() {
-    return this._registry.size;
-  }
-  unregister(name) {
-    this._registry.delete(name);
-  }
-  clear() {
-    this._registry.clear();
-  }
-}
-var app = new HypenApp;
-
-class HypenModuleInstance {
-  engine;
-  definition;
-  state;
-  isDestroyed = false;
-  isActive = false;
-  router;
-  globalContext;
-  stateChangeCallbacks = [];
-  dataSourceManager;
-  dataSourceAccessor = {};
-  stateStore;
-  currentPersistKey = null;
-  persistDebounceTimer;
-  sessionId;
-  moduleKey = "";
-  constructor(engine, definition, router, globalContext, sessionId) {
-    this.engine = engine;
-    this.definition = definition;
-    this.router = router ?? null;
-    this.globalContext = globalContext;
-    this.sessionId = sessionId ?? crypto.randomUUID();
-    this.stateStore = definition.stateStore;
-    const moduleKey = (definition.name || "").toLowerCase();
-    this.moduleKey = moduleKey;
-    this.state = createObservableState(definition.initialState, {
-      onChange: (change) => {
-        this.engine.updateStateSparse(moduleKey || null, change.paths, change.newValues);
-        this.stateChangeCallbacks.forEach((cb) => cb());
-        this.persistIfNeeded();
-      }
-    });
-    const snapshot = getStateSnapshot(this.state);
-    if (moduleKey) {
-      this.engine.registerModule(moduleKey, definition.actions, definition.stateKeys, snapshot);
-    } else {
-      this.engine.setModule("AnonymousModule", definition.actions, definition.stateKeys, snapshot);
-    }
-    for (const [actionName, handler] of definition.handlers.onAction) {
-      log2.debug(`Registering action handler: ${actionName} for module ${definition.name}`);
-      this.engine.onAction(actionName, async (action) => {
-        log2.debug(`Action handler fired: ${actionName}`, action);
-        const actionCtx = {
-          name: action.name,
-          payload: action.payload,
-          sender: action.sender
-        };
-        const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
-        const result = await this.executeAction(actionName, handler, {
-          action: actionCtx,
-          state: this.state,
-          context,
-          dataSources: this.dataSourceAccessor
-        });
-        if (!result.ok) {
-          const shouldRethrow = await this.handleError(result.error, { actionName });
-          if (shouldRethrow) {
-            throw result.error;
-          }
-        } else {
-          log2.debug(`Action handler completed: ${actionName}`);
-        }
-      });
-    }
-    this.engine.onAction("__hypen_bind", (action) => {
-      const payload = action.payload;
-      if (!payload?.path)
-        return;
-      const segments = payload.path.split(".");
-      let target = this.state;
-      for (let i = 0;i < segments.length - 1; i++) {
-        const seg = segments[i];
-        target = target?.[seg];
-        if (target == null)
-          return;
-      }
-      const lastSeg = segments[segments.length - 1];
-      target[lastSeg] = payload.value;
-    });
-    this._readyPromise = this.callCreatedHandler();
-  }
-  _readyPromise = Promise.resolve();
-  async waitForReady() {
-    await this._readyPromise;
-  }
-  async activate() {
-    if (this.isDestroyed || this.isActive)
-      return;
-    await this._readyPromise;
-    if (this.isDestroyed || this.isActive)
-      return;
-    this.isActive = true;
-    if (this.definition.handlers.onActivated) {
-      const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
-      try {
-        await this.definition.handlers.onActivated(this.state, context);
-      } catch (e) {
-        const error = e instanceof HypenError ? e : new ActionError("onActivated", e);
-        const shouldRethrow = await this.handleError(error, { lifecycle: "activated" });
-        if (shouldRethrow) {
-          throw error;
-        }
-      }
-    }
-  }
-  async deactivate() {
-    if (this.isDestroyed || !this.isActive)
-      return;
-    this.isActive = false;
-    if (this.definition.handlers.onDeactivated) {
-      const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
-      try {
-        await this.definition.handlers.onDeactivated(this.state, context);
-      } catch (e) {
-        const error = e instanceof HypenError ? e : new ActionError("onDeactivated", e);
-        const shouldRethrow = await this.handleError(error, { lifecycle: "deactivated" });
-        if (shouldRethrow) {
-          throw error;
-        }
-      }
-    }
-  }
-  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),
-      router: this.router
-    };
-    const ctxRecord = ctx;
-    if (ctxRecord.__hypenEngine) {
-      api.__hypenEngine = ctxRecord.__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) {
-        log2.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
-      });
-    }
-    log2.error(`${context.actionName ? `Action "${context.actionName}"` : `Lifecycle "${context.lifecycle}"`} error:`, error);
-    return false;
-  }
-  persistIfNeeded() {
-    if (!this.stateStore)
-      return;
-    const store = this.stateStore;
-    const newKey = store.resolveKey(this.state, this.definition.name || "AnonymousModule", this.sessionId);
-    if (newKey && !this.currentPersistKey) {
-      this.activatePersistence(newKey);
-      return;
-    }
-    if (!newKey && this.currentPersistKey) {
-      this.currentPersistKey = null;
-      return;
-    }
-    if (newKey && newKey !== this.currentPersistKey) {
-      this.activatePersistence(newKey);
-      return;
-    }
-    if (!this.currentPersistKey)
-      return;
-    clearTimeout(this.persistDebounceTimer);
-    this.persistDebounceTimer = setTimeout(() => {
-      const snapshot = getStateSnapshot(this.state);
-      store.save(this.currentPersistKey, snapshot);
-    }, 50);
-  }
-  async activatePersistence(key) {
-    this.currentPersistKey = key;
-    const stored = await this.stateStore.load(key);
-    if (stored) {
-      const merged = { ...this.definition.initialState, ...stored };
-      Object.assign(this.state, merged);
-    } else {
-      const snapshot = getStateSnapshot(this.state);
-      await this.stateStore.save(key, snapshot);
-    }
-  }
-  async callCreatedHandler() {
-    if (this.stateStore) {
-      const key = this.stateStore.resolveKey(this.state, this.definition.name || "AnonymousModule", this.sessionId);
-      if (key) {
-        this.currentPersistKey = key;
-        const stored = await this.stateStore.load(key);
-        if (stored) {
-          const merged = { ...this.definition.initialState, ...stored };
-          Object.assign(this.state, merged);
-        }
-      }
-    }
-    if (this.definition.dataSources?.length) {
-      const dsEngine = this.engine;
-      this.dataSourceManager = new DataSourceManager(dsEngine);
-      for (const { plugin, config: config2 } of this.definition.dataSources) {
-        try {
-          await this.dataSourceManager.use(plugin, config2);
-          this.dataSourceAccessor[plugin.name] = new Proxy(plugin, {
-            get(target, prop) {
-              if (typeof prop === "string" && !(prop in target)) {
-                return (...args) => target.call(prop, ...args);
-              }
-              return target[prop];
-            }
-          });
-        } catch (e) {
-          log2.error(`Failed to connect data source "${plugin.name}":`, e);
-        }
-      }
-    }
-    if (this.definition.handlers.onCreated) {
-      const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
-      try {
-        await this.definition.handlers.onCreated(this.state, context);
-      } catch (e) {
-        const error = e instanceof HypenError ? e : new ActionError("onCreated", e);
-        const shouldRethrow = await this.handleError(error, { lifecycle: "created" });
-        if (shouldRethrow) {
-          throw error;
-        }
-      }
-    }
-  }
-  onStateChange(callback) {
-    this.stateChangeCallbacks.push(callback);
-  }
-  async destroy() {
-    if (this.isDestroyed)
-      return;
-    if (this.isActive) {
-      await this.deactivate();
-    }
-    if (this.currentPersistKey && this.stateStore) {
-      clearTimeout(this.persistDebounceTimer);
-      const snapshot = getStateSnapshot(this.state);
-      await this.stateStore.save(this.currentPersistKey, snapshot);
-    }
-    if (this.dataSourceManager) {
-      try {
-        await this.dataSourceManager.disconnectAll();
-      } catch (e) {
-        log2.error("Error disconnecting data sources:", e);
-      }
-      this.dataSourceManager = undefined;
-      this.dataSourceAccessor = {};
-    }
-    if (this.definition.handlers.onDestroyed) {
-      try {
-        await this.definition.handlers.onDestroyed(this.state);
-      } catch (e) {
-        const error = e instanceof HypenError ? e : new ActionError("onDestroyed", e);
-        const shouldRethrow = await this.handleError(error, { lifecycle: "destroyed" });
-        if (shouldRethrow) {
-          throw error;
-        }
-      }
-    }
-    this.isDestroyed = true;
-  }
-  getState() {
-    return getStateSnapshot(this.state);
-  }
-  getLiveState() {
-    return this.state;
-  }
-  updateState(patch) {
-    Object.assign(this.state, patch);
-  }
-}
-
-// src/hypen.ts
-function createBindingProxy(root) {
-  const handler = {
-    get(_, prop) {
-      if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
-        return () => `@{${root}}`;
-      }
-      if (typeof prop === "symbol") {
-        return;
-      }
-      if (prop === "toJSON") {
-        return () => `@{${root}}`;
-      }
-      return createBindingProxy(`${root}.${prop}`);
-    },
-    has() {
-      return true;
-    },
-    ownKeys() {
-      return [];
-    },
-    getOwnPropertyDescriptor() {
-      return {
-        configurable: true,
-        enumerable: true
-      };
-    }
-  };
-  return new Proxy({}, handler);
-}
-var state = createBindingProxy("state");
-var item = createBindingProxy("item");
-var index = {
-  [Symbol.toPrimitive]: () => "@{index}",
-  toString: () => "@{index}",
-  valueOf: () => "@{index}",
-  toJSON: () => "@{index}"
-};
-function hypen(strings, ...expressions) {
-  let result = strings[0];
-  for (let i = 0;i < expressions.length; i++) {
-    const expr = expressions[i];
-    result += String(expr);
-    result += strings[i + 1];
-  }
-  return result.trim();
-}
-
-// src/renderer.ts
-var log3 = frameworkLoggers.renderer;
-
-class BaseRenderer {
-  nodes = new Map;
-  getNode(id) {
-    return this.nodes.get(id);
-  }
-  clear() {
-    this.nodes.clear();
-  }
-  applyPatch(patch) {
-    switch (patch.type) {
-      case "create":
-        this.onCreate(patch.id, patch.elementType, patch.props || {});
-        break;
-      case "setProp":
-        this.onSetProp(patch.id, patch.name, patch.value);
-        break;
-      case "setText":
-        this.onSetText(patch.id, patch.text);
-        break;
-      case "insert":
-        this.onInsert(patch.parentId, patch.id, patch.beforeId);
-        break;
-      case "move":
-        this.onMove(patch.parentId, patch.id, patch.beforeId);
-        break;
-      case "remove":
-        this.onRemove(patch.id);
-        break;
-      case "attachEvent":
-        this.onAttachEvent(patch.id, patch.eventName);
-        break;
-      case "detachEvent":
-        this.onDetachEvent(patch.id, patch.eventName);
-        break;
-    }
-  }
-}
-
-class ConsoleRenderer {
-  applyPatches(patches) {
-    console.group("Hypen Patches");
-    for (const patch of patches) {
-      console.log(patch);
-    }
-    console.groupEnd();
-  }
-}
-
-// src/disposable.ts
-var log4 = frameworkLoggers.lifecycle;
-function isDisposable(obj) {
-  return obj !== null && typeof obj === "object" && "dispose" in obj && typeof obj.dispose === "function";
-}
-
-class DisposableStack {
-  stack = [];
-  disposed = false;
-  add(disposable) {
-    if (this.disposed) {
-      disposable.dispose();
-      return disposable;
-    }
-    this.stack.push(disposable);
-    return disposable;
-  }
-  addCallback(callback) {
-    this.add({ dispose: callback });
-  }
-  addValue(value, dispose) {
-    this.add({ dispose: () => dispose(value) });
-    return value;
-  }
-  dispose() {
-    if (this.disposed)
-      return;
-    this.disposed = true;
-    while (this.stack.length > 0) {
-      const item2 = this.stack.pop();
-      try {
-        item2.dispose();
-      } catch (error) {
-        log4.error("Error during dispose:", error);
-      }
-    }
-  }
-  get isDisposed() {
-    return this.disposed;
-  }
-  get size() {
-    return this.stack.length;
-  }
-}
-function disposableListener(target, event, handler, options) {
-  target.addEventListener(event, handler, options);
-  return {
-    dispose: () => target.removeEventListener(event, handler, options)
-  };
-}
-function disposableTimeout(callback, ms) {
-  const id = setTimeout(callback, ms);
-  return {
-    id,
-    dispose: () => clearTimeout(id)
-  };
-}
-function disposableInterval(callback, ms) {
-  const id = setInterval(callback, ms);
-  return {
-    id,
-    dispose: () => clearInterval(id)
-  };
-}
-function disposableWebSocket(ws) {
-  return {
-    dispose: () => {
-      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
-        ws.close();
-      }
-    }
-  };
+  return { unknownTypes: [...unknown] };
 }
-function disposableAbortController() {
-  const controller = new AbortController;
-  return {
-    controller,
-    signal: controller.signal,
-    dispose: () => controller.abort()
-  };
-}
-function disposableSubscription(unsubscribe) {
-  return { dispose: unsubscribe };
-}
-var ELEMENT_DISPOSABLES = Symbol("hypen.disposables");
-function getElementDisposables(element) {
-  const existing = element[ELEMENT_DISPOSABLES];
-  if (existing instanceof DisposableStack) {
-    return existing;
-  }
-  const stack = new DisposableStack;
-  element[ELEMENT_DISPOSABLES] = stack;
-  return stack;
-}
-function disposeElement(element) {
-  const stack = element[ELEMENT_DISPOSABLES];
-  if (stack instanceof DisposableStack) {
-    stack.dispose();
-    delete element[ELEMENT_DISPOSABLES];
-  }
-}
-function hasElementDisposables(element) {
-  return element[ELEMENT_DISPOSABLES] instanceof DisposableStack;
-}
-
-class DisposableMixin {
-  disposables = new DisposableStack;
-  track(disposable) {
-    return this.disposables.add(disposable);
-  }
-  onDispose(callback) {
-    this.disposables.addCallback(callback);
-  }
-  dispose() {
-    this.disposables.dispose();
-  }
-}
-function compositeDisposable(...disposables) {
-  return {
-    dispose: () => {
-      for (const d of disposables) {
-        try {
-          d.dispose();
-        } catch (error) {
-          log4.error("Error during dispose:", error);
-        }
-      }
-    }
-  };
-}
-async function using(resource, fn) {
-  const r = typeof resource === "function" ? resource() : resource;
-  try {
-    return await fn(r);
-  } finally {
-    r.dispose();
-  }
-}
-function usingSync(resource, fn) {
-  const r = typeof resource === "function" ? resource() : resource;
-  try {
-    return fn(r);
-  } finally {
-    r.dispose();
-  }
-}
-
-// src/router.ts
-var log5 = frameworkLoggers.router;
-
-class HypenRouter {
-  state;
-  subscribers = new Set;
-  isInitialized = false;
-  isUpdating = false;
-  browserListeners = [];
-  constructor() {
-    this.state = createObservableState({
-      currentPath: "/",
-      params: {},
-      query: {},
-      previousPath: null
-    }, {
-      onChange: () => {
-        this.notifySubscribers();
-      }
-    });
-    if (typeof window !== "undefined") {
-      this.initializeBrowserSync();
-    }
-  }
-  initializeBrowserSync() {
-    const initialPath = this.getPathFromBrowser();
-    this.state.currentPath = initialPath;
-    this.state.params = {};
-    this.state.query = this.parseQuery();
-    this.browserListeners.push(disposableListener(window, "popstate", () => {
-      const newPath = this.getPathFromBrowser();
-      this.updatePath(newPath, false);
-    }));
-    this.browserListeners.push(disposableListener(window, "hashchange", () => {
-      if (this.isUpdating)
-        return;
-      const newPath = this.getPathFromBrowser();
-      this.updatePath(newPath, false);
-    }));
-    this.isInitialized = true;
-    log5.debug("Router initialized at:", initialPath);
-  }
-  getPathFromBrowser() {
-    if (typeof window === "undefined")
-      return "/";
-    const hash = window.location.hash.slice(1);
-    if (hash)
-      return hash;
-    return window.location.pathname;
-  }
-  parseQuery() {
-    if (typeof window === "undefined")
-      return {};
-    const query = {};
-    const searchParams = new URLSearchParams(window.location.search);
-    searchParams.forEach((value, key) => {
-      query[key] = value;
-    });
-    return query;
-  }
-  push(path) {
-    log5.debug("push:", path);
-    this.updatePath(path, true);
-  }
-  replace(path) {
-    log5.debug("replace:", path);
-    this.updatePath(path, true, true);
-  }
-  back() {
-    log5.debug("back");
-    if (typeof window !== "undefined") {
-      window.history.back();
-    }
-  }
-  forward() {
-    log5.debug("forward");
-    if (typeof window !== "undefined") {
-      window.history.forward();
-    }
-  }
-  updatePath(path, updateBrowser, replace = false) {
-    if (this.isUpdating)
-      return;
-    this.isUpdating = true;
-    try {
-      const oldPath = this.state.currentPath;
-      this.state.previousPath = oldPath;
-      this.state.currentPath = path;
-      this.state.query = this.parseQuery();
-      this.notifySubscribers();
-      if (updateBrowser && typeof window !== "undefined") {
-        const url = "#" + path;
-        if (replace) {
-          window.history.replaceState(null, "", url);
-        } else {
-          window.history.pushState(null, "", url);
-        }
-        try {
-          const hashChangeEvent = new HashChangeEvent("hashchange", {
-            oldURL: window.location.href.replace(window.location.hash, "#" + oldPath),
-            newURL: window.location.href
-          });
-          window.dispatchEvent(hashChangeEvent);
-        } catch {}
-      }
-    } finally {
-      this.isUpdating = false;
-    }
-  }
-  getCurrentPath() {
-    return this.state.currentPath;
-  }
-  getParams() {
-    return { ...this.state.params };
-  }
-  getQuery() {
-    return { ...this.state.query };
-  }
-  getState() {
-    return getStateSnapshot(this.state);
-  }
-  matchPath(pattern, path) {
-    if (!pattern || typeof pattern !== "string")
-      return null;
-    if (!path || typeof path !== "string")
-      return null;
-    const cleanPath = path.split("?")[0] ?? path;
-    const result = portable.matchPath(pattern, cleanPath);
-    if (!result)
-      return null;
-    const params = {};
-    for (const [name, raw] of Object.entries(result.params)) {
-      try {
-        params[name] = decodeURIComponent(raw);
-      } catch {
-        params[name] = raw;
-      }
-    }
-    return {
-      params,
-      query: this.state.query,
-      path
-    };
-  }
-  onNavigate(callback) {
-    this.subscribers.add(callback);
-    try {
-      callback(this.getState());
-    } catch (error) {
-      log5.error("Error in route subscriber:", error);
-    }
-    return () => {
-      this.subscribers.delete(callback);
-    };
-  }
-  notifySubscribers() {
-    const routeState = this.getState();
-    this.subscribers.forEach((callback) => {
-      try {
-        callback(routeState);
-      } catch (error) {
-        log5.error("Error in route subscriber:", error);
-      }
-    });
-  }
-  isActive(pattern) {
-    return this.matchPath(pattern, this.state.currentPath) !== null;
-  }
-  buildUrl(path, query) {
-    if (!query || Object.keys(query).length === 0) {
-      return path;
-    }
-    const queryString = new URLSearchParams(query).toString();
-    return `${path}?${queryString}`;
-  }
-  dispose() {
-    for (const listener of this.browserListeners) {
-      listener.dispose();
-    }
-    this.browserListeners = [];
-    this.subscribers.clear();
-    this.isInitialized = false;
-    log5.debug("Router disposed");
-  }
-  [Symbol.dispose]() {
-    this.dispose();
-  }
-}
-
-// src/managed-router.ts
-var log6 = createLogger("ManagedRouter");
-var DEFAULT_MAX_PERSISTED_MODULES = 10;
-
-class ManagedRouter {
-  router;
-  engine;
-  registry;
-  globalContext;
-  routes = [];
-  activeModule = null;
-  activeRoute = null;
-  unsubscribe = null;
-  persistedModules = new Map;
-  maxPersistedModules;
-  navPromise = Promise.resolve();
-  constructor(router, engine, registry, globalContext, options = {}) {
-    this.router = router;
-    this.engine = engine;
-    this.registry = registry;
-    this.globalContext = globalContext;
-    const cap = options.maxPersistedModules ?? DEFAULT_MAX_PERSISTED_MODULES;
-    this.maxPersistedModules = cap > 0 ? cap : DEFAULT_MAX_PERSISTED_MODULES;
-  }
-  addRoute(route) {
-    this.routes.push(route);
-    return this;
-  }
-  start() {
-    this.unsubscribe = this.router.onNavigate((routeState) => {
-      this.handleRouteChange(routeState);
-    });
-    this.installRouterActions();
-  }
-  installRouterActions() {
-    const router = this.router;
-    const defer = (fn) => queueMicrotask(fn);
-    const readTo = (action) => {
-      const payload = action?.payload;
-      const to = payload?.to;
-      return typeof to === "string" && to.length > 0 ? to : null;
-    };
-    this.engine.onAction("router.push", (action) => {
-      const to = readTo(action);
-      if (to)
-        defer(() => router.push(to));
-    });
-    this.engine.onAction("router.replace", (action) => {
-      const to = readTo(action);
-      if (to)
-        defer(() => router.replace(to));
-    });
-    this.engine.onAction("router.back", () => {
-      defer(() => router.back());
-    });
-    this.engine.onAction("router.forward", () => {
-      defer(() => router.forward());
-    });
-  }
-  async stop() {
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = null;
-    }
-    const cleanup = this.navPromise.catch(() => {}).then(async () => {
-      await this.unmountActive();
-      for (const [moduleId, instance] of this.persistedModules) {
-        log6.debug(`Destroying persisted module on stop: ${moduleId}`);
-        try {
-          await instance.destroy();
-        } catch (e) {
-          log6.error(`Error destroying persisted module ${moduleId}:`, e);
-        }
-        this.globalContext.unregisterModule(moduleId);
-      }
-      this.persistedModules.clear();
-    });
-    this.navPromise = cleanup;
-    await cleanup;
-    this.router.dispose();
-  }
-  async waitForNavigation() {
-    try {
-      await this.navPromise;
-    } catch {}
-  }
-  getActiveModule() {
-    return this.activeModule;
-  }
-  getActiveRoute() {
-    return this.activeRoute;
-  }
-  handleRouteChange(routeState) {
-    this.navPromise = this.navPromise.catch((e) => {
-      log6.error("Previous navigation failed:", e);
-    }).then(() => this.processRouteChange(routeState));
-  }
-  async processRouteChange(routeState) {
-    const path = routeState.currentPath;
-    const matched = this.matchRoute(path);
-    if (!matched) {
-      log6.debug(`No route matched for path: ${path}`);
-      await this.unmountActive();
-      return;
-    }
-    if (this.activeRoute && this.activeRoute.path === matched.path) {
-      return;
-    }
-    await this.unmountActive();
-    await this.mount(matched);
-  }
-  matchRoute(path) {
-    for (const route of this.routes) {
-      if (this.router.matchPath(route.path, path) !== null) {
-        return route;
-      }
-    }
-    return null;
-  }
-  async mount(route) {
-    const definition = route.module || this.registry.get(route.component);
-    if (!definition) {
-      log6.debug(`No module definition found for component: ${route.component}`);
-      this.activeRoute = route;
-      return;
-    }
-    const namedDef = {
-      ...definition,
-      name: definition.name || route.component.toLowerCase()
-    };
-    const moduleId = namedDef.name.toLowerCase();
-    const persisted = this.persistedModules.get(moduleId);
-    if (persisted) {
-      log6.debug(`Restoring persisted module: ${moduleId} for route: ${route.path}`);
-      this.activeModule = persisted;
-      this.activeRoute = route;
-      this.persistedModules.delete(moduleId);
-      await persisted.activate();
-      return;
-    }
-    log6.debug(`Mounting module: ${namedDef.name} for route: ${route.path}`);
-    const instance = new HypenModuleInstance(this.engine, namedDef, this.router, this.globalContext);
-    this.globalContext.registerModule(moduleId, instance);
-    this.activeModule = instance;
-    this.activeRoute = route;
-    await instance.activate();
-  }
-  async unmountActive() {
-    if (!this.activeModule || !this.activeRoute) {
-      this.activeModule = null;
-      this.activeRoute = null;
-      return;
-    }
-    const active = this.activeModule;
-    const route = this.activeRoute;
-    const definition = route.module || this.registry.get(route.component);
-    const moduleId = (definition?.name || route.component).toLowerCase();
-    const persist = definition != null && definition.persist !== false;
-    this.activeModule = null;
-    this.activeRoute = null;
-    try {
-      await active.deactivate();
-    } catch (e) {
-      log6.error(`Error deactivating module ${moduleId}:`, e);
-    }
-    if (persist) {
-      log6.debug(`Persisting module: ${moduleId}`);
-      this.persistedModules.delete(moduleId);
-      this.persistedModules.set(moduleId, active);
-      await this.evictPersistedOverflow();
-    } else {
-      log6.debug(`Unmounting module: ${moduleId}`);
-      try {
-        await active.destroy();
-      } catch (e) {
-        log6.error(`Error destroying module ${moduleId}:`, e);
-      }
-      this.globalContext.unregisterModule(moduleId);
-    }
-  }
-  async evictPersistedOverflow() {
-    while (this.persistedModules.size > this.maxPersistedModules) {
-      const oldest = this.persistedModules.keys().next();
-      if (oldest.done)
-        break;
-      const oldestId = oldest.value;
-      const evicted = this.persistedModules.get(oldestId);
-      this.persistedModules.delete(oldestId);
-      log6.debug(`Evicting persisted module (LRU): ${oldestId}`);
-      try {
-        await evicted.destroy();
-      } catch (e) {
-        log6.error(`Error destroying evicted module ${oldestId}:`, e);
-      }
-      this.globalContext.unregisterModule(oldestId);
-    }
-  }
-}
-
-// src/events.ts
-var log7 = frameworkLoggers.events;
-
-class TypedEventEmitter {
-  eventBus = new Map;
-  emit(event, payload) {
-    const handlers = this.eventBus.get(event);
-    if (!handlers || handlers.size === 0) {
-      return;
-    }
-    handlers.forEach((handler) => {
-      try {
-        handler(payload);
-      } catch (error) {
-        log7.error(`Error in event handler for "${String(event)}":`, error);
-      }
-    });
-  }
-  on(event, handler) {
-    if (!this.eventBus.has(event)) {
-      this.eventBus.set(event, new Set);
-    }
-    const handlers = this.eventBus.get(event);
-    handlers.add(handler);
-    return () => {
-      handlers.delete(handler);
-      if (handlers.size === 0) {
-        this.eventBus.delete(event);
-      }
-    };
-  }
-  once(event, handler) {
-    const wrappedHandler = (payload) => {
-      handler(payload);
-      unsubscribe();
-    };
-    const unsubscribe = this.on(event, wrappedHandler);
-    return unsubscribe;
-  }
-  off(event, handler) {
-    const handlers = this.eventBus.get(event);
-    if (handlers) {
-      handlers.delete(handler);
-      if (handlers.size === 0) {
-        this.eventBus.delete(event);
-      }
-    }
-  }
-  removeAllListeners(event) {
-    this.eventBus.delete(event);
-  }
-  clearAll() {
-    this.eventBus.clear();
-  }
-  listenerCount(event) {
-    return this.eventBus.get(event)?.size ?? 0;
-  }
-  eventNames() {
-    return Array.from(this.eventBus.keys());
-  }
-}
-function createEventEmitter() {
-  return new TypedEventEmitter;
-}
-
-// src/context.ts
-var log8 = frameworkLoggers.context;
-
-class HypenGlobalContext {
-  modules = new Map;
-  typedEvents;
-  constructor() {
-    this.typedEvents = new TypedEventEmitter;
-  }
-  get events() {
-    return this.typedEvents;
-  }
-  registerModule(id, instance) {
-    if (this.modules.has(id)) {
-      log8.warn(`Module "${id}" is already registered. Overwriting.`);
-    }
-    this.modules.set(id, instance);
-    log8.debug(`Registered module: ${id}`);
-  }
-  unregisterModule(id) {
-    this.modules.delete(id);
-    log8.debug(`Unregistered module: ${id}`);
-  }
-  getModule(id) {
-    const module = this.modules.get(id);
-    if (!module) {
-      throw new Error(`Module "${id}" not found. Available modules: ${Array.from(this.modules.keys()).join(", ")}`);
-    }
-    return {
-      state: module.getLiveState(),
-      setState: (patch) => module.updateState(patch),
-      getState: () => module.getState()
-    };
-  }
-  hasModule(id) {
-    return this.modules.has(id);
-  }
-  getModuleIds() {
-    return Array.from(this.modules.keys());
-  }
-  getGlobalState() {
-    const state2 = {};
-    this.modules.forEach((module, id) => {
-      state2[id] = module.getState();
-    });
-    return state2;
-  }
-  emit(event, payload) {
-    if (this.typedEvents.listenerCount(event) === 0) {
-      log8.debug(`Event "${event}" emitted but no listeners`);
-      return;
-    }
-    log8.debug(`Emitting event: ${event}`, payload);
-    this.typedEvents.emit(event, payload);
-  }
-  on(event, handler) {
-    log8.debug(`Listening to event: ${event}`);
-    return this.typedEvents.on(event, handler);
-  }
-  off(event, handler) {
-    this.typedEvents.off(event, handler);
-  }
-  clearEvent(event) {
-    this.typedEvents.removeAllListeners(event);
-  }
-  clearAllEvents() {
-    this.typedEvents.clearAll();
-  }
-  debug() {
-    return {
-      modules: this.getModuleIds(),
-      events: this.typedEvents.eventNames(),
-      state: this.getGlobalState()
-    };
-  }
-}
-
-// src/retry.ts
-var DEFAULT_OPTIONS = {
-  maxAttempts: 3,
-  delayMs: 1000,
-  backoff: "exponential",
-  maxDelayMs: 30000,
-  jitter: 0.1
-};
-function calculateDelay(attempt, options) {
-  let delay;
-  switch (options.backoff) {
-    case "exponential":
-      delay = options.delayMs * Math.pow(2, attempt - 1);
-      break;
-    case "linear":
-      delay = options.delayMs * attempt;
-      break;
-    case "none":
-      delay = options.delayMs;
-      break;
-  }
-  if (options.jitter > 0) {
-    const jitterRange = delay * options.jitter;
-    delay += (Math.random() * 2 - 1) * jitterRange;
-  }
-  return Math.min(delay, options.maxDelayMs);
-}
-function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(new Error("Retry aborted"));
-      return;
-    }
-    const timeoutId = setTimeout(resolve, ms);
-    signal?.addEventListener("abort", () => {
-      clearTimeout(timeoutId);
-      reject(new Error("Retry aborted"));
-    });
-  });
-}
-async function retry(fn, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  let lastError = new Error("No attempts made");
-  for (let attempt = 1;attempt <= opts.maxAttempts; attempt++) {
-    try {
-      if (opts.signal?.aborted) {
-        throw new Error("Retry aborted");
-      }
-      return await fn();
-    } catch (e) {
-      lastError = e instanceof Error ? e : new Error(String(e));
-      if (opts.shouldRetry && !opts.shouldRetry(lastError)) {
-        throw lastError;
-      }
-      if (attempt === opts.maxAttempts) {
-        break;
-      }
-      const delayMs = calculateDelay(attempt, opts);
-      opts.onRetry?.(attempt, lastError, delayMs);
-      await sleep(delayMs, opts.signal);
-    }
-  }
-  throw lastError;
-}
-async function retryResult(fn, options = {}) {
-  try {
-    const value = await retry(fn, options);
-    return Ok(value);
-  } catch (e) {
-    return Err(e instanceof Error ? e : new Error(String(e)));
-  }
-}
-function withRetry(fn, options = {}) {
-  return (...args) => retry(() => fn(...args), options);
-}
-var RetryConditions = {
-  networkErrors: (error) => {
-    const message = error.message.toLowerCase();
-    return message.includes("network") || message.includes("fetch") || message.includes("timeout") || message.includes("econnrefused") || message.includes("econnreset") || message.includes("socket");
-  },
-  httpRetryable: (error) => {
-    const status = error.status;
-    if (!status)
-      return false;
-    return [408, 429, 500, 502, 503, 504].includes(status);
-  },
-  websocketErrors: (error) => {
-    const message = error.message.toLowerCase();
-    return message.includes("websocket") || message.includes("connection") || message.includes("close");
-  },
-  any: (...conditions) => (error) => conditions.some((c) => c(error)),
-  all: (...conditions) => (error) => conditions.every((c) => c(error))
-};
-var RetryPresets = {
-  aggressive: {
-    maxAttempts: 10,
-    delayMs: 500,
-    backoff: "exponential",
-    maxDelayMs: 60000,
-    jitter: 0.2
-  },
-  conservative: {
-    maxAttempts: 3,
-    delayMs: 2000,
-    backoff: "linear",
-    maxDelayMs: 1e4,
-    jitter: 0.1
-  },
-  fast: {
-    maxAttempts: 5,
-    delayMs: 100,
-    backoff: "exponential",
-    maxDelayMs: 2000,
-    jitter: 0
-  },
-  websocket: {
-    maxAttempts: 10,
-    delayMs: 1000,
-    backoff: "exponential",
-    maxDelayMs: 30000,
-    jitter: 0.1,
-    shouldRetry: RetryConditions.websocketErrors
-  }
-};
-
-// src/remote/client.ts
-var log9 = frameworkLoggers.remote;
-
-class RemoteEngine {
-  ws = null;
-  url;
-  state = "disconnected";
-  options;
-  reconnectAttempts = 0;
-  disposables = new DisposableStack;
-  reconnectDisposable = null;
-  currentSessionId = null;
-  sessionOptions;
-  patchCallbacks = [];
-  stateCallbacks = [];
-  connectionCallbacks = [];
-  disconnectionCallbacks = [];
-  errorCallbacks = [];
-  sessionEstablishedCallbacks = [];
-  sessionExpiredCallbacks = [];
-  currentState = null;
-  currentRevision = 0;
-  moduleName = "";
-  navigationDisposable = null;
-  lastViewValue = null;
-  handlingPopState = false;
-  constructor(url, options = {}) {
-    this.url = url;
-    const navOpt = options.navigation;
-    const navigation = navOpt ? {
-      backAction: (typeof navOpt === "object" ? navOpt.backAction : undefined) ?? "navigateBack",
-      viewStateKey: (typeof navOpt === "object" ? navOpt.viewStateKey : undefined) ?? "currentView"
-    } : undefined;
-    this.options = {
-      autoReconnect: options.autoReconnect ?? true,
-      reconnectInterval: options.reconnectInterval ?? 3000,
-      maxReconnectAttempts: options.maxReconnectAttempts ?? 10,
-      session: options.session,
-      navigation
-    };
-    this.sessionOptions = options.session;
-    if (options.session?.id) {
-      this.currentSessionId = options.session.id;
-    }
-  }
-  async connect() {
-    if (this.state === "connected" || this.state === "connecting") {
-      return Ok(undefined);
-    }
-    this.state = "connecting";
-    return new Promise((resolve) => {
-      try {
-        this.ws = new WebSocket(this.url);
-        this.disposables.add(disposableWebSocket(this.ws));
-        const messageHandler = (event) => {
-          this.handleMessage(event.data);
-        };
-        this.disposables.add(disposableListener(this.ws, "message", messageHandler));
-        const errorHandler = () => {
-          this.state = "error";
-          const error = new ConnectionError(this.url, new Error("WebSocket error"));
-          this.errorCallbacks.forEach((cb) => cb(error));
-          resolve(Err(error));
-        };
-        this.disposables.add(disposableListener(this.ws, "error", errorHandler));
-        const closeHandler = () => {
-          this.state = "disconnected";
-          this.disconnectionCallbacks.forEach((cb) => cb());
-          this.attemptReconnect();
-        };
-        this.disposables.add(disposableListener(this.ws, "close", closeHandler));
-        this.ws.onopen = () => {
-          this.state = "connected";
-          this.reconnectAttempts = 0;
-          if (this.reconnectDisposable) {
-            this.reconnectDisposable.dispose();
-            this.reconnectDisposable = null;
-          }
-          this.sendHello();
-          this.connectionCallbacks.forEach((cb) => cb());
-          resolve(Ok(undefined));
-        };
-      } catch (e) {
-        this.state = "error";
-        const error = new ConnectionError(this.url, e);
-        resolve(Err(error));
-      }
-    });
-  }
-  sendHello() {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
-      return;
-    const hello = {
-      type: "hello",
-      sessionId: this.currentSessionId ?? this.sessionOptions?.id,
-      props: this.sessionOptions?.props,
-      persistKey: this.sessionOptions?.persistKey
-    };
-    this.ws.send(JSON.stringify(hello));
-  }
-  disconnect() {
-    if (this.reconnectDisposable) {
-      this.reconnectDisposable.dispose();
-      this.reconnectDisposable = null;
-    }
-    if (this.ws) {
-      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
-        this.ws.close();
-      }
-      this.ws = null;
-    }
-    this.state = "disconnected";
-  }
-  dispose() {
-    this.disconnect();
-    if (this.navigationDisposable) {
-      this.navigationDisposable.dispose();
-      this.navigationDisposable = null;
-    }
-    this.disposables.dispose();
-  }
-  setupNavigation() {
-    const nav = this.options.navigation;
-    if (!nav || typeof window === "undefined")
-      return;
-    if (this.navigationDisposable)
-      return;
-    this.navigationDisposable = disposableListener(window, "popstate", () => {
-      if (this.handlingPopState)
-        return;
-      log9.debug("Back navigation detected, dispatching:", nav.backAction);
-      this.handlingPopState = true;
-      this.dispatchAction(nav.backAction);
-    });
-  }
-  trackViewChange(state2) {
-    const nav = this.options.navigation;
-    if (!nav || typeof window === "undefined")
-      return;
-    const viewValue = this.resolveStateKey(state2, nav.viewStateKey);
-    if (viewValue === undefined || viewValue === this.lastViewValue)
-      return;
-    if (this.handlingPopState) {
-      this.handlingPopState = false;
-      this.lastViewValue = viewValue;
-      return;
-    }
-    if (this.lastViewValue !== null) {
-      window.history.pushState({ view: viewValue }, "", "");
-    }
-    this.lastViewValue = viewValue;
-  }
-  resolveStateKey(state2, key) {
-    if (!state2 || typeof state2 !== "object")
-      return;
-    const parts = key.split(".");
-    let current2 = state2;
-    for (const part of parts) {
-      if (current2 == null || typeof current2 !== "object")
-        return;
-      current2 = current2[part];
-    }
-    return typeof current2 === "string" ? current2 : undefined;
-  }
-  dispatchAction(action, payload) {
-    if (this.state !== "connected" || !this.ws) {
-      log9.warn("Cannot dispatch action: not connected");
-      return;
-    }
-    const message = {
-      type: "dispatchAction",
-      module: this.moduleName,
-      action,
-      payload
-    };
-    this.ws.send(JSON.stringify(message));
-  }
-  subscribeState() {
-    if (this.state !== "connected" || !this.ws) {
-      log9.warn("Cannot subscribe to state: not connected");
-      return;
-    }
-    const message = { type: "subscribeState" };
-    this.ws.send(JSON.stringify(message));
-  }
-  updateState(state2) {
-    if (this.state !== "connected" || !this.ws) {
-      log9.warn("Cannot update state: not connected");
-      return;
-    }
-    const message = {
-      type: "updateState",
-      module: this.moduleName,
-      state: state2
-    };
-    this.ws.send(JSON.stringify(message));
-  }
-  onPatches(callback) {
-    this.patchCallbacks.push(callback);
-    return this;
-  }
-  onStateUpdate(callback) {
-    this.stateCallbacks.push(callback);
-    return this;
-  }
-  onConnect(callback) {
-    this.connectionCallbacks.push(callback);
-    return this;
-  }
-  onDisconnect(callback) {
-    this.disconnectionCallbacks.push(callback);
-    return this;
-  }
-  onError(callback) {
-    this.errorCallbacks.push(callback);
-    return this;
-  }
-  onSessionEstablished(callback) {
-    this.sessionEstablishedCallbacks.push(callback);
-    return this;
-  }
-  onSessionExpired(callback) {
-    this.sessionExpiredCallbacks.push(callback);
-    return this;
-  }
-  getConnectionState() {
-    return this.state;
-  }
-  getCurrentState() {
-    return this.currentState;
-  }
-  getRevision() {
-    return this.currentRevision;
-  }
-  getSessionId() {
-    return this.currentSessionId;
-  }
-  handleMessage(data) {
-    try {
-      const message = JSON.parse(data);
-      switch (message.type) {
-        case "sessionAck":
-          this.handleSessionAck(message);
-          break;
-        case "sessionExpired":
-          this.handleSessionExpired(message);
-          break;
-        case "initialTree":
-          this.handleInitialTree(message);
-          break;
-        case "patch":
-          this.handlePatch(message);
-          break;
-        case "stateUpdate":
-          this.currentState = message.state;
-          this.trackViewChange(this.currentState);
-          this.stateCallbacks.forEach((cb) => cb(this.currentState));
-          break;
-      }
-    } catch (e) {
-      log9.error("Error handling remote message:", e);
-      const error = e instanceof Error ? e : new Error(String(e));
-      this.errorCallbacks.forEach((cb) => cb(error));
-    }
-  }
-  handleSessionAck(message) {
-    this.currentSessionId = message.sessionId;
-    const info = {
-      sessionId: message.sessionId,
-      isNew: message.isNew,
-      isRestored: message.isRestored
-    };
-    this.sessionEstablishedCallbacks.forEach((cb) => cb(info));
-  }
-  handleSessionExpired(message) {
-    this.currentSessionId = null;
-    this.sessionExpiredCallbacks.forEach((cb) => cb(message.reason));
-  }
-  handleInitialTree(message) {
-    this.moduleName = message.module;
-    this.currentState = message.state;
-    this.currentRevision = message.revision;
-    if (message.patches.length > 0) {
-      this.patchCallbacks.forEach((cb) => cb(message.patches));
-    }
-    this.trackViewChange(message.state);
-    this.setupNavigation();
-    if (this.options.navigation) {
-      this.subscribeState();
-    }
-    this.stateCallbacks.forEach((cb) => cb(message.state));
-  }
-  handlePatch(message) {
-    if (message.revision <= this.currentRevision) {
-      log9.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
-      return;
-    }
-    this.currentRevision = message.revision;
-    if (message.patches.length > 0) {
-      this.patchCallbacks.forEach((cb) => cb(message.patches));
-    }
-  }
-  attemptReconnect() {
-    if (!this.options.autoReconnect) {
-      return;
-    }
-    this.reconnectDisposable = disposableTimeout(() => {
-      this.reconnectDisposable = null;
-      retry(async () => {
-        const result = await this.connect();
-        if (!result.ok) {
-          throw result.error;
-        }
-      }, {
-        maxAttempts: this.options.maxReconnectAttempts,
-        delayMs: this.options.reconnectInterval,
-        backoff: "exponential",
-        maxDelayMs: 30000,
-        jitter: 0.1,
-        onRetry: (attempt, error) => {
-          log9.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
-        }
-      }).catch((error) => {
-        log9.error("Max reconnection attempts reached:", error.message);
-        this.errorCallbacks.forEach((cb) => cb(new ConnectionError(this.url, error, this.options.maxReconnectAttempts)));
-      });
-    }, this.options.reconnectInterval);
-  }
-}
-
-// 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
-    };
-    this.activeSessions.set(session.id, session);
-    return session;
-  }
-  getActiveSession(id) {
-    return this.activeSessions.get(id) ?? null;
-  }
-  getPendingSession(id) {
-    return this.pendingSessions.get(id) ?? null;
-  }
-  hasSession(id) {
-    return this.activeSessions.has(id) || this.pendingSessions.has(id);
-  }
-  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);
-      }
-    }, 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);
-    }
-    this.sessionConnections.delete(sessionId);
-  }
-  trackConnection(sessionId, ws) {
-    let connections = this.sessionConnections.get(sessionId);
-    if (!connections) {
-      connections = new Set;
-      this.sessionConnections.set(sessionId, connections);
-    }
-    connections.add(ws);
-  }
-  untrackConnection(sessionId, ws) {
-    const connections = this.sessionConnections.get(sessionId);
-    if (connections) {
-      connections.delete(ws);
-      if (connections.size === 0) {
-        this.sessionConnections.delete(sessionId);
-      }
-    }
-  }
-  getConnections(sessionId) {
-    return this.sessionConnections.get(sessionId);
-  }
-  getConnectionCount(sessionId) {
-    return this.sessionConnections.get(sessionId)?.size ?? 0;
-  }
-  getStats() {
-    let totalConnections = 0;
-    for (const connections of this.sessionConnections.values()) {
-      totalConnections += connections.size;
-    }
-    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/resolver.ts
-class ComponentResolver {
-  cache = new Map;
-  options;
-  moduleRegistry;
-  constructor(options = {}) {
-    this.options = {
-      baseDir: options.baseDir || process.cwd(),
-      cache: options.cache ?? true,
-      customFetch: options.customFetch || this.defaultFetch.bind(this),
-      moduleRegistry: options.moduleRegistry
-    };
-    this.moduleRegistry = options.moduleRegistry;
-  }
-  async resolve(importStmt) {
-    if (this.moduleRegistry) {
-      const names = importStmt.clause.type === "named" ? importStmt.clause.names : [importStmt.clause.name];
-      const allFound = names.every((name) => this.moduleRegistry.has(name));
-      if (allFound) {
-        const result = {};
-        for (const name of names) {
-          const def = this.moduleRegistry.get(name);
-          result[name] = {
-            module: def,
-            template: def?.template || ""
-          };
-        }
-        return result;
-      }
-    }
-    const sourcePath = this.getSourcePath(importStmt.source);
-    if (this.options.cache && this.cache.has(sourcePath)) {
-      const cached = this.cache.get(sourcePath);
-      return this.extractComponents(importStmt.clause, cached);
-    }
-    let component;
-    if (importStmt.source.type === "local") {
-      component = await this.resolveLocal(importStmt.source.path);
-    } else {
-      component = await this.resolveUrl(importStmt.source.url);
-    }
-    if (this.options.cache) {
-      this.cache.set(sourcePath, component);
-    }
-    return this.extractComponents(importStmt.clause, component);
-  }
-  async resolveLocal(path) {
-    const { resolve: resolve2, join: join2 } = await Promise.resolve().then(() => (init_path(), exports_path));
-    const { readFile } = await import("fs/promises");
-    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");
-    let module = {};
-    try {
-      module = await import(modulePath);
-    } catch {}
-    return { module, template };
-  }
-  async resolveUrl(url) {
-    try {
-      const response = await this.options.customFetch(url);
-      const data = JSON.parse(response);
-      if (!data.module || !data.template) {
-        throw new Error(`Invalid component format from ${url}. Expected { module, template }`);
-      }
-      return data;
-    } catch (error) {
-      throw new Error(`Failed to resolve component from ${url}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  async defaultFetch(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    return response.text();
-  }
-  extractComponents(clause, component) {
-    if (clause.type === "default") {
-      return {
-        [clause.name]: component
-      };
-    } else {
-      const result = {};
-      for (const name of clause.names) {
-        result[name] = component;
-      }
-      return result;
-    }
-  }
-  getSourcePath(source) {
-    return source.type === "local" ? source.path : source.url;
-  }
-  clearCache() {
-    this.cache.clear();
-  }
-  static parseImports(text) {
-    const imports = [];
-    const importRegex = /import\s+(?:(\{[^}]*\})|(\w+))\s+from\s+["']([^"']+)["']/g;
-    let match2;
-    while ((match2 = importRegex.exec(text)) !== null) {
-      const [, namedImports, defaultImport, source] = match2;
-      if (!source)
-        continue;
-      let clause;
-      if (namedImports) {
-        const names = namedImports.slice(1, -1).split(",").map((n) => n.trim()).filter((n) => n.length > 0);
-        clause = { type: "named", names };
-      } else if (defaultImport) {
-        clause = { type: "default", name: defaultImport };
-      } else {
-        continue;
-      }
-      const sourceObj = source.startsWith("http://") || source.startsWith("https://") ? { type: "url", url: source } : { type: "local", path: source };
-      imports.push({ clause, source: sourceObj });
-    }
-    return imports;
-  }
-}
-
-// src/components/builtin.ts
-var log10 = 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) {
-          log10.error(`Failed to render route ${routePath}:`, err);
-        }
-      }
-    }
-  }
-  if (!matchFound) {
-    log10.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
-  }
-}
-var Router = app.defineState({
-  currentPath: "/",
-  matchedRoute: null,
-  routeParams: {}
-}, { name: "__Router" }).onCreated((state2, context) => {
-  if (!context) {
-    log10.error("Requires global context");
-    return;
-  }
-  const router = context.router;
-  if (!router) {
-    log10.error("Router not found in context");
-    return;
-  }
-  const hypenEngine = context.__hypenEngine;
-  setTimeout(() => {
-    updateRouteVisibility(state2.currentPath, hypenEngine);
-  }, 100);
-  router.onNavigate((routeState) => {
-    state2.currentPath = routeState.currentPath;
-    state2.routeParams = routeState.params;
-    updateRouteVisibility(routeState.currentPath, hypenEngine);
-  });
-}).build();
-var Route = app.defineState({}, { name: "__Route" }).build();
-var Link = app.defineState({
-  to: "/",
-  isActive: false
-}, { name: "__Link" }).onAction("navigate", ({ state: state2, context }) => {
-  const router = context?.router;
-  if (!router) {
-    log10.error("Link requires router context");
-    return;
-  }
-  const targetPath = state2.to;
-  router.push(targetPath);
-}).onCreated((state2, context) => {
-  if (!context)
-    return;
-  const router = context.router;
-  if (router) {
-    router.onNavigate((routeState) => {
-      state2.isActive = routeState.currentPath === state2.to;
-    });
-  }
-}).build();
 export {
   withRetry,
+  validatePatches,
   usingSync,
   using,
   unwrapProxy,
@@ -3144,4 +218,4 @@ export {
   ActionError
 };
 
-//# debugId=6ED7F94267EF229064756E2164756E21
+//# debugId=14404B08846A6FEF64756E2164756E21