@hypen-space/core 0.3.12 → 0.4.1

package/dist/remote/index.js

@@ -27,205 +27,6 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/logger.ts
-function isProduction() {
-  if (typeof process !== "undefined" && process.env) {
-    return false;
-  }
-  return false;
-}
-function setLogLevel(level) {
-  config.level = level;
-}
-function getLogLevel() {
-  return config.level;
-}
-function configureLogger(options) {
-  config = { ...config, ...options };
-}
-function enableLogging() {
-  config.level = "debug";
-}
-function disableLogging() {
-  config.level = "none";
-}
-function setDebugMode(enabled) {
-  config.level = enabled ? "debug" : "error";
-}
-function isDebugMode() {
-  return config.level === "debug";
-}
-function shouldLog(level) {
-  return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[config.level];
-}
-function formatTag(tag, level) {
-  const timestamp = config.timestamps ? `${new Date().toISOString()} ` : "";
-  if (config.colors && level !== "none") {
-    const color = LOG_LEVEL_COLORS[level];
-    return `${timestamp}${color}[${tag}]${RESET_COLOR}`;
-  }
-  return `${timestamp}[${tag}]`;
-}
-
-class Logger {
-  tag;
-  constructor(tag) {
-    this.tag = tag;
-  }
-  debug(...args) {
-    if (!shouldLog("debug"))
-      return;
-    if (config.handler) {
-      config.handler.debug(this.tag, ...args);
-    } else {
-      console.log(formatTag(this.tag, "debug"), ...args);
-    }
-  }
-  info(...args) {
-    if (!shouldLog("info"))
-      return;
-    if (config.handler) {
-      config.handler.info(this.tag, ...args);
-    } else {
-      console.info(formatTag(this.tag, "info"), ...args);
-    }
-  }
-  warn(...args) {
-    if (!shouldLog("warn"))
-      return;
-    if (config.handler) {
-      config.handler.warn(this.tag, ...args);
-    } else {
-      console.warn(formatTag(this.tag, "warn"), ...args);
-    }
-  }
-  error(...args) {
-    if (!shouldLog("error"))
-      return;
-    if (config.handler) {
-      config.handler.error(this.tag, ...args);
-    } else {
-      console.error(formatTag(this.tag, "error"), ...args);
-    }
-  }
-  time(label, fn) {
-    if (!shouldLog("debug")) {
-      return fn();
-    }
-    const start = performance.now();
-    try {
-      return fn();
-    } finally {
-      const duration = performance.now() - start;
-      this.debug(`${label}: ${duration.toFixed(2)}ms`);
-    }
-  }
-  async timeAsync(label, fn) {
-    if (!shouldLog("debug")) {
-      return fn();
-    }
-    const start = performance.now();
-    try {
-      return await fn();
-    } finally {
-      const duration = performance.now() - start;
-      this.debug(`${label}: ${duration.toFixed(2)}ms`);
-    }
-  }
-  child(subTag) {
-    return new Logger(`${this.tag}:${subTag}`);
-  }
-  debugIf(condition, ...args) {
-    if (condition)
-      this.debug(...args);
-  }
-  warnIf(condition, ...args) {
-    if (condition)
-      this.warn(...args);
-  }
-  errorIf(condition, ...args) {
-    if (condition)
-      this.error(...args);
-  }
-  loggedOnce = new Set;
-  warnOnce(key, ...args) {
-    if (this.loggedOnce.has(key))
-      return;
-    this.loggedOnce.add(key);
-    this.warn(...args);
-  }
-  debugOnce(key, ...args) {
-    if (this.loggedOnce.has(key))
-      return;
-    this.loggedOnce.add(key);
-    this.debug(...args);
-  }
-}
-function createLogger(tag) {
-  return new Logger(tag);
-}
-var LOG_LEVEL_ORDER, LOG_LEVEL_COLORS, RESET_COLOR = "\x1B[0m", config, logger, log, frameworkLoggers;
-var init_logger = __esm(() => {
-  LOG_LEVEL_ORDER = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-    none: 4
-  };
-  LOG_LEVEL_COLORS = {
-    debug: "\x1B[36m",
-    info: "\x1B[32m",
-    warn: "\x1B[33m",
-    error: "\x1B[31m"
-  };
-  config = {
-    level: isProduction() ? "error" : "debug",
-    colors: true,
-    timestamps: false
-  };
-  logger = createLogger("Hypen");
-  log = {
-    debug: (tag, ...args) => {
-      if (!shouldLog("debug"))
-        return;
-      console.log(formatTag(tag, "debug"), ...args);
-    },
-    info: (tag, ...args) => {
-      if (!shouldLog("info"))
-        return;
-      console.info(formatTag(tag, "info"), ...args);
-    },
-    warn: (tag, ...args) => {
-      if (!shouldLog("warn"))
-        return;
-      console.warn(formatTag(tag, "warn"), ...args);
-    },
-    error: (tag, ...args) => {
-      if (!shouldLog("error"))
-        return;
-      console.error(formatTag(tag, "error"), ...args);
-    }
-  };
-  frameworkLoggers = {
-    hypen: createLogger("Hypen"),
-    engine: createLogger("Engine"),
-    router: createLogger("Router"),
-    state: createLogger("State"),
-    events: createLogger("Events"),
-    remote: createLogger("Remote"),
-    renderer: createLogger("Renderer"),
-    module: createLogger("Module"),
-    lifecycle: createLogger("Lifecycle"),
-    loader: createLogger("Loader"),
-    context: createLogger("Context"),
-    discovery: createLogger("Discovery"),
-    plugin: createLogger("Plugin"),
-    canvas: createLogger("Canvas"),
-    debug: createLogger("Debug")
-  };
-});
-
 // src/state.ts
 function deepClone(obj) {
   if (obj === null || typeof obj !== "object") {
@@ -599,17 +400,216 @@ var init_result = __esm(() => {
       this.attempt = attempt;
     }
   };
-  StateError = class StateError extends HypenError {
-    path;
-    constructor(message, path, cause) {
-      super("STATE_ERROR", message, {
-        context: { path },
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "StateError";
-      this.path = path;
+  StateError = class StateError extends HypenError {
+    path;
+    constructor(message, path, cause) {
+      super("STATE_ERROR", message, {
+        context: { path },
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "StateError";
+      this.path = path;
+    }
+  };
+});
+
+// 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
@@ -710,17 +710,21 @@ class HypenModuleInstance {
     this.definition = definition;
     this.routerContext = routerContext;
     this.globalContext = globalContext;
+    const statePrefix = (definition.name || "").toLowerCase();
     this.state = createObservableState(definition.initialState, {
       onChange: (change) => {
         this.engine.notifyStateChange(change.paths, change.newValues);
         this.stateChangeCallbacks.forEach((cb) => cb());
-      }
+      },
+      pathPrefix: statePrefix || undefined
     });
-    this.engine.setModule(definition.name || "AnonymousModule", definition.actions, definition.stateKeys, getStateSnapshot(this.state));
+    const snapshot = getStateSnapshot(this.state);
+    const prefixedState = statePrefix ? { [statePrefix]: snapshot } : snapshot;
+    this.engine.setModule(definition.name || "AnonymousModule", definition.actions, definition.stateKeys, prefixedState);
     for (const [actionName, handler] of definition.handlers.onAction) {
-      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,
@@ -742,7 +746,7 @@ class HypenModuleInstance {
             throw result.error;
           }
         } else {
-          log3.debug(`Action handler completed: ${actionName}`);
+          log2.debug(`Action handler completed: ${actionName}`);
         }
       });
     }
@@ -797,7 +801,7 @@ class HypenModuleInstance {
           }
         }
       } catch (handlerError) {
-        log3.error("Error in onError handler:", handlerError);
+        log2.error("Error in onError handler:", handlerError);
       }
     }
     if (this.globalContext) {
@@ -808,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() {
@@ -838,127 +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.ts
-init_logger();
-var WasmEngineClass = null;
-var log2 = frameworkLoggers.engine;
-function unwrapForWasm(value) {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (typeof value.__getSnapshot === "function") {
-    return value.__getSnapshot();
-  }
-  try {
-    return structuredClone(value);
-  } catch {
-    return JSON.parse(JSON.stringify(value));
-  }
-}
-
-class Engine {
-  wasmEngine = null;
-  initialized = false;
-  async init() {
-    if (this.initialized)
-      return;
-    if (!WasmEngineClass) {
-      const wasm = await import("../wasm-node/hypen_engine.js");
-      WasmEngineClass = wasm.WasmEngine;
-    }
-    this.wasmEngine = new WasmEngineClass;
-    this.initialized = true;
-  }
-  ensureInitialized() {
-    if (!this.wasmEngine) {
-      throw new Error("Engine not initialized. Call init() first.");
-    }
-    return this.wasmEngine;
-  }
-  setRenderCallback(callback) {
-    const engine = this.ensureInitialized();
-    engine.setRenderCallback((patches) => {
-      callback(patches);
-    });
-  }
-  setComponentResolver(resolver) {
-    const engine = this.ensureInitialized();
-    engine.setComponentResolver((componentName, contextPath) => {
-      const result = resolver(componentName, contextPath);
-      return result;
-    });
-  }
-  renderSource(source) {
-    const engine = this.ensureInitialized();
-    engine.renderSource(source);
-  }
-  renderLazyComponent(source) {
-    const engine = this.ensureInitialized();
-    engine.renderLazyComponent(source);
-  }
-  renderInto(source, parentNodeId, state) {
-    const engine = this.ensureInitialized();
-    engine.renderInto(source, parentNodeId, unwrapForWasm(state));
-  }
-  notifyStateChange(paths, values) {
-    const engine = this.ensureInitialized();
-    if (paths.length === 0) {
-      return;
-    }
-    engine.updateStateSparse(paths, unwrapForWasm(values));
-    log2.debug("State changed (sparse):", paths);
-  }
-  notifyStateChangeFull(paths, currentState) {
-    const engine = this.ensureInitialized();
-    engine.updateState(unwrapForWasm(currentState));
-    if (paths.length > 0) {
-      log2.debug("State changed (full):", paths);
-    }
-  }
-  updateState(statePatch) {
-    const engine = this.ensureInitialized();
-    engine.updateState(unwrapForWasm(statePatch));
-  }
-  dispatchAction(name, payload) {
-    const engine = this.ensureInitialized();
-    engine.dispatchAction(name, payload ?? null);
-  }
-  onAction(actionName, handler) {
-    const engine = this.ensureInitialized();
-    engine.onAction(actionName, (action) => {
-      Promise.resolve(handler(action)).catch((err) => log2.error("Action handler error:", err));
-    });
-  }
-  setModule(name, actions, stateKeys, initialState) {
-    const engine = this.ensureInitialized();
-    engine.setModule(name, actions, stateKeys, initialState);
-  }
-  getRevision() {
-    const engine = this.ensureInitialized();
-    return Number(engine.getRevision());
-  }
-  clearTree() {
-    const engine = this.ensureInitialized();
-    engine.clearTree();
-  }
-  debugParseComponent(source) {
-    const engine = this.ensureInitialized();
-    return engine.debugParseComponent(source);
-  }
-}
-
 // src/disposable.ts
 init_logger();
-var log4 = frameworkLoggers.lifecycle;
+var log3 = frameworkLoggers.lifecycle;
 function isDisposable(obj) {
   return obj !== null && typeof obj === "object" && "dispose" in obj && typeof obj.dispose === "function";
 }
@@ -990,7 +885,7 @@ class DisposableStack {
       try {
         item.dispose();
       } catch (error) {
-        log4.error("Error during dispose:", error);
+        log3.error("Error during dispose:", error);
       }
     }
   }
@@ -1081,7 +976,7 @@ function compositeDisposable(...disposables) {
         try {
           d.dispose();
         } catch (error) {
-          log4.error("Error during dispose:", error);
+          log3.error("Error during dispose:", error);
         }
       }
     }
