@hypen-space/core 0.3.11 → 0.4.0

package/dist/remote/server.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,19 +842,19 @@ 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();
 import { WasmEngine } from "../wasm-node/hypen_engine.js";
-var log2 = frameworkLoggers.engine;
+var log3 = frameworkLoggers.engine;
 function unwrapForWasm(value) {
   if (value === null || typeof value !== "object") {
     return value;
@@ -894,13 +915,13 @@ class Engine {
       return;
     }
     engine.updateStateSparse(paths, unwrapForWasm(values));
-    log2.debug("State changed (sparse):", paths);
+    log3.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);
+      log3.debug("State changed (full):", paths);
     }
   }
   updateState(statePatch) {
@@ -914,7 +935,7 @@ class Engine {
   onAction(actionName, handler) {
     const engine = this.ensureInitialized();
     engine.onAction(actionName, (action) => {
-      Promise.resolve(handler(action)).catch((err) => log2.error("Action handler error:", err));
+      Promise.resolve(handler(action)).catch((err) => log3.error("Action handler error:", err));
     });
   }
   setModule(name, actions, stateKeys, initialState) {
@@ -1439,4 +1460,4 @@ export {
   RemoteServer
 };
 
-//# debugId=C7697DC74216A40C64756E2164756E21
+//# debugId=1E9F674E53CBE95764756E2164756E21