@hypen-space/core 0.4.956 → 0.5.2

package/dist/remote/index.js

@@ -1,1139 +1,584 @@
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/result.ts
-function Ok(value) {
-  return { ok: true, value };
-}
-function Err(error) {
-  return { ok: false, error };
-}
-function isOk(result) {
-  return result.ok;
-}
-function isErr(result) {
-  return !result.ok;
-}
-async function fromPromise(promise, mapError) {
-  try {
-    const value = await promise;
-    return Ok(value);
-  } catch (e) {
-    if (mapError) {
-      return Err(mapError(e));
-    }
-    return Err(e);
-  }
-}
-function fromTry(fn, mapError) {
-  try {
-    return Ok(fn());
-  } catch (e) {
-    if (mapError) {
-      return Err(mapError(e));
-    }
-    return Err(e);
-  }
-}
-function map(result, fn) {
-  if (result.ok) {
-    return Ok(fn(result.value));
-  }
-  return result;
-}
-function mapErr(result, fn) {
-  if (!result.ok) {
-    return Err(fn(result.error));
-  }
-  return result;
-}
-function flatMap(result, fn) {
-  if (result.ok) {
-    return fn(result.value);
-  }
-  return result;
-}
-function unwrap(result) {
-  if (result.ok) {
-    return result.value;
-  }
-  throw result.error;
-}
-function unwrapOr(result, defaultValue) {
-  if (result.ok) {
-    return result.value;
-  }
-  return defaultValue;
-}
-function unwrapOrElse(result, fn) {
-  if (result.ok) {
-    return result.value;
-  }
-  return fn(result.error);
-}
-function match(result, handlers) {
-  if (result.ok) {
-    return handlers.ok(result.value);
-  }
-  return handlers.err(result.error);
-}
-function all(results) {
-  const values = [];
-  for (const result of results) {
-    if (!result.ok) {
-      return result;
-    }
-    values.push(result.value);
-  }
-  return Ok(values);
-}
-
-class HypenError extends Error {
-  code;
-  context;
-  cause;
-  constructor(code, message, options) {
-    super(message);
-    this.name = "HypenError";
-    this.code = code;
-    this.context = options?.context;
-    this.cause = options?.cause;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-}
-
-class ActionError extends HypenError {
-  actionName;
-  constructor(actionName, cause) {
-    super("ACTION_ERROR", `Action handler "${actionName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
-      context: { actionName },
-      cause: cause instanceof Error ? cause : undefined
-    });
-    this.name = "ActionError";
-    this.actionName = actionName;
-  }
-}
-
-class ConnectionError extends HypenError {
-  url;
-  attempt;
-  constructor(url, cause, attempt) {
-    super("CONNECTION_ERROR", `Connection to "${url}" failed${attempt ? ` (attempt ${attempt})` : ""}: ${cause instanceof Error ? cause.message : String(cause)}`, {
-      context: { url, attempt },
-      cause: cause instanceof Error ? cause : undefined
-    });
-    this.name = "ConnectionError";
-    this.url = url;
-    this.attempt = attempt;
-  }
-}
+import {
+  SessionManager
+} from "../chunk-gtwh1sg7.js";
+import {
+  HypenGlobalContext
+} from "../chunk-3zvyth50.js";
+import"../chunk-k12cwfst.js";
+import {
+  RemoteEngine
+} from "../chunk-g7g3jxty.js";
+import"../chunk-g2gz9pgg.js";
+import {
+  HypenRouter
+} from "../chunk-p3pj1bax.js";
+import"../chunk-ec0tgy9a.js";
+import {
+  ManagedRouter
+} from "../chunk-ne632swm.js";
+import {
+  HypenApp,
+  HypenModuleInstance
+} from "../chunk-fnss4dm2.js";
+import"../chunk-vshdk2pw.js";
+import"../chunk-7222131a.js";
+import"../chunk-ycxp4drd.js";
+import"../chunk-g830re2c.js";
+import {
+  frameworkLoggers
+} from "../chunk-avchpwhf.js";
+import"../chunk-5gtx3pza.js";
+// src/remote/remote-session.ts
+var log = frameworkLoggers.remote;
+var nextSessionCounter = 1;
 
-class StateError extends HypenError {
-  path;
-  constructor(message, path, cause) {
-    super("STATE_ERROR", message, {
-      context: { path },
-      cause: cause instanceof Error ? cause : undefined
+class RemoteSession {
+  id;
+  connectedAt;
+  host;
+  transport;
+  socketHandle;
+  engine;
+  _moduleInstance = null;
+  _sessionId = null;
+  _helloReceived = false;
+  _stateSubscribed = false;
+  _revision = 0;
+  _destroyed = false;
+  helloTimeout = null;
+  _autoManagedRouter = null;
+  autoRouterEnabled = true;
+  ready;
+  closed;
+  _resolveReady;
+  _resolveClosed;
+  constructor(host, transport, options = {}) {
+    this.host = host;
+    this.transport = transport;
+    this.id = options.clientId ?? `client_${nextSessionCounter++}`;
+    this.connectedAt = new Date;
+    this.socketHandle = options.socketHandle;
+    this.ready = new Promise((resolve) => {
+      this._resolveReady = resolve;
     });
-    this.name = "StateError";
-    this.path = path;
-  }
-}
-
-class ParseError extends HypenError {
-  source;
-  constructor(message, source, cause) {
-    super("PARSE_ERROR", message, {
-      context: { source },
-      cause: cause instanceof Error ? cause : undefined
+    this.closed = new Promise((resolve) => {
+      this._resolveClosed = resolve;
     });
-    this.name = "ParseError";
-    this.source = source;
-  }
-}
-
-class RenderError extends HypenError {
-  constructor(message, cause) {
-    super("RENDER_ERROR", message, {
-      cause: cause instanceof Error ? cause : undefined
-    });
-    this.name = "RenderError";
-  }
-}
-function classifyEngineError(err) {
-  if (err && typeof err === "object" && "message" in err && "type" in err) {
-    const structured = err;
-    switch (structured.type) {
-      case "parseError":
-        return new ParseError(structured.message);
-      case "stateError":
-        return new StateError(structured.message);
-      case "renderError":
-        return new RenderError(structured.message);
-      case "actionError":
-        return new HypenError("ACTION_ERROR", structured.message);
-      default:
-        return new HypenError("UNKNOWN_ERROR", structured.message);
+    this.engine = host.createEngine();
+    this.engine.init().catch((err) => log.error("Engine init failed:", err));
+    this.setupComponentResolver();
+    if (Object.keys(host.resources).length > 0) {
+      this.engine.registerResources(host.resources);
+    }
+    log.info(`Session ${this.id} created, engine initialized`);
+    const graceMs = options.helloGraceMs ?? 1000;
+    if (graceMs !== null) {
+      this.helloTimeout = setTimeout(() => {
+        if (!this._helloReceived) {
+          this.initializeSession(undefined, undefined).catch((err) => log.error("Error initializing legacy session:", err));
+        }
+      }, graceMs);
     }
   }
-  const message = err instanceof Error ? err.message : String(err);
-  if (message.startsWith("Parse error:")) {
-    return new ParseError(message);
+  get sessionId() {
+    return this._sessionId;
   }
-  if (message.startsWith("Invalid state:") || message.startsWith("Invalid state patch:")) {
-    return new StateError(message);
+  get moduleInstance() {
+    return this._moduleInstance;
   }
-  if (message.startsWith("Parent node not found:")) {
-    return new RenderError(message);
-  }
-  return new RenderError(message);
-}
-
-// src/logger.ts
-var LOG_LEVEL_ORDER = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  none: 4
-};
-var LOG_LEVEL_COLORS = {
-  debug: "\x1B[36m",
-  info: "\x1B[32m",
-  warn: "\x1B[33m",
-  error: "\x1B[31m"
-};
-var RESET_COLOR = "\x1B[0m";
-function isProduction() {
-  if (typeof process !== "undefined" && process.env) {
-    return false;
+  get helloReceived() {
+    return this._helloReceived;
   }
-  return false;
-}
-var config = {
-  level: isProduction() ? "error" : "info",
-  colors: true,
-  timestamps: false
-};
-function setLogLevel(level) {
-  config.level = level;
-}
-function getLogLevel() {
-  return config.level;
-}
-function configureLogger(options) {
-  config = { ...config, ...options };
-}
-function enableLogging() {
-  config.level = "debug";
-}
-function disableLogging() {
-  config.level = "none";
-}
-function setDebugMode(enabled) {
-  config.level = enabled ? "debug" : "error";
-}
-function isDebugMode() {
-  return config.level === "debug";
-}
-function shouldLog(level) {
-  return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[config.level];
-}
-function formatTag(tag, level) {
-  const timestamp = config.timestamps ? `${new Date().toISOString()} ` : "";
-  if (config.colors && level !== "none") {
-    const color = LOG_LEVEL_COLORS[level];
-    return `${timestamp}${color}[${tag}]${RESET_COLOR}`;
+  get stateSubscribed() {
+    return this._stateSubscribed;
   }
-  return `${timestamp}[${tag}]`;
-}
-
-class Logger {
-  tag;
-  constructor(tag) {
-    this.tag = tag;
+  get revision() {
+    return this._revision;
   }
-  debug(...args) {
-    if (!shouldLog("debug"))
-      return;
-    if (config.handler) {
-      config.handler.debug(this.tag, ...args);
-    } else {
-      console.log(formatTag(this.tag, "debug"), ...args);
-    }
+  get isDestroyed() {
+    return this._destroyed;
   }
-  info(...args) {
-    if (!shouldLog("info"))
-      return;
-    if (config.handler) {
-      config.handler.info(this.tag, ...args);
-    } else {
-      console.info(formatTag(this.tag, "info"), ...args);
-    }
+  toRemoteClient() {
+    return {
+      id: this.id,
+      socket: this.socketHandle,
+      connectedAt: this.connectedAt
+    };
   }
-  warn(...args) {
-    if (!shouldLog("warn"))
+  async receive(raw) {
+    if (this._destroyed)
       return;
-    if (config.handler) {
-      config.handler.warn(this.tag, ...args);
-    } else {
-      console.warn(formatTag(this.tag, "warn"), ...args);
-    }
-  }
-  error(...args) {
-    if (!shouldLog("error"))
+    let msg;
+    try {
+      if (typeof raw === "string" || raw instanceof Buffer) {
+        msg = JSON.parse(raw.toString());
+      } else {
+        msg = raw;
+      }
+    } catch (err) {
+      log.error(`Invalid message on session ${this.id}:`, err);
       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`);
+      switch (msg.type) {
+        case "hello": {
+          const hello = msg;
+          await this.initializeSession(hello.sessionId, hello.props);
+          break;
+        }
+        case "dispatchAction": {
+          const action = msg;
+          this.engine.dispatchAction(action.action, action.payload);
+          if (this.host.syncActions) {
+            for (const other of this.host.otherSessions(this)) {
+              if (!other._helloReceived)
+                continue;
+              other.engine.dispatchAction(action.action, action.payload);
+            }
+          }
+          break;
+        }
+        case "updateState": {
+          const stateMsg = msg;
+          this._moduleInstance?.updateState(stateMsg.state);
+          if (this.host.syncActions) {
+            for (const other of this.host.otherSessions(this)) {
+              if (!other._helloReceived || !other._moduleInstance)
+                continue;
+              other._moduleInstance.updateState(stateMsg.state);
+            }
+          }
+          break;
+        }
+        case "subscribeState": {
+          this._stateSubscribed = true;
+          log.info(`Session ${this.id} subscribed to state updates`);
+          break;
+        }
+        default:
+          break;
+      }
+    } catch (err) {
+      log.error(`Error handling message on session ${this.id}:`, err);
     }
   }
-  async timeAsync(label, fn) {
-    if (!shouldLog("debug")) {
-      return fn();
-    }
-    const start = performance.now();
+  send(message) {
+    if (this._destroyed)
+      return;
     try {
-      return await fn();
-    } finally {
-      const duration = performance.now() - start;
-      this.debug(`${label}: ${duration.toFixed(2)}ms`);
+      this.transport.send(message);
+    } catch (err) {
+      log.error(`Failed to send message on session ${this.id}:`, err);
     }
   }
-  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))
+  expireAndClose(reason) {
+    if (!this._sessionId) {
+      this.transport.close(1000, "Session closed");
       return;
-    this.loggedOnce.add(key);
-    this.debug(...args);
-  }
-}
-function createLogger(tag) {
-  return new Logger(tag);
-}
-var logger = createLogger("Hypen");
-var log = {
-  debug: (tag, ...args) => {
-    if (!shouldLog("debug"))
-      return;
-    console.log(formatTag(tag, "debug"), ...args);
-  },
-  info: (tag, ...args) => {
-    if (!shouldLog("info"))
-      return;
-    console.info(formatTag(tag, "info"), ...args);
-  },
-  warn: (tag, ...args) => {
-    if (!shouldLog("warn"))
-      return;
-    console.warn(formatTag(tag, "warn"), ...args);
-  },
-  error: (tag, ...args) => {
-    if (!shouldLog("error"))
-      return;
-    console.error(formatTag(tag, "error"), ...args);
-  }
-};
-var frameworkLoggers = {
-  hypen: createLogger("Hypen"),
-  engine: createLogger("Engine"),
-  router: createLogger("Router"),
-  state: createLogger("State"),
-  events: createLogger("Events"),
-  remote: createLogger("Remote"),
-  renderer: createLogger("Renderer"),
-  module: createLogger("Module"),
-  lifecycle: createLogger("Lifecycle"),
-  loader: createLogger("Loader"),
-  context: createLogger("Context"),
-  discovery: createLogger("Discovery"),
-  plugin: createLogger("Plugin"),
-  canvas: createLogger("Canvas"),
-  debug: createLogger("Debug")
-};
-
-// src/disposable.ts
-var log2 = frameworkLoggers.lifecycle;
-function isDisposable(obj) {
-  return obj !== null && typeof obj === "object" && "dispose" in obj && typeof obj.dispose === "function";
-}
-
-class DisposableStack {
-  stack = [];
-  disposed = false;
-  add(disposable) {
-    if (this.disposed) {
-      disposable.dispose();
-      return disposable;
     }
-    this.stack.push(disposable);
-    return disposable;
-  }
-  addCallback(callback) {
-    this.add({ dispose: callback });
-  }
-  addValue(value, dispose) {
-    this.add({ dispose: () => dispose(value) });
-    return value;
+    const expired = {
+      type: "sessionExpired",
+      sessionId: this._sessionId,
+      reason
+    };
+    this.send(expired);
+    this.transport.close(1000, "Session " + reason);
   }
-  dispose() {
-    if (this.disposed)
+  async destroy() {
+    if (this._destroyed)
       return;
-    this.disposed = true;
-    while (this.stack.length > 0) {
-      const item = this.stack.pop();
-      try {
-        item.dispose();
-      } catch (error) {
-        log2.error("Error during dispose:", error);
-      }
-    }
-  }
-  get isDisposed() {
-    return this.disposed;
-  }
-  get size() {
-    return this.stack.length;
-  }
-}
-function disposableListener(target, event, handler, options) {
-  target.addEventListener(event, handler, options);
-  return {
-    dispose: () => target.removeEventListener(event, handler, options)
-  };
-}
-function disposableTimeout(callback, ms) {
-  const id = setTimeout(callback, ms);
-  return {
-    id,
-    dispose: () => clearTimeout(id)
-  };
-}
-function disposableInterval(callback, ms) {
-  const id = setInterval(callback, ms);
-  return {
-    id,
-    dispose: () => clearInterval(id)
-  };
-}
-function disposableWebSocket(ws) {
-  return {
-    dispose: () => {
-      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
-        ws.close();
-      }
-    }
-  };
-}
-function disposableAbortController() {
-  const controller = new AbortController;
-  return {
-    controller,
-    signal: controller.signal,
-    dispose: () => controller.abort()
-  };
-}
-function disposableSubscription(unsubscribe) {
-  return { dispose: unsubscribe };
-}
-var ELEMENT_DISPOSABLES = Symbol("hypen.disposables");
-function getElementDisposables(element) {
-  const existing = element[ELEMENT_DISPOSABLES];
-  if (existing instanceof DisposableStack) {
-    return existing;
-  }
-  const stack = new DisposableStack;
-  element[ELEMENT_DISPOSABLES] = stack;
-  return stack;
-}
-function disposeElement(element) {
-  const stack = element[ELEMENT_DISPOSABLES];
-  if (stack instanceof DisposableStack) {
-    stack.dispose();
-    delete element[ELEMENT_DISPOSABLES];
-  }
-}
-function hasElementDisposables(element) {
-  return element[ELEMENT_DISPOSABLES] instanceof DisposableStack;
-}
-
-class DisposableMixin {
-  disposables = new DisposableStack;
-  track(disposable) {
-    return this.disposables.add(disposable);
-  }
-  onDispose(callback) {
-    this.disposables.addCallback(callback);
-  }
-  dispose() {
-    this.disposables.dispose();
-  }
-}
-function compositeDisposable(...disposables) {
-  return {
-    dispose: () => {
-      for (const d of disposables) {
+    this._destroyed = true;
+    if (this.helloTimeout) {
+      clearTimeout(this.helloTimeout);
+      this.helloTimeout = null;
+    }
+    const currentState = this._moduleInstance?.getState() ?? {};
+    if (this._sessionId && this.host.module.handlers.onDisconnect) {
+      const session = this.host.sessionManager.getActiveSession(this._sessionId);
+      if (session) {
         try {
-          d.dispose();
-        } catch (error) {
-          log2.error("Error during dispose:", error);
+          await this.host.module.handlers.onDisconnect({
+            state: currentState,
+            session
+          });
+        } catch (err) {
+          log.error(`onDisconnect threw on session ${this.id}:`, err);
         }
       }
     }
-  };
-}
-async function using(resource, fn) {
-  const r = typeof resource === "function" ? resource() : resource;
-  try {
-    return await fn(r);
-  } finally {
-    r.dispose();
-  }
-}
-function usingSync(resource, fn) {
-  const r = typeof resource === "function" ? resource() : resource;
-  try {
-    return fn(r);
-  } finally {
-    r.dispose();
-  }
-}
-
-// src/retry.ts
-var DEFAULT_OPTIONS = {
-  maxAttempts: 3,
-  delayMs: 1000,
-  backoff: "exponential",
-  maxDelayMs: 30000,
-  jitter: 0.1
-};
-function calculateDelay(attempt, options) {
-  let delay;
-  switch (options.backoff) {
-    case "exponential":
-      delay = options.delayMs * Math.pow(2, attempt - 1);
-      break;
-    case "linear":
-      delay = options.delayMs * attempt;
-      break;
-    case "none":
-      delay = options.delayMs;
-      break;
-  }
-  if (options.jitter > 0) {
-    const jitterRange = delay * options.jitter;
-    delay += (Math.random() * 2 - 1) * jitterRange;
-  }
-  return Math.min(delay, options.maxDelayMs);
-}
-function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(new Error("Retry aborted"));
-      return;
-    }
-    const timeoutId = setTimeout(resolve, ms);
-    signal?.addEventListener("abort", () => {
-      clearTimeout(timeoutId);
-      reject(new Error("Retry aborted"));
-    });
-  });
-}
-async function retry(fn, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  let lastError = new Error("No attempts made");
-  for (let attempt = 1;attempt <= opts.maxAttempts; attempt++) {
-    try {
-      if (opts.signal?.aborted) {
-        throw new Error("Retry aborted");
-      }
-      return await fn();
-    } catch (e) {
-      lastError = e instanceof Error ? e : new Error(String(e));
-      if (opts.shouldRetry && !opts.shouldRetry(lastError)) {
-        throw lastError;
-      }
-      if (attempt === opts.maxAttempts) {
-        break;
+    if (this._sessionId) {
+      this.host.sessionManager.untrackConnection(this._sessionId, this);
+      if (this.host.sessionManager.getConnectionCount(this._sessionId) === 0) {
+        const session = this.host.sessionManager.getActiveSession(this._sessionId);
+        if (session) {
+          this.host.sessionManager.suspendSession(this._sessionId, currentState, async (expiredSession) => {
+            if (this.host.module.handlers.onExpire) {
+              await this.host.module.handlers.onExpire({
+                session: expiredSession
+              });
+            }
+          });
+        }
       }
-      const delayMs = calculateDelay(attempt, opts);
-      opts.onRetry?.(attempt, lastError, delayMs);
-      await sleep(delayMs, opts.signal);
     }
-  }
-  throw lastError;
-}
-async function retryResult(fn, options = {}) {
-  try {
-    const value = await retry(fn, options);
-    return Ok(value);
-  } catch (e) {
-    return Err(e instanceof Error ? e : new Error(String(e)));
-  }
-}
-function withRetry(fn, options = {}) {
-  return (...args) => retry(() => fn(...args), options);
-}
-var RetryConditions = {
-  networkErrors: (error) => {
-    const message = error.message.toLowerCase();
-    return message.includes("network") || message.includes("fetch") || message.includes("timeout") || message.includes("econnrefused") || message.includes("econnreset") || message.includes("socket");
-  },
-  httpRetryable: (error) => {
-    const status = error.status;
-    if (!status)
-      return false;
-    return [408, 429, 500, 502, 503, 504].includes(status);
-  },
-  websocketErrors: (error) => {
-    const message = error.message.toLowerCase();
-    return message.includes("websocket") || message.includes("connection") || message.includes("close");
-  },
-  any: (...conditions) => (error) => conditions.some((c) => c(error)),
-  all: (...conditions) => (error) => conditions.every((c) => c(error))
-};
-var RetryPresets = {
-  aggressive: {
-    maxAttempts: 10,
-    delayMs: 500,
-    backoff: "exponential",
-    maxDelayMs: 60000,
-    jitter: 0.2
-  },
-  conservative: {
-    maxAttempts: 3,
-    delayMs: 2000,
-    backoff: "linear",
-    maxDelayMs: 1e4,
-    jitter: 0.1
-  },
-  fast: {
-    maxAttempts: 5,
-    delayMs: 100,
-    backoff: "exponential",
-    maxDelayMs: 2000,
-    jitter: 0
-  },
-  websocket: {
-    maxAttempts: 10,
-    delayMs: 1000,
-    backoff: "exponential",
-    maxDelayMs: 30000,
-    jitter: 0.1,
-    shouldRetry: RetryConditions.websocketErrors
-  }
-};
-
-// src/remote/client.ts
-var log3 = frameworkLoggers.remote;
-
-class RemoteEngine {
-  ws = null;
-  url;
-  state = "disconnected";
-  options;
-  reconnectAttempts = 0;
-  disposables = new DisposableStack;
-  reconnectDisposable = null;
-  currentSessionId = null;
-  sessionOptions;
-  patchCallbacks = [];
-  stateCallbacks = [];
-  connectionCallbacks = [];
-  disconnectionCallbacks = [];
-  errorCallbacks = [];
-  sessionEstablishedCallbacks = [];
-  sessionExpiredCallbacks = [];
-  currentState = null;
-  currentRevision = 0;
-  moduleName = "";
-  navigationDisposable = null;
-  lastViewValue = null;
-  handlingPopState = false;
-  constructor(url, options = {}) {
-    this.url = url;
-    const navOpt = options.navigation;
-    const navigation = navOpt ? {
-      backAction: (typeof navOpt === "object" ? navOpt.backAction : undefined) ?? "navigateBack",
-      viewStateKey: (typeof navOpt === "object" ? navOpt.viewStateKey : undefined) ?? "currentView"
-    } : undefined;
-    this.options = {
-      autoReconnect: options.autoReconnect ?? true,
-      reconnectInterval: options.reconnectInterval ?? 3000,
-      maxReconnectAttempts: options.maxReconnectAttempts ?? 10,
-      session: options.session,
-      navigation
-    };
-    this.sessionOptions = options.session;
-    if (options.session?.id) {
-      this.currentSessionId = options.session.id;
-    }
-  }
-  async connect() {
-    if (this.state === "connected" || this.state === "connecting") {
-      return Ok(undefined);
-    }
-    this.state = "connecting";
-    return new Promise((resolve) => {
+    if (this._autoManagedRouter) {
       try {
-        this.ws = new WebSocket(this.url);
-        this.disposables.add(disposableWebSocket(this.ws));
-        const messageHandler = (event) => {
-          this.handleMessage(event.data);
-        };
-        this.disposables.add(disposableListener(this.ws, "message", messageHandler));
-        const errorHandler = () => {
-          this.state = "error";
-          const error = new ConnectionError(this.url, new Error("WebSocket error"));
-          this.errorCallbacks.forEach((cb) => cb(error));
-          resolve(Err(error));
-        };
-        this.disposables.add(disposableListener(this.ws, "error", errorHandler));
-        const closeHandler = () => {
-          this.state = "disconnected";
-          this.disconnectionCallbacks.forEach((cb) => cb());
-          this.attemptReconnect();
-        };
-        this.disposables.add(disposableListener(this.ws, "close", closeHandler));
-        this.ws.onopen = () => {
-          this.state = "connected";
-          this.reconnectAttempts = 0;
-          if (this.reconnectDisposable) {
-            this.reconnectDisposable.dispose();
-            this.reconnectDisposable = null;
-          }
-          this.sendHello();
-          this.connectionCallbacks.forEach((cb) => cb());
-          resolve(Ok(undefined));
-        };
-      } catch (e) {
-        this.state = "error";
-        const error = new ConnectionError(this.url, e);
-        resolve(Err(error));
+        await this._autoManagedRouter.stop();
+      } catch (err) {
+        log.error(`Auto-router stop failed on ${this.id}:`, err);
       }
-    });
-  }
-  sendHello() {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
-      return;
-    const hello = {
-      type: "hello",
-      sessionId: this.currentSessionId ?? this.sessionOptions?.id,
-      props: this.sessionOptions?.props,
-      persistKey: this.sessionOptions?.persistKey
-    };
-    this.ws.send(JSON.stringify(hello));
-  }
-  disconnect() {
-    if (this.reconnectDisposable) {
-      this.reconnectDisposable.dispose();
-      this.reconnectDisposable = null;
+      this._autoManagedRouter = null;
     }
-    if (this.ws) {
-      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
-        this.ws.close();
+    if (this._moduleInstance) {
+      try {
+        await this._moduleInstance.destroy();
+      } catch (err) {
+        log.error(`ModuleInstance.destroy() failed on ${this.id}:`, err);
       }
-      this.ws = null;
     }
-    this.state = "disconnected";
+    this.host.onSessionDestroyed(this, this.toRemoteClient());
+    this._resolveReady();
+    this._resolveClosed();
   }
-  dispose() {
-    this.disconnect();
-    if (this.navigationDisposable) {
-      this.navigationDisposable.dispose();
-      this.navigationDisposable = null;
-    }
-    this.disposables.dispose();
-  }
-  setupNavigation() {
-    const nav = this.options.navigation;
-    if (!nav || typeof window === "undefined")
-      return;
-    if (this.navigationDisposable)
-      return;
-    this.navigationDisposable = disposableListener(window, "popstate", () => {
-      if (this.handlingPopState)
-        return;
-      log3.debug("Back navigation detected, dispatching:", nav.backAction);
-      this.handlingPopState = true;
-      this.dispatchAction(nav.backAction);
+  setupComponentResolver() {
+    this.engine.setComponentResolver((componentName, _contextPath) => {
+      const comp = this.host.discoveredComponents.get(componentName);
+      if (!comp)
+        return null;
+      return { source: comp.template, path: componentName };
     });
   }
-  trackViewChange(state) {
-    const nav = this.options.navigation;
-    if (!nav || typeof window === "undefined")
-      return;
-    const viewValue = this.resolveStateKey(state, nav.viewStateKey);
-    if (viewValue === undefined || viewValue === this.lastViewValue)
-      return;
-    if (this.handlingPopState) {
-      this.handlingPopState = false;
-      this.lastViewValue = viewValue;
-      return;
-    }
-    if (this.lastViewValue !== null) {
-      window.history.pushState({ view: viewValue }, "", "");
-    }
-    this.lastViewValue = viewValue;
-  }
-  resolveStateKey(state, key) {
-    if (!state || typeof state !== "object")
-      return;
-    const parts = key.split(".");
-    let current = state;
-    for (const part of parts) {
-      if (current == null || typeof current !== "object")
-        return;
-      current = current[part];
+  registerNestedModules() {
+    const primary = this.host.moduleName;
+    if (this.host.app) {
+      for (const [name, def] of this.host.app.components) {
+        if (name === primary)
+          continue;
+        const stateKeys = def.initialState !== null && typeof def.initialState === "object" ? Object.keys(def.initialState) : [];
+        const snapshot = def.initialState !== null && typeof def.initialState === "object" ? structuredClone(def.initialState) : {};
+        this.engine.registerModule(name, def.actions ?? [], stateKeys, snapshot);
+        log.info(`Registered nested module "${name}" (${def.actions?.length ?? 0} actions, ${stateKeys.length} state keys)`);
+      }
     }
-    return typeof current === "string" ? current : undefined;
-  }
-  dispatchAction(action, payload) {
-    if (this.state !== "connected" || !this.ws) {
-      log3.warn("Cannot dispatch action: not connected");
+    for (const [name, comp] of this.host.discoveredComponents) {
+      if (name === primary)
+        continue;
+      if (!comp.module)
+        continue;
+      if (this.host.app?.has(name))
+        continue;
+      const def = comp.module;
+      const hasState = def.initialState !== null && typeof def.initialState === "object" && Object.keys(def.initialState).length > 0;
+      const hasActions = (def.actions?.length ?? 0) > 0;
+      if (!hasState && !hasActions)
+        continue;
+      const stateKeys = def.initialState !== null && typeof def.initialState === "object" ? Object.keys(def.initialState) : [];
+      const snapshot = def.initialState !== null && typeof def.initialState === "object" ? JSON.parse(JSON.stringify(def.initialState)) : {};
+      this.engine.registerModule(name, def.actions ?? [], stateKeys, snapshot);
+      log.info(`Registered nested module "${name}" from discovery`);
+    }
+  }
+  async initializeSession(requestedSessionId, props) {
+    if (this._helloReceived || this._destroyed)
       return;
-    }
-    const message = {
-      type: "dispatchAction",
-      module: this.moduleName,
-      action,
-      payload
+    this._helloReceived = true;
+    log.info(`Initializing session for ${this.id} (sessionId: ${requestedSessionId ?? "new"})`);
+    if (this.helloTimeout) {
+      clearTimeout(this.helloTimeout);
+      this.helloTimeout = null;
+    }
+    let session;
+    let isNew = true;
+    let isRestored = false;
+    let restoredState = null;
+    const sm = this.host.sessionManager;
+    if (requestedSessionId) {
+      const resumed = sm.resumeSession(requestedSessionId);
+      if (resumed) {
+        session = resumed.session;
+        restoredState = resumed.savedState;
+        isNew = false;
+        isRestored = true;
+      } else {
+        const activeSession = sm.getActiveSession(requestedSessionId);
+        if (activeSession) {
+          const allowed = this.resolveConcurrentConnection(activeSession, props);
+          if (!allowed)
+            return;
+          session = activeSession;
+          isNew = false;
+        } else {
+          session = sm.createSession(props);
+        }
+      }
+    } else {
+      session = sm.createSession(props);
+    }
+    this._sessionId = session.id;
+    sm.trackConnection(session.id, this);
+    const sessionAck = {
+      type: "sessionAck",
+      sessionId: session.id,
+      isNew,
+      isRestored
     };
-    this.ws.send(JSON.stringify(message));
-  }
-  subscribeState() {
-    if (this.state !== "connected" || !this.ws) {
-      log3.warn("Cannot subscribe to state: not connected");
-      return;
-    }
-    const message = { type: "subscribeState" };
-    this.ws.send(JSON.stringify(message));
-  }
-  updateState(state) {
-    if (this.state !== "connected" || !this.ws) {
-      log3.warn("Cannot update state: not connected");
+    this.send(sessionAck);
+    log.info(`Sent sessionAck to ${this.id} (session: ${session.id})`);
+    if (!this._moduleInstance) {
+      this._moduleInstance = new HypenModuleInstance(this.engine, this.host.module);
+    }
+    if (isRestored) {
+      await this.triggerReconnect(session, restoredState);
+    }
+    await this._moduleInstance.waitForReady();
+    this.registerNestedModules();
+    await new Promise((resolve) => queueMicrotask(resolve));
+    const initialPatches = [];
+    this.engine.setRenderCallback((patches) => {
+      initialPatches.push(...patches);
+    });
+    try {
+      this.engine.renderSource(this.host.ui);
+    } catch (err) {
+      log.error(`Failed to render UI for ${this.id}:`, err);
+      this.transport.close(1011, "Render failed");
       return;
     }
-    const message = {
-      type: "updateState",
-      module: this.moduleName,
-      state
+    this.setupStreamingRenderCallback();
+    const initialMessage = {
+      type: "initialTree",
+      module: this.host.moduleName,
+      state: this._moduleInstance.getState(),
+      patches: initialPatches,
+      revision: 0
     };
-    this.ws.send(JSON.stringify(message));
-  }
-  onPatches(callback) {
-    this.patchCallbacks.push(callback);
-    return this;
-  }
-  onStateUpdate(callback) {
-    this.stateCallbacks.push(callback);
-    return this;
-  }
-  onConnect(callback) {
-    this.connectionCallbacks.push(callback);
-    return this;
-  }
-  onDisconnect(callback) {
-    this.disconnectionCallbacks.push(callback);
-    return this;
-  }
-  onError(callback) {
-    this.errorCallbacks.push(callback);
-    return this;
-  }
-  onSessionEstablished(callback) {
-    this.sessionEstablishedCallbacks.push(callback);
-    return this;
-  }
-  onSessionExpired(callback) {
-    this.sessionExpiredCallbacks.push(callback);
-    return this;
-  }
-  getConnectionState() {
-    return this.state;
-  }
-  getCurrentState() {
-    return this.currentState;
-  }
-  getRevision() {
-    return this.currentRevision;
-  }
-  getSessionId() {
-    return this.currentSessionId;
-  }
-  handleMessage(data) {
-    try {
-      const message = JSON.parse(data);
-      switch (message.type) {
-        case "sessionAck":
-          this.handleSessionAck(message);
-          break;
-        case "sessionExpired":
-          this.handleSessionExpired(message);
-          break;
-        case "initialTree":
-          this.handleInitialTree(message);
-          break;
-        case "patch":
-          this.handlePatch(message);
-          break;
-        case "stateUpdate":
-          this.currentState = message.state;
-          this.trackViewChange(this.currentState);
-          this.stateCallbacks.forEach((cb) => cb(this.currentState));
-          break;
+    this.send(initialMessage);
+    log.info(`Sent initialTree to ${this.id} (${initialPatches.length} patches)`);
+    this.host.onSessionReady(this, this.toRemoteClient());
+    this._resolveReady();
+    if (this.autoRouterEnabled) {
+      this.autoWireManagedRouter();
+    }
+  }
+  autoWireManagedRouter() {
+    const app = this.host.app ?? new HypenApp;
+    const discovered = [];
+    const runDiscover = (source, label) => {
+      try {
+        const blocks = this.engine.discoverRouters(source);
+        for (const b of blocks)
+          discovered.push(b);
+      } catch (err) {
+        log.error(`Auto-router: discoverRouters failed on ${label}:`, err);
       }
-    } catch (e) {
-      log3.error("Error handling remote message:", e);
-      const error = e instanceof Error ? e : new Error(String(e));
-      this.errorCallbacks.forEach((cb) => cb(error));
-    }
-  }
-  handleSessionAck(message) {
-    this.currentSessionId = message.sessionId;
-    const info = {
-      sessionId: message.sessionId,
-      isNew: message.isNew,
-      isRestored: message.isRestored
     };
-    this.sessionEstablishedCallbacks.forEach((cb) => cb(info));
-  }
-  handleSessionExpired(message) {
-    this.currentSessionId = null;
-    this.sessionExpiredCallbacks.forEach((cb) => cb(message.reason));
-  }
-  handleInitialTree(message) {
-    this.moduleName = message.module;
-    this.currentState = message.state;
-    this.currentRevision = message.revision;
-    if (message.patches.length > 0) {
-      this.patchCallbacks.forEach((cb) => cb(message.patches));
+    runDiscover(this.host.ui, this.id);
+    for (const [name, comp] of this.host.discoveredComponents) {
+      if (comp.template)
+        runDiscover(comp.template, `${this.id} / ${name}`);
     }
-    this.trackViewChange(message.state);
-    this.setupNavigation();
-    if (this.options.navigation) {
-      this.subscribeState();
-    }
-    this.stateCallbacks.forEach((cb) => cb(message.state));
-  }
-  handlePatch(message) {
-    if (message.revision <= this.currentRevision) {
-      log3.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
+    if (discovered.length === 0)
       return;
+    const primaryScope = this.host.moduleName.toLowerCase();
+    const router = new HypenRouter;
+    const globalContext = new HypenGlobalContext;
+    const managed = new ManagedRouter(router, this.engine, app, globalContext);
+    const primary = this._moduleInstance;
+    if (primary) {
+      globalContext.registerModule(primaryScope, primary);
+    }
+    let added = 0;
+    const seenPaths = new Set;
+    for (const block of discovered) {
+      for (const route of block.routes) {
+        if (seenPaths.has(route.path)) {
+          log.debug(`Auto-router: path "${route.path}" already registered; ignoring nested duplicate`);
+          continue;
+        }
+        const component = this.pickComponent(route.elementNames);
+        if (!component) {
+          log.debug(`Auto-router: no registered module matched route "${route.path}" — skipping`);
+          continue;
+        }
+        managed.addRoute({ path: route.path, component });
+        seenPaths.add(route.path);
+        added += 1;
+      }
     }
-    this.currentRevision = message.revision;
-    if (message.patches.length > 0) {
-      this.patchCallbacks.forEach((cb) => cb(message.patches));
-    }
-  }
-  attemptReconnect() {
-    if (!this.options.autoReconnect) {
+    const locationKey = this.primaryHasLocationKey() ? "location" : null;
+    if (added === 0 && !locationKey) {
+      log.debug(`Auto-router: nothing to mount for ${this.id}`);
       return;
     }
-    this.reconnectDisposable = disposableTimeout(() => {
-      this.reconnectDisposable = null;
-      retry(async () => {
-        const result = await this.connect();
-        if (!result.ok) {
-          throw result.error;
-        }
-      }, {
-        maxAttempts: this.options.maxReconnectAttempts,
-        delayMs: this.options.reconnectInterval,
-        backoff: "exponential",
-        maxDelayMs: 30000,
-        jitter: 0.1,
-        onRetry: (attempt, error) => {
-          log3.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
-        }
-      }).catch((error) => {
-        log3.error("Max reconnection attempts reached:", error.message);
-        this.errorCallbacks.forEach((cb) => cb(new ConnectionError(this.url, error, this.options.maxReconnectAttempts)));
+    if (locationKey) {
+      router.onNavigate((rs) => {
+        const path = rs.currentPath;
+        queueMicrotask(() => {
+          try {
+            this._moduleInstance?.updateState({ [locationKey]: path });
+          } catch (err) {
+            log.error(`Auto-router: state.${locationKey} sync failed:`, err);
+          }
+        });
       });
-    }, this.options.reconnectInterval);
-  }
-}
-
-// src/remote/session.ts
-class SessionManager {
-  activeSessions = new Map;
-  pendingSessions = new Map;
-  sessionConnections = new Map;
-  config;
-  constructor(config2 = {}) {
-    this.config = {
-      ttl: config2.ttl ?? 3600,
-      concurrent: config2.concurrent ?? "kick-old",
-      generateId: config2.generateId ?? (() => crypto.randomUUID())
-    };
-  }
-  getTtl() {
-    return this.config.ttl;
-  }
-  getConcurrentPolicy() {
-    return this.config.concurrent;
+    }
+    managed.start();
+    router.push(router.getCurrentPath());
+    this._autoManagedRouter = managed;
   }
-  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;
+  pickComponent(elementNames) {
+    const app = this.host.app;
+    if (!app)
+      return null;
+    for (const name of elementNames) {
+      if (app.has(name))
+        return name;
+    }
+    return null;
   }
-  getActiveSession(id) {
-    return this.activeSessions.get(id) ?? null;
+  primaryHasLocationKey() {
+    const state = this._moduleInstance?.getState();
+    return state !== null && state !== undefined && typeof state === "object" && "location" in state;
   }
-  getPendingSession(id) {
-    return this.pendingSessions.get(id) ?? null;
+  setupStreamingRenderCallback() {
+    this.engine.setRenderCallback((patches) => {
+      if (this._destroyed)
+        return;
+      this._revision++;
+      log.info(`Streaming ${patches.length} patches to ${this.id} (rev ${this._revision})`);
+      const patchMessage = {
+        type: "patch",
+        module: this.host.moduleName,
+        patches,
+        revision: this._revision
+      };
+      this.send(patchMessage);
+      if (this._stateSubscribed && this._moduleInstance) {
+        const stateMessage = {
+          type: "stateUpdate",
+          module: this.host.moduleName,
+          state: this._moduleInstance.getState(),
+          revision: this._revision
+        };
+        this.send(stateMessage);
+      }
+      if (this._sessionId && this.host.sessionManager.getConcurrentPolicy() === "allow-multiple") {
+        for (const peer of this.host.sessionsForId(this._sessionId)) {
+          if (peer === this)
+            continue;
+          peer.send(patchMessage);
+          if (peer._stateSubscribed && this._moduleInstance) {
+            const stateMessage = {
+              type: "stateUpdate",
+              module: this.host.moduleName,
+              state: this._moduleInstance.getState(),
+              revision: this._revision
+            };
+            peer.send(stateMessage);
+          }
+        }
+      }
+    });
   }
-  hasSession(id) {
-    return this.activeSessions.has(id) || this.pendingSessions.has(id);
+  resolveConcurrentConnection(existingSession, _props) {
+    const policy = this.host.sessionManager.getConcurrentPolicy();
+    switch (policy) {
+      case "kick-old": {
+        for (const peer of this.host.sessionsForId(existingSession.id)) {
+          if (peer === this)
+            continue;
+          peer.expireAndClose("kicked");
+        }
+        return true;
+      }
+      case "reject-new": {
+        this.expireAndClose("kicked");
+        return false;
+      }
+      case "allow-multiple":
+      default:
+        return true;
+    }
   }
-  suspendSession(sessionId, savedState, onExpire) {
-    const session = this.activeSessions.get(sessionId);
-    if (!session)
+  async triggerReconnect(session, savedState) {
+    const handler = this.host.module.handlers.onReconnect;
+    if (!handler)
       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);
+    const restore = (state) => {
+      if (state === null || typeof state !== "object") {
+        log.warn("restore() called with non-object state, ignoring:", typeof state);
+        return;
       }
-    }, 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
+      this._moduleInstance?.updateState(state);
     };
+    await handler({ session, restore });
   }
-  destroySession(sessionId) {
-    this.activeSessions.delete(sessionId);
-    const pending = this.pendingSessions.get(sessionId);
-    if (pending) {
-      clearTimeout(pending.expiryTimer);
-      this.pendingSessions.delete(sessionId);
+}
+function createBunWebSocketTransport(ws) {
+  return {
+    send(message) {
+      ws.send(JSON.stringify(message));
+    },
+    close(code, reason) {
+      ws.close(code, reason);
     }
-    this.sessionConnections.delete(sessionId);
-  }
-  trackConnection(sessionId, ws) {
-    let connections = this.sessionConnections.get(sessionId);
-    if (!connections) {
-      connections = new Set;
-      this.sessionConnections.set(sessionId, connections);
+  };
+}
+
+class AsyncQueueTransport {
+  queue = [];
+  waiters = [];
+  closed = false;
+  send(message) {
+    if (this.closed)
+      return;
+    const w = this.waiters.shift();
+    if (w) {
+      w({ value: message, done: false });
+    } else {
+      this.queue.push(message);
     }
-    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);
+  close(_code, _reason) {
+    if (this.closed)
+      return;
+    this.closed = true;
+    while (this.waiters.length) {
+      const w = this.waiters.shift();
+      w({ value: undefined, done: true });
+    }
+  }
+  stream() {
+    const self = this;
+    const iter = {
+      [Symbol.asyncIterator]() {
+        return iter;
+      },
+      async next() {
+        if (self.queue.length) {
+          return { value: self.queue.shift(), done: false };
+        }
+        if (self.closed) {
+          return { value: undefined, done: true };
+        }
+        return new Promise((resolve) => {
+          self.waiters.push(resolve);
+        });
+      },
+      async return() {
+        self.close();
+        return { value: undefined, done: true };
       }
-    }
-  }
-  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();
+    return iter;
   }
 }
 export {
+  createBunWebSocketTransport,
   SessionManager,
-  RemoteEngine
+  RemoteSession,
+  RemoteEngine,
+  AsyncQueueTransport
 };
 
-//# debugId=88C744E190AA51D464756E2164756E21
+//# debugId=EC47228D45CD496064756E2164756E21