@hypen-space/core 0.3.11 → 0.4.0

package/dist/index.browser.js

@@ -1,4 +1,20 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -9,205 +25,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-
-// src/logger.ts
-function isProduction() {
-  if (typeof process !== "undefined" && process.env) {
-    return false;
-  }
-  return false;
-}
-function setLogLevel(level) {
-  config.level = level;
-}
-function getLogLevel() {
-  return config.level;
-}
-function configureLogger(options) {
-  config = { ...config, ...options };
-}
-function enableLogging() {
-  config.level = "debug";
-}
-function disableLogging() {
-  config.level = "none";
-}
-function setDebugMode(enabled) {
-  config.level = enabled ? "debug" : "error";
-}
-function isDebugMode() {
-  return config.level === "debug";
-}
-function shouldLog(level) {
-  return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[config.level];
-}
-function formatTag(tag, level) {
-  const timestamp = config.timestamps ? `${new Date().toISOString()} ` : "";
-  if (config.colors && level !== "none") {
-    const color = LOG_LEVEL_COLORS[level];
-    return `${timestamp}${color}[${tag}]${RESET_COLOR}`;
-  }
-  return `${timestamp}[${tag}]`;
-}
-
-class Logger {
-  tag;
-  constructor(tag) {
-    this.tag = tag;
-  }
-  debug(...args) {
-    if (!shouldLog("debug"))
-      return;
-    if (config.handler) {
-      config.handler.debug(this.tag, ...args);
-    } else {
-      console.log(formatTag(this.tag, "debug"), ...args);
-    }
-  }
-  info(...args) {
-    if (!shouldLog("info"))
-      return;
-    if (config.handler) {
-      config.handler.info(this.tag, ...args);
-    } else {
-      console.info(formatTag(this.tag, "info"), ...args);
-    }
-  }
-  warn(...args) {
-    if (!shouldLog("warn"))
-      return;
-    if (config.handler) {
-      config.handler.warn(this.tag, ...args);
-    } else {
-      console.warn(formatTag(this.tag, "warn"), ...args);
-    }
-  }
-  error(...args) {
-    if (!shouldLog("error"))
-      return;
-    if (config.handler) {
-      config.handler.error(this.tag, ...args);
-    } else {
-      console.error(formatTag(this.tag, "error"), ...args);
-    }
-  }
-  time(label, fn) {
-    if (!shouldLog("debug")) {
-      return fn();
-    }
-    const start = performance.now();
-    try {
-      return fn();
-    } finally {
-      const duration = performance.now() - start;
-      this.debug(`${label}: ${duration.toFixed(2)}ms`);
-    }
-  }
-  async timeAsync(label, fn) {
-    if (!shouldLog("debug")) {
-      return fn();
-    }
-    const start = performance.now();
-    try {
-      return await fn();
-    } finally {
-      const duration = performance.now() - start;
-      this.debug(`${label}: ${duration.toFixed(2)}ms`);
-    }
-  }
-  child(subTag) {
-    return new Logger(`${this.tag}:${subTag}`);
-  }
-  debugIf(condition, ...args) {
-    if (condition)
-      this.debug(...args);
-  }
-  warnIf(condition, ...args) {
-    if (condition)
-      this.warn(...args);
-  }
-  errorIf(condition, ...args) {
-    if (condition)
-      this.error(...args);
-  }
-  loggedOnce = new Set;
-  warnOnce(key, ...args) {
-    if (this.loggedOnce.has(key))
-      return;
-    this.loggedOnce.add(key);
-    this.warn(...args);
-  }
-  debugOnce(key, ...args) {
-    if (this.loggedOnce.has(key))
-      return;
-    this.loggedOnce.add(key);
-    this.debug(...args);
-  }
-}
-function createLogger(tag) {
-  return new Logger(tag);
-}
-var LOG_LEVEL_ORDER, LOG_LEVEL_COLORS, RESET_COLOR = "\x1B[0m", config, logger, log, frameworkLoggers;
-var init_logger = __esm(() => {
-  LOG_LEVEL_ORDER = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-    none: 4
-  };
-  LOG_LEVEL_COLORS = {
-    debug: "\x1B[36m",
-    info: "\x1B[32m",
-    warn: "\x1B[33m",
-    error: "\x1B[31m"
-  };
-  config = {
-    level: isProduction() ? "error" : "debug",
-    colors: true,
-    timestamps: false
-  };
-  logger = createLogger("Hypen");
-  log = {
-    debug: (tag, ...args) => {
-      if (!shouldLog("debug"))
-        return;
-      console.log(formatTag(tag, "debug"), ...args);
-    },
-    info: (tag, ...args) => {
-      if (!shouldLog("info"))
-        return;
-      console.info(formatTag(tag, "info"), ...args);
-    },
-    warn: (tag, ...args) => {
-      if (!shouldLog("warn"))
-        return;
-      console.warn(formatTag(tag, "warn"), ...args);
-    },
-    error: (tag, ...args) => {
-      if (!shouldLog("error"))
-        return;
-      console.error(formatTag(tag, "error"), ...args);
-    }
-  };
-  frameworkLoggers = {
-    hypen: createLogger("Hypen"),
-    engine: createLogger("Engine"),
-    router: createLogger("Router"),
-    state: createLogger("State"),
-    events: createLogger("Events"),
-    remote: createLogger("Remote"),
-    renderer: createLogger("Renderer"),
-    module: createLogger("Module"),
-    lifecycle: createLogger("Lifecycle"),
-    loader: createLogger("Loader"),
-    context: createLogger("Context"),
-    discovery: createLogger("Discovery"),
-    plugin: createLogger("Plugin"),
-    canvas: createLogger("Canvas"),
-    debug: createLogger("Debug")
-  };
-});
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/state.ts
 function deepClone(obj) {
@@ -595,6 +413,205 @@ var init_result = __esm(() => {
   };
 });
 
