reflex-sync 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+# REFLEX
+
+Transparent reactive state synchronization for distributed Node.js environments.
+
+## ⚙️ Configuration Reference
+
+```typescript
+interface ReflexOptions {
+  mode: 'master' | 'client';
+  host?: string;                // Remote address (required for client)
+  port: number;                 // Port for TCP/TLS tunnel
+  key: string;                  // Shared secret for HMAC handshake
+  secure?: boolean;             // Enable TLS 1.3 encryption
+  tls?: {                       // Standard Node.js TLS options
+    cert?: string;
+    key?: string;
+    ca?: string;
+    rejectUnauthorized?: boolean;
+  };
+  limits?: {
+    maxClients?: number;        // Maximum inbound connections
+    maxPayloadSize?: number;    // Inbound packet size cap (default 1MB)
+    opsPerSecond?: number;      // Sliding-window update threshold (default 500)
+  };
+}
+```
+
+## 🛠️ API Reference
+
+### `reflex.boot(): Promise<void>`
+Initializes the instance. On `master`, starts the TCP/TLS listener. On `client`, initiates the handshake and state hydration.
+
+### `reflex.state: T`
+A reactive `Proxy` representing the synchronized state. Changes made to this object are automatically propagated across the network using path-based delta updates. Supports deep nesting and property deletion.
+
+### 📡 Events
+
+| Event | Origin | Payload | Description |
+|-------|--------|---------|-------------|
+| `ready` | Master | `string` | Listener is active and awaiting connections. |
+| `synced` | Client | `void` | Initial state hydration from master is complete. |
+| `update` | Any | `Packet` | Fired when a property change is received from the network. |
+| `clientConnect` | Master | `string` | Fired when a client successfully authenticates (returns IP). |
+| `error` | Any | `Error` | Fired on connection drops or socket failures. |
+| `warn` | Any | `string` | Fired for non-fatal security violations (Rate limits, Over-sized payloads). |
+
+## 🕹️ Examples
+
+### Synchronization Patterns
+
+```typescript
+// Master: Authoritative Node
+const bot = new Reflex({ mode: 'master', port: 8080, key: 'secret' }, { stats: { uptime: 0 } });
+await bot.boot();
+
+// Client: Remote Dashboard
+const web = new Reflex({ mode: 'client', host: 'bot.server.com', port: 8080, key: 'secret' });
+await web.boot();
+
+// Cross-application reaction
+web.on('update', (pkg) => {
+  if (pkg.p.includes('uptime')) renderUI(pkg.v);
+});
+```
+
+## 🔐 Protocol Implementation Details
+
+### Conflict Resolution
+Reflex implements a **Last Write Wins (LWW)** strategy using UTC timestamps (`ts`) generated at the point of origin. Updates arriving at a node with a timestamp older than the current property metadata are discarded to prevent out-of-order state transitions.
+
+### Security Handshake
+1. Client initiates TCP/TLS connection.
+2. Client sends `AUTH` packet with the `key`.
+3. Master validates the `key`.
+4. Master transmits the full current state and metadata mapping (`SYNC`).
+5. Connection is promoted to the active sync set.
+
+---
+
+MIT © 2026 Andrei

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+import { EventEmitter } from 'node:events';
+
+/**
+ * @copyright 2026 Andrei
+ * @license MIT
+ * @package REFLEX
+ */
+type Operation = 'SET' | 'DELETE' | 'AUTH' | 'SYNC' | 'PONG' | 'PING';
+interface Packet {
+    t: Operation;
+    p?: string[];
+    v?: any;
+    ts?: number;
+    m?: Record<string, number>;
+    k?: string;
+    s?: string;
+}
+interface ReflexOptions {
+    host?: string;
+    port: number;
+    key: string;
+    mode: 'master' | 'client';
+    secure?: boolean;
+    tls?: {
+        cert?: string;
+        key?: string;
+        ca?: string;
+        rejectUnauthorized?: boolean;
+    };
+    limits?: {
+        maxClients?: number;
+        maxPayloadSize?: number;
+        opsPerSecond?: number;
+    };
+}
+
+/**
+ * @copyright 2026 Andrei
+ */
+
+declare class Reflex<T extends object> extends EventEmitter {
+    private opts;
+    private _state;
+    private _proxy;
+    private _server;
+    private _socket;
+    private _clients;
+    private readonly _auth;
+    private _timestamps;
+    constructor(opts: ReflexOptions, initial?: T);
+    get state(): T;
+    boot(): Promise<void>;
+    private _serve;
+    private _join;
+    private _handleInbound;
+    private _process;
+    private _propagate;
+    private _transmit;
+}
+
+export { type Operation, type Packet, Reflex, type ReflexOptions };

