@rstmdb/client 0.1.0

package/dist/index.js

@@ -0,0 +1,1332 @@
+'use strict';
+
+var events = require('events');
+var net = require('net');
+var tls = require('tls');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var net__namespace = /*#__PURE__*/_interopNamespace(net);
+var tls__namespace = /*#__PURE__*/_interopNamespace(tls);
+
+// src/client.ts
+
+// src/protocol/crc32c.ts
+var CRC32C_TABLE = new Uint32Array(256);
+(function initTable() {
+  const POLYNOMIAL = 2197175160;
+  for (let i = 0; i < 256; i++) {
+    let crc = i;
+    for (let j = 0; j < 8; j++) {
+      if (crc & 1) {
+        crc = crc >>> 1 ^ POLYNOMIAL;
+      } else {
+        crc = crc >>> 1;
+      }
+    }
+    CRC32C_TABLE[i] = crc >>> 0;
+  }
+})();
+function crc32c(data) {
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) {
+    const byte = data[i];
+    const tableIndex = (crc ^ byte) & 255;
+    crc = crc >>> 8 ^ CRC32C_TABLE[tableIndex];
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function verifyCrc32c(data, expected) {
+  return crc32c(data) === expected;
+}
+
+// src/errors/codes.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["UNSUPPORTED_PROTOCOL"] = "UNSUPPORTED_PROTOCOL";
+  ErrorCode2["BAD_REQUEST"] = "BAD_REQUEST";
+  ErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  ErrorCode2["AUTH_FAILED"] = "AUTH_FAILED";
+  ErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  ErrorCode2["MACHINE_NOT_FOUND"] = "MACHINE_NOT_FOUND";
+  ErrorCode2["MACHINE_VERSION_EXISTS"] = "MACHINE_VERSION_EXISTS";
+  ErrorCode2["INSTANCE_NOT_FOUND"] = "INSTANCE_NOT_FOUND";
+  ErrorCode2["INSTANCE_EXISTS"] = "INSTANCE_EXISTS";
+  ErrorCode2["INVALID_TRANSITION"] = "INVALID_TRANSITION";
+  ErrorCode2["GUARD_FAILED"] = "GUARD_FAILED";
+  ErrorCode2["CONFLICT"] = "CONFLICT";
+  ErrorCode2["WAL_IO_ERROR"] = "WAL_IO_ERROR";
+  ErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  ErrorCode2["RATE_LIMITED"] = "RATE_LIMITED";
+  ErrorCode2["CONNECTION_FAILED"] = "CONNECTION_FAILED";
+  ErrorCode2["CONNECTION_CLOSED"] = "CONNECTION_CLOSED";
+  ErrorCode2["TIMEOUT"] = "TIMEOUT";
+  return ErrorCode2;
+})(ErrorCode || {});
+function isRetryableCode(code) {
+  switch (code) {
+    case "CONNECTION_FAILED" /* CONNECTION_FAILED */:
+    case "CONNECTION_CLOSED" /* CONNECTION_CLOSED */:
+    case "TIMEOUT" /* TIMEOUT */:
+    case "RATE_LIMITED" /* RATE_LIMITED */:
+    case "WAL_IO_ERROR" /* WAL_IO_ERROR */:
+    case "INTERNAL_ERROR" /* INTERNAL_ERROR */:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/errors/base.ts
+var RstmdbError = class _RstmdbError extends Error {
+  /** Error code */
+  code;
+  /** Whether the operation can be retried */
+  retryable;
+  /** Additional error details */
+  details;
+  constructor(message, code, options) {
+    super(message, { cause: options?.cause });
+    this.name = "RstmdbError";
+    this.code = code;
+    this.retryable = options?.retryable ?? isRetryableCode(code);
+    this.details = options?.details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Create an error from a server response.
+   */
+  static fromResponse(response) {
+    const code = response.code || "INTERNAL_ERROR" /* INTERNAL_ERROR */;
+    return new _RstmdbError(response.message, code, {
+      details: response.details
+    });
+  }
+};
+
+// src/errors/classes.ts
+var ConnectionError = class extends RstmdbError {
+  constructor(message, options) {
+    super(message, "CONNECTION_FAILED" /* CONNECTION_FAILED */, {
+      retryable: true,
+      ...options
+    });
+    this.name = "ConnectionError";
+  }
+};
+var TimeoutError = class extends RstmdbError {
+  constructor(message, options) {
+    super(message, "TIMEOUT" /* TIMEOUT */, {
+      retryable: true,
+      ...options
+    });
+    this.name = "TimeoutError";
+  }
+};
+var ProtocolError = class extends RstmdbError {
+  constructor(message, code = "BAD_REQUEST" /* BAD_REQUEST */, options) {
+    super(message, code, {
+      retryable: false,
+      ...options
+    });
+    this.name = "ProtocolError";
+  }
+};
+var ServerError = class _ServerError extends RstmdbError {
+  constructor(message, code, options) {
+    super(message, code, options);
+    this.name = "ServerError";
+  }
+  /**
+   * Create a ServerError from a server response.
+   */
+  static fromResponse(response) {
+    const code = response.code || "INTERNAL_ERROR" /* INTERNAL_ERROR */;
+    const message = response.message || "Unknown server error";
+    switch (code) {
+      case "NOT_FOUND" /* NOT_FOUND */:
+      case "MACHINE_NOT_FOUND" /* MACHINE_NOT_FOUND */:
+      case "INSTANCE_NOT_FOUND" /* INSTANCE_NOT_FOUND */:
+        return new NotFoundError(message, code, { details: response.details });
+      case "CONFLICT" /* CONFLICT */:
+      case "INSTANCE_EXISTS" /* INSTANCE_EXISTS */:
+      case "MACHINE_VERSION_EXISTS" /* MACHINE_VERSION_EXISTS */:
+        return new ConflictError(message, code, { details: response.details });
+      case "UNAUTHORIZED" /* UNAUTHORIZED */:
+      case "AUTH_FAILED" /* AUTH_FAILED */:
+        return new AuthenticationError(message, code, { details: response.details });
+      case "INVALID_TRANSITION" /* INVALID_TRANSITION */:
+        return new InvalidTransitionError(message, { details: response.details });
+      case "GUARD_FAILED" /* GUARD_FAILED */:
+        return new GuardFailedError(message, { details: response.details });
+      default:
+        return new _ServerError(message, code, { details: response.details });
+    }
+  }
+};
+var NotFoundError = class extends ServerError {
+  constructor(message, code = "NOT_FOUND" /* NOT_FOUND */, options) {
+    super(message, code, { retryable: false, ...options });
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends ServerError {
+  constructor(message, code = "CONFLICT" /* CONFLICT */, options) {
+    super(message, code, { retryable: false, ...options });
+    this.name = "ConflictError";
+  }
+};
+var AuthenticationError = class extends ServerError {
+  constructor(message, code = "UNAUTHORIZED" /* UNAUTHORIZED */, options) {
+    super(message, code, { retryable: false, ...options });
+    this.name = "AuthenticationError";
+  }
+};
+var InvalidTransitionError = class extends ServerError {
+  constructor(message, options) {
+    super(message, "INVALID_TRANSITION" /* INVALID_TRANSITION */, { retryable: false, ...options });
+    this.name = "InvalidTransitionError";
+  }
+};
+var GuardFailedError = class extends ServerError {
+  constructor(message, options) {
+    super(message, "GUARD_FAILED" /* GUARD_FAILED */, { retryable: false, ...options });
+    this.name = "GuardFailedError";
+  }
+};
+
+// src/protocol/frame.ts
+var FRAME_MAGIC = 1380143192;
+var PROTOCOL_VERSION = 1;
+var HEADER_SIZE = 18;
+var FrameFlags = /* @__PURE__ */ ((FrameFlags2) => {
+  FrameFlags2[FrameFlags2["NONE"] = 0] = "NONE";
+  FrameFlags2[FrameFlags2["CRC_PRESENT"] = 1] = "CRC_PRESENT";
+  FrameFlags2[FrameFlags2["COMPRESSED"] = 2] = "COMPRESSED";
+  FrameFlags2[FrameFlags2["STREAM"] = 4] = "STREAM";
+  FrameFlags2[FrameFlags2["END_STREAM"] = 8] = "END_STREAM";
+  return FrameFlags2;
+})(FrameFlags || {});
+var FrameEncoder = class {
+  useCrc;
+  constructor(options) {
+    this.useCrc = options?.useCrc ?? true;
+  }
+  /**
+   * Encode an object into an RCP frame.
+   */
+  encode(payload) {
+    const payloadJson = JSON.stringify(payload);
+    const payloadBuffer = Buffer.from(payloadJson, "utf8");
+    const flags = this.useCrc ? 1 /* CRC_PRESENT */ : 0 /* NONE */;
+    const crcValue = this.useCrc ? crc32c(payloadBuffer) : 0;
+    return this.encodeRaw(payloadBuffer, flags, crcValue);
+  }
+  /**
+   * Encode a stream frame.
+   */
+  encodeStream(payload, endStream = false) {
+    const payloadJson = JSON.stringify(payload);
+    const payloadBuffer = Buffer.from(payloadJson, "utf8");
+    let flags = 4 /* STREAM */;
+    if (this.useCrc) flags |= 1 /* CRC_PRESENT */;
+    if (endStream) flags |= 8 /* END_STREAM */;
+    const crcValue = this.useCrc ? crc32c(payloadBuffer) : 0;
+    return this.encodeRaw(payloadBuffer, flags, crcValue);
+  }
+  /**
+   * Encode raw payload with specified flags.
+   */
+  encodeRaw(payload, flags, crcValue) {
+    const headerExtLen = 0;
+    const payloadLen = payload.length;
+    const frame = Buffer.allocUnsafe(HEADER_SIZE + headerExtLen + payloadLen);
+    frame.writeUInt32BE(FRAME_MAGIC, 0);
+    frame.writeUInt16BE(PROTOCOL_VERSION, 4);
+    frame.writeUInt16BE(flags, 6);
+    frame.writeUInt16BE(headerExtLen, 8);
+    frame.writeUInt32BE(payloadLen, 10);
+    frame.writeUInt32BE(crcValue, 14);
+    payload.copy(frame, HEADER_SIZE);
+    return frame;
+  }
+};
+var FrameDecoder = class {
+  buffer = Buffer.alloc(0);
+  verifyCrc;
+  constructor(options) {
+    this.verifyCrc = options?.verifyCrc ?? true;
+  }
+  /**
+   * Append data to the internal buffer.
+   */
+  append(data) {
+    this.buffer = Buffer.concat([this.buffer, data]);
+  }
+  /**
+   * Try to decode a frame from the buffer.
+   * Returns null if not enough data is available.
+   */
+  decode() {
+    if (this.buffer.length < HEADER_SIZE) {
+      return null;
+    }
+    const magic = this.buffer.readUInt32BE(0);
+    if (magic !== FRAME_MAGIC) {
+      throw new ProtocolError(
+        `Invalid frame magic: expected 0x${FRAME_MAGIC.toString(16)} (RCPX), got 0x${magic.toString(16)}`,
+        "BAD_REQUEST" /* BAD_REQUEST */
+      );
+    }
+    const version = this.buffer.readUInt16BE(4);
+    if (version !== PROTOCOL_VERSION) {
+      throw new ProtocolError(
+        `Unsupported protocol version: ${version}`,
+        "UNSUPPORTED_PROTOCOL" /* UNSUPPORTED_PROTOCOL */
+      );
+    }
+    const flags = this.buffer.readUInt16BE(6);
+    const headerExtLen = this.buffer.readUInt16BE(8);
+    const payloadLen = this.buffer.readUInt32BE(10);
+    const crcValue = this.buffer.readUInt32BE(14);
+    const totalLen = HEADER_SIZE + headerExtLen + payloadLen;
+    if (this.buffer.length < totalLen) {
+      return null;
+    }
+    const payloadStart = HEADER_SIZE + headerExtLen;
+    const payload = this.buffer.subarray(payloadStart, payloadStart + payloadLen);
+    if (this.verifyCrc && flags & 1 /* CRC_PRESENT */) {
+      if (!verifyCrc32c(payload, crcValue)) {
+        throw new ProtocolError("CRC32C checksum mismatch", "BAD_REQUEST" /* BAD_REQUEST */);
+      }
+    }
+    this.buffer = this.buffer.subarray(totalLen);
+    return { flags, payload: Buffer.from(payload) };
+  }
+  /**
+   * Reset the decoder state.
+   */
+  reset() {
+    this.buffer = Buffer.alloc(0);
+  }
+  /**
+   * Get the current buffer length.
+   */
+  get bufferedLength() {
+    return this.buffer.length;
+  }
+};
+
+// src/protocol/operations.ts
+var Operation = /* @__PURE__ */ ((Operation2) => {
+  Operation2["HELLO"] = "HELLO";
+  Operation2["AUTH"] = "AUTH";
+  Operation2["PING"] = "PING";
+  Operation2["INFO"] = "INFO";
+  Operation2["PUT_MACHINE"] = "PUT_MACHINE";
+  Operation2["GET_MACHINE"] = "GET_MACHINE";
+  Operation2["LIST_MACHINES"] = "LIST_MACHINES";
+  Operation2["CREATE_INSTANCE"] = "CREATE_INSTANCE";
+  Operation2["GET_INSTANCE"] = "GET_INSTANCE";
+  Operation2["DELETE_INSTANCE"] = "DELETE_INSTANCE";
+  Operation2["APPLY_EVENT"] = "APPLY_EVENT";
+  Operation2["BATCH"] = "BATCH";
+  Operation2["WAL_READ"] = "WAL_READ";
+  Operation2["SNAPSHOT_INSTANCE"] = "SNAPSHOT_INSTANCE";
+  Operation2["COMPACT"] = "COMPACT";
+  Operation2["WATCH_INSTANCE"] = "WATCH_INSTANCE";
+  Operation2["WATCH_ALL"] = "WATCH_ALL";
+  Operation2["UNWATCH"] = "UNWATCH";
+  return Operation2;
+})(Operation || {});
+Object.values(Operation);
+
+// src/protocol/messages.ts
+function isResponseMessage(msg) {
+  return msg.type === "response";
+}
+function isStreamEventMessage(msg) {
+  return msg.type === "event";
+}
+function isStreamEndMessage(msg) {
+  return msg.type === "end";
+}
+function parseBigIntFields(obj, fields) {
+  const result = { ...obj };
+  for (const field of fields) {
+    const value = result[field];
+    if (typeof value === "string") {
+      result[field] = BigInt(value);
+    }
+  }
+  return result;
+}
+
+// src/connection.ts
+var Connection = class extends events.EventEmitter {
+  config;
+  socket = null;
+  state = "DISCONNECTED" /* DISCONNECTED */;
+  encoder;
+  decoder;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  subscriptions;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  closing = false;
+  constructor(config, subscriptions) {
+    super();
+    this.config = config;
+    this.subscriptions = subscriptions;
+    this.encoder = new FrameEncoder({ useCrc: true });
+    this.decoder = new FrameDecoder({ verifyCrc: true });
+  }
+  /**
+   * Get the current connection state.
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Check if connected.
+   */
+  isConnected() {
+    return this.state === "CONNECTED" /* CONNECTED */;
+  }
+  /**
+   * Connect to the server.
+   */
+  async connect() {
+    if (this.state !== "DISCONNECTED" /* DISCONNECTED */) {
+      throw new ConnectionError("Already connected or connecting");
+    }
+    this.closing = false;
+    this.state = "CONNECTING" /* CONNECTING */;
+    try {
+      await this.createSocket();
+      this.state = "HANDSHAKING" /* HANDSHAKING */;
+      await this.handshake();
+      this.state = "CONNECTED" /* CONNECTED */;
+      this.reconnectAttempt = 0;
+      this.emit("connect");
+    } catch (error) {
+      this.state = "DISCONNECTED" /* DISCONNECTED */;
+      this.cleanup();
+      throw error;
+    }
+  }
+  /**
+   * Close the connection.
+   */
+  async close() {
+    this.closing = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.socket) {
+      this.state = "CLOSING" /* CLOSING */;
+      const error = new ConnectionError("Connection closed");
+      for (const pending of this.pending.values()) {
+        clearTimeout(pending.timeout);
+        pending.reject(error);
+      }
+      this.pending.clear();
+      this.subscriptions.closeAll(error);
+      await new Promise((resolve) => {
+        if (this.socket) {
+          this.socket.once("close", () => resolve());
+          this.socket.end();
+          setTimeout(() => {
+            if (this.socket) {
+              this.socket.destroy();
+            }
+            resolve();
+          }, 1e3);
+        } else {
+          resolve();
+        }
+      });
+      this.cleanup();
+    }
+    this.state = "DISCONNECTED" /* DISCONNECTED */;
+  }
+  /**
+   * Send a request and wait for response.
+   */
+  async request(op, params) {
+    if (this.state !== "CONNECTED" /* CONNECTED */ && this.state !== "HANDSHAKING" /* HANDSHAKING */) {
+      throw new ConnectionError("Not connected");
+    }
+    const socket = this.socket;
+    if (!socket) {
+      throw new ConnectionError("Socket not available");
+    }
+    const id = String(this.nextId++);
+    const message = { type: "request", id, op, params };
+    const frame = this.encoder.encode(message);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new TimeoutError(`Request ${op} timed out after ${this.config.requestTimeout}ms`));
+      }, this.config.requestTimeout);
+      this.pending.set(id, {
+        id,
+        resolve: (response) => {
+          clearTimeout(timeout);
+          this.pending.delete(id);
+          if (response.status !== "ok") {
+            reject(
+              ServerError.fromResponse(
+                response.error || { code: "INTERNAL_ERROR" /* INTERNAL_ERROR */, message: "Unknown error" }
+              )
+            );
+          } else {
+            resolve(response.result);
+          }
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          this.pending.delete(id);
+          reject(error);
+        },
+        timeout
+      });
+      socket.write(frame, (err) => {
+        if (err) {
+          const pending = this.pending.get(id);
+          if (pending) {
+            clearTimeout(pending.timeout);
+            this.pending.delete(id);
+            reject(new ConnectionError(`Failed to send request: ${err.message}`, { cause: err }));
+          }
+        }
+      });
+    });
+  }
+  /**
+   * Create the TCP/TLS socket.
+   */
+  async createSocket() {
+    return new Promise((resolve, reject) => {
+      const connectTimeout = setTimeout(() => {
+        if (this.socket) {
+          this.socket.destroy();
+          this.socket = null;
+        }
+        reject(new TimeoutError(`Connection timeout after ${this.config.connectTimeout}ms`));
+      }, this.config.connectTimeout);
+      const options = {
+        host: this.config.host,
+        port: this.config.port
+      };
+      const onConnect = () => {
+        clearTimeout(connectTimeout);
+        this.setupSocket();
+        resolve();
+      };
+      const onError = (err) => {
+        clearTimeout(connectTimeout);
+        reject(new ConnectionError(`Failed to connect: ${err.message}`, { cause: err }));
+      };
+      if (this.config.tls) {
+        const tlsOptions = {
+          ...options,
+          ...this.config.tls
+        };
+        this.socket = tls__namespace.connect(tlsOptions);
+        this.socket.once("secureConnect", onConnect);
+      } else {
+        this.socket = net__namespace.connect(options);
+        this.socket.once("connect", onConnect);
+      }
+      this.socket.once("error", onError);
+    });
+  }
+  /**
+   * Set up socket event handlers.
+   */
+  setupSocket() {
+    if (!this.socket) return;
+    this.socket.on("data", (data) => this.handleData(data));
+    this.socket.on("close", () => {
+      const wasConnected = this.state === "CONNECTED" /* CONNECTED */;
+      this.cleanup();
+      this.state = "DISCONNECTED" /* DISCONNECTED */;
+      if (!this.closing && wasConnected) {
+        this.emit("disconnect");
+        this.scheduleReconnect();
+      }
+    });
+    this.socket.on("error", (err) => {
+      this.emit("error", new ConnectionError(err.message, { cause: err }));
+    });
+  }
+  /**
+   * Handle incoming data.
+   */
+  handleData(data) {
+    this.decoder.append(data);
+    let frame;
+    try {
+      while ((frame = this.decoder.decode()) !== null) {
+        this.handleFrame(frame);
+      }
+    } catch (error) {
+      this.emit("error", error);
+      this.socket?.destroy();
+    }
+  }
+  /**
+   * Handle a decoded frame.
+   */
+  handleFrame(frame) {
+    let message;
+    try {
+      message = JSON.parse(frame.payload.toString("utf8"));
+    } catch {
+      throw new ProtocolError("Invalid JSON payload");
+    }
+    if (isResponseMessage(message)) {
+      const pending = this.pending.get(message.id);
+      if (pending) {
+        pending.resolve(message);
+      }
+    } else if (isStreamEventMessage(message)) {
+      this.subscriptions.dispatch(message);
+    } else if (isStreamEndMessage(message)) {
+      this.subscriptions.end(message.subscription_id);
+    }
+  }
+  /**
+   * Perform the handshake (HELLO + AUTH).
+   */
+  async handshake() {
+    const helloParams = {
+      protocol_version: 1,
+      wire_modes: ["binary_json"],
+      features: ["idempotency", "batch"]
+    };
+    if (this.config.clientName) {
+      helloParams["client_name"] = this.config.clientName;
+    }
+    const helloResult = await this.request(
+      "HELLO" /* HELLO */,
+      helloParams
+    );
+    if (helloResult.protocol_version !== 1) {
+      throw new ProtocolError(
+        `Unsupported protocol version: ${helloResult.protocol_version}`,
+        "UNSUPPORTED_PROTOCOL" /* UNSUPPORTED_PROTOCOL */
+      );
+    }
+    if (this.config.authToken) {
+      await this.request("AUTH" /* AUTH */, {
+        method: "bearer",
+        token: this.config.authToken
+      });
+    }
+  }
+  /**
+   * Schedule a reconnection attempt.
+   */
+  scheduleReconnect() {
+    if (this.closing || !this.config.reconnect) {
+      return;
+    }
+    if (this.reconnectAttempt >= this.config.reconnectMaxAttempts) {
+      this.emit(
+        "error",
+        new ConnectionError(
+          `Max reconnection attempts (${this.config.reconnectMaxAttempts}) reached`
+        )
+      );
+      return;
+    }
+    this.reconnectAttempt++;
+    const delay = this.config.reconnectInterval * Math.min(this.reconnectAttempt, 5);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.emit("reconnect", this.reconnectAttempt);
+      this.connect().catch(() => {
+      });
+    }, delay);
+  }
+  /**
+   * Clean up resources.
+   */
+  cleanup() {
+    this.decoder.reset();
+    if (this.socket) {
+      this.socket.removeAllListeners();
+      this.socket = null;
+    }
+  }
+};
+var SubscriptionHandler = class extends events.EventEmitter {
+  subscriptionId;
+  events = [];
+  waiters = [];
+  closed = false;
+  closeError;
+  unsubscribeFn;
+  constructor(subscriptionId, unsubscribeFn) {
+    super();
+    this.subscriptionId = subscriptionId;
+    this.unsubscribeFn = unsubscribeFn;
+  }
+  /**
+   * Push an event to the subscription.
+   */
+  push(event) {
+    if (this.closed) return;
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve({ value: event, done: false });
+    } else {
+      this.events.push(event);
+    }
+    this.emit("event", event);
+  }
+  /**
+   * Close the subscription with an optional error.
+   */
+  close(error) {
+    if (this.closed) return;
+    this.closed = true;
+    this.closeError = error;
+    for (const waiter of this.waiters) {
+      if (error) {
+        waiter.reject(error);
+      } else {
+        waiter.resolve({ value: void 0, done: true });
+      }
+    }
+    this.waiters = [];
+    if (error) {
+      this.emit("error", error);
+    }
+    this.emit("end");
+  }
+  /**
+   * AsyncIterator implementation.
+   */
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      if (this.closed) {
+        if (this.closeError) {
+          throw this.closeError;
+        }
+        while (this.events.length > 0) {
+          yield this.events.shift();
+        }
+        return;
+      }
+      if (this.events.length > 0) {
+        yield this.events.shift();
+        continue;
+      }
+      const result = await new Promise((resolve, reject) => {
+        this.waiters.push({ resolve, reject });
+      });
+      if (result.done) {
+        return;
+      }
+      yield result.value;
+    }
+  }
+  /**
+   * Cancel the subscription.
+   */
+  async unsubscribe() {
+    if (!this.closed) {
+      await this.unsubscribeFn();
+      this.close();
+    }
+  }
+  /**
+   * Check if the subscription is closed.
+   */
+  get isClosed() {
+    return this.closed;
+  }
+};
+
+// src/streaming/manager.ts
+var SubscriptionManager = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  /**
+   * Register a new subscription.
+   */
+  register(subscriptionId, handler) {
+    this.subscriptions.set(subscriptionId, handler);
+  }
+  /**
+   * Unregister a subscription.
+   */
+  unregister(subscriptionId) {
+    const handler = this.subscriptions.get(subscriptionId);
+    if (handler) {
+      handler.close();
+      this.subscriptions.delete(subscriptionId);
+    }
+  }
+  /**
+   * Get a subscription handler.
+   */
+  get(subscriptionId) {
+    return this.subscriptions.get(subscriptionId);
+  }
+  /**
+   * Check if a subscription exists.
+   */
+  has(subscriptionId) {
+    return this.subscriptions.has(subscriptionId);
+  }
+  /**
+   * Dispatch an event to the appropriate subscription.
+   */
+  dispatch(message) {
+    const handler = this.subscriptions.get(message.subscription_id);
+    if (!handler) {
+      return;
+    }
+    const event = {
+      subscriptionId: message.subscription_id,
+      instanceId: message.instance_id,
+      machine: message.machine,
+      version: message.version,
+      walOffset: BigInt(message.wal_offset),
+      fromState: message.from_state,
+      toState: message.to_state,
+      event: message.event,
+      payload: message.payload,
+      ctx: message.ctx
+    };
+    handler.push(event);
+  }
+  /**
+   * End a subscription (e.g., when server sends end message).
+   */
+  end(subscriptionId, error) {
+    const handler = this.subscriptions.get(subscriptionId);
+    if (handler) {
+      handler.close(error);
+      this.subscriptions.delete(subscriptionId);
+    }
+  }
+  /**
+   * Close all subscriptions (e.g., on disconnect).
+   */
+  closeAll(error) {
+    for (const handler of this.subscriptions.values()) {
+      handler.close(error);
+    }
+    this.subscriptions.clear();
+  }
+  /**
+   * Get the number of active subscriptions.
+   */
+  get size() {
+    return this.subscriptions.size;
+  }
+};
+
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  port: 7401,
+  connectTimeout: 1e4,
+  requestTimeout: 3e4,
+  reconnect: true,
+  reconnectInterval: 1e3,
+  reconnectMaxAttempts: 10
+};
+function resolveConfig(config) {
+  let tlsConfig;
+  if (config.tls === true) {
+    tlsConfig = { rejectUnauthorized: true };
+  } else if (config.tls && typeof config.tls === "object") {
+    tlsConfig = config.tls;
+  }
+  return {
+    host: config.host,
+    port: config.port ?? DEFAULT_CONFIG.port,
+    connectTimeout: config.connectTimeout ?? DEFAULT_CONFIG.connectTimeout,
+    requestTimeout: config.requestTimeout ?? DEFAULT_CONFIG.requestTimeout,
+    authToken: config.authToken,
+    tls: tlsConfig,
+    reconnect: config.reconnect ?? DEFAULT_CONFIG.reconnect,
+    reconnectInterval: config.reconnectInterval ?? DEFAULT_CONFIG.reconnectInterval,
+    reconnectMaxAttempts: config.reconnectMaxAttempts ?? DEFAULT_CONFIG.reconnectMaxAttempts,
+    clientName: config.clientName
+  };
+}
+var ClientOptions = class _ClientOptions {
+  config;
+  constructor(host) {
+    this.config = { host };
+  }
+  /**
+   * Create a new options builder with the given host.
+   */
+  static create(host) {
+    return new _ClientOptions(host);
+  }
+  /**
+   * Set the server port.
+   * @default 7401
+   */
+  port(port) {
+    this.config.port = port;
+    return this;
+  }
+  /**
+   * Set the authentication token.
+   */
+  auth(token) {
+    this.config.authToken = token;
+    return this;
+  }
+  /**
+   * Configure TLS settings.
+   *
+   * @param config - TLS configuration, or `true` to enable with system CA
+   *
+   * @example
+   * ```typescript
+   * // Enable TLS with system CA
+   * options.tls(true)
+   *
+   * // Custom CA certificate
+   * options.tls({ ca: fs.readFileSync('ca.pem') })
+   *
+   * // mTLS with client certificate
+   * options.tls({
+   *   ca: fs.readFileSync('ca.pem'),
+   *   cert: fs.readFileSync('client.pem'),
+   *   key: fs.readFileSync('client-key.pem'),
+   * })
+   * ```
+   */
+  tls(config) {
+    this.config.tls = config;
+    return this;
+  }
+  /**
+   * Set timeout values.
+   */
+  timeout(options) {
+    if (options.connect !== void 0) {
+      this.config.connectTimeout = options.connect;
+    }
+    if (options.request !== void 0) {
+      this.config.requestTimeout = options.request;
+    }
+    return this;
+  }
+  /**
+   * Configure reconnection behavior.
+   */
+  reconnect(options) {
+    if (options.enabled !== void 0) {
+      this.config.reconnect = options.enabled;
+    }
+    if (options.interval !== void 0) {
+      this.config.reconnectInterval = options.interval;
+    }
+    if (options.maxAttempts !== void 0) {
+      this.config.reconnectMaxAttempts = options.maxAttempts;
+    }
+    return this;
+  }
+  /**
+   * Set the client name (sent in HELLO handshake).
+   */
+  clientName(name) {
+    this.config.clientName = name;
+    return this;
+  }
+  /**
+   * Build the configuration object.
+   */
+  build() {
+    return { ...this.config };
+  }
+};
+
+// src/client.ts
+var Client = class _Client extends events.EventEmitter {
+  connection;
+  subscriptions;
+  config;
+  constructor(config) {
+    super();
+    this.config = config;
+    const resolvedConfig = resolveConfig(config);
+    this.subscriptions = new SubscriptionManager();
+    this.connection = new Connection(resolvedConfig, this.subscriptions);
+    this.connection.on("connect", () => this.emit("connect"));
+    this.connection.on("disconnect", (error) => this.emit("disconnect", error));
+    this.connection.on("error", (error) => this.emit("error", error));
+    this.connection.on("reconnect", (attempt) => this.emit("reconnect", attempt));
+  }
+  /**
+   * Create a client and connect to the server.
+   *
+   * @param host - Server hostname
+   * @param port - Server port (default: 7401)
+   * @param options - Additional options
+   * @returns Connected client instance
+   *
+   * @example
+   * ```typescript
+   * const client = await Client.connect('localhost');
+   * const client = await Client.connect('localhost', 7401);
+   * const client = await Client.connect('localhost', 7401, { auth: 'token' });
+   * ```
+   */
+  static async connect(host, port = 7401, options) {
+    const client = new _Client({
+      host,
+      port,
+      authToken: options?.auth,
+      tls: options?.tls,
+      clientName: options?.clientName
+    });
+    await client.connect();
+    return client;
+  }
+  /**
+   * Get the current configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Connection Lifecycle
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Connect to the server.
+   */
+  async connect() {
+    await this.connection.connect();
+  }
+  /**
+   * Close the connection.
+   */
+  async close() {
+    await this.connection.close();
+  }
+  /**
+   * Check if connected to the server.
+   */
+  isConnected() {
+    return this.connection.getState() === "CONNECTED" /* CONNECTED */;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // System Operations
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Ping the server.
+   */
+  async ping() {
+    await this.connection.request("PING" /* PING */);
+  }
+  /**
+   * Get server information.
+   */
+  async info() {
+    const result = await this.connection.request("INFO" /* INFO */);
+    return {
+      serverName: result.server_name,
+      serverVersion: result.server_version,
+      protocolVersion: result.protocol_version,
+      maxPayloadBytes: result.max_payload_bytes,
+      maxBatchOps: result.max_batch_ops,
+      walSegmentSize: result.wal_segment_size,
+      authRequired: result.auth_required,
+      features: result.features
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Machine Operations
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Create or update a state machine definition.
+   */
+  async putMachine(machine, version, definition) {
+    const result = await this.connection.request("PUT_MACHINE" /* PUT_MACHINE */, {
+      machine,
+      version,
+      definition
+    });
+    return {
+      machine: result.machine,
+      version: result.version,
+      storedChecksum: result.stored_checksum,
+      created: result.created
+    };
+  }
+  /**
+   * Get a state machine definition.
+   */
+  async getMachine(machine, version) {
+    const result = await this.connection.request("GET_MACHINE" /* GET_MACHINE */, {
+      machine,
+      version
+    });
+    return result;
+  }
+  /**
+   * List all state machines.
+   */
+  async listMachines(options) {
+    const result = await this.connection.request(
+      "LIST_MACHINES" /* LIST_MACHINES */,
+      options
+    );
+    return result;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Instance Operations
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Create a new state machine instance.
+   */
+  async createInstance(machine, version, options) {
+    const params = { machine, version };
+    if (options?.instanceId) params["instance_id"] = options.instanceId;
+    if (options?.initialCtx) params["initial_ctx"] = options.initialCtx;
+    if (options?.idempotencyKey) params["idempotency_key"] = options.idempotencyKey;
+    const result = await this.connection.request("CREATE_INSTANCE" /* CREATE_INSTANCE */, params);
+    return {
+      instanceId: result.instance_id,
+      state: result.state,
+      walOffset: BigInt(result.wal_offset)
+    };
+  }
+  /**
+   * Get instance state and context.
+   */
+  async getInstance(instanceId) {
+    const result = await this.connection.request("GET_INSTANCE" /* GET_INSTANCE */, { instance_id: instanceId });
+    return {
+      machine: result.machine,
+      version: result.version,
+      state: result.state,
+      ctx: result.ctx,
+      lastEventId: result.last_event_id,
+      lastWalOffset: BigInt(result.last_wal_offset)
+    };
+  }
+  /**
+   * Delete an instance.
+   */
+  async deleteInstance(instanceId, options) {
+    const params = { instance_id: instanceId };
+    if (options?.idempotencyKey) params["idempotency_key"] = options.idempotencyKey;
+    await this.connection.request("DELETE_INSTANCE" /* DELETE_INSTANCE */, params);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Event Operations
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Apply an event to an instance.
+   */
+  async applyEvent(instanceId, event, options) {
+    const params = {
+      instance_id: instanceId,
+      event
+    };
+    if (options?.payload) params["payload"] = options.payload;
+    if (options?.expectedState) params["expected_state"] = options.expectedState;
+    if (options?.expectedWalOffset !== void 0) {
+      params["expected_wal_offset"] = Number(options.expectedWalOffset);
+    }
+    if (options?.eventId) params["event_id"] = options.eventId;
+    if (options?.idempotencyKey) params["idempotency_key"] = options.idempotencyKey;
+    const result = await this.connection.request("APPLY_EVENT" /* APPLY_EVENT */, params);
+    return {
+      fromState: result.from_state,
+      toState: result.to_state,
+      ctx: result.ctx,
+      walOffset: BigInt(result.wal_offset),
+      applied: result.applied,
+      eventId: result.event_id
+    };
+  }
+  /**
+   * Execute multiple operations in a batch.
+   */
+  async batch(operations, options) {
+    const serializedOps = operations.map((op) => {
+      const params = {};
+      for (const [key, value] of Object.entries(op.params)) {
+        const snakeKey = key.replace(/([A-Z])/g, "_$1").toLowerCase();
+        params[snakeKey] = value;
+      }
+      return { op: op.op, params };
+    });
+    const result = await this.connection.request("BATCH" /* BATCH */, {
+      ops: serializedOps,
+      ...options
+    });
+    return {
+      results: result.results.map((r) => ({
+        status: r.status,
+        result: r.result ? parseBigIntFields(r.result, ["wal_offset"]) : void 0,
+        error: r.error ? ServerError.fromResponse(r.error) : void 0
+      })),
+      walOffset: result.wal_offset ? BigInt(result.wal_offset) : void 0
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // WAL Operations
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Read entries from the write-ahead log.
+   */
+  async walRead(fromOffset, options) {
+    const result = await this.connection.request("WAL_READ" /* WAL_READ */, {
+      fromOffset: fromOffset.toString(),
+      ...options
+    });
+    return {
+      entries: result.entries.map((e) => ({
+        ...e,
+        offset: BigInt(e.offset)
+      })),
+      hasMore: result.hasMore,
+      nextOffset: result.nextOffset ? BigInt(result.nextOffset) : void 0
+    };
+  }
+  /**
+   * Create a snapshot of an instance.
+   */
+  async snapshotInstance(instanceId) {
+    const result = await this.connection.request("SNAPSHOT_INSTANCE" /* SNAPSHOT_INSTANCE */, { instance_id: instanceId });
+    return {
+      instanceId,
+      walOffset: BigInt(result.wal_offset),
+      sizeBytes: 0
+      // Not provided by server
+    };
+  }
+  /**
+   * Trigger WAL compaction.
+   */
+  async compact(options) {
+    const params = {};
+    if (options?.force) params["force_snapshot"] = options.force;
+    const result = await this.connection.request("COMPACT" /* COMPACT */, params);
+    return {
+      snapshotsCreated: result.snapshots_created,
+      segmentsDeleted: result.segments_deleted,
+      bytesReclaimed: BigInt(result.bytes_reclaimed)
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Watch/Streaming Operations
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Watch a specific instance for state changes.
+   */
+  async watchInstance(instanceId, options) {
+    const params = {
+      instance_id: instanceId
+    };
+    if (options?.includeCtx !== void 0) params["include_ctx"] = options.includeCtx;
+    if (options?.fromOffset !== void 0) params["from_offset"] = Number(options.fromOffset);
+    const result = await this.connection.request(
+      "WATCH_INSTANCE" /* WATCH_INSTANCE */,
+      params
+    );
+    const handler = new SubscriptionHandler(
+      result.subscription_id,
+      () => this.unwatch(result.subscription_id)
+    );
+    this.subscriptions.register(result.subscription_id, handler);
+    return handler;
+  }
+  /**
+   * Watch all instances matching the filter.
+   */
+  async watchAll(options) {
+    const params = {};
+    if (options?.includeCtx !== void 0) params["include_ctx"] = options.includeCtx;
+    if (options?.fromOffset !== void 0) params["from_offset"] = Number(options.fromOffset);
+    if (options?.machines) params["machines"] = options.machines;
+    if (options?.fromStates) params["from_states"] = options.fromStates;
+    if (options?.toStates) params["to_states"] = options.toStates;
+    if (options?.events) params["events"] = options.events;
+    const result = await this.connection.request(
+      "WATCH_ALL" /* WATCH_ALL */,
+      params
+    );
+    const handler = new SubscriptionHandler(
+      result.subscription_id,
+      () => this.unwatch(result.subscription_id)
+    );
+    this.subscriptions.register(result.subscription_id, handler);
+    return handler;
+  }
+  /**
+   * Cancel a watch subscription.
+   */
+  async unwatch(subscriptionId) {
+    await this.connection.request("UNWATCH" /* UNWATCH */, { subscription_id: subscriptionId });
+    this.subscriptions.unregister(subscriptionId);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+};
+
+exports.AuthenticationError = AuthenticationError;
+exports.Client = Client;
+exports.ClientOptions = ClientOptions;
+exports.ConflictError = ConflictError;
+exports.ConnectionError = ConnectionError;
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+exports.ErrorCode = ErrorCode;
+exports.FRAME_MAGIC = FRAME_MAGIC;
+exports.FrameDecoder = FrameDecoder;
+exports.FrameEncoder = FrameEncoder;
+exports.FrameFlags = FrameFlags;
+exports.GuardFailedError = GuardFailedError;
+exports.HEADER_SIZE = HEADER_SIZE;
+exports.InvalidTransitionError = InvalidTransitionError;
+exports.NotFoundError = NotFoundError;
+exports.Operation = Operation;
+exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
+exports.ProtocolError = ProtocolError;
+exports.RstmdbError = RstmdbError;
+exports.ServerError = ServerError;
+exports.TimeoutError = TimeoutError;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map