+// src/logger.ts
+function isProduction() {
+  if (typeof process !== "undefined" && process.env) {
+    return false;
+  }
+  return false;
+}
+function setLogLevel(level) {
+  config.level = level;
+}
+function getLogLevel() {
+  return config.level;
+}
+function configureLogger(options) {
+  config = { ...config, ...options };
+}
+function enableLogging() {
+  config.level = "debug";
+}
+function disableLogging() {
+  config.level = "none";
+}
+function setDebugMode(enabled) {
+  config.level = enabled ? "debug" : "error";
+}
+function isDebugMode() {
+  return config.level === "debug";
+}
+function shouldLog(level) {
+  return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[config.level];
+}
+function formatTag(tag, level) {
+  const timestamp = config.timestamps ? `${new Date().toISOString()} ` : "";
+  if (config.colors && level !== "none") {
+    const color = LOG_LEVEL_COLORS[level];
+    return `${timestamp}${color}[${tag}]${RESET_COLOR}`;
+  }
+  return `${timestamp}[${tag}]`;
+}
+
+class Logger {
+  tag;
+  constructor(tag) {
+    this.tag = tag;
+  }
+  debug(...args) {
+    if (!shouldLog("debug"))
+      return;
+    if (config.handler) {
+      config.handler.debug(this.tag, ...args);
+    } else {
+      console.log(formatTag(this.tag, "debug"), ...args);
+    }
+  }
+  info(...args) {
+    if (!shouldLog("info"))
+      return;
+    if (config.handler) {
+      config.handler.info(this.tag, ...args);
+    } else {
+      console.info(formatTag(this.tag, "info"), ...args);
+    }
+  }
+  warn(...args) {
+    if (!shouldLog("warn"))
+      return;
+    if (config.handler) {
+      config.handler.warn(this.tag, ...args);
+    } else {
+      console.warn(formatTag(this.tag, "warn"), ...args);
+    }
+  }
+  error(...args) {
+    if (!shouldLog("error"))
+      return;
+    if (config.handler) {
+      config.handler.error(this.tag, ...args);
+    } else {
+      console.error(formatTag(this.tag, "error"), ...args);
+    }
+  }
+  time(label, fn) {
+    if (!shouldLog("debug")) {
+      return fn();
+    }
+    const start = performance.now();
+    try {
+      return fn();
+    } finally {
+      const duration = performance.now() - start;
+      this.debug(`${label}: ${duration.toFixed(2)}ms`);
+    }
+  }
+  async timeAsync(label, fn) {
+    if (!shouldLog("debug")) {
+      return fn();
+    }
+    const start = performance.now();
+    try {
+      return await fn();
+    } finally {
+      const duration = performance.now() - start;
+      this.debug(`${label}: ${duration.toFixed(2)}ms`);
+    }
+  }
+  child(subTag) {
+    return new Logger(`${this.tag}:${subTag}`);
+  }
+  debugIf(condition, ...args) {
+    if (condition)
+      this.debug(...args);
+  }
+  warnIf(condition, ...args) {
+    if (condition)
+      this.warn(...args);
+  }
+  errorIf(condition, ...args) {
+    if (condition)
+      this.error(...args);
+  }
+  loggedOnce = new Set;
+  warnOnce(key, ...args) {
+    if (this.loggedOnce.has(key))
+      return;
+    this.loggedOnce.add(key);
+    this.warn(...args);
+  }
+  debugOnce(key, ...args) {
+    if (this.loggedOnce.has(key))
+      return;
+    this.loggedOnce.add(key);
+    this.debug(...args);
+  }
+}
+function createLogger(tag) {
+  return new Logger(tag);
+}
+var LOG_LEVEL_ORDER, LOG_LEVEL_COLORS, RESET_COLOR = "\x1B[0m", config, logger, log, frameworkLoggers;
+var init_logger = __esm(() => {
+  LOG_LEVEL_ORDER = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    none: 4
+  };
+  LOG_LEVEL_COLORS = {
+    debug: "\x1B[36m",
+    info: "\x1B[32m",
+    warn: "\x1B[33m",
+    error: "\x1B[31m"
+  };
+  config = {
+    level: isProduction() ? "error" : "debug",
+    colors: true,
+    timestamps: false
+  };
+  logger = createLogger("Hypen");
+  log = {
+    debug: (tag, ...args) => {
+      if (!shouldLog("debug"))
+        return;
+      console.log(formatTag(tag, "debug"), ...args);
+    },
+    info: (tag, ...args) => {
+      if (!shouldLog("info"))
+        return;
+      console.info(formatTag(tag, "info"), ...args);
+    },
+    warn: (tag, ...args) => {
+      if (!shouldLog("warn"))
+        return;
+      console.warn(formatTag(tag, "warn"), ...args);
+    },
+    error: (tag, ...args) => {
+      if (!shouldLog("error"))
+        return;
+      console.error(formatTag(tag, "error"), ...args);
+    }
+  };
+  frameworkLoggers = {
+    hypen: createLogger("Hypen"),
+    engine: createLogger("Engine"),
+    router: createLogger("Router"),
+    state: createLogger("State"),
+    events: createLogger("Events"),
+    remote: createLogger("Remote"),
+    renderer: createLogger("Renderer"),
+    module: createLogger("Module"),
+    lifecycle: createLogger("Lifecycle"),
+    loader: createLogger("Loader"),
+    context: createLogger("Context"),
+    discovery: createLogger("Discovery"),
+    plugin: createLogger("Plugin"),
+    canvas: createLogger("Canvas"),
+    debug: createLogger("Debug")
+  };
+});
+
 // src/app.ts
 var exports_app = {};
 __export(exports_app, {
@@ -693,17 +710,21 @@ class HypenModuleInstance {
     this.definition = definition;
     this.routerContext = routerContext;
     this.globalContext = globalContext;
+    const statePrefix = (definition.name || "").toLowerCase();
     this.state = createObservableState(definition.initialState, {
       onChange: (change) => {
         this.engine.notifyStateChange(change.paths, change.newValues);
         this.stateChangeCallbacks.forEach((cb) => cb());
-      }
+      },
+      pathPrefix: statePrefix || undefined
     });
-    this.engine.setModule(definition.name || "AnonymousModule", definition.actions, definition.stateKeys, getStateSnapshot(this.state));
+    const snapshot = getStateSnapshot(this.state);
+    const prefixedState = statePrefix ? { [statePrefix]: snapshot } : snapshot;
+    this.engine.setModule(definition.name || "AnonymousModule", definition.actions, definition.stateKeys, prefixedState);
     for (const [actionName, handler] of definition.handlers.onAction) {
-      log3.debug(`Registering action handler: ${actionName} for module ${definition.name}`);
+      log2.debug(`Registering action handler: ${actionName} for module ${definition.name}`);
       this.engine.onAction(actionName, async (action) => {
-        log3.debug(`Action handler fired: ${actionName}`, action);
+        log2.debug(`Action handler fired: ${actionName}`, action);
         const actionCtx = {
           name: action.name,
           payload: action.payload,
@@ -725,7 +746,7 @@ class HypenModuleInstance {
             throw result.error;
           }
         } else {
-          log3.debug(`Action handler completed: ${actionName}`);
+          log2.debug(`Action handler completed: ${actionName}`);
         }
       });
     }
@@ -780,7 +801,7 @@ class HypenModuleInstance {
           }
         }
       } catch (handlerError) {
-        log3.error("Error in onError handler:", handlerError);
+        log2.error("Error in onError handler:", handlerError);
       }
     }
     if (this.globalContext) {
@@ -791,7 +812,7 @@ class HypenModuleInstance {
         context: eventContext
       });
     }