@@ -1235,7 +1130,7 @@ var RetryPresets = {
 
 // src/remote/client.ts
 init_logger();
-var log5 = frameworkLoggers.remote;
+var log4 = frameworkLoggers.remote;
 
 class RemoteEngine {
   ws = null;
@@ -1343,7 +1238,7 @@ class RemoteEngine {
   }
   dispatchAction(action, payload) {
     if (this.state !== "connected" || !this.ws) {
-      log5.warn("Cannot dispatch action: not connected");
+      log4.warn("Cannot dispatch action: not connected");
       return;
     }
     const message = {
@@ -1416,7 +1311,7 @@ class RemoteEngine {
           break;
       }
     } catch (e) {
-      log5.error("Error handling remote message:", e);
+      log4.error("Error handling remote message:", e);
       const error = e instanceof Error ? e : new Error(String(e));
       this.errorCallbacks.forEach((cb) => cb(error));
     }
@@ -1445,7 +1340,7 @@ class RemoteEngine {
   }
   handlePatch(message) {
     if (message.revision <= this.currentRevision) {
-      log5.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
+      log4.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
       return;
     }
     this.currentRevision = message.revision;
@@ -1471,16 +1366,121 @@ class RemoteEngine {
         maxDelayMs: 30000,
         jitter: 0.1,
         onRetry: (attempt, error) => {
-          log5.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
+          log4.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
         }
       }).catch((error) => {
-        log5.error("Max reconnection attempts reached:", error.message);
+        log4.error("Max reconnection attempts reached:", error.message);
         this.errorCallbacks.forEach((cb) => cb(new ConnectionError(this.url, error, this.options.maxReconnectAttempts)));
       });
     }, this.options.reconnectInterval);
   }
 }
 
