@hypen-space/core 0.4.13 → 0.4.15

package/dist/index.js

@@ -27,6 +27,176 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// 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);
+}
+function classifyEngineError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (message.startsWith("Parse error:")) {
+    return new ParseError(message);
+  }
+  if (message.startsWith("Invalid state:") || message.startsWith("Invalid state patch:")) {
+    return new StateError(message);
+  }
+  if (message.startsWith("Parent node not found:")) {
+    return new RenderError(message);
+  }
+  return new RenderError(message);
+}
+var HypenError, ActionError, ConnectionError, StateError, ParseError, RenderError;
+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;
+    }
+  };
+  ParseError = class ParseError extends HypenError {
+    source;
+    constructor(message, source, cause) {
+      super("PARSE_ERROR", message, {
+        context: { source },
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "ParseError";
+      this.source = source;
+    }
+  };
+  RenderError = class RenderError extends HypenError {
+    constructor(message, cause) {
+      super("RENDER_ERROR", message, {
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "RenderError";
+    }
+  };
+});
+
 // src/state.ts
 function deepClone(obj) {
   if (obj === null || typeof obj !== "object") {
@@ -474,217 +644,47 @@ var init_logger = __esm(() => {
   };
 });
 
-// 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);
+// 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;
+  _registry;
+  constructor(initialState, options, registry) {
+    this.initialState = initialState;
+    this.options = options || {};
+    this._registry = registry;
   }
-}
-function fromTry(fn, mapError) {
-  try {
-    return Ok(fn());
-  } catch (e) {
-    if (mapError) {
-      return Err(mapError(e));
-    }
-    return Err(e);
+  onCreated(fn) {
+    this.createdHandler = fn;
+    return this;
   }
-}
-function map(result, fn) {
-  if (result.ok) {
-    return Ok(fn(result.value));
+  onAction(name, fn) {
+    this.actionHandlers.set(name, fn);
+    return this;
   }
-  return result;
-}
-function mapErr(result, fn) {
-  if (!result.ok) {
-    return Err(fn(result.error));
+  onDestroyed(fn) {
+    this.destroyedHandler = fn;
+    return this;
   }
-  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:")) {
-    return new ParseError(message);
-  }
-  if (message.startsWith("Invalid state:") || message.startsWith("Invalid state patch:")) {
-    return new StateError(message);
-  }
-  if (message.startsWith("Parent node not found:")) {
-    return new RenderError(message);
-  }
-  return new RenderError(message);
-}
-var HypenError, ActionError, ConnectionError, StateError, ParseError, RenderError;
-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;
-    }
-  };
-  ParseError = class ParseError extends HypenError {
-    source;
-    constructor(message, source, cause) {
-      super("PARSE_ERROR", message, {
-        context: { source },
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "ParseError";
-      this.source = source;
-    }
-  };
-  RenderError = class RenderError extends HypenError {
-    constructor(message, cause) {
-      super("RENDER_ERROR", message, {
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "RenderError";
-    }
-  };
-});
-
-// 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;
-  _registry;
-  constructor(initialState, options, registry) {
-    this.initialState = initialState;
-    this.options = options || {};
-    this._registry = registry;
-  }
-  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;
+  onDisconnect(fn) {
+    this.disconnectHandler = fn;
+    return this;
   }
   onReconnect(fn) {
     this.reconnectHandler = fn;
@@ -944,6 +944,60 @@ var init_app = __esm(() => {
   app = new HypenApp;
 });
 
+// src/index.ts
+init_app();
+
+// src/hypen.ts
+function createBindingProxy(root) {
+  const handler = {
+    get(_, prop) {
+      if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
+        return () => `\${${root}}`;
+      }
+      if (typeof prop === "symbol") {
+        return;
+      }
+      if (prop === "toJSON") {
+        return () => `\${${root}}`;
+      }
+      return createBindingProxy(`${root}.${prop}`);
+    },
+    has() {
+      return true;
+    },
+    ownKeys() {
+      return [];
+    },
+    getOwnPropertyDescriptor() {
+      return {
+        configurable: true,
+        enumerable: true
+      };
+    }
+  };
+  return new Proxy({}, handler);
+}
+var state = createBindingProxy("state");
+var item = createBindingProxy("item");
+var index = {
+  [Symbol.toPrimitive]: () => "${index}",
+  toString: () => "${index}",
+  valueOf: () => "${index}",
+  toJSON: () => "${index}"
+};
+function hypen(strings, ...expressions) {
+  let result = strings[0];
+  for (let i = 0;i < expressions.length; i++) {
+    const expr = expressions[i];
+    result += String(expr);
+    result += strings[i + 1];
+  }
+  return result.trim();
+}
+
+// src/index.ts
+init_state();
+
 // src/renderer.ts
 init_logger();
 var log3 = frameworkLoggers.renderer;
@@ -995,7 +1049,6 @@ class ConsoleRenderer {
     console.groupEnd();
   }
 }
-
 // src/router.ts
 init_state();
 init_logger();
@@ -1195,7 +1248,6 @@ class HypenRouter {
     return `${path}?${queryString}`;
   }
 }
-
 // src/events.ts
 init_logger();
 var log5 = frameworkLoggers.events;
@@ -1261,7 +1313,6 @@ class TypedEventEmitter {
 function createEventEmitter() {
   return new TypedEventEmitter;
 }
-
 // src/context.ts
 init_logger();
 var log6 = frameworkLoggers.context;
@@ -1305,11 +1356,11 @@ class HypenGlobalContext {
     return Array.from(this.modules.keys());
   }
   getGlobalState() {
-    const state = {};
+    const state2 = {};
     this.modules.forEach((module, id) => {
-      state[id] = module.getState();
+      state2[id] = module.getState();
     });
-    return state;
+    return state2;
   }
   emit(event, payload) {
     const handlers = this.legacyEventBus.get(event);
@@ -1367,6 +1418,8 @@ class HypenGlobalContext {
     };
   }
 }
+// src/remote/client.ts
+init_result();
 
 // src/disposable.ts
 init_logger();
@@ -1398,9 +1451,9 @@ class DisposableStack {
       return;
     this.disposed = true;
     while (this.stack.length > 0) {
-      const item = this.stack.pop();
+      const item2 = this.stack.pop();
       try {
-        item.dispose();
+        item2.dispose();
       } catch (error) {
         log7.error("Error during dispose:", error);
       }
@@ -1516,9 +1569,6 @@ function usingSync(resource, fn) {
   }
 }
 
-// src/remote/client.ts
-init_result();
-
 // src/retry.ts
 init_result();
 var DEFAULT_OPTIONS = {
@@ -1892,33 +1942,155 @@ class RemoteEngine {
     }, this.options.reconnectInterval);
   }
 }
-
-// src/resolver.ts
-class ComponentResolver {
-  cache = new Map;
-  options;
-  moduleRegistry;
-  constructor(options = {}) {
-    this.options = {
-      baseDir: options.baseDir || process.cwd(),
-      cache: options.cache ?? true,
-      customFetch: options.customFetch || this.defaultFetch.bind(this),
-      moduleRegistry: options.moduleRegistry
+// 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())
     };
-    this.moduleRegistry = options.moduleRegistry;
   }
-  async resolve(importStmt) {
-    if (this.moduleRegistry) {
-      const names = importStmt.clause.type === "named" ? importStmt.clause.names : [importStmt.clause.name];
-      const allFound = names.every((name) => this.moduleRegistry.has(name));
-      if (allFound) {
-        const result = {};
-        for (const name of names) {
-          const def = this.moduleRegistry.get(name);
-          result[name] = {
-            module: def,
-            template: def?.template || ""
-          };
+  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/resolver.ts
+class ComponentResolver {
+  cache = new Map;
+  options;
+  moduleRegistry;
+  constructor(options = {}) {
+    this.options = {
+      baseDir: options.baseDir || process.cwd(),
+      cache: options.cache ?? true,
+      customFetch: options.customFetch || this.defaultFetch.bind(this),
+      moduleRegistry: options.moduleRegistry
+    };
+    this.moduleRegistry = options.moduleRegistry;
+  }
+  async resolve(importStmt) {
+    if (this.moduleRegistry) {
+      const names = importStmt.clause.type === "named" ? importStmt.clause.names : [importStmt.clause.name];
+      const allFound = names.every((name) => this.moduleRegistry.has(name));
+      if (allFound) {
+        const result = {};
+        for (const name of names) {
+          const def = this.moduleRegistry.get(name);
+          result[name] = {
+            module: def,
+            template: def?.template || ""
+          };
         }
         return result;
       }
@@ -2013,7 +2185,6 @@ class ComponentResolver {
     return imports;
   }
 }
-
 // src/components/builtin.ts
 init_app();
 init_logger();
@@ -2022,7 +2193,7 @@ var Router = app.defineState({
   currentPath: "/",
   matchedRoute: null,
   routeParams: {}
-}, { name: "__Router" }).onCreated((state, context) => {
+}, { name: "__Router" }).onCreated((state2, context) => {
   if (!context) {
     log9.error("Requires global context");
     return;
@@ -2036,8 +2207,8 @@ var Router = app.defineState({
   const updateRouteVisibility = async (currentPath) => {
     const routeElements = document.querySelectorAll('[data-hypen-type="route"]');
     let matchFound = false;
-    for (let index = 0;index < routeElements.length; index++) {
-      const routeEl = routeElements[index];
+    for (let index2 = 0;index2 < routeElements.length; index2++) {
+      const routeEl = routeElements[index2];
       const htmlEl = routeEl;
       const routePath = htmlEl.dataset.routePath || "/";
       const isMatch = routePath === currentPath;
@@ -2061,11 +2232,11 @@ var Router = app.defineState({
     }
   };
   setTimeout(() => {
-    updateRouteVisibility(state.currentPath);
+    updateRouteVisibility(state2.currentPath);
   }, 100);
   router.onNavigate((routeState) => {
-    state.currentPath = routeState.currentPath;
-    state.routeParams = routeState.params;
+    state2.currentPath = routeState.currentPath;
+    state2.routeParams = routeState.params;
     updateRouteVisibility(routeState.currentPath);
   });
 }).build();
@@ -2073,203 +2244,25 @@ var Route = app.defineState({}, { name: "__Route" }).build();
 var Link = app.defineState({
   to: "/",
   isActive: false
-}, { name: "__Link" }).onAction("navigate", ({ state, context }) => {
+}, { name: "__Link" }).onAction("navigate", ({ state: state2, context }) => {
   const router = context?.router;
   if (!router) {
     log9.error("Link requires router context");
     return;
   }
-  const targetPath = state.to;
+  const targetPath = state2.to;
   router.push(targetPath);
-}).onCreated((state, context) => {
+}).onCreated((state2, context) => {
   if (!context)
     return;
   const router = context.router;
   if (router) {
     router.onNavigate((routeState) => {
-      state.isActive = routeState.currentPath === state.to;
+      state2.isActive = routeState.currentPath === state2.to;
     });
   }
 }).build();
 
-// src/index.ts
-init_app();
-
-// src/hypen.ts
-function createBindingProxy(root) {
-  const handler = {
-    get(_, prop) {
-      if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
-        return () => `\${${root}}`;
-      }
-      if (typeof prop === "symbol") {
-        return;
-      }
-      if (prop === "toJSON") {
-        return () => `\${${root}}`;
-      }
-      return createBindingProxy(`${root}.${prop}`);
-    },
-    has() {
-      return true;
-    },
-    ownKeys() {
-      return [];
-    },
-    getOwnPropertyDescriptor() {
-      return {
-        configurable: true,
-        enumerable: true
-      };
-    }
-  };
-  return new Proxy({}, handler);
-}
-var state = createBindingProxy("state");
-var item = createBindingProxy("item");
-var index = {
-  [Symbol.toPrimitive]: () => "${index}",
-  toString: () => "${index}",
-  valueOf: () => "${index}",
-  toJSON: () => "${index}"
-};
-function hypen(strings, ...expressions) {
-  let result = strings[0];
-  for (let i = 0;i < expressions.length; i++) {
-    const expr = expressions[i];
-    result += String(expr);
-    result += strings[i + 1];
-  }
-  return result.trim();
-}
-
-// src/index.ts
-init_state();
-
-// 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/index.ts
 init_result();
 init_logger();
@@ -2354,4 +2347,4 @@ export {
   ActionError
 };
 
-//# debugId=6B890301380275E464756E2164756E21
+//# debugId=7C35E17ECF9C051B64756E2164756E21