-    log3.error(`${context.actionName ? `Action "${context.actionName}"` : `Lifecycle "${context.lifecycle}"`} error:`, error);
+    log2.error(`${context.actionName ? `Action "${context.actionName}"` : `Lifecycle "${context.lifecycle}"`} error:`, error);
     return false;
   }
   async callCreatedHandler() {
@@ -821,150 +842,18 @@ class HypenModuleInstance {
     Object.assign(this.state, patch);
   }
 }
-var log3, app;
+var log2, app;
 var init_app = __esm(() => {
   init_result();
   init_state();
   init_logger();
-  log3 = createLogger("ModuleInstance");
+  log2 = createLogger("ModuleInstance");
   app = new HypenApp;
 });
 
-// src/engine.browser.ts
-init_logger();
-var log2 = frameworkLoggers.engine;
-var wasmInit = null;
-var WasmEngineClass = null;
-function mapToObject(value) {
-  if (value instanceof Map) {
-    const obj = {};
-    for (const [key, val] of value.entries()) {
-      obj[key] = mapToObject(val);
-    }
-    return obj;
-  } else if (Array.isArray(value)) {
-    return value.map(mapToObject);
-  } else if (value && typeof value === "object" && value.constructor === Object) {
-    const obj = {};
-    for (const [key, val] of Object.entries(value)) {
-      obj[key] = mapToObject(val);
-    }
-    return obj;
-  }
-  return value;
-}
-
-class Engine {
-  wasmEngine = null;
-  initialized = false;
-  async init(options = {}) {
-    if (this.initialized)
-      return;
-    const cdnBase = "https://unpkg.com/@hypen-space/core@latest/wasm-browser";
-    const jsUrl = options.jsUrl ?? `${cdnBase}/hypen_engine.js`;
-    const wasmUrl = options.wasmUrl ?? `${cdnBase}/hypen_engine_bg.wasm`;
-    try {
-      const wasmModule = await import(jsUrl);
-      wasmInit = wasmModule.default;
-      WasmEngineClass = wasmModule.WasmEngine;
-      await wasmInit(wasmUrl);
-      this.wasmEngine = new WasmEngineClass;
-      this.initialized = true;
-    } catch (error) {
-      log2.error("Failed to initialize WASM engine:", error);
-      throw error;
-    }
-  }
-  ensureInitialized() {
-    if (!this.wasmEngine) {
-      throw new Error("Engine not initialized. Call init() first.");
-    }
-    return this.wasmEngine;
-  }
-  setRenderCallback(callback) {
-    const engine = this.ensureInitialized();
-    engine.setRenderCallback((patches) => {
-      callback(patches);
-    });
-  }
-  setComponentResolver(resolver) {
-    const engine = this.ensureInitialized();
-    engine.setComponentResolver((componentName, contextPath) => {
-      const result = resolver(componentName, contextPath);
-      return result;
-    });
-  }
-  renderSource(source) {
-    const engine = this.ensureInitialized();
-    engine.renderSource(source);
-  }
-  renderLazyComponent(source) {
-    const engine = this.ensureInitialized();
-    engine.renderLazyComponent(source);
-  }
-  renderInto(source, parentNodeId, state) {
-    const engine = this.ensureInitialized();
-    const safeState = JSON.parse(JSON.stringify(state));
-    engine.renderInto(source, parentNodeId, safeState);
-  }
-  notifyStateChange(paths, values) {
-    const engine = this.ensureInitialized();
-    if (paths.length === 0) {
-      return;
-    }
-    const plainValues = JSON.parse(JSON.stringify(values));
-    engine.updateStateSparse(paths, plainValues);
-    log2.debug("State changed (sparse):", paths);
-  }
-  notifyStateChangeFull(paths, currentState) {
-    const engine = this.ensureInitialized();
-    const plainObject = JSON.parse(JSON.stringify(currentState));
-    engine.updateState(plainObject);
-    if (paths.length > 0) {
-      log2.debug("State changed (full):", paths);
-    }
-  }
-  updateState(statePatch) {
-    const engine = this.ensureInitialized();
-    const plainObject = JSON.parse(JSON.stringify(statePatch));
-    engine.updateState(plainObject);
-  }
-  dispatchAction(name, payload) {
-    const engine = this.ensureInitialized();
-    log2.debug(`Action dispatched: ${name}`);
-    engine.dispatchAction(name, payload ?? null);
-  }
-  onAction(actionName, handler) {
-    const engine = this.ensureInitialized();
-    engine.onAction(actionName, (action) => {
-      const normalizedAction = {
-        ...action,
-        payload: action.payload ? mapToObject(action.payload) : action.payload
-      };
-      Promise.resolve(handler(normalizedAction)).catch((err) => log2.error("Action handler error:", err));
-    });
-  }
-  setModule(name, actions, stateKeys, initialState) {
-    const engine = this.ensureInitialized();
-    engine.setModule(name, actions, stateKeys, initialState);
-  }
-  getRevision() {
-    const engine = this.ensureInitialized();
-    return engine.getRevision();
-  }
-  clearTree() {
-    const engine = this.ensureInitialized();
-    engine.clearTree();
-  }
-  debugParseComponent(source) {
-    const engine = this.ensureInitialized();
-    return engine.debugParseComponent(source);
-  }
-}
-
 // src/renderer.ts
 init_logger();