+// src/engine.ts
+init_logger();
+import { WasmEngine } from "../wasm-node/hypen_engine.js";
+var log5 = frameworkLoggers.engine;
+function unwrapForWasm(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (typeof value.__getSnapshot === "function") {
+    return value.__getSnapshot();
+  }
+  try {
+    return structuredClone(value);
+  } catch {
+    return JSON.parse(JSON.stringify(value));
+  }
+}
+
+class Engine {
+  wasmEngine = null;
+  initialized = false;
+  async init() {
+    if (this.initialized)
+      return;
+    this.wasmEngine = new WasmEngine;
+    this.initialized = true;
+  }
+  ensureInitialized() {
+    if (!this.wasmEngine) {
+      throw new Error("Engine not initialized. Call init() first.");
+    }
+    return this.wasmEngine;
+  }
+  setRenderCallback(callback) {
+    const engine = this.ensureInitialized();
+    engine.setRenderCallback((patches) => {
+      callback(patches);
+    });
+  }
+  setComponentResolver(resolver) {
+    const engine = this.ensureInitialized();
+    engine.setComponentResolver((componentName, contextPath) => {
+      const result = resolver(componentName, contextPath);
+      return result;
+    });
+  }
+  renderSource(source) {
+    const engine = this.ensureInitialized();
+    engine.renderSource(source);
+  }
+  renderLazyComponent(source) {
+    const engine = this.ensureInitialized();
+    engine.renderLazyComponent(source);
+  }
+  renderInto(source, parentNodeId, state) {
+    const engine = this.ensureInitialized();
+    engine.renderInto(source, parentNodeId, unwrapForWasm(state));
+  }
+  notifyStateChange(paths, values) {
+    const engine = this.ensureInitialized();
+    if (paths.length === 0) {
+      return;
+    }
+    engine.updateStateSparse(paths, unwrapForWasm(values));
+    log5.debug("State changed (sparse):", paths);
+  }
+  notifyStateChangeFull(paths, currentState) {
+    const engine = this.ensureInitialized();
+    engine.updateState(unwrapForWasm(currentState));
+    if (paths.length > 0) {
+      log5.debug("State changed (full):", paths);
+    }
+  }
+  updateState(statePatch) {
+    const engine = this.ensureInitialized();
+    engine.updateState(unwrapForWasm(statePatch));
+  }
+  dispatchAction(name, payload) {
+    const engine = this.ensureInitialized();
+    engine.dispatchAction(name, payload ?? null);
+  }
+  onAction(actionName, handler) {
+    const engine = this.ensureInitialized();
+    engine.onAction(actionName, (action) => {
+      Promise.resolve(handler(action)).catch((err) => log5.error("Action handler error:", err));
+    });
+  }
+  setModule(name, actions, stateKeys, initialState) {
+    const engine = this.ensureInitialized();
+    engine.setModule(name, actions, stateKeys, initialState);
+  }
+  getRevision() {
+    const engine = this.ensureInitialized();
+    return Number(engine.getRevision());
+  }
+  clearTree() {
+    const engine = this.ensureInitialized();
+    engine.clearTree();
+  }
+  debugParseComponent(source) {
+    const engine = this.ensureInitialized();
+    return engine.debugParseComponent(source);
+  }
+}
+
 // src/remote/server.ts
 init_app();
 
@@ -1987,4 +1987,4 @@ export {
   RemoteEngine
 };
 
-//# debugId=C53D35A16364877D64756E2164756E21
+//# debugId=BAD14814BBB641A464756E2164756E21