@hypen-space/core 0.4.14 → 0.4.16

package/dist/remote/index.js

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -25,7 +24,13 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+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/state.ts
 function deepClone(obj) {
@@ -428,7 +433,7 @@ var init_logger = __esm(() => {
     error: "\x1B[31m"
   };
   config = {
-    level: isProduction() ? "error" : "debug",
+    level: isProduction() ? "error" : "info",
     colors: true,
     timestamps: false
   };
@@ -481,85 +486,6 @@ function Ok(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);
-}
 function classifyEngineError(err) {
   const message = err instanceof Error ? err.message : String(err);
   if (message.startsWith("Parse error:")) {
@@ -944,6 +870,346 @@ var init_app = __esm(() => {
   app = new HypenApp;
 });
 
+// node:path
+var exports_path = {};
+__export(exports_path, {
+  sep: () => sep,
+  resolve: () => resolve,
+  relative: () => relative,
+  posix: () => posix,
+  parse: () => parse,
+  normalize: () => normalize,
+  join: () => join,
+  isAbsolute: () => isAbsolute,
+  format: () => format,
+  extname: () => extname,
+  dirname: () => dirname,
+  delimiter: () => delimiter,
+  default: () => path_default,
+  basename: () => basename,
+  _makeLong: () => _makeLong
+});
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw new TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/", delimiter = ":", posix, path_default;
+var init_path = __esm(() => {
+  posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+  path_default = posix;
+});
+
 // src/disposable.ts
 init_logger();
 var log3 = frameworkLoggers.lifecycle;
@@ -1160,17 +1426,6 @@ async function retry(fn, options = {}) {
   }
   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();
@@ -1591,10 +1846,140 @@ class Engine {
   }
 }
 
+// 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();
+
 // src/discovery.ts
+init_path();
 init_logger();
-import { existsSync, readdirSync, readFileSync, watch } from "fs";
-import { join, basename, resolve, relative } from "path";
+var {existsSync, readdirSync, readFileSync, watch} = (() => ({}));
 async function discoverComponents(baseDir, options = {}) {
   const {
     patterns = ["single-file", "folder", "sibling", "index"],
@@ -1763,254 +2148,8 @@ async function loadDiscoveredComponents(components) {
   }
   return loaded;
 }
-function watchComponents(baseDir, options = {}) {
-  const resolvedDir = resolve(baseDir);
-  const {
-    onChange,
-    onAdd,
-    onRemove,
-    onUpdate,
-    debug = false,
-    ...discoveryOptions
-  } = options;
-  const log6 = debug ? (...args) => frameworkLoggers.discovery.debug("[watch]", ...args) : () => {};
-  let currentComponents = new Map;
-  let debounceTimer = null;
-  const initialScan = async () => {
-    const components = await discoverComponents(resolvedDir, discoveryOptions);
-    currentComponents = new Map(components.map((c) => [c.name, c]));
-    onChange?.(components);
-  };
-  const rescan = async () => {
-    if (debounceTimer) {
-      clearTimeout(debounceTimer);
-    }
-    debounceTimer = setTimeout(async () => {
-      log6("Rescanning...");
-      const newComponents = await discoverComponents(resolvedDir, discoveryOptions);
-      const newMap = new Map(newComponents.map((c) => [c.name, c]));
-      for (const [name, component] of newMap) {
-        const existing = currentComponents.get(name);
-        if (!existing) {
-          log6("Added:", name);
-          onAdd?.(component);
-        } else if (existing.template !== component.template || existing.modulePath !== component.modulePath) {
-          log6("Updated:", name);
-          onUpdate?.(component);
-        }
-      }
-      for (const name of currentComponents.keys()) {
-        if (!newMap.has(name)) {
-          log6("Removed:", name);
-          onRemove?.(name);
-        }
-      }
-      currentComponents = newMap;
-      onChange?.(newComponents);
-    }, 100);
-  };
-  const watcher = watch(resolvedDir, { recursive: true }, (event, filename) => {
-    if (!filename)
-      return;
-    if (filename.endsWith(".hypen") || filename.endsWith(".ts")) {
-      log6("File changed:", filename);
-      rescan();
-    }
-  });
-  initialScan();
-  return {
-    stop: () => {
-      watcher.close();
-      if (debounceTimer) {
-        clearTimeout(debounceTimer);
-      }
-    }
-  };
-}
-async function generateComponentsCode(baseDir, options = {}) {
-  const components = await discoverComponents(baseDir, options);
-  const resolvedDir = resolve(baseDir);
-  const outputBase = options.outputDir ? resolve(options.outputDir) : resolvedDir;
-  let code = `/**
- * Auto-generated component imports
- * Generated by @hypen-space/core discovery
- */
-
-`;
-  for (const component of components) {
-    let importPath = null;
-    if (component.modulePath) {
-      const rel = relative(outputBase, component.modulePath).replace(/\.ts$/, ".js");
-      importPath = rel.startsWith(".") ? rel : "./" + rel;
-    }
-    if (importPath) {
-      code += `import ${component.name}Module from "${importPath}";
-`;
-    }
-  }
-  code += `
-import { app } from "@hypen-space/core";
-
-`;
-  for (const component of components) {
-    if (component.isSingleFile) {
-      code += `export const ${component.name} = {
-  module: ${component.name}Module,
-  template: ${component.name}Module.template,
-};
-
-`;
-    } else if (component.hasModule) {
-      const templateJson = JSON.stringify(component.template);
-      code += `export const ${component.name} = {
-  module: ${component.name}Module,
-  template: ${templateJson},
-};
-
-`;
-    } else {
-      const templateJson = JSON.stringify(component.template);
-      code += `const ${component.name}Module = app.defineState({}).build();
-export const ${component.name} = {
-  module: ${component.name}Module,
-  template: ${templateJson},
-};
-
-`;
-    }
-  }
-  return code;
-}
 
 // 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 log6 = frameworkLoggers.remote;
 
 class RemoteServer {
@@ -2433,4 +2572,4 @@ export {
   RemoteEngine
 };
 
-//# debugId=6490411AAAF0974364756E2164756E21
+//# debugId=914D90741C165F9464756E2164756E21