@hypen-space/core 0.2.12 → 0.3.0

package/dist/src/remote/client.js

@@ -10,6 +10,419 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// src/result.ts
+function Ok(value) {
+  return { ok: true, value };
+}
+function Err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok;
+}
+function isErr(result) {
+  return !result.ok;
+}
+async function fromPromise(promise, mapError) {
+  try {
+    const value = await promise;
+    return Ok(value);
+  } catch (e) {
+    if (mapError) {
+      return Err(mapError(e));
+    }
+    return Err(e);
+  }
+}
+function fromTry(fn, mapError) {
+  try {
+    return Ok(fn());
+  } catch (e) {
+    if (mapError) {
+      return Err(mapError(e));
+    }
+    return Err(e);
+  }
+}
+function map(result, fn) {
+  if (result.ok) {
+    return Ok(fn(result.value));
+  }
+  return result;
+}
+function mapErr(result, fn) {
+  if (!result.ok) {
+    return Err(fn(result.error));
+  }
+  return result;
+}
+function flatMap(result, fn) {
+  if (result.ok) {
+    return fn(result.value);
+  }
+  return result;
+}
+function unwrap(result) {
+  if (result.ok) {
+    return result.value;
+  }
+  throw result.error;
+}
+function unwrapOr(result, defaultValue) {
+  if (result.ok) {
+    return result.value;
+  }
+  return defaultValue;
+}
+function unwrapOrElse(result, fn) {
+  if (result.ok) {
+    return result.value;
+  }
+  return fn(result.error);
+}
+function match(result, handlers) {
+  if (result.ok) {
+    return handlers.ok(result.value);
+  }
+  return handlers.err(result.error);
+}
+function all(results) {
+  const values = [];
+  for (const result of results) {
+    if (!result.ok) {
+      return result;
+    }
+    values.push(result.value);
+  }
+  return Ok(values);
+}
+var HypenError, ActionError, ConnectionError, StateError;
+var init_result = __esm(() => {
+  HypenError = class HypenError extends Error {
+    code;
+    context;
+    cause;
+    constructor(code, message, options) {
+      super(message);
+      this.name = "HypenError";
+      this.code = code;
+      this.context = options?.context;
+      this.cause = options?.cause;
+      Object.setPrototypeOf(this, new.target.prototype);
+    }
+  };
+  ActionError = class ActionError extends HypenError {
+    actionName;
+    constructor(actionName, cause) {
+      super("ACTION_ERROR", `Action handler "${actionName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
+        context: { actionName },
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "ActionError";
+      this.actionName = actionName;
+    }
+  };
+  ConnectionError = class ConnectionError extends HypenError {
+    url;
+    attempt;
+    constructor(url, cause, attempt) {
+      super("CONNECTION_ERROR", `Connection to "${url}" failed${attempt ? ` (attempt ${attempt})` : ""}: ${cause instanceof Error ? cause.message : String(cause)}`, {
+        context: { url, attempt },
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "ConnectionError";
+      this.url = url;
+      this.attempt = attempt;
+    }
+  };
+  StateError = class StateError extends HypenError {
+    path;
+    constructor(message, path, cause) {
+      super("STATE_ERROR", message, {
+        context: { path },
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "StateError";
+      this.path = path;
+    }
+  };
+});
+
+// src/remote/client.ts
+init_result();
+
+// src/disposable.ts
+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;
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    while (this.stack.length > 0) {
+      const item = this.stack.pop();
+      try {
+        item.dispose();
+      } catch (error) {
+        console.error("[DisposableStack] 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) {
+        try {
+          d.dispose();
+        } catch (error) {
+          console.error("[compositeDisposable] Error during dispose:", error);
+        }
+      }
+    }
+  };
+}
+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
+init_result();
+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;
+      }
+      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
 class RemoteEngine {
   ws = null;
@@ -17,12 +430,17 @@ class RemoteEngine {
   state = "disconnected";
   options;
   reconnectAttempts = 0;
-  reconnectTimer = null;
+  disposables = new DisposableStack;
+  reconnectDisposable = null;
+  currentSessionId = null;
+  sessionOptions;
   patchCallbacks = [];
   stateCallbacks = [];
   connectionCallbacks = [];
   disconnectionCallbacks = [];
   errorCallbacks = [];
+  sessionEstablishedCallbacks = [];
+  sessionExpiredCallbacks = [];
   currentState = null;
   currentRevision = 0;
   moduleName = "";
@@ -31,54 +449,85 @@ class RemoteEngine {
     this.options = {
       autoReconnect: options.autoReconnect ?? true,
       reconnectInterval: options.reconnectInterval ?? 3000,
-      maxReconnectAttempts: options.maxReconnectAttempts ?? 10
+      maxReconnectAttempts: options.maxReconnectAttempts ?? 10,
+      session: options.session
     };
+    this.sessionOptions = options.session;
+    if (options.session?.id) {
+      this.currentSessionId = options.session.id;
+    }
   }
   async connect() {
     if (this.state === "connected" || this.state === "connecting") {
-      return;
+      return Ok(undefined);
     }
     this.state = "connecting";
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
       try {
         this.ws = new WebSocket(this.url);
-        this.ws.onopen = () => {
-          this.state = "connected";
-          this.reconnectAttempts = 0;
-          this.connectionCallbacks.forEach((cb) => cb());
-          resolve();
-        };
-        this.ws.onmessage = (event) => {
+        this.disposables.add(disposableWebSocket(this.ws));
+        const messageHandler = (event) => {
           this.handleMessage(event.data);
         };
-        this.ws.onerror = () => {
+        this.disposables.add(disposableListener(this.ws, "message", messageHandler));
+        const errorHandler = () => {
           this.state = "error";
-          const error = new Error("WebSocket error");
+          const error = new ConnectionError(this.url, new Error("WebSocket error"));
           this.errorCallbacks.forEach((cb) => cb(error));
-          reject(error);
+          resolve(Err(error));
         };
-        this.ws.onclose = () => {
+        this.disposables.add(disposableListener(this.ws, "error", errorHandler));
+        const closeHandler = () => {
           this.state = "disconnected";
           this.disconnectionCallbacks.forEach((cb) => cb());
           this.attemptReconnect();
         };
-      } catch (error) {
+        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";
-        reject(error);
+        const error = new ConnectionError(this.url, e);
+        resolve(Err(error));
       }
     });
   }
+  sendHello() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+      return;
+    const hello = {
+      type: "hello",
+      sessionId: this.currentSessionId ?? this.sessionOptions?.id,
+      props: this.sessionOptions?.props
+    };
+    this.ws.send(JSON.stringify(hello));
+  }
   disconnect() {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
+    if (this.reconnectDisposable) {
+      this.reconnectDisposable.dispose();
+      this.reconnectDisposable = null;
     }
     if (this.ws) {
-      this.ws.close();
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        this.ws.close();
+      }
       this.ws = null;
     }
     this.state = "disconnected";
   }
+  dispose() {
+    this.disconnect();
+    this.disposables.dispose();
+  }
   dispatchAction(action, payload) {
     if (this.state !== "connected" || !this.ws) {
       console.warn("Cannot dispatch action: not connected");
@@ -112,6 +561,14 @@ class RemoteEngine {
     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;
   }
@@ -121,10 +578,19 @@ class RemoteEngine {
   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;
@@ -133,14 +599,28 @@ class RemoteEngine {
           break;
         case "stateUpdate":
           this.currentState = message.state;
-          this.stateCallbacks.forEach((cb) => cb(message.state));
+          this.stateCallbacks.forEach((cb) => cb(this.currentState));
           break;
       }
-    } catch (error) {
-      console.error("Error handling remote message:", error);
-      this.errorCallbacks.forEach((cb) => cb(error instanceof Error ? error : new Error(String(error))));
+    } catch (e) {
+      console.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;
@@ -164,15 +644,25 @@ class RemoteEngine {
     if (!this.options.autoReconnect) {
       return;
     }
-    if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
-      console.error("Max reconnection attempts reached");
-      return;
-    }
-    this.reconnectAttempts++;
-    console.log(`Attempting to reconnect (${this.reconnectAttempts}/${this.options.maxReconnectAttempts})...`);
-    this.reconnectTimer = setTimeout(() => {
-      this.connect().catch((error) => {
-        console.error("Reconnection failed:", error);
+    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) => {
+          console.log(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
+        }
+      }).catch((error) => {
+        console.error("Max reconnection attempts reached:", error.message);
+        this.errorCallbacks.forEach((cb) => cb(new ConnectionError(this.url, error, this.options.maxReconnectAttempts)));
       });
     }, this.options.reconnectInterval);
   }
@@ -181,4 +671,4 @@ export {
   RemoteEngine
 };
 
-//# debugId=F4162E97D225BE4664756E2164756E21
+//# debugId=B73E531E82606EFA64756E2164756E21