topazcube 0.0.2 → 0.1.0

package/dist/topazcube-server.js

@@ -0,0 +1,740 @@
+import * as G from "node:https";
+import * as b from "node:fs";
+import { FLOAT32_OPTIONS as N, Packr as W } from "msgpackr";
+import { promisify as x } from "util";
+import { constants as H, gzip as Z, gunzip as X } from "zlib";
+import q from "fast-json-patch";
+import { WebSocketServer as B } from "ws";
+import { MongoClient as K } from "mongodb";
+import * as L from "@roamhq/wrtc";
+import { glMatrix as Q } from "gl-matrix";
+const { ALWAYS: J, DECIMAL_ROUND: ft, DECIMAL_FIT: pt } = N;
+let O = new W({
+  useFloat32: J
+});
+function w(o) {
+  return O.pack(o);
+}
+function P(o) {
+  return O.unpack(o);
+}
+function U(o, t, e, s = "", n = !1) {
+  if (t === null || typeof t != "object")
+    return t;
+  function i(a) {
+    let l = !0;
+    return a.startsWith("_") && (l = !1), n && n[a] && (l = !1), s == "/entities" && (l = !1), l;
+  }
+  for (const a in t)
+    i(a) && (t[a] = U(
+      o,
+      t[a],
+      e,
+      s + "/" + a,
+      n
+    ));
+  return new Proxy(t, {
+    get(a, l, u) {
+      return Reflect.get(a, l, u);
+    },
+    set(a, l, u) {
+      let h, f = s + "/" + String(l);
+      return i(l) ? (h = U(o, u, e, f, n), e(o, "replace", a, f, h)) : h = u, Reflect.set(a, l, h);
+    },
+    deleteProperty(a, l) {
+      let u = s + "/" + String(l);
+      return delete a[l], i(l) && e(o, "delete", a, u, null), !0;
+    }
+  });
+}
+function C(o, t = "_") {
+  if (o === null || typeof o != "object")
+    return o;
+  function e(n) {
+    let i = !1;
+    return (typeof t == "string" && n.startsWith(t) || typeof t == "object" && (t[n] || n.startsWith("_"))) && (i = !0), i;
+  }
+  if (o instanceof Map) {
+    const n = /* @__PURE__ */ new Map();
+    for (let [i, a] of o)
+      n.set(C(i, t), C(a, t));
+    return n;
+  }
+  let s;
+  if (Array.isArray(o)) {
+    s = [];
+    for (let n = 0; n < o.length; n++)
+      s[n] = C(o[n], t);
+  } else {
+    s = {};
+    for (let n in o)
+      o.hasOwnProperty(n) && !e(n) && (typeof o[n] == "object" ? s[n] = C(o[n], t) : s[n] = o[n]);
+  }
+  return s;
+}
+function $(o) {
+  if (Array.isArray(o))
+    return o.map($);
+  if (o !== null && typeof o == "object") {
+    const t = {};
+    for (const e in o)
+      t[e] = $(o[e]);
+    return t;
+  } else return typeof o == "number" ? Number.isInteger(o) ? o : parseFloat(o.toFixed(3)) : o;
+}
+function V(o) {
+  let t = {};
+  return o.o ? t.op = {
+    a: "add",
+    r: "remove",
+    d: "delete",
+    t: "test"
+  }[o.o] : t.op = "replace", t.path = o.p, t.value = o.v, t;
+}
+function Y(o, t, e, s) {
+  let n = { p: e, v: s };
+  return o != "replace" && (n.o = {
+    add: "a",
+    remove: "r",
+    delete: "d",
+    test: "t"
+  }[o]), n;
+}
+function I(o, t, e = 0) {
+  t || (t = new Uint8Array(4));
+  let s = e + 3;
+  return t[s--] = o & 255, o >>= 8, t[s--] = o & 255, o >>= 8, t[s--] = o & 255, o >>= 8, t[s] = o, t;
+}
+function j(o, t, e = 0) {
+  t || (t = new Uint8Array(3));
+  let s = e + 2;
+  return t[s--] = o & 255, o >>= 8, t[s--] = o & 255, o >>= 8, t[s] = o, t;
+}
+function tt(o, t, e = 0) {
+  t || (t = new Uint8Array(2));
+  let s = e + 1;
+  return t[s--] = o & 255, o >>= 8, t[s] = o, t;
+}
+function E(o, t, e = 0) {
+  const s = Math.round(Math.abs(o) * 256);
+  j(s, t, e), o < 0 && (t[e] |= 128);
+}
+function M(o, t, e = 0) {
+  const s = Math.round(Math.abs(o) * 65536);
+  I(s, t, e), o < 0 && (t[e] |= 128);
+}
+function S(o, t, e = 0) {
+  const s = Math.round(Math.abs(o) * 4096);
+  tt(s, t, e), o < 0 && (t[e] |= 128);
+}
+const et = 256, st = 999999, nt = x(Z);
+x(X);
+async function T(o) {
+  if (o.byteLength <= et || o.byteLength >= st) return o;
+  try {
+    let t = Date.now(), e = await nt(o, {
+      level: H.Z_BEST_SPEED
+    }), s = Date.now(), n = Buffer.from(e), i = Date.now();
+    return n;
+  } catch (t) {
+    return console.error("Error compressing buffer:", t), o;
+  }
+}
+Q.setMatrixArrayType(Array);
+const D = {
+  type: !0,
+  // string 'enemy'
+  status: !0,
+  // string 'idle'
+  level: !0,
+  // number 2
+  race: !0,
+  // string 'goblin'
+  class: !0,
+  // string 'warrior'
+  model: !0,
+  // string 'models/models.glb|goblin'
+  animation: !0,
+  // string 'idle2'
+  sound: !0,
+  // string 'sound/goblin.snd|snarl'
+  effect: !0,
+  // 'selected'
+  position: !0,
+  // [0, 0, 0] Vector (Number)
+  rotation: !0,
+  // [0, 0, 0, 1] Quaternion (Number)
+  scale: !0
+  // [1, 1, 1] Vector (Number)
+}, F = {
+  type: !0,
+  status: !0,
+  level: !0,
+  race: !0,
+  class: !0,
+  model: !0,
+  animation: !0,
+  sound: !0,
+  effect: !0
+}, { applyOperation: ot } = q, it = (() => {
+  const o = new ArrayBuffer(2);
+  return new DataView(o).setInt16(0, 256, !0), new Int16Array(o)[0] === 256;
+})(), k = 65400;
+class gt {
+  constructor({
+    name: t = "TopazCubeServer",
+    cycle: e = 100,
+    port: s = 8799,
+    useHttps: n = !1,
+    key: i = "./cert/key.pem",
+    cert: a = "./cert/fullchain.pem",
+    MongoUrl: l = "mongodb://localhost:27017",
+    database: u = "topazcube",
+    collection: h = "documents",
+    allowSave: f = !0,
+    allowSync: y = !0,
+    allowWebRTC: R = !1,
+    allowFastPatch: r = !1,
+    allowCompression: p = !1,
+    simulateLatency: g = 0
+  }) {
+    if (this.name = "TopazCubeServer", this.cycle = 100, this.patchCycleDivider = 1, this.port = 8799, this.useHttps = !1, this.key = "./cert/key.pem", this.cert = "./cert/fullchain.pem", this.MongoUrl = "mongodb://localhost:27017", this.mongoClient = null, this.DB = null, this.database = "topazcube", this.collection = "documents", this.allowSave = !0, this.allowSync = !0, this.allowWebRTC = !1, this.allowFastPatch = !1, this.allowCompression = !1, this.simulateLatency = 0, this._lastUID = 100, this.clients = [], this.documents = {}, this.isLoading = {}, this._documentChanges = {}, this._documentState = {}, this.update = 0, this.lastUpdate = 0, this._loopiv = null, this._statsiv = null, this._stillUpdating = !1, this.stats = {
+      tUpdate: [],
+      tPatch: [],
+      send: 0,
+      sendRTC: 0,
+      _sendRTCUpdate: 0
+    }, this._wss = null, this._exited = !1, this.name = t, this.cycle = e, this.port = s, this.useHttps = n, this.key = i, this.cert = a, this.MongoUrl = l, this.database = u, this.collection = h, this.allowSave = f, this.allowSync = y, this.allowWebRTC = R, this.allowFastPatch = r, this.allowCompression = p, this.simulateLatency = g, this._initDB(), n) {
+      let c = G.createServer({
+        key: b.readFileSync(this.key),
+        cert: b.readFileSync(this.cert)
+      }, (d, _) => {
+        _.writeHead(200), _.end("<b>Hello World!</b>");
+      }).listen(this.port);
+      this._wss = new B({ server: c }), c = null, console.log(this.name + " running on HTTPS port " + this.port);
+    } else
+      this._wss = new B({ port: this.port }), console.log(this.name + " running on port " + this.port);
+    this._wss.on("connection", (c) => {
+      this._onConnected(c);
+    }), process.stdin.resume(), process.on("SIGINT", () => {
+      this._exitSignal("SIGINT");
+    }), process.on("SIGQUIT", () => {
+      this._exitSignal("SIGQUIT");
+    }), process.on("SIGTERM", () => {
+      this._exitSignal("SIGTERM");
+    }), process.on("SIGUSR2", () => {
+      this._exitSignal("SIGUSR2");
+    }), process.stdin.resume(), process.stdin.setEncoding("utf8"), process.stdin.on("data", (c) => {
+      if (c = ("" + c).trim(), c == "") {
+        this._exitSignal("SIGINT");
+        return;
+      }
+      console.log(`Key pressed: ${c}`), c == "s" && (console.log("Saving all documents..."), this._saveAllDocuments()), c == "i" && console.log(
+        `Server: ${this.name}, Clients: ${this.clients.length}, Documents: ${Object.keys(this.documents).length}`
+      );
+    }), this._startLoop();
+  }
+  /*= DOCUMENTS ==============================================================*/
+  // to be redefined. Called before a new document is created. Returns true if
+  // the client has the right to create an empty document
+  canCreate(t, e) {
+    return !0;
+  }
+  // to be redefined. Called when a new document is created
+  // (returns an empty document)
+  onCreate(t) {
+    return {
+      data: {}
+    };
+  }
+  // to be redefined. Called when a client wants to sync (modify) a document.
+  // Returns true if the client has the right to sync that operation.
+  canSync(t, e, s) {
+    return !0;
+  }
+  // to be redefined. Called when a new document is hydrated
+  // (created, or loaded from db)
+  async onHydrate(t, e) {
+    e.__hydrated = !0;
+  }
+  _makeReactive(t) {
+    let e = !1;
+    this.allowFastPatch && (e = D), this.documents[t] = U(
+      t,
+      this.documents[t],
+      this._onDocumentChange.bind(this),
+      "",
+      e
+    ), this._documentChanges[t] || (this._documentChanges[t] = []);
+  }
+  _createEmptyDocument(t) {
+    let e = this.onCreate(t);
+    e && (this.documents[t] = e);
+  }
+  async _waitLoad(t) {
+    if (this.isLoading[t])
+      for (; this.isLoading[t]; )
+        await new Promise((e) => setTimeout(e, 50));
+  }
+  async _checkDocument(t, e) {
+    await this._waitLoad(t), this.documents[t] || (this.isLoading[t] = !0, await this._loadDocument(t), !this.documents[t] && this.canCreate(e, t) && this._createEmptyDocument(t), this.documents[t] && (this._makeReactive(t), this.onHydrate(t, this.documents[t])), this.isLoading[t] = !1, this._documentState[t] = {
+      subscibers: 0,
+      lastModified: Date.now()
+    });
+  }
+  _updateAllDocumentsState() {
+    for (let t in this.documents)
+      if (t != "_server") {
+        this.documents[t], this._documentState[t].subscibers = 0;
+        for (let e of this.clients)
+          e.subscribed[t] && this._documentState[t].subscibers++;
+      }
+  }
+  /*= UPDATE LOOP ============================================================*/
+  // to be redefined. called every this.cycle ms
+  onUpdate(t, e, s) {
+  }
+  _startLoop() {
+    this.lastUpdate = Date.now(), this._loop(), this._statsiv = setInterval(() => {
+      this._doStats();
+    }, 1e3);
+  }
+  _loop() {
+    let t = Date.now(), e = t - this.lastUpdate, s = e / 1e3;
+    this.lastUpdate = t, this._stillUpdating = !0;
+    for (let h in this.documents)
+      this.onUpdate(h, this.documents[h], s);
+    let n = Date.now();
+    this._stillUpdating = !1;
+    let i = n - t;
+    this.stats.tUpdate.push(i);
+    let a = 0;
+    this.update % this.patchCycleDivider == 0 && (this._sendPatches(), a = Date.now() - n, this.stats.tPatch.push(a), this.allowFastPatch && console.log(`update ${this.update} dt:${e}ms RTC:${this.stats._sendRTCUpdate}bytes, tUpdate: ${i}ms, tPatch: ${a}ms`), this.stats._sendRTCUpdate = 0), this.update++;
+    let u = Date.now() - t;
+    setTimeout(() => {
+      this._loop();
+    }, Math.max(this.cycle - u, 10));
+  }
+  _doStats() {
+    for (let t in this.stats) {
+      let e = this.stats[t];
+      if (e.length > 0) {
+        for (; e.length > 60; )
+          e.shift();
+        this.stats["_avg_" + t] = e.reduce((s, n) => s + n, 0) / e.length;
+      } else t.startsWith("_") || (this.stats["_persec_" + t] = e / 3, this.stats[t] = 0);
+    }
+  }
+  /*= MESSAGES ===============================================================*/
+  // to be redefined. Called on message (operation) from client
+  onMessage(t, e) {
+  }
+  // to be redefined. Called when a client connects
+  onConnect(t) {
+  }
+  // to be redefined. Called when a client disconnects
+  onDisconnect(t) {
+  }
+  _onConnected(t) {
+    t.ID = this.getUID(), t.ping = 0, t.ctdiff = 0, t.subscribed = {}, t.dataChannel = null, t.peerConnection = null, console.log("client connected", t.ID), this.clients.push(t), t.on("error", () => {
+      this._onError(t, arguments);
+    }), t.on("message", (e) => {
+      let s = P(e);
+      this.simulateLatency ? setTimeout(() => {
+        this._onMessage(t, s);
+      }, this.simulateLatency) : this._onMessage(t, s);
+    }), t.on("close", (e) => {
+      this._onDisconnected(t), this.onDisconnect(t);
+    }), this.onConnect(t);
+  }
+  async _onMessage(t, e) {
+    if (e.c == "sync" && this.allowSync && t.subscribed[e.n] && this.documents[e.n]) {
+      let s = e.n;
+      this._documentChanges[s] || (this._documentChanges[s] = []);
+      for (let n of e.p) {
+        if (!this.canSync(t, s, n))
+          continue;
+        this._documentChanges[s].push(n);
+        let i = V(n);
+        ot(this.documents[s], i);
+      }
+    } else if (e.c == "ping")
+      this.send(t, {
+        c: "pong",
+        t: Date.now(),
+        ct: e.ct,
+        ID: t.ID
+      });
+    else if (e.c == "peng") {
+      let s = Date.now(), n = s - e.st;
+      t.ctdiff = e.ct + n / 2 - s, t.ping = n;
+    } else if (e.c == "rtc-offer")
+      this._processOffer(t, e);
+    else if (e.c == "rtc-candidate")
+      this._processICECandidate(t, e);
+    else if (e.c == "sub") {
+      if (await this._checkDocument(e.n, t), !this.documents[e.n]) {
+        this.send(t, {
+          c: "error",
+          t: Date.now(),
+          message: "Document not found"
+        });
+        return;
+      }
+      t.subscribed[e.n] = !0, this._sendFullState(e.n, t);
+    } else e.c == "unsub" ? t.subscribed[e.n] = !1 : this.onMessage(t, e);
+  }
+  _onError(t, e) {
+    console.error("onError:", e);
+  }
+  _onDisconnected(t) {
+    t.dataChannel && t.dataChannel.close(), t.peerConnection && t.peerConnection.close(), console.log("client disconnected");
+    let e = this.clients.indexOf(t);
+    e !== -1 && this.clients.splice(e, 1);
+  }
+  async send(t, e) {
+    try {
+      let s = Date.now(), n = w(e), i = Date.now(), a = n.byteLength;
+      this.allowCompression && (n = await T(n));
+      let l = Date.now();
+      n.length > 4096 && console.log(`Big message ${a} -> ${n.length} (${(100 * n.length / a).toFixed()}%) encoding:${i - s}ms compression:${l - s}ms`), this.stats.send += n.byteLength, this.simulateLatency ? setTimeout(() => {
+        t.send(n);
+      }, this.simulateLatency) : t.send(n);
+    } catch (s) {
+      console.error("Error sending message:", s, e);
+    }
+  }
+  async broadcast(t, e = !1) {
+    e || (e = this.clients);
+    let s = w(t);
+    this.allowCompression && (s = await T(s));
+    for (let n of this.clients)
+      this.stats.send += s.byteLength, this.simulateLatency ? setTimeout(() => {
+        n.send(s);
+      }, this.simulateLatency) : n.send(s);
+  }
+  async _sendFullState(t, e) {
+    await this._waitLoad(t);
+    let s = "_";
+    this.allowFastPatch && (s = D);
+    let n = C(this.documents[t], s);
+    $(n);
+    let i = !1;
+    this.allowFastPatch && (i = this._encodeFastChanges(t, !1));
+    let a = {
+      c: "full",
+      le: it,
+      t: Date.now(),
+      n: t,
+      doc: n,
+      fdata: i
+    };
+    this.send(e, a);
+  }
+  _encodeFastChanges(t, e = !0) {
+    let s = this.documents[t];
+    if (!s)
+      return !1;
+    let n = this.documents[t].origin;
+    n || (n = [0, 0, 0], this.documents[t].origin = n);
+    let i = s.entities, a = Object.keys(i);
+    if (!i)
+      return !1;
+    let l = {}, u = {}, h = {}, f = {}, y = {};
+    for (let r in D)
+      e ? (l[r] = 0, u[r] = {}, h[r] = !1) : (l[r] = a.length, u[r] = {}, h[r] = !0), f[r] = {};
+    if (e)
+      for (let r in i) {
+        let p = i[r];
+        for (let g in D)
+          p["__changed_" + g] && (u[g][r] = !0, l[g]++, h[g] = !0, p["__changed_" + g] = !1);
+      }
+    else
+      for (let r in i)
+        for (let p in D)
+          u[p][r] = !0;
+    let R = 1;
+    for (let r in h)
+      if (h[r] && F[r])
+        for (let p in u[r]) {
+          let c = i[p][r];
+          f[r][c] || (f[r][c] = R++);
+        }
+    console.log("--------------------------------------------------");
+    for (let r in h)
+      if (h[r]) {
+        let p = l[r], g = {};
+        if (F[r]) {
+          g.dict = f[r];
+          let c = new Uint8Array(p * 8), d = 0;
+          for (let _ in u[r]) {
+            let m = i[_], v = parseInt(_);
+            I(v, c, d), d += 4;
+            let A = m[r], z = parseInt(f[r][A]);
+            I(z, c, d), d += 4;
+          }
+          g.pdata = c;
+        } else {
+          let c;
+          r == "position" ? c = new Uint8Array(p * 13) : r == "rotation" ? c = new Uint8Array(p * 16) : r == "scale" && (c = new Uint8Array(p * 16));
+          let d = 0;
+          for (let _ in u[r]) {
+            let m = i[_], v = parseInt(_);
+            I(v, c, d), d += 4, r == "position" ? (E(m.position[0] - n[0], c, d), d += 3, E(m.position[1] - n[1], c, d), d += 3, E(m.position[2] - n[2], c, d), d += 3) : r == "rotation" ? (S(m.rotation[0], c, d), d += 2, S(m.rotation[1], c, d), d += 2, S(m.rotation[2], c, d), d += 2, S(m.rotation[3], c, d), d += 2) : r == "scale" && (M(m.scale[0], c, d), d += 4, M(m.scale[1], c, d), d += 4, M(m.scale[2], c, d), d += 4);
+          }
+          g.pdata = c;
+        }
+        y[r] = g;
+      }
+    return y;
+  }
+  _sendPatches() {
+    let t = Date.now();
+    for (let e in this._documentChanges) {
+      let s = this._documentChanges[e];
+      this._documentChanges[e] = [];
+      let n = this.clients.filter((i) => i.subscribed[e]);
+      if (n.length > 0 && s.length > 0) {
+        let i = {
+          c: "patch",
+          t,
+          // server time
+          u: this.update,
+          n: e,
+          doc: s
+        };
+        this.broadcast(i, n);
+      }
+      if (this.allowFastPatch && n.length > 0) {
+        let i = Date.now(), a = this._encodeFastChanges(e), l = Date.now(), u = {
+          c: "fpatch",
+          t,
+          // server time
+          u: this.update,
+          n: e,
+          fdata: a
+        };
+        this.broadcastRTC(u, n);
+        let h = Date.now();
+        console.log(`_sendPatches: ${e} encode_changes: ${l - i}ms broadcast:${h - l}ms`);
+      }
+    }
+  }
+  _onDocumentChange(t, e, s, n, i) {
+    this._documentChanges[t].push(Y(e, s, n, i));
+  }
+  propertyChange(t, e, s) {
+    let n = this.documents[t];
+    if (!n)
+      return;
+    let i = n.entities;
+    if (!i)
+      return;
+    let a = i[e];
+    a && (a["__changed_" + s] = !0);
+  }
+  /*= WEBRTC ===================================================================*/
+  async _processOffer(t, e) {
+    const s = new L.RTCPeerConnection({
+      iceServers: [
+        { urls: "stun:stun.l.google.com:19302" },
+        { urls: "stun:stun.cloudflare.com:3478" },
+        { urls: "stun:freestun.net:3478" }
+      ],
+      iceCandidatePoolSize: 10
+    });
+    t.peerConnection = s, s.onicecandidate = (n) => {
+      n.candidate && this.send(t, {
+        c: "rtc-candidate",
+        type: "ice-candidate",
+        candidate: n.candidate.toJSON()
+      });
+    }, s.onconnectionstatechange = () => {
+      s.connectionState === "connected" ? (t.webRTCConnected = !0, console.log(`RTC: Connection established with client ${t.ID}`)) : (s.connectionState === "failed" || s.connectionState === "disconnected" || s.connectionState === "closed") && (t.webRTCConnected = !1, console.log(`RTC: Connection failed or closed with client ${t.ID}`));
+    }, s.onicegatheringstatechange = () => {
+    }, s.oniceconnectionstatechange = () => {
+      s.iceConnectionState === "connected" || s.iceConnectionState;
+    };
+    try {
+      await s.setRemoteDescription(
+        new L.RTCSessionDescription(e)
+      ), t.dataChannel = s.createDataChannel("serverchannel", {
+        ordered: !0,
+        maxRetransmits: 1
+      }), t.dataChannel.onopen = () => {
+        try {
+          const i = { c: "test", message: "Hello WebRTC" };
+          this.sendRTC(t, i);
+        } catch (i) {
+          console.error(
+            `RTC: Error sending test message to client ${t.ID}`,
+            i
+          );
+        }
+      }, t.dataChannel.onclose = () => {
+        console.log(`RTC: Data channel closed for client ${t.ID}`);
+      }, t.dataChannel.onerror = (i) => {
+        console.error(`RTC: Data channel error for client ${t.ID}:`, i);
+      }, t.dataChannel.onmessage = (i) => {
+        try {
+          const a = P(i.data);
+          console.log(
+            `RTC: Data channel message from client ${t.ID}:`,
+            a
+          );
+        } catch (a) {
+          console.error(
+            `RTC: Error decoding message from client ${t.ID}:`,
+            a
+          );
+        }
+      };
+      const n = await s.createAnswer();
+      await s.setLocalDescription(n), this.send(t, {
+        c: "rtc-answer",
+        type: n.type,
+        sdp: n.sdp
+      });
+    } catch (n) {
+      console.error(
+        `RTC: Error processing offer from client ${t.ID}:`,
+        n
+      );
+    }
+  }
+  async _processICECandidate(t, e) {
+    try {
+      t.peerConnection && e.candidate && await t.peerConnection.addIceCandidate(
+        new L.RTCIceCandidate(e.candidate)
+      );
+    } catch {
+      console.error(`RTC: Error adding ICE candidate for client ${t.ID}`);
+    }
+  }
+  _clientRTCOpen(t) {
+    return t.dataChannel && t.dataChannel.readyState === "open";
+  }
+  async sendRTC(t, e) {
+    let s = w(e);
+    this.allowCompression && (s = await T(s)), this.stats.sendRTC += s.byteLength, this.stats._sendRTCUpdate += s.byteLength;
+    let n = this._splitRTCMessage(s);
+    this.simulateLatency ? setTimeout(() => {
+      this._clientRTCOpen(t) && n.forEach((i) => {
+        t.dataChannel.send(i);
+      });
+    }, this.simulateLatency) : this._clientRTCOpen(t) && n.forEach((i) => {
+      t.dataChannel.send(i);
+    });
+  }
+  async broadcastRTC(t, e = []) {
+    e.length == 0 && (e = this.clients);
+    let s = Date.now(), n = w(t), i = n.byteLength, a = Date.now();
+    this.allowCompression && (n = await T(n));
+    let l = Date.now();
+    n.length > 16384 && console.log(`BroadcastRTC message ${i} -> ${n.length} (${(100 * n.length / i).toFixed()}%) encoding:${a - s}ms compression:${l - s}ms`);
+    let u = this._splitRTCMessage(n);
+    for (let h of this.clients)
+      this.stats.sendRTC += n.byteLength, this.stats._sendRTCUpdate += n.byteLength, this.simulateLatency ? setTimeout(() => {
+        h.dataChannel && h.dataChannel.readyState === "open" && u.forEach((f) => {
+          h.dataChannel.send(f);
+        });
+      }, this.simulateLatency) : h.dataChannel && h.dataChannel.readyState === "open" && u.forEach((f) => {
+        h.dataChannel.send(f);
+      });
+  }
+  _splitRTCMessage(t) {
+    let e;
+    if (t.byteLength > 65535) {
+      const s = Date.now();
+      console.warn(`RTC: Message too large: ${t.byteLength} bytes`), e = [];
+      let n = 0, i = this.update + "-" + s, a = 0;
+      for (; n < t.byteLength; ) {
+        const l = t.byteLength - n, u = Math.min(l, k), h = new Uint8Array(t.buffer, n, u);
+        let f = {
+          c: "chunk",
+          t: s,
+          mid: i,
+          seq: a,
+          ofs: n,
+          chs: u,
+          ts: t.byteLength,
+          data: h,
+          last: l <= k
+        };
+        e.push(w(f)), n += u, a++;
+      }
+      console.log(`RTC: Large message split into ${e.length} packages`);
+    } else
+      e = [t], console.log(`RTC: Message - ${t.byteLength} bytes`);
+    return e;
+  }
+  /*= DATABASE =================================================================*/
+  // properties (of the documents) that starts with __ are not saved to the database.
+  // __properties are restored on hydration. (for example __physicsBody or __bigObject)
+  getUID() {
+    return this.documents._server.nextUID++, this.documents._server.nextUID;
+  }
+  async _initDB() {
+    await this._connectDB(), await this._loadDocument("_server"), this.documents._server || this._initServerDocument();
+  }
+  async _connectDB() {
+    this.mongoClient = new K(this.MongoUrl);
+    try {
+      await this.mongoClient.connect(), console.log("Connected to MongoDB");
+      const t = this.mongoClient.db(this.database);
+      this.DB = t;
+    } catch (t) {
+      console.error("Error connecting to MongoDB:", t), this.mongoClient = null;
+    }
+  }
+  async _loadDocument(t) {
+    if (console.log(`Loading document '${t}' from MongoDB`), this.DB)
+      try {
+        const e = await this.DB.collection(this.collection).findOne({
+          name: t
+        });
+        e && (delete e._id, this.documents[t] = e);
+      } catch (e) {
+        console.error("Error loading document from MongoDB:", e);
+      }
+    else
+      console.warn("MongoDB client not initialized. Document not loaded.");
+  }
+  async _saveDocument(t) {
+    if (this.DB)
+      try {
+        const e = this.documents[t];
+        let s = C(e, "__");
+        console.log(`Saving document '${t}' to MongoDB`), await this.DB.collection(this.collection).updateOne(
+          { name: t },
+          { $set: s },
+          { upsert: !0 }
+        ), console.log("Document saved to MongoDB");
+      } catch (e) {
+        console.error("Error saving document to MongoDB:", e);
+      }
+    else
+      console.warn("MongoDB client not initialized. Document not saved.");
+  }
+  async _saveAllDocuments() {
+    if (this.allowSave)
+      for (let t in this.documents)
+        await this._saveDocument(t);
+  }
+  _initServerDocument() {
+    this.documents._server = {
+      nextUID: 100
+    };
+  }
+  /*= EXIT ===================================================================*/
+  _exitSignal(t) {
+    this._exited || (console.log(`
+EXIT: Caught interrupt signal ` + t), this._exited = !0, clearInterval(this._loopiv), this.onBeforeExit(), this.broadcast({ server: "Going down" }), this._saveAllDocuments(), this._wss.close(), setTimeout(() => process.exit(0), 1e3));
+  }
+  // To be redefined. Called BEFORE program exit, and saving all documents
+  onBeforeExit() {
+  }
+}
+export {
+  gt as default
+};