-var log4 = frameworkLoggers.renderer;
+var log3 = frameworkLoggers.renderer;
 
 class BaseRenderer {
   nodes = new Map;
@@ -1006,14 +895,14 @@ class BaseRenderer {
 
 class ConsoleRenderer {
   applyPatches(patches) {
-    log4.debug("Patches:", patches);
+    log3.debug("Patches:", patches);
   }
 }
 
 // src/router.ts
 init_state();
 init_logger();
-var log5 = frameworkLoggers.router;
+var log4 = frameworkLoggers.router;
 
 class HypenRouter {
   state;
@@ -1051,7 +940,7 @@ class HypenRouter {
       this.updatePath(newPath, false);
     });
     this.isInitialized = true;
-    log5.debug("Router initialized at:", initialPath);
+    log4.debug("Router initialized at:", initialPath);
   }
   getPathFromBrowser() {
     if (typeof window === "undefined")
@@ -1072,21 +961,21 @@ class HypenRouter {
     return query;
   }
   push(path) {
-    log5.debug("push:", path);
+    log4.debug("push:", path);
     this.updatePath(path, true);
   }
   replace(path) {
-    log5.debug("replace:", path);
+    log4.debug("replace:", path);
     this.updatePath(path, true, true);
   }
   back() {
-    log5.debug("back");
+    log4.debug("back");
     if (typeof window !== "undefined") {
       window.history.back();
     }
   }
   forward() {
-    log5.debug("forward");
+    log4.debug("forward");
     if (typeof window !== "undefined") {
       window.history.forward();
     }
@@ -1182,7 +1071,7 @@ class HypenRouter {
     try {
       callback(this.getState());
     } catch (error) {
-      log5.error("Error in route subscriber:", error);
+      log4.error("Error in route subscriber:", error);
     }
     return () => {
       this.subscribers.delete(callback);
@@ -1194,7 +1083,7 @@ class HypenRouter {
       try {
         callback(routeState);
       } catch (error) {
-        log5.error("Error in route subscriber:", error);
+        log4.error("Error in route subscriber:", error);
       }
     });
   }
@@ -1212,7 +1101,7 @@ class HypenRouter {
 
 // src/events.ts
 init_logger();
-var log6 = frameworkLoggers.events;
+var log5 = frameworkLoggers.events;
 
 class TypedEventEmitter {
   eventBus = new Map;
@@ -1225,7 +1114,7 @@ class TypedEventEmitter {
       try {
         handler(payload);
       } catch (error) {
-        log6.error(`Error in event handler for "${String(event)}":`, error);
+        log5.error(`Error in event handler for "${String(event)}":`, error);
       }
     });
   }
@@ -1278,7 +1167,7 @@ function createEventEmitter() {
 
 // src/context.ts
 init_logger();
-var log7 = frameworkLoggers.context;
+var log6 = frameworkLoggers.context;
 
 class HypenGlobalContext {
   modules = new Map;
@@ -1292,14 +1181,14 @@ class HypenGlobalContext {
   }
   registerModule(id, instance) {
     if (this.modules.has(id)) {
-      log7.warn(`Module "${id}" is already registered. Overwriting.`);
+      log6.warn(`Module "${id}" is already registered. Overwriting.`);
     }
     this.modules.set(id, instance);
-    log7.debug(`Registered module: ${id}`);
+    log6.debug(`Registered module: ${id}`);
   }
   unregisterModule(id) {
     this.modules.delete(id);
-    log7.debug(`Unregistered module: ${id}`);
+    log6.debug(`Unregistered module: ${id}`);
   }
   getModule(id) {
     const module = this.modules.get(id);
@@ -1328,14 +1217,14 @@ class HypenGlobalContext {
   emit(event, payload) {
     const handlers = this.legacyEventBus.get(event);
     if (!handlers || handlers.size === 0) {
-      log7.debug(`Event "${event}" emitted but no listeners`);
+      log6.debug(`Event "${event}" emitted but no listeners`);
     } else {
-      log7.debug(`Emitting event: ${event}`, payload);
+      log6.debug(`Emitting event: ${event}`, payload);
       handlers.forEach((handler) => {
         try {
           handler(payload);
         } catch (error) {
-          log7.error(`Error in event handler for "${event}":`, error);
+          log6.error(`Error in event handler for "${event}":`, error);
         }
       });
     }
@@ -1349,7 +1238,7 @@ class HypenGlobalContext {
     }
     const handlers = this.legacyEventBus.get(event);
     handlers.add(handler);
-    log7.debug(`Listening to event: ${event}`);
+    log6.debug(`Listening to event: ${event}`);
     return () => {
       handlers.delete(handler);
       if (handlers.size === 0) {
@@ -1384,7 +1273,7 @@ class HypenGlobalContext {
 
 // src/disposable.ts
 init_logger();
-var log8 = frameworkLoggers.lifecycle;
+var log7 = frameworkLoggers.lifecycle;
 function isDisposable(obj) {
   return obj !== null && typeof obj === "object" && "dispose" in obj && typeof obj.dispose === "function";
 }
@@ -1416,7 +1305,7 @@ class DisposableStack {
       try {
         item.dispose();
       } catch (error) {
-        log8.error("Error during dispose:", error);
+        log7.error("Error during dispose:", error);
       }
     }
   }
@@ -1507,7 +1396,7 @@ function compositeDisposable(...disposables) {
         try {
           d.dispose();
         } catch (error) {
-          log8.error("Error during dispose:", error);
+          log7.error("Error during dispose:", error);
         }
       }
     }
@@ -1661,7 +1550,7 @@ var RetryPresets = {
 
 // src/remote/client.ts
 init_logger();
-var log9 = frameworkLoggers.remote;
+var log8 = frameworkLoggers.remote;
 
 class RemoteEngine {
   ws = null;
@@ -1769,7 +1658,7 @@ class RemoteEngine {
   }
   dispatchAction(action, payload) {
     if (this.state !== "connected" || !this.ws) {
-      log9.warn("Cannot dispatch action: not connected");
+      log8.warn("Cannot dispatch action: not connected");
       return;
     }
     const message = {
@@ -1842,7 +1731,7 @@ class RemoteEngine {
           break;
       }
     } catch (e) {
-      log9.error("Error handling remote message:", e);
+      log8.error("Error handling remote message:", e);
       const error = e instanceof Error ? e : new Error(String(e));
       this.errorCallbacks.forEach((cb) => cb(error));
     }
@@ -1871,7 +1760,7 @@ class RemoteEngine {
   }
   handlePatch(message) {
     if (message.revision <= this.currentRevision) {
-      log9.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
+      log8.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
       return;
     }
     this.currentRevision = message.revision;
@@ -1897,10 +1786,10 @@ class RemoteEngine {
         maxDelayMs: 30000,
         jitter: 0.1,
         onRetry: (attempt, error) => {
-          log9.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
+          log8.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
         }
       }).catch((error) => {
-        log9.error("Max reconnection attempts reached:", error.message);
+        log8.error("Max reconnection attempts reached:", error.message);
         this.errorCallbacks.forEach((cb) => cb(new ConnectionError(this.url, error, this.options.maxReconnectAttempts)));
       });
     }, this.options.reconnectInterval);
@@ -1943,10 +1832,9 @@ export {
   HypenGlobalContext,
   HypenAppBuilder,
   HypenApp,
-  Engine,
   DisposableStack,
   ConsoleRenderer,
   BaseRenderer
 };
 
-//# debugId=9618BA73380775CC64756E2164756E21
+//# debugId=98631CC049082F4164756E2164756E21