package/dist/index.js

@@ -0,0 +1,256 @@
+// src/core/Reflex.ts
+import net from "net";
+import tls from "tls";
+import { EventEmitter } from "events";
+
+// src/security/Authenticator.ts
+import crypto from "crypto";
+var Authenticator = class {
+  static ALGORITHM = "sha256";
+  clientOps = /* @__PURE__ */ new Map();
+  lastReset = Date.now();
+  /**
+   * @params {string} key
+   * @params {string} salt
+   * @returns {string} HMAC signature
+   */
+  static sign(key, salt) {
+    return crypto.createHmac(this.ALGORITHM, key).update(salt).digest("hex");
+  }
+  /**
+   * @params {string} challenge
+   * @params {string} signature
+   * @params {string} key
+   * @returns {boolean} Valid/Invalid
+   */
+  static verify(challenge, signature, key) {
+    const expected = this.sign(key, challenge);
+    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+  }
+  /**
+   * @params {string} id
+   * @params {number} limit
+   * @returns {boolean} Within limit/Exceeded
+   */
+  rateLimit(id, limit) {
+    const now = Date.now();
+    if (now - this.lastReset > 1e3) {
+      this.clientOps.clear();
+      this.lastReset = now;
+    }
+    const count = (this.clientOps.get(id) || 0) + 1;
+    if (count > limit) return false;
+    this.clientOps.set(id, count);
+    return true;
+  }
+};
+
+// src/state/ProxyManager.ts
+var ProxyManager = class {
+  _onChange;
+  /**
+   * @params {(path: string[], value: any) => void} listener
+   */
+  constructor(listener) {
+    this._onChange = listener;
+  }
+  /**
+   * @params {T} source
+   * @params {string[]} path
+   * @returns {T} Observability Proxy
+   */
+  observe(source, path = []) {
+    const self = this;
+    return new Proxy(source, {
+      set(target, prop, value) {
+        const fullPath = [...path, String(prop)];
+        if (target[prop] === value) return true;
+        target[prop] = value;
+        self._onChange(fullPath, value);
+        return true;
+      },
+      get(target, prop) {
+        const value = target[prop];
+        if (typeof value === "object" && value !== null) {
+          return self.observe(value, [...path, String(prop)]);
+        }
+        return value;
+      },
+      deleteProperty(target, prop) {
+        delete target[prop];
+        self._onChange([...path, String(prop)], void 0);
+        return true;
+      }
+    });
+  }
+  /**
+   * @params {any} root
+   * @params {string[]} path
+   * @params {any} value
+   */
+  patch(root, path, value) {
+    const last = path.pop();
+    if (!last) return;
+    let target = root;
+    for (const segment of path) {
+      if (!target[segment]) target[segment] = {};
+      target = target[segment];
+    }
+    if (value === void 0) {
+      delete target[last];
+    } else {
+      target[last] = value;
+    }
+  }
+};
+
+// src/core/Reflex.ts
+var Reflex = class extends EventEmitter {
+  constructor(opts, initial = {}) {
+    super();
+    this.opts = opts;
+    this._auth = new Authenticator();
+    this._proxy = new ProxyManager((p, v) => this._propagate(p, v));
+    this._state = this._proxy.observe(initial);
+  }
+  _state;
+  _proxy;
+  _server = null;
+  _socket = null;
+  _clients = /* @__PURE__ */ new Set();
+  _auth;
+  _timestamps = /* @__PURE__ */ new Map();
+  get state() {
+    return this._state;
+  }
+  async boot() {
+    if (this.opts.mode === "master") {
+      return this._serve();
+    } else {
+      return this._join();
+    }
+  }
+  async _serve() {
+    const handler = (s) => this._handleInbound(s);
+    if (this.opts.secure && this.opts.tls) {
+      this._server = tls.createServer(this.opts.tls, handler);
+    } else {
+      this._server = net.createServer(handler);
+    }
+    return new Promise((r) => {
+      this._server?.listen(this.opts.port, this.opts.host || "0.0.0.0", () => {
+        this.emit("ready", `REFLEX Master initialized on ${this.opts.port}`);
+        r();
+      });
+    });
+  }
+  async _join() {
+    return new Promise((resolve) => {
+      const connect = () => {
+        const port = this.opts.port;
+        const host = this.opts.host || "localhost";
+        if (this.opts.secure) {
+          this._socket = tls.connect({ port, host, ...this.opts.tls }, () => {
+            this._transmit({ t: "AUTH", k: this.opts.key });
+            resolve();
+          });
+        } else {
+          this._socket = net.connect({ port, host }, () => {
+            this._transmit({ t: "AUTH", k: this.opts.key });
+            resolve();
+          });
+        }
+        this._socket.on("data", (d) => this._process(d));
+        this._socket.on("error", (e) => {
+          this.emit("error", e);
+          setTimeout(connect, 5e3);
+        });
+      };
+      connect();
+    });
+  }
+  _handleInbound(s) {
+    let verified = false;
+    const remote = s.remoteAddress || "unknown";
+    const heartbeat = setInterval(() => {
+      if (s.writable) s.write(JSON.stringify({ t: "PING" }));
+    }, 3e4);
+    s.on("data", (d) => {
+      if (d.length > (this.opts.limits?.maxPayloadSize || 1024 * 1024)) {
+        this.emit("warn", `Payload too large from ${remote}`);
+        return s.destroy();
+      }
+      try {
+        const pkg = JSON.parse(d.toString());
+        if (pkg.t === "AUTH" && pkg.k === this.opts.key) {
+          verified = true;
+          this._clients.add(s);
+          s.write(JSON.stringify({ t: "SYNC", v: this.state, m: Object.fromEntries(this._timestamps) }));
+          this.emit("clientConnect", remote);
+        } else if (verified) {
+          if (pkg.t === "PONG") return;
+          if (!this._auth.rateLimit(remote, this.opts.limits?.opsPerSecond || 500)) return;
+          this._process(d, s);
+        } else {
+          s.destroy();
+        }
+      } catch (e) {
+        s.destroy();
+      }
+    });
+    s.on("close", () => {
+      clearInterval(heartbeat);
+      this._clients.delete(s);
+    });
+  }
+  _process(d, source) {
+    try {
+      const pkg = JSON.parse(d.toString());
+      if (pkg.t === "PING") return this._transmit({ t: "PONG" });
+      if (pkg.t === "SYNC" && this.opts.mode === "client") {
+        Object.assign(this.state, pkg.v);
+        if (pkg.m) this._timestamps = new Map(Object.entries(pkg.m));
+        this.emit("synced");
+      } else if (pkg.t === "SET") {
+        const key = pkg.p.join(".");
+        const last = this._timestamps.get(key) || 0;
+        if (pkg.ts && pkg.ts < last) return;
+        this._timestamps.set(key, pkg.ts || Date.now());
+        this._proxy.patch(this.state, pkg.p, pkg.v);
+        if (this.opts.mode === "master") {
+          const raw = d.toString();
+          this._clients.forEach((c) => {
+            if (c !== source) c.write(raw);
+          });
+        }
+        this.emit("update", pkg);
+      }
+    } catch (e) {
+    }
+  }
+  _propagate(p, v) {
+    const ts = Date.now();
+    this._timestamps.set(p.join("."), ts);
+    this._transmit({ t: "SET", p, v, ts });
+  }
+  _transmit(pkg) {
+    const raw = JSON.stringify(pkg);
+    if (this.opts.mode === "master") {
+      this._clients.forEach((c) => c.write(raw));
+    } else if (this._socket && !this._socket.destroyed) {
+      this._socket.write(raw);
+    }
+  }
+};
+export {
+  Reflex
+};
+/**
+ * @copyright 2026 Andrei
+ * @license MIT
+ */
+/**
+ * @copyright 2026 Andrei
+ * @license MIT
+ * @package REFLEX
+ */

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "reflex-sync",
+  "version": "1.0.0",
+  "description": "High-performance, secure, real-time reactive state synchronization across processes and servers.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch --dts",
+    "test": "node --test tests/*.test.js"
+  },
+  "keywords": [
+    "state",
+    "sync",
+    "reactive",
+    "ipc",
+    "tls",
+    "proxy",
+    "reflex"
+  ],
+  "author": "Andrei",
+  "license": "MIT",
+  "devDependencies": {
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3",
+    "@types/node": "^20.11.24"
+  },
+  "dependencies": {
+    "zod": "^3.22.4"
+  }
+}

