@hypen-space/core 0.3.9 → 0.3.11

package/dist/remote/server.js

@@ -0,0 +1,1442 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+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")
+  };
+});
+
+// src/state.ts
+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 = "") {
+  const paths = [];
+  const newValues = {};
+  function diff(oldVal, newVal, path) {
+    if (oldVal === newVal)
+      return;
+    if (typeof oldVal !== "object" || typeof newVal !== "object" || oldVal === null || newVal === null) {
+      if (oldVal !== newVal) {
+        paths.push(path);
+        newValues[path] = newVal;
+      }
+      return;
+    }
+    if (Array.isArray(oldVal) || Array.isArray(newVal)) {
+      if (!Array.isArray(oldVal) || !Array.isArray(newVal) || oldVal.length !== newVal.length) {
+        paths.push(path);
+        newValues[path] = newVal;
+        return;
+      }
+      for (let i = 0;i < newVal.length; i++) {
+        const itemPath = path ? `${path}.${i}` : `${i}`;
+        diff(oldVal[i], newVal[i], itemPath);
+      }
+      return;
+    }
+    const oldKeys = new Set(Object.keys(oldVal));
+    const newKeys = new Set(Object.keys(newVal));
+    for (const key of newKeys) {
+      const propPath = path ? `${path}.${key}` : key;
+      if (!oldKeys.has(key)) {
+        paths.push(propPath);
+        newValues[propPath] = newVal[key];
+      } else {
+        diff(oldVal[key], newVal[key], propPath);
+      }
+    }
+    for (const key of oldKeys) {
+      if (!newKeys.has(key)) {
+        const propPath = path ? `${path}.${key}` : key;
+        paths.push(propPath);
+        newValues[propPath] = undefined;
+      }
+    }
+  }
+  diff(oldState, newState, basePath);
+  return { paths, newValues };
+}
+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();
+          }
+        });
+      }
+    }
+  }
+  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) {
+        if (prop in obj) {
+          delete obj[prop];
+          scheduleBatch();
+        }
+        return true;
+      }
+    });
+    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;
+}
+var IS_PROXY, RAW_TARGET;
+var init_state = __esm(() => {
+  IS_PROXY = Symbol.for("hypen.isProxy");
+  RAW_TARGET = Symbol.for("hypen.rawTarget");
+});
+
+// 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);
+}
+var HypenError, ActionError, ConnectionError, StateError;
+var init_result = __esm(() => {
+  HypenError = class HypenError extends Error {
+    code;
+    context;
+    cause;
+    constructor(code, message, options) {
+      super(message);
+      this.name = "HypenError";
+      this.code = code;
+      this.context = options?.context;
+      this.cause = options?.cause;
+      Object.setPrototypeOf(this, new.target.prototype);
+    }
+  };
+  ActionError = class ActionError extends HypenError {
+    actionName;
+    constructor(actionName, cause) {
+      super("ACTION_ERROR", `Action handler "${actionName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
+        context: { actionName },
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "ActionError";
+      this.actionName = actionName;
+    }
+  };
+  ConnectionError = class ConnectionError extends HypenError {
+    url;
+    attempt;
+    constructor(url, cause, attempt) {
+      super("CONNECTION_ERROR", `Connection to "${url}" failed${attempt ? ` (attempt ${attempt})` : ""}: ${cause instanceof Error ? cause.message : String(cause)}`, {
+        context: { url, attempt },
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "ConnectionError";
+      this.url = url;
+      this.attempt = attempt;
+    }
+  };
+  StateError = class StateError extends HypenError {
+    path;
+    constructor(message, path, cause) {
+      super("STATE_ERROR", message, {
+        context: { path },
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "StateError";
+      this.path = path;
+    }
+  };
+});
+
+// src/app.ts
+var exports_app = {};
+__export(exports_app, {
+  app: () => app,
+  HypenModuleInstance: () => HypenModuleInstance,
+  HypenAppBuilder: () => HypenAppBuilder,
+  HypenApp: () => HypenApp
+});
+
+class HypenAppBuilder {
+  initialState;
+  options;
+  createdHandler;
+  actionHandlers = new Map;
+  destroyedHandler;
+  disconnectHandler;
+  reconnectHandler;
+  expireHandler;
+  errorHandler;
+  template;
+  constructor(initialState, options) {
+    this.initialState = initialState;
+    this.options = options || {};
+  }
+  onCreated(fn) {
+    this.createdHandler = fn;
+    return this;
+  }
+  onAction(name, fn) {
+    this.actionHandlers.set(name, 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;
+  }
+  ui(template) {
+    this.template = template;
+    return this.build();
+  }
+  build() {
+    const stateKeys = this.initialState !== null && typeof this.initialState === "object" ? Object.keys(this.initialState) : [];
+    return {
+      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,
+      handlers: {
+        onCreated: this.createdHandler,
+        onAction: this.actionHandlers,
+        onDestroyed: this.destroyedHandler,
+        onDisconnect: this.disconnectHandler,
+        onReconnect: this.reconnectHandler,
+        onExpire: this.expireHandler,
+        onError: this.errorHandler
+      }
+    };
+  }
+}
+
+class HypenApp {
+  defineState(initial, options) {
+    return new HypenAppBuilder(initial, options);
+  }
+}
+
+class HypenModuleInstance {
+  engine;
+  definition;
+  state;
+  isDestroyed = false;
+  routerContext;
+  globalContext;
+  stateChangeCallbacks = [];
+  constructor(engine, definition, routerContext, globalContext) {
+    this.engine = engine;
+    this.definition = definition;
+    this.routerContext = routerContext;
+    this.globalContext = globalContext;
+    this.state = createObservableState(definition.initialState, {
+      onChange: (change) => {
+        this.engine.notifyStateChange(change.paths, change.newValues);
+        this.stateChangeCallbacks.forEach((cb) => cb());
+      }
+    });
+    this.engine.setModule(definition.name || "AnonymousModule", definition.actions, definition.stateKeys, getStateSnapshot(this.state));
+    for (const [actionName, handler] of definition.handlers.onAction) {
+      log3.debug(`Registering action handler: ${actionName} for module ${definition.name}`);
+      this.engine.onAction(actionName, async (action) => {
+        log3.debug(`Action handler fired: ${actionName}`, action);
+        const actionCtx = {
+          name: action.name,
+          payload: action.payload,
+          sender: action.sender
+        };
+        const next = {
+          router: this.routerContext?.root || null
+        };
+        const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
+        const result = await this.executeAction(actionName, handler, {
+          action: actionCtx,
+          state: this.state,
+          next,
+          context
+        });
+        if (!result.ok) {
+          const shouldRethrow = await this.handleError(result.error, { actionName });
+          if (shouldRethrow) {
+            throw result.error;
+          }
+        } else {
+          log3.debug(`Action handler completed: ${actionName}`);
+        }
+      });
+    }
+    this.callCreatedHandler();
+  }
+  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)
+    };
+    if (ctx.__router) {
+      api.__router = ctx.__router;
+    }
+    if (ctx.__hypenEngine) {
+      api.__hypenEngine = ctx.__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) {
+        log3.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
+      });
+    }
+    log3.error(`${context.actionName ? `Action "${context.actionName}"` : `Lifecycle "${context.lifecycle}"`} error:`, error);
+    return false;
+  }
+  async callCreatedHandler() {
+    if (this.definition.handlers.onCreated) {
+      const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
+      await this.definition.handlers.onCreated(this.state, context);
+    }
+  }
+  onStateChange(callback) {
+    this.stateChangeCallbacks.push(callback);
+  }
+  async destroy() {
+    if (this.isDestroyed)
+      return;
+    if (this.definition.handlers.onDestroyed) {
+      await this.definition.handlers.onDestroyed(this.state);
+    }
+    this.isDestroyed = true;
+  }
+  getState() {
+    return getStateSnapshot(this.state);
+  }
+  getLiveState() {
+    return this.state;
+  }
+  updateState(patch) {
+    Object.assign(this.state, patch);
+  }
+}
+var log3, app;
+var init_app = __esm(() => {
+  init_result();
+  init_state();
+  init_logger();
+  log3 = createLogger("ModuleInstance");
+  app = new HypenApp;
+});
+
+// src/engine.ts
+init_logger();
+import { WasmEngine } from "../wasm-node/hypen_engine.js";
+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;
+    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));
+    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/remote/server.ts
+init_app();
+
+// 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/remote/server.ts
+init_logger();
+var log4 = frameworkLoggers.remote;
+
+class RemoteServer {
+  _module = null;
+  _moduleName = "App";
+  _ui = "";
+  _config = {};
+  _sessionConfig = {};
+  _onConnectionCallbacks = [];
+  _onDisconnectionCallbacks = [];
+  clients = new Map;
+  nextClientId = 1;
+  server = null;
+  sessionManager = null;
+  module(name, module) {
+    this._moduleName = name;
+    this._module = module;
+    return this;
+  }
+  ui(dsl) {
+    this._ui = dsl;
+    return this;
+  }
+  config(config2) {
+    this._config = { ...this._config, ...config2 };
+    return this;
+  }
+  session(config2) {
+    this._sessionConfig = config2;
+    return this;
+  }
+  onConnection(callback) {
+    this._onConnectionCallbacks.push(callback);
+    return this;
+  }
+  onDisconnection(callback) {
+    this._onDisconnectionCallbacks.push(callback);
+    return this;
+  }
+  listen(port) {
+    if (!this._module) {
+      throw new Error("Module not set. Call .module() before .listen()");
+    }
+    if (!this._ui) {
+      throw new Error("UI not set. Call .ui() before .listen()");
+    }
+    this.sessionManager = new SessionManager(this._sessionConfig);
+    const finalPort = port ?? this._config.port ?? 3000;
+    const hostname = this._config.hostname ?? "0.0.0.0";
+    this.server = Bun.serve({
+      port: finalPort,
+      hostname,
+      websocket: {
+        open: (ws) => this.handleOpen(ws),
+        message: (ws, message) => this.handleMessage(ws, message),
+        close: (ws) => this.handleClose(ws)
+      },
+      fetch: (req, server) => {
+        const url = new URL(req.url);
+        if (server.upgrade(req, { data: undefined })) {
+          return;
+        }
+        if (url.pathname === "/health") {
+          return new Response("OK", { status: 200 });
+        }
+        if (url.pathname === "/stats") {
+          const stats = this.sessionManager?.getStats() ?? {
+            activeSessions: 0,
+            pendingSessions: 0,
+            totalConnections: 0
+          };
+          return new Response(JSON.stringify(stats), {
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        return new Response("Hypen Remote Server", { status: 200 });
+      }
+    });
+    log4.info(`Hypen app streaming on ws://${hostname}:${finalPort}`);
+    return this;
+  }
+  stop() {
+    if (this.server) {
+      this.server.stop();
+      this.server = null;
+    }
+    if (this.sessionManager) {
+      this.sessionManager.destroy();
+      this.sessionManager = null;
+    }
+  }
+  get url() {
+    if (!this.server)
+      return null;
+    const hostname = this._config.hostname ?? "localhost";
+    const port = this._config.port ?? 3000;
+    return `ws://${hostname}:${port}`;
+  }
+  async handleOpen(ws) {
+    try {
+      const clientId = `client_${this.nextClientId++}`;
+      const connectedAt = new Date;
+      const engine = new Engine;
+      await engine.init();
+      const moduleInstance = new HypenModuleInstance(engine, this._module);
+      const clientData = {
+        id: clientId,
+        engine,
+        moduleInstance,
+        revision: 0,
+        connectedAt,
+        sessionId: "",
+        helloReceived: false
+      };
+      this.clients.set(ws, clientData);
+      clientData.helloTimeout = setTimeout(() => {
+        if (!clientData.helloReceived) {
+          this.initializeSession(ws, clientData, undefined, undefined);
+        }
+      }, 1000);
+    } catch (error) {
+      log4.error("Error handling WebSocket open:", error);
+      ws.close(1011, "Internal server error");
+    }
+  }
+  async initializeSession(ws, clientData, requestedSessionId, props) {
+    if (clientData.helloReceived)
+      return;
+    clientData.helloReceived = true;
+    if (clientData.helloTimeout) {
+      clearTimeout(clientData.helloTimeout);
+      clientData.helloTimeout = undefined;
+    }
+    let session;
+    let isNew = true;
+    let isRestored = false;
+    let restoredState = null;
+    if (requestedSessionId && this.sessionManager) {
+      const resumed = this.sessionManager.resumeSession(requestedSessionId);
+      if (resumed) {
+        session = resumed.session;
+        restoredState = resumed.savedState;
+        isNew = false;
+        isRestored = true;
+        await this.triggerReconnect(clientData, session, restoredState);
+      } else {
+        const activeSession = this.sessionManager.getActiveSession(requestedSessionId);
+        if (activeSession) {
+          const handled = await this.handleConcurrentConnection(ws, clientData, activeSession, props);
+          if (!handled)
+            return;
+          session = activeSession;
+          isNew = false;
+        } else {
+          session = this.sessionManager.createSession(props);
+        }
+      }
+    } else if (this.sessionManager) {
+      session = this.sessionManager.createSession(props);
+    } else {
+      session = {
+        id: crypto.randomUUID(),
+        ttl: 3600,
+        createdAt: new Date,
+        lastConnectedAt: new Date,
+        props
+      };
+    }
+    clientData.sessionId = session.id;
+    this.sessionManager?.trackConnection(session.id, ws);
+    const sessionAck = {
+      type: "sessionAck",
+      sessionId: session.id,
+      isNew,
+      isRestored
+    };
+    ws.send(JSON.stringify(sessionAck));
+    this.setupRenderCallback(ws, clientData);
+    const initialPatches = [];
+    clientData.engine.setRenderCallback((patches) => {
+      initialPatches.push(...patches);
+    });
+    clientData.engine.renderSource(this._ui);
+    this.setupRenderCallback(ws, clientData);
+    const initialMessage = {
+      type: "initialTree",
+      module: this._moduleName,
+      state: clientData.moduleInstance.getState(),
+      patches: initialPatches,
+      revision: 0
+    };
+    ws.send(JSON.stringify(initialMessage));
+    const client = {
+      id: clientData.id,
+      socket: ws,
+      connectedAt: clientData.connectedAt
+    };
+    this._onConnectionCallbacks.forEach((cb) => cb(client));
+  }
+  setupRenderCallback(ws, clientData) {
+    clientData.engine.setRenderCallback((patches) => {
+      const data = this.clients.get(ws);
+      if (!data)
+        return;
+      data.revision++;
+      const message = {
+        type: "patch",
+        module: this._moduleName,
+        patches,
+        revision: data.revision
+      };
+      ws.send(JSON.stringify(message));
+      if (this.sessionManager?.getConcurrentPolicy() === "allow-multiple" && data.sessionId) {
+        const connections = this.sessionManager.getConnections(data.sessionId);
+        if (connections) {
+          for (const conn of connections) {
+            if (conn !== ws) {
+              conn.send(JSON.stringify(message));
+            }
+          }
+        }
+      }
+    });
+  }
+  async handleConcurrentConnection(ws, clientData, existingSession, props) {
+    const policy = this.sessionManager?.getConcurrentPolicy() ?? "kick-old";
+    switch (policy) {
+      case "kick-old": {
+        const existingConnections = this.sessionManager?.getConnections(existingSession.id);
+        if (existingConnections) {
+          for (const conn of existingConnections) {
+            const oldWs = conn;
+            const expiredMsg = {
+              type: "sessionExpired",
+              sessionId: existingSession.id,
+              reason: "kicked"
+            };
+            oldWs.send(JSON.stringify(expiredMsg));
+            oldWs.close(1000, "Session taken by new connection");
+          }
+        }
+        return true;
+      }
+      case "reject-new": {
+        const expiredMsg = {
+          type: "sessionExpired",
+          sessionId: existingSession.id,
+          reason: "kicked"
+        };
+        ws.send(JSON.stringify(expiredMsg));
+        ws.close(1000, "Session already active");
+        return false;
+      }
+      case "allow-multiple": {
+        return true;
+      }
+      default:
+        return true;
+    }
+  }
+  async triggerReconnect(clientData, session, savedState) {
+    const handler = this._module?.handlers.onReconnect;
+    if (!handler)
+      return;
+    let restored = false;
+    const restore = (state) => {
+      restored = true;
+      clientData.moduleInstance.updateState(state);
+    };
+    await handler({ session, restore });
+  }
+  handleMessage(ws, message) {
+    try {
+      const clientData = this.clients.get(ws);
+      if (!clientData)
+        return;
+      const msg = JSON.parse(message.toString());
+      switch (msg.type) {
+        case "hello": {
+          const helloMsg = msg;
+          this.initializeSession(ws, clientData, helloMsg.sessionId, helloMsg.props);
+          break;
+        }
+        case "dispatchAction": {
+          const actionMsg = msg;
+          clientData.engine.dispatchAction(actionMsg.action, actionMsg.payload);
+          break;
+        }
+        default:
+          break;
+      }
+    } catch (error) {
+      log4.error("Error handling WebSocket message:", error);
+    }
+  }
+  async handleClose(ws) {
+    const clientData = this.clients.get(ws);
+    if (!clientData)
+      return;
+    if (clientData.helloTimeout) {
+      clearTimeout(clientData.helloTimeout);
+    }
+    const currentState = clientData.moduleInstance.getState();
+    if (clientData.sessionId && this._module?.handlers.onDisconnect) {
+      const session = this.sessionManager?.getActiveSession(clientData.sessionId);
+      if (session) {
+        await this._module.handlers.onDisconnect({
+          state: currentState,
+          session
+        });
+      }
+    }
+    if (clientData.sessionId && this.sessionManager) {
+      this.sessionManager.untrackConnection(clientData.sessionId, ws);
+      if (this.sessionManager.getConnectionCount(clientData.sessionId) === 0) {
+        const session = this.sessionManager.getActiveSession(clientData.sessionId);
+        if (session) {
+          this.sessionManager.suspendSession(clientData.sessionId, currentState, async (expiredSession) => {
+            if (this._module?.handlers.onExpire) {
+              await this._module.handlers.onExpire({ session: expiredSession });
+            }
+          });
+        }
+      }
+    }
+    await clientData.moduleInstance.destroy();
+    this.clients.delete(ws);
+    const client = {
+      id: clientData.id,
+      socket: ws,
+      connectedAt: clientData.connectedAt
+    };
+    this._onDisconnectionCallbacks.forEach((cb) => cb(client));
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+  getSessionStats() {
+    return this.sessionManager?.getStats() ?? {
+      activeSessions: 0,
+      pendingSessions: 0,
+      totalConnections: 0
+    };
+  }
+  broadcast(message) {
+    const json = JSON.stringify(message);
+    this.clients.forEach((_, ws) => {
+      ws.send(json);
+    });
+  }
+}
+function serve(options) {
+  const server = new RemoteServer().module(options.moduleName ?? "App", options.module).ui(options.ui);
+  if (options.port || options.hostname) {
+    server.config({
+      port: options.port,
+      hostname: options.hostname
+    });
+  }
+  if (options.session) {
+    server.session(options.session);
+  }
+  if (options.onConnection) {
+    server.onConnection(options.onConnection);
+  }
+  if (options.onDisconnection) {
+    server.onDisconnection(options.onDisconnection);
+  }
+  return server.listen(options.port);
+}
+export {
+  serve,
+  RemoteServer
+};
+
+//# debugId=C7697DC74216A40C64756E2164756E21