package/src/core/Reflex.ts

@@ -0,0 +1,164 @@
+/**
+ * @copyright 2026 Andrei
+ */
+
+import net from 'node:net';
+import tls from 'node:tls';
+import { EventEmitter } from 'node:events';
+import { ReflexOptions, Packet } from '../types/index.js';
+import { Authenticator } from '../security/Authenticator.js';
+import { ProxyManager } from '../state/ProxyManager.js';
+
+export class Reflex<T extends object> extends EventEmitter {
+  private _state: T;
+  private _proxy: ProxyManager;
+  private _server: net.Server | tls.Server | null = null;
+  private _socket: net.Socket | tls.TLSSocket | null = null;
+  private _clients: Set<net.Socket | tls.TLSSocket> = new Set();
+  private readonly _auth: Authenticator;
+  private _timestamps: Map<string, number> = new Map();
+
+  constructor(private opts: ReflexOptions, initial: T = {} as T) {
+    super();
+    this._auth = new Authenticator();
+    this._proxy = new ProxyManager((p, v) => this._propagate(p, v));
+    this._state = this._proxy.observe(initial);
+  }
+
+  public get state(): T {
+    return this._state;
+  }
+
+  public async boot(): Promise<void> {
+    if (this.opts.mode === 'master') {
+      return this._serve();
+    } else {
+      return this._join();
+    }
+  }
+
+  private async _serve(): Promise<void> {
+    const handler = (s: net.Socket | tls.TLSSocket) => this._handleInbound(s);
+    
+    if (this.opts.secure && this.opts.tls) {
+      this._server = tls.createServer(this.opts.tls, handler);
+    } else {
+      this._server = net.createServer(handler);
+    }
+    
+    return new Promise((r) => {
+      this._server?.listen(this.opts.port, this.opts.host || '0.0.0.0', () => {
+        this.emit('ready', `REFLEX Master initialized on ${this.opts.port}`);
+        r();
+      });
+    });
+  }
+
+  private async _join(): Promise<void> {
+    return new Promise((resolve) => {
+      const connect = () => {
+        const port = this.opts.port;
+        const host = this.opts.host || 'localhost';
+
+        if (this.opts.secure) {
+          this._socket = tls.connect({ port, host, ...this.opts.tls }, () => {
+             this._transmit({ t: 'AUTH', k: this.opts.key });
+             resolve();
+          });
+        } else {
+          this._socket = net.connect({ port, host }, () => {
+            this._transmit({ t: 'AUTH', k: this.opts.key });
+            resolve();
+          });
+        }
+
+        this._socket.on('data', (d: Buffer) => this._process(d));
+        this._socket.on('error', (e: Error) => {
+          this.emit('error', e);
+          setTimeout(connect, 5000);
+        });
+      };
+      connect();
+    });
+  }
+
+  private _handleInbound(s: net.Socket | tls.TLSSocket): void {
+    let verified = false;
+    const remote = s.remoteAddress || 'unknown';
+
+    const heartbeat = setInterval(() => {
+      if (s.writable) s.write(JSON.stringify({ t: 'PING' }));
+    }, 30000);
+
+    s.on('data', (d: Buffer) => {
+      if (d.length > (this.opts.limits?.maxPayloadSize || 1024 * 1024)) {
+        this.emit('warn', `Payload too large from ${remote}`);
+        return s.destroy();
+      }
+
+      try {
+        const pkg: Packet = JSON.parse(d.toString());
+        
+        if (pkg.t === 'AUTH' && pkg.k === this.opts.key) {
+          verified = true;
+          this._clients.add(s);
+          s.write(JSON.stringify({ t: 'SYNC', v: this.state, m: Object.fromEntries(this._timestamps) }));
+          this.emit('clientConnect', remote);
+        } else if (verified) {
+          if (pkg.t === 'PONG') return;
+          if (!this._auth.rateLimit(remote, this.opts.limits?.opsPerSecond || 500)) return;
+          this._process(d, s);
+        } else {
+          s.destroy();
+        }
+      } catch (e) { s.destroy(); }
+    });
+
+    s.on('close', () => {
+      clearInterval(heartbeat);
+      this._clients.delete(s);
+    });
+  }
+
+  private _process(d: Buffer, source?: net.Socket | tls.TLSSocket): void {
+    try {
+      const pkg: Packet = JSON.parse(d.toString());
+      if (pkg.t === 'PING') return this._transmit({ t: 'PONG' });
+      
+      if (pkg.t === 'SYNC' && this.opts.mode === 'client') {
+        Object.assign(this.state, pkg.v);
+        if (pkg.m) this._timestamps = new Map(Object.entries(pkg.m));
+        this.emit('synced');
+      } else if (pkg.t === 'SET') {
+        const key = pkg.p!.join('.');
+        const last = this._timestamps.get(key) || 0;
+        
+        if (pkg.ts && pkg.ts < last) return; // Conflict resolution: LWW
+        
+        this._timestamps.set(key, pkg.ts || Date.now());
+        this._proxy.patch(this.state, pkg.p!, pkg.v);
+
+        if (this.opts.mode === 'master') {
+          const raw = d.toString();
+          this._clients.forEach(c => { if (c !== source) c.write(raw); });
+        }
+        this.emit('update', pkg);
+      }
+    } catch (e) {}
+  }
+
+  private _propagate(p: string[], v: any): void {
+    const ts = Date.now();
+    this._timestamps.set(p.join('.'), ts);
+    this._transmit({ t: 'SET', p, v, ts });
+  }
+
+  private _transmit(pkg: Packet): void {
+    const raw = JSON.stringify(pkg);
+    if (this.opts.mode === 'master') {
+      this._clients.forEach(c => c.write(raw));
+    } else if (this._socket && !this._socket.destroyed) {
+      this._socket.write(raw);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @copyright 2026 Andrei
+ * @license MIT
+ */
+
+export * from './core/Reflex.js';
+export * from './types/index.js';

package/src/security/Authenticator.ts

@@ -0,0 +1,54 @@
+/**
+ * @copyright 2026 Andrei
+ * @license MIT
+ */
+
+import crypto from 'node:crypto';
+
+export class Authenticator {
+  private static readonly ALGORITHM = 'sha256';
+  private clientOps: Map<string, number> = new Map();
+  private lastReset = Date.now();
+
+  /**
+   * @params {string} key
+   * @params {string} salt
+   * @returns {string} HMAC signature
+   */
+  public static sign(key: string, salt: string): string {
+    return crypto
+      .createHmac(this.ALGORITHM, key)
+      .update(salt)
+      .digest('hex');
+  }
+
+  /**
+   * @params {string} challenge
+   * @params {string} signature
+   * @params {string} key
+   * @returns {boolean} Valid/Invalid
+   */
+  public static verify(challenge: string, signature: string, key: string): boolean {
+    const expected = this.sign(key, challenge);
+    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+  }
+
+  /**
+   * @params {string} id
+   * @params {number} limit
+   * @returns {boolean} Within limit/Exceeded
+   */
+  public rateLimit(id: string, limit: number): boolean {
+    const now = Date.now();
+    if (now - this.lastReset > 1000) {
+      this.clientOps.clear();
+      this.lastReset = now;
+    }
+
+    const count = (this.clientOps.get(id) || 0) + 1;
+    if (count > limit) return false;
+
+    this.clientOps.set(id, count);
+    return true;
+  }
+}

package/src/state/ProxyManager.ts

@@ -0,0 +1,69 @@
+/**
+ * @copyright 2026 Andrei
+ */
+
+export class ProxyManager {
+  private _onChange: (path: string[], value: any) => void;
+
+  /**
+   * @params {(path: string[], value: any) => void} listener
+   */
+  constructor(listener: (path: string[], value: any) => void) {
+    this._onChange = listener;
+  }
+
+  /**
+   * @params {T} source
+   * @params {string[]} path
+   * @returns {T} Observability Proxy
+   */
+  public observe<T extends object>(source: T, path: string[] = []): T {
+    const self = this;
+    return new Proxy(source, {
+      set(target: any, prop: string | symbol, value: any): boolean {
+        const fullPath = [...path, String(prop)];
+        
+        // Prevent recursive triggers if same value
+        if (target[prop] === value) return true;
+
+        target[prop] = value;
+        self._onChange(fullPath, value);
+        return true;
+      },
+      get(target: any, prop: string | symbol): any {
+        const value = target[prop];
+        if (typeof value === 'object' && value !== null) {
+          return self.observe(value, [...path, String(prop)]);
+        }
+        return value;
+      },
+      deleteProperty(target: any, prop: string | symbol): boolean {
+        delete target[prop];
+        self._onChange([...path, String(prop)], undefined);
+        return true;
+      }
+    });
+  }
+
+  /**
+   * @params {any} root
+   * @params {string[]} path
+   * @params {any} value
+   */
+  public patch(root: any, path: string[], value: any): void {
+    const last = path.pop();
+    if (!last) return;
+
+    let target = root;
+    for (const segment of path) {
+      if (!target[segment]) target[segment] = {};
+      target = target[segment];
+    }
+
+    if (value === undefined) {
+      delete target[last];
+    } else {
+      target[last] = value;
+    }
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,36 @@
+/**
+ * @copyright 2026 Andrei
+ * @license MIT
+ * @package REFLEX
+ */
+
+export type Operation = 'SET' | 'DELETE' | 'AUTH' | 'SYNC' | 'PONG' | 'PING';
+
+export interface Packet {
+  t: Operation;
+  p?: string[]; // Path
+  v?: any;      // Value
+  ts?: number;  // Timestamp (Conflict Resolution)
+  m?: Record<string, number>; // Full Metadata Sync
+  k?: string;   // Key/Handshake
+  s?: string;   // Salt/Signature
+}
+
+export interface ReflexOptions {
+  host?: string;
+  port: number;
+  key: string;
+  mode: 'master' | 'client';
+  secure?: boolean;
+  tls?: {
+    cert?: string;
+    key?: string;
+    ca?: string;
+    rejectUnauthorized?: boolean;
+  };
+  limits?: {
+    maxClients?: number;
+    maxPayloadSize?: number; // In bytes
+    opsPerSecond?: number; 
+  };
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}