@hcikn/colibri 1.3.2 → 2.0.0

package/dist/index.js

@@ -1,966 +1,1562 @@
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
-}
-function _assert_this_initialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
     }
-    return self;
-}
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/Colibri.ts
+import { Subject } from "rxjs";
+import { connect } from "socket.io-client";
+
+// src/ColibriError.ts
+import { CustomError } from "ts-custom-error";
+var ColibriError = class extends CustomError {
+};
+var ProtocolMismatchError = class extends ColibriError {
+  constructor(message, serverVersion, clientVersion, fatal = true) {
+    super(message);
+    this.serverVersion = serverVersion;
+    this.clientVersion = clientVersion;
+    this.fatal = fatal;
+  }
+};
+
+// src/lifecycle.ts
+var awaitingInstance = [];
+var whenColibriCreated = (action) => {
+  awaitingInstance.push(action);
+  return () => {
+    const index = awaitingInstance.indexOf(action);
+    if (index >= 0) awaitingInstance.splice(index, 1);
+  };
+};
+var colibriCreated = (colibri) => {
+  for (const action of awaitingInstance.splice(0)) {
     try {
-        var info = gen[key](arg);
-        var value = info.value;
+      action(colibri);
     } catch (error) {
-        reject(error);
-        return;
+      console.error("Colibri: a registration made before new Colibri() failed to attach.", error);
     }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
+  }
+};
+var reconnectActions = /* @__PURE__ */ new WeakMap();
+var disconnectActions = /* @__PURE__ */ new WeakMap();
+var addAction = (actions, colibri, action) => {
+  const forInstance = actions.get(colibri);
+  if (forInstance) forInstance.push(action);
+  else actions.set(colibri, [action]);
+};
+var runActions = (actions, colibri, failure) => {
+  for (const action of actions.get(colibri) ?? []) {
+    try {
+      action(colibri);
+    } catch (error) {
+      console.error(failure, error);
     }
-}
-function _async_to_generator(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
-function _call_super(_this, derived, args) {
-    derived = _get_prototype_of(derived);
-    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
-}
-function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
+  }
+};
+var onColibriReconnected = (colibri, action) => {
+  addAction(reconnectActions, colibri, action);
+};
+var colibriReconnected = (colibri) => {
+  runActions(reconnectActions, colibri, "Colibri: catching up after a reconnect failed.");
+};
+var onColibriDisconnected = (colibri, action) => {
+  addAction(disconnectActions, colibri, action);
+};
+var colibriDisconnected = (colibri) => {
+  runActions(disconnectActions, colibri, "Colibri: handling a disconnect failed.");
+};
+var lastHeard = /* @__PURE__ */ new WeakMap();
+var colibriHeardFrom = (colibri) => {
+  lastHeard.set(colibri, Date.now());
+};
+var lastHeardFrom = (colibri) => lastHeard.get(colibri);
+
+// src/Colibri.ts
+var PROTOCOL_VERSION = "2";
+var REST_MEDIA_TYPE = `application/vnd.colibri.v${PROTOCOL_VERSION}+json`;
+var COLIBRI_CHANNEL = "colibri";
+var ADMIN_APP = "colibri";
+var PROTOCOL_REJECTED_COMMAND = "protocol::rejected";
+var PROTOCOL_ACCEPTED_COMMAND = "protocol::accepted";
+var LATENCY_COMMAND = "latency";
+var OLD_SERVER_TIMEOUT_MS = 5e3;
+var OLD_SERVER_PROTOCOL_VERSION = "1";
+var pageHostname = () => typeof window !== "undefined" ? window.location?.hostname ?? "" : "";
+var SCHEMES = {
+  ws: { socket: "ws", rest: "http" },
+  http: { socket: "ws", rest: "http" },
+  wss: { socket: "wss", rest: "https" },
+  https: { socket: "wss", rest: "https" }
+};
+var parseServerAddress = (server) => {
+  const address = server.trim();
+  const match = /^([a-z][a-z0-9+.-]*):\/\/(.*)$/i.exec(address);
+  const schemes = match ? SCHEMES[match[1].toLowerCase()] : SCHEMES.ws;
+  if (!schemes) {
+    throw new ColibriError(
+      `Unsupported scheme in server address '${server}' - use ws://, wss://, http://, https:// or none.`
+    );
+  }
+  const authority = (match ? match[2] : address).replace(/\/+$/, "");
+  if (authority.length === 0) {
+    throw new ColibriError("Server Address missing or empty!");
+  }
+  if (/[/?#]/.test(authority)) {
+    throw new ColibriError(
+      `Server address '${server}' has a path or query after the host - pass only the host and, optionally, the port, e.g. 'http://example.com:9211'.`
+    );
+  }
+  const hostAndPort = /^(\[[^\]]+\]|[^:]+)(?::(\d+))?$/.exec(authority);
+  if (!hostAndPort) {
+    throw new ColibriError(
+      `Server address '${server}' is not a host, or a host and a numeric port - an IPv6 address goes in brackets.`
+    );
+  }
+  const portText = hostAndPort.at(2);
+  return { ...schemes, host: hostAndPort[1], port: portText === void 0 ? void 0 : Number(portText) };
+};
+var DEFAULT_PORT = 9211;
+var checkPort = (port) => {
+  if (!Number.isInteger(port)) {
+    throw new ColibriError(`Port must be a whole number (1 - 65535): ${port}`);
+  }
+  if (port < 1 || port > 65535) {
+    throw new ColibriError(`Port out of allowed range (1 - 65535): ${port}`);
+  }
+};
+var coercePort = (port) => typeof port === "string" && /^\s*\d+\s*$/.test(port) ? Number(port) : port;
+var resolvePort = (server, fromAddress, given) => {
+  if (given !== void 0) checkPort(given);
+  if (fromAddress === void 0) return given ?? DEFAULT_PORT;
+  checkPort(fromAddress);
+  if (given !== void 0 && given !== fromAddress) {
+    throw new ColibriError(
+      `Server address '${server}' has port ${fromAddress}, but port ${given} was passed as well - give the port once.`
+    );
+  }
+  return fromAddress;
+};
+var pendingRegistrations = [];
+var Colibri = class _Colibri {
+  /**
+   * Connects to a Colibri server. Only one instance may exist.
+   * @param app the application name; clients only see each other's messages within one app
+   * @param server the host, optionally after `ws://`, `wss://`, `http://` or `https://` (the
+   *   secure ones mean `wss` for the socket and `https` for REST) and optionally with a port,
+   *   as in `'http://example.com:9211'`; no path. Defaults to the host that served the page,
+   *   and is required outside a browser.
+   * @param port the server port, if the address has none; 9211 if neither does. When both have
+   *   one, they must agree.
+   * @throws ColibriError for an address or port this client cannot connect to, or when an
+   *   instance already exists
+   */
+  constructor(app, server = pageHostname(), port) {
+    this.app = app;
+    this.server = server;
+    if (server.trim().length <= 0) {
+      throw new ColibriError(
+        typeof window === "undefined" ? "Server Address missing or empty! Outside a browser there is no page to take it from, so pass it as the second argument." : "Server Address missing or empty!"
+      );
     }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
+    const address = parseServerAddress(server);
+    this.port = resolvePort(server, address.port, coercePort(port));
+    this.uri = `${address.socket}://${address.host}:${this.port}`;
+    this.uriRestApi = `${address.rest}://${address.host}:${this.port}/api/store/${encodeURIComponent(app)}/`;
+    if (_Colibri.instance) throw new ColibriError("A Colibri instance already exists!");
+    else _Colibri.instance = this;
+    if (app === ADMIN_APP) {
+      console.warn(
+        `Colibri: the app name '${ADMIN_APP}' is reserved for the server's admin UI, and the server treats this client as one: it sends it the server's log as it is written and every client's connects and disconnects, shares its messages with every open admin UI, and skips the protocol version check. Give your app a name of its own.`
+      );
     }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _get_prototype_of(o) {
-    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _get_prototype_of(o);
-}
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
+    this.socket = connect(this.uri, {
+      query: { app, version: PROTOCOL_VERSION },
+      transports: ["websocket"]
     });
-    if (superClass) _set_prototype_of(subClass, superClass);
-}
-function _instanceof(left, right) {
-    "@swc/helpers - instanceof";
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else {
-        return left instanceof right;
+    this.socket.on("connect", this.onSocketConnect.bind(this));
+    this.socket.on("disconnect", this.onSocketDisconnect.bind(this));
+    this.socket.on("connect_error", this.onSocketConnectError.bind(this));
+    this.socket.onAny(this.onSocketAny.bind(this));
+    this.registerChannel(COLIBRI_CHANNEL, (msg) => {
+      if (msg.command === LATENCY_COMMAND) {
+        SendMessage(COLIBRI_CHANNEL, LATENCY_COMMAND, msg.payload);
+      }
+    });
+    for (const { channel, handler, once } of pendingRegistrations.splice(0)) {
+      if (once) this.registerOnce(channel, handler);
+      else this.registerChannel(channel, handler);
     }
-}
-function _iterable_to_array(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _non_iterable_spread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _possible_constructor_return(self, call) {
-    if (call && (_type_of(call) === "object" || typeof call === "function")) {
-        return call;
+    colibriCreated(this);
+  }
+  static instance = null;
+  socket;
+  messageSubject = new Subject();
+  messages = this.messageSubject.asObservable();
+  protocolMismatchSubject = new Subject();
+  /**
+   * Reports that this client and the server do not speak the same wire protocol. Two kinds,
+   * told apart by {@link ProtocolMismatchError.fatal `fatal`}, each emitted at most once per
+   * instance:
+   *
+   * - `fatal: true`: the server refused this client. The connection is closed and not retried.
+   * - `fatal: false`: the server did not announce itself within 5s of connecting, so it is
+   *   suspected to predate colibri-server 2.0.0. The connection stays up.
+   *
+   * A suspicion can be followed by a refusal, never the other way round. Nothing is replayed to
+   * a late subscriber, so subscribe right after construction. Both kinds are also logged.
+   */
+  protocolMismatch = this.protocolMismatchSubject.asObservable();
+  uri;
+  uriRestApi;
+  /** The port connected to: the one in the server address, else the one passed, else 9211. */
+  port;
+  oldServerTimer;
+  // Once per instance, not per connection, so a reconnect does not repeat the warning.
+  hasReportedOldServer = false;
+  // Once per instance, not once per `protocol::rejected` received.
+  hasReportedRefusal = false;
+  hasConnected = false;
+  // An outage runs from a failed connection attempt to the next connect.
+  hasReportedOutage = false;
+  onSocketConnect() {
+    console.debug(`Connected to colibri server on ${this.server}`);
+    this.hasReportedOutage = false;
+    this.waitForServerHello();
+    if (this.hasConnected) colibriReconnected(this);
+    this.hasConnected = true;
+  }
+  // Until the next connect, sends wait in Socket.IO's buffer and go out ahead of anything a
+  // catch-up sends, which is the wrong order for some of them.
+  onSocketDisconnect() {
+    colibriDisconnected(this);
+  }
+  // Socket.IO retries silently, so a mistyped address, a server that is down and a firewall all
+  // look like a slow connection. Reported once per outage, on its first failed attempt, not on
+  // every retry.
+  onSocketConnectError(error) {
+    if (this.hasReportedOutage) return;
+    this.hasReportedOutage = true;
+    const cause = error.description?.message;
+    const reason = typeof cause === "string" && cause.length > 0 ? `${error.message}: ${cause}` : error.message;
+    console.warn(
+      `Colibri: could not connect to ${this.uri} (${reason}). ` + (this.socket.active ? "Retrying until it answers - check the server address and that the server is running." : "Not retrying.")
+    );
+  }
+  /*
+   *  Detecting a server that predates the protocol version check.
+   *
+   *  Such a server neither refuses this client nor says what it speaks, so a current one
+   *  announces itself unprompted and the missing announcement is the signal. The timer only
+   *  observes; it does not gate message delivery.
+   */
+  waitForServerHello() {
+    if (this.hasReportedOldServer) return;
+    clearTimeout(this.oldServerTimer);
+    this.oldServerTimer = setTimeout(() => {
+      this.onServerHelloMissing();
+    }, OLD_SERVER_TIMEOUT_MS);
+  }
+  stopWaitingForServerHello() {
+    clearTimeout(this.oldServerTimer);
+    this.oldServerTimer = void 0;
+  }
+  onServerHelloMissing() {
+    if (!this.socket.connected) return;
+    if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+      this.waitForServerHello();
+      return;
     }
-    return _assert_this_initialized(self);
-}
-function _set_prototype_of(o, p) {
-    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _set_prototype_of(o, p);
-}
-function _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-function _is_native_reflect_construct() {
-    try {
-        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-    } catch (_) {}
-    return (_is_native_reflect_construct = function() {
-        return !!result;
-    })();
-}
-function _ts_generator(thisArg, body) {
-    var f, y, t, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
-    return d(g, "next", {
-        value: verb(0)
-    }), d(g, "throw", {
-        value: verb(1)
-    }), d(g, "return", {
-        value: verb(2)
-    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
-        value: function() {
-            return this;
-        }
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(g && (g = 0, op[0] && (_ = 0)), _)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
+    this.hasReportedOldServer = true;
+    this.stopWaitingForServerHello();
+    const error = new ProtocolMismatchError(
+      `The server did not identify itself within ${OLD_SERVER_TIMEOUT_MS / 1e3}s, so it predates colibri-server 2.0.0 and speaks protocol v1; this client speaks v${PROTOCOL_VERSION}.`,
+      // A protocol version, as in the refusal. Inferred, not received: every 2.0.0+ server
+      // announces itself, and everything older speaks v1.
+      OLD_SERVER_PROTOCOL_VERSION,
+      PROTOCOL_VERSION,
+      false
+    );
+    console.warn(`Colibri: ${error.message} The connection still works; upgrade the server when you can.`);
+    this.protocolMismatchSubject.next(error);
+  }
+  onSocketAny(channel, msg) {
+    colibriHeardFrom(this);
+    const { command, payload } = msg;
+    if (channel === COLIBRI_CHANNEL && command === PROTOCOL_REJECTED_COMMAND) {
+      this.onProtocolRejected(payload);
+      return;
     }
-}
-// src/Colibri.ts
-import { connect } from "socket.io-client";
-// src/ColibriError.ts
-import { CustomError } from "ts-custom-error";
-var ColibriError = /*#__PURE__*/ function(CustomError) {
-    "use strict";
-    _inherits(ColibriError, CustomError);
-    function ColibriError(message) {
-        _class_call_check(this, ColibriError);
-        return _call_super(this, ColibriError, [
-            message
-        ]);
-    }
-    return ColibriError;
-}(CustomError);
-// src/Colibri.ts
-import { Subject } from "rxjs";
-var _Colibri = /*#__PURE__*/ function() {
-    "use strict";
-    function _Colibri(app) {
-        var server = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function() {
-            var _ref;
-            var _window_location, _window;
-            return (_ref = (_window = window) === null || _window === void 0 ? void 0 : (_window_location = _window.location) === null || _window_location === void 0 ? void 0 : _window_location.hostname) !== null && _ref !== void 0 ? _ref : "";
-        }(), port = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 9011;
-        _class_call_check(this, _Colibri);
-        this.app = app;
-        this.server = server;
-        this.port = port;
-        this.messageSubject = new Subject();
-        this.messages = this.messageSubject.asObservable();
-        if (server.trim().length <= 0) {
-            throw new ColibriError("Server Address missing or empty!");
-        }
-        if (port < 1 || port > 65535) {
-            throw new ColibriError("Port out of allowed range (0 - 65535)");
-        }
-        this.uri = "".concat(server, ":").concat(port);
-        if (!new RegExp("wss?://", "i").test(this.uri)) {
-            this.uri = "ws://".concat(this.uri);
-        }
-        this.uriRestApi = "".concat(this.uri, "/api/store/").concat(app, "/");
-        if (_Colibri.instance) throw new ColibriError("A Colibri instance already exists!");
-        else _Colibri.instance = this;
-        this.socket = connect(this.uri, {
-            query: {
-                app: app,
-                version: "1"
-            },
-            transports: [
-                "websocket"
-            ]
-        });
-        this.socket.on("connect", this.onSocketConnect.bind(this));
-        this.socket.onAny(this.onSocketAny.bind(this));
-        this.registerChannel("colibri", function(msg) {
-            if (msg.command === "latency") {
-                SendMessage("colibri", "latency", msg.payload);
-            }
-        });
+    if (channel === COLIBRI_CHANNEL && command === PROTOCOL_ACCEPTED_COMMAND) {
+      this.stopWaitingForServerHello();
+      return;
+    }
+    this.messageSubject.next({ channel, command, payload });
+  }
+  // `rejection` is optional because it comes off the wire, and a bare `protocol::rejected` must
+  // still give a usable error rather than a TypeError.
+  onProtocolRejected(rejection) {
+    this.stopWaitingForServerHello();
+    this.hasReportedOldServer = true;
+    this.socket.io.reconnection(false);
+    this.socket.disconnect();
+    if (this.hasReportedRefusal) return;
+    this.hasReportedRefusal = true;
+    const serverVersion = rejection?.serverVersion ?? "unknown";
+    const error = new ProtocolMismatchError(
+      rejection?.reason ?? `Server refused the connection: it speaks protocol v${serverVersion}, this client speaks v${PROTOCOL_VERSION}.`,
+      serverVersion,
+      rejection?.clientVersion ?? PROTOCOL_VERSION
+    );
+    console.error(
+      `Colibri: ${error.message} Update colibri-web and colibri-server to matching versions. Not reconnecting.`
+    );
+    this.protocolMismatchSubject.next(error);
+  }
+  /**
+   * Returns the existing Colibri instance or null if there's none yet
+   * @param warnIfNotInitialized true => print Log message if Colibri has not been initialized yet
+   * @returns
+   */
+  static getInstance(warnIfNotInitialized = true) {
+    if (warnIfNotInitialized && !_Colibri.instance) {
+      console.warn("Colibri not initialized yet! (Instance is null)");
     }
-    _create_class(_Colibri, [
-        {
-            key: "onSocketConnect",
-            value: function onSocketConnect() {
-                console.debug("Connected to colibri server on ".concat(this.server));
-            }
-        },
-        {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            key: "onSocketAny",
-            value: function onSocketAny(channel, msg) {
-                this.messageSubject.next({
-                    channel: channel,
-                    command: msg.command,
-                    payload: msg.payload
-                });
-            }
-        },
-        {
-            /**
+    return _Colibri.instance;
+  }
+  /**
    * Sends a single message in the given `channel`.
    * @param channel message channel
    * @param command message command
    * @param payload message payload
-   */ key: "sendMessage",
-            value: function sendMessage(channel, command) {
-                var payload = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-                this.socket.emit(channel, {
-                    command: command,
-                    payload: payload
-                });
-            }
-        },
-        {
-            //#region Socket Events
-            /**
+   */
+  sendMessage(channel, command, payload = {}) {
+    this.socket.emit(channel, {
+      command,
+      payload
+    });
+  }
+  // #region Socket Events
+  /**
    * Adds a `handler` function listening for messages in `channel`.
    * @param channel message channel
    * @param handler handler to be executed when a message is received
-   */ key: "registerChannel",
-            value: function registerChannel(channel, handler) {
-                this.socket.on(channel, handler);
-            }
-        },
-        {
-            /**
+   */
+  registerChannel(channel, handler) {
+    this.socket.on(channel, handler);
+  }
+  /**
    * Removes the `handler` function listening for messages in `channel`.
    * @param channel message channel
    * @param handler handler to be executed when a message is received
-   */ key: "unregisterChannel",
-            value: function unregisterChannel(channel, handler) {
-                this.socket.off(channel, handler);
-            }
-        },
-        {
-            /**
+   */
+  unregisterChannel(channel, handler) {
+    this.socket.off(channel, handler);
+  }
+  /**
    * Adds a one-time `handler` function listening for the next message in `channel`.
    * @param channel message channel
    * @param handler handler to be executed when a message is received
-   */ key: "registerOnce",
-            value: function registerOnce(channel, handler) {
-                this.socket.once(channel, handler);
-            }
-        },
-        {
-            //#endregion
-            //#region Rest API
-            /**
-   * Returns the REST API Endpoint for a given `key` or null of the key is empty.
+   */
+  registerOnce(channel, handler) {
+    this.socket.once(channel, handler);
+  }
+  // #endregion
+  // #region Rest API
+  /**
+   * Returns the REST API Endpoint for a given `key`, or null if the key is empty, `.` or `..`.
+   * Any other key is stored under exactly that name (`#`, `?`, `/`, `%` and spaces included)
+   * after surrounding whitespace and leading slashes are stripped.
    * @param key REST API storage key
    * @returns
-   */ key: "getRestUri",
-            value: function getRestUri(key) {
-                key = key.trim();
-                while(key.startsWith("/"))key = key.substring(1);
-                return key.length === 0 ? null : this.uriRestApi + key;
-            }
-        },
-        {
-            key: "getRestObject",
-            value: /**
+   */
+  getRestUri(key) {
+    key = key.trim();
+    while (key.startsWith("/")) key = key.substring(1);
+    if (key.length === 0 || key === "." || key === "..") return null;
+    return this.uriRestApi + encodeURIComponent(key);
+  }
+  /**
    * Queries an object from the REST API identified by `key`.
+   *
+   * Rejects when the server cannot be reached (wrong address, server down, no network) or an
+   * answer with a success status is not JSON.
    * @param key REST API storage key
-   * @returns JSON object with data or null if object does not exist or any other error occurrs
-   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            function getRestObject(key) {
-                return _async_to_generator(function() {
-                    var uri, response;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                uri = this.getRestUri(key);
-                                if (!uri) return [
-                                    2,
-                                    null
-                                ];
-                                return [
-                                    4,
-                                    fetch(uri, {
-                                        method: "GET",
-                                        headers: {
-                                            "Content-Type": "application/json"
-                                        }
-                                    })
-                                ];
-                            case 1:
-                                response = _state.sent();
-                                if (response.status >= 400) return [
-                                    2,
-                                    null
-                                ];
-                                else return [
-                                    2,
-                                    response.json()
-                                ];
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                }).call(this);
-            }
-        },
-        {
-            key: "setRestObject",
-            value: /**
-   * Sets or updatees an object in the REST API identified by `key`.
+   * @returns the stored value; or null if `key` is empty or the server answered with an error
+   *   status, such as 404 for a key that was never stored. A stored `null` looks the same.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async getRestObject(key) {
+    const uri = this.getRestUri(key);
+    if (!uri) return null;
+    const response = await fetch(uri, {
+      method: "GET",
+      headers: {
+        Accept: REST_MEDIA_TYPE
+      }
+    });
+    if (response.status >= 400) return null;
+    else return response.json();
+  }
+  /**
+   * Sets or updates an object in the REST API identified by `key`.
+   *
+   * Rejects when the server cannot be reached (wrong address, server down, no network) or
+   * `data` cannot be serialized to JSON (circular structure, BigInt).
    * @param key REST API storage key
    * @param data JSON data to write
-   * @returns true if data was written to REST API
-   */ function setRestObject(key, data) {
-                return _async_to_generator(function() {
-                    var uri, response;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                uri = this.getRestUri(key);
-                                if (!uri) return [
-                                    2,
-                                    false
-                                ];
-                                return [
-                                    4,
-                                    fetch(uri, {
-                                        method: "PUT",
-                                        headers: {
-                                            "Content-Type": "application/json"
-                                        },
-                                        body: JSON.stringify(data)
-                                    })
-                                ];
-                            case 1:
-                                response = _state.sent();
-                                return [
-                                    2,
-                                    response.status >= 200 && response.status < 300
-                                ];
-                        }
-                    });
-                }).call(this);
-            }
-        }
-    ], [
-        {
-            key: "getInstance",
-            value: /**
-   * Returns the existing Colibri instance or null if there's none yet
-   * @param warnIfNotInitialized true => print Log message if Colibri has not been initialized yet
-   * @returns
-   */ function getInstance() {
-                var warnIfNotInitialized = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
-                if (warnIfNotInitialized && !_Colibri.instance) {
-                    console.warn("Colibri not initialized yet! (Instance is null)");
-                }
-                return _Colibri.instance;
-            }
-        }
-    ]);
-    return _Colibri;
-}();
-_Colibri.instance = null;
-var Colibri = _Colibri;
-var SendMessage = function SendMessage(channel, command) {
-    var payload = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-    var _Colibri_getInstance;
-    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.sendMessage(channel, command, payload);
-};
-var RegisterChannel = function RegisterChannel(channel, handler) {
-    var _Colibri_getInstance;
-    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.registerChannel(channel, handler);
-};
-var UnregisterChannel = function UnregisterChannel(channel, handler) {
-    var _Colibri_getInstance;
-    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.unregisterChannel(channel, handler);
-};
-var RegisterOnce = function RegisterOnce(channel, handler) {
-    var _Colibri_getInstance;
-    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.registerOnce(channel, handler);
-};
-var GetRestApi = function GetRestApi(key) {
-    var _Colibri_getInstance;
-    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.getRestObject(key);
-};
-var PutRestApi = function PutRestApi(key, data) {
-    var _Colibri_getInstance;
-    return (_Colibri_getInstance = Colibri.getInstance()) === null || _Colibri_getInstance === void 0 ? void 0 : _Colibri_getInstance.setRestObject(key, data);
+   * @returns true if the server stored the data; false if `key` is empty or the server answered
+   *   with any other status
+   */
+  async setRestObject(key, data) {
+    const uri = this.getRestUri(key);
+    if (!uri) return false;
+    const response = await fetch(uri, {
+      method: "PUT",
+      headers: {
+        Accept: REST_MEDIA_TYPE,
+        "Content-Type": REST_MEDIA_TYPE
+      },
+      body: JSON.stringify(data)
+    });
+    return response.status >= 200 && response.status < 300;
+  }
+  /**
+   * Deletes the object identified by `key` from the REST API.
+   *
+   * Rejects when the server cannot be reached (wrong address, server down, no network).
+   * @param key REST API storage key
+   * @returns true if the server deleted the value; false if `key` is empty or the server answered
+   *   with any other status, such as 404 for a key that holds no value
+   */
+  async deleteRestObject(key) {
+    const uri = this.getRestUri(key);
+    if (!uri) return false;
+    const response = await fetch(uri, {
+      method: "DELETE",
+      headers: {
+        Accept: REST_MEDIA_TYPE
+      }
+    });
+    return response.status >= 200 && response.status < 300;
+  }
+  // #endregion
+};
+var SendMessage = (channel, command, payload = {}) => Colibri.getInstance()?.sendMessage(channel, command, payload);
+var RegisterChannel = (channel, handler) => {
+  const colibri = Colibri.getInstance(false);
+  if (colibri) colibri.registerChannel(channel, handler);
+  else pendingRegistrations.push({ channel, handler, once: false });
+};
+var UnregisterChannel = (channel, handler) => {
+  const colibri = Colibri.getInstance(false);
+  if (colibri) {
+    colibri.unregisterChannel(channel, handler);
+    return;
+  }
+  const index = pendingRegistrations.findIndex((p) => p.channel === channel && p.handler === handler);
+  if (index >= 0) pendingRegistrations.splice(index, 1);
 };
+var RegisterOnce = (channel, handler) => {
+  const colibri = Colibri.getInstance(false);
+  if (colibri) colibri.registerOnce(channel, handler);
+  else pendingRegistrations.push({ channel, handler, once: true });
+};
+var GetRestApi = (key) => Colibri.getInstance()?.getRestObject(key);
+var PutRestApi = (key, data) => Colibri.getInstance()?.setRestObject(key, data);
+var DeleteRestApi = (key) => Colibri.getInstance()?.deleteRestObject(key);
+
 // src/Broadcasting.ts
-var sendBool = function sendBool(channel, val) {
-    SendMessage(channel, "broadcast::bool", val);
+var sendBool = (channel, val) => {
+  SendMessage(channel, "broadcast::bool", val);
+};
+var sendBoolArray = (channel, val) => {
+  SendMessage(channel, "broadcast::bool[]", val);
+};
+var sendNumber = (channel, val) => {
+  SendMessage(channel, "broadcast::float", val);
 };
-var sendBoolArray = function sendBoolArray(channel, val) {
-    SendMessage(channel, "broadcast::bool[]", val);
+var sendNumberArray = (channel, val) => {
+  SendMessage(channel, "broadcast::float[]", val);
 };
-var sendNumber = function sendNumber(channel, val) {
-    SendMessage(channel, "broadcast::float", val);
+var sendString = (channel, val) => {
+  SendMessage(channel, "broadcast::string", val);
 };
-var sendNumberArray = function sendNumberArray(channel, val) {
-    SendMessage(channel, "broadcast::float[]", val);
+var sendStringArray = (channel, val) => {
+  SendMessage(channel, "broadcast::string[]", val);
 };
-var sendString = function sendString(channel, val) {
-    SendMessage(channel, "broadcast::string", val);
+var sendVector2 = (channel, val) => {
+  SendMessage(channel, "broadcast::vector2", val);
 };
-var sendStringArray = function sendStringArray(channel, val) {
-    SendMessage(channel, "broadcast::string[]", val);
+var sendVector2Array = (channel, val) => {
+  SendMessage(channel, "broadcast::vector2[]", val);
 };
-var sendVector3 = function sendVector3(channel, val) {
-    SendMessage(channel, "broadcast::vector3", val);
+var sendVector3 = (channel, val) => {
+  SendMessage(channel, "broadcast::vector3", val);
 };
-var sendVector3Array = function sendVector3Array(channel, val) {
-    SendMessage(channel, "broadcast::vector3[]", val);
+var sendVector3Array = (channel, val) => {
+  SendMessage(channel, "broadcast::vector3[]", val);
 };
-var sendQuaternion = function sendQuaternion(channel, val) {
-    SendMessage(channel, "broadcast::quaternion", val);
+var sendQuaternion = (channel, val) => {
+  SendMessage(channel, "broadcast::quaternion", val);
 };
-var sendQuaternionArray = function sendQuaternionArray(channel, val) {
-    SendMessage(channel, "broadcast::quaternion[]", val);
+var sendQuaternionArray = (channel, val) => {
+  SendMessage(channel, "broadcast::quaternion[]", val);
 };
-var sendColor = function sendColor(channel, val) {
-    SendMessage(channel, "broadcast::color", val);
+var sendColor = (channel, val) => {
+  SendMessage(channel, "broadcast::color", val);
 };
-var sendColorArray = function sendColorArray(channel, val) {
-    SendMessage(channel, "broadcast::color[]", val);
+var sendColorArray = (channel, val) => {
+  SendMessage(channel, "broadcast::color[]", val);
 };
-var sendJson = function sendJson(channel, val) {
-    SendMessage(channel, "broadcast::json", val);
+var sendJson = (channel, val) => {
+  SendMessage(channel, "broadcast::json", val);
 };
 var listeners = {};
-var registerListener = function registerListener(channel, type, callback) {
-    if (listeners[channel] === void 0) {
-        listeners[channel] = {};
-        RegisterChannel(channel, function(msg) {
-            if (msg.command in listeners[channel]) {
-                listeners[channel][msg.command].forEach(function(cb) {
-                    return cb(msg.payload);
-                });
-            }
+var channelHandlers = {};
+var registerListener = (channel, type, callback) => {
+  let channelListeners = listeners[channel];
+  if (channelListeners === void 0) {
+    const newChannelListeners = {};
+    channelListeners = newChannelListeners;
+    listeners[channel] = newChannelListeners;
+    const handler = (msg) => {
+      const commandListeners = newChannelListeners[msg.command];
+      if (commandListeners !== void 0) {
+        commandListeners.forEach((cb) => {
+          cb(msg.payload);
         });
-    }
-    if (listeners[channel][type] === void 0) {
-        listeners[channel][type] = [];
-    }
-    listeners[channel][type].push(callback);
+      }
+    };
+    channelHandlers[channel] = handler;
+    RegisterChannel(channel, handler);
+  }
+  let typeListeners = channelListeners[type];
+  if (typeListeners === void 0) {
+    typeListeners = [];
+    channelListeners[type] = typeListeners;
+  }
+  typeListeners.push(callback);
 };
-var receiveBool = function receiveBool(channel, callback) {
-    registerListener(channel, "broadcast::bool", callback);
+var receiveBool = (channel, callback) => {
+  registerListener(channel, "broadcast::bool", callback);
 };
-var receiveBoolArray = function receiveBoolArray(channel, callback) {
-    registerListener(channel, "broadcast::bool[]", callback);
+var receiveBoolArray = (channel, callback) => {
+  registerListener(channel, "broadcast::bool[]", callback);
 };
-var receiveNumber = function receiveNumber(channel, callback) {
-    registerListener(channel, "broadcast::float", callback);
+var receiveNumber = (channel, callback) => {
+  registerListener(channel, "broadcast::float", callback);
+  registerListener(channel, "broadcast::int", callback);
 };
-var receiveNumberArray = function receiveNumberArray(channel, callback) {
-    registerListener(channel, "broadcast::float[]", callback);
+var receiveNumberArray = (channel, callback) => {
+  registerListener(channel, "broadcast::float[]", callback);
+  registerListener(channel, "broadcast::int[]", callback);
 };
-var receiveString = function receiveString(channel, callback) {
-    registerListener(channel, "broadcast::string", callback);
+var receiveString = (channel, callback) => {
+  registerListener(channel, "broadcast::string", callback);
 };
-var receiveStringArray = function receiveStringArray(channel, callback) {
-    registerListener(channel, "broadcast::string[]", callback);
+var receiveStringArray = (channel, callback) => {
+  registerListener(channel, "broadcast::string[]", callback);
 };
-var receiveVector3 = function receiveVector3(channel, callback) {
-    registerListener(channel, "broadcast::vector3", callback);
+var receiveVector2 = (channel, callback) => {
+  registerListener(channel, "broadcast::vector2", callback);
 };
-var receiveVector3Array = function receiveVector3Array(channel, callback) {
-    registerListener(channel, "broadcast::vector3[]", callback);
+var receiveVector2Array = (channel, callback) => {
+  registerListener(channel, "broadcast::vector2[]", callback);
 };
-var receiveQuaternion = function receiveQuaternion(channel, callback) {
-    registerListener(channel, "broadcast::quaternion", callback);
+var receiveVector3 = (channel, callback) => {
+  registerListener(channel, "broadcast::vector3", callback);
 };
-var receiveQuaternionArray = function receiveQuaternionArray(channel, callback) {
-    registerListener(channel, "broadcast::quaternion[]", callback);
+var receiveVector3Array = (channel, callback) => {
+  registerListener(channel, "broadcast::vector3[]", callback);
 };
-var receiveColor = function receiveColor(channel, callback) {
-    registerListener(channel, "broadcast::color", callback);
+var receiveQuaternion = (channel, callback) => {
+  registerListener(channel, "broadcast::quaternion", callback);
 };
-var receiveColorArray = function receiveColorArray(channel, callback) {
-    registerListener(channel, "broadcast::color[]", callback);
+var receiveQuaternionArray = (channel, callback) => {
+  registerListener(channel, "broadcast::quaternion[]", callback);
 };
-var receiveJson = function receiveJson(channel, callback) {
-    registerListener(channel, "broadcast::json", callback);
+var receiveColor = (channel, callback) => {
+  registerListener(channel, "broadcast::color", callback);
 };
-var unregister = function unregister(channel, callback) {
-    for(var command in listeners[channel]){
-        var index = listeners[channel][command].indexOf(callback);
-        if (index >= 0) {
-            listeners[channel][command].splice(index, 1);
-        }
+var receiveColorArray = (channel, callback) => {
+  registerListener(channel, "broadcast::color[]", callback);
+};
+var receiveJson = (channel, callback) => {
+  registerListener(channel, "broadcast::json", callback);
+};
+var clamp01 = (n) => Math.min(1, Math.max(0, n));
+var hexPair = (n) => Math.round(clamp01(n) * 255).toString(16).padStart(2, "0");
+var warnNotAColor = (val) => {
+  console.warn(`Colibri: '${JSON.stringify(val)}' is not a colour - expected "#RRGGBBAA" or [r,g,b,a]. Using black.`);
+};
+var asComponents = (val) => {
+  if (!Array.isArray(val) || val.length < 3) return null;
+  const numbers = val;
+  if (!numbers.every((c) => typeof c === "number" && !Number.isNaN(c))) return null;
+  return numbers;
+};
+var toHexColor = (val) => {
+  const rgba = toRgbaColor(val);
+  return `#${hexPair(rgba[0])}${hexPair(rgba[1])}${hexPair(rgba[2])}${hexPair(rgba[3])}`;
+};
+var toRgbaColor = (val) => {
+  const components = asComponents(val);
+  if (components !== null) {
+    return [
+      clamp01(components[0]),
+      clamp01(components[1]),
+      clamp01(components[2]),
+      components.length > 3 ? clamp01(components[3]) : 1
+    ];
+  }
+  if (typeof val === "string") {
+    const hex = val.startsWith("#") ? val.slice(1) : val;
+    const digits = hex.length === 3 || hex.length === 4 ? hex.replace(/./g, (c) => c + c) : hex;
+    if ((digits.length === 6 || digits.length === 8) && /^[0-9a-f]+$/i.test(digits)) {
+      const byteAt = (i) => parseInt(digits.slice(i, i + 2), 16) / 255;
+      return [byteAt(0), byteAt(2), byteAt(4), digits.length === 8 ? byteAt(6) : 1];
     }
+  }
+  warnNotAColor(val);
+  return [0, 0, 0, 1];
+};
+var unregister = (channel, callback) => {
+  const channelListeners = listeners[channel];
+  if (channelListeners === void 0) return;
+  let hasRemainingListeners = false;
+  for (const command in channelListeners) {
+    const commandListeners = channelListeners[command];
+    const index = commandListeners?.indexOf(callback) ?? -1;
+    if (index >= 0) {
+      commandListeners?.splice(index, 1);
+    }
+    if ((commandListeners?.length ?? 0) > 0) {
+      hasRemainingListeners = true;
+    }
+  }
+  if (!hasRemainingListeners) {
+    const handler = channelHandlers[channel];
+    if (handler !== void 0) {
+      UnregisterChannel(channel, handler);
+    }
+    Reflect.deleteProperty(listeners, channel);
+    Reflect.deleteProperty(channelHandlers, channel);
+  }
 };
 var Sync = {
-    sendBool: sendBool,
-    sendBoolArray: sendBoolArray,
-    sendNumber: sendNumber,
-    sendNumberArray: sendNumberArray,
-    sendString: sendString,
-    sendStringArray: sendStringArray,
-    sendVector3: sendVector3,
-    sendVector3Array: sendVector3Array,
-    sendQuaternion: sendQuaternion,
-    sendQuaternionArray: sendQuaternionArray,
-    sendColor: sendColor,
-    sendColorArray: sendColorArray,
-    sendJson: sendJson,
-    receiveBool: receiveBool,
-    receiveBoolArray: receiveBoolArray,
-    receiveNumber: receiveNumber,
-    receiveNumberArray: receiveNumberArray,
-    receiveString: receiveString,
-    receiveStringArray: receiveStringArray,
-    receiveVector3: receiveVector3,
-    receiveVector3Array: receiveVector3Array,
-    receiveQuaternion: receiveQuaternion,
-    receiveQuaternionArray: receiveQuaternionArray,
-    receiveColor: receiveColor,
-    receiveColorArray: receiveColorArray,
-    receiveJson: receiveJson,
-    unregister: unregister,
-    // for better compatibility with Unity Colibri
-    sendFloat: sendNumber,
-    sendInt: sendNumber,
-    sendFloatArray: sendNumberArray,
-    sendIntArray: sendNumberArray
+  sendBool,
+  sendBoolArray,
+  sendNumber,
+  sendNumberArray,
+  sendString,
+  sendStringArray,
+  sendVector2,
+  sendVector2Array,
+  sendVector3,
+  sendVector3Array,
+  sendQuaternion,
+  sendQuaternionArray,
+  sendColor,
+  sendColorArray,
+  sendJson,
+  receiveBool,
+  receiveBoolArray,
+  receiveNumber,
+  receiveNumberArray,
+  receiveString,
+  receiveStringArray,
+  receiveVector2,
+  receiveVector2Array,
+  receiveVector3,
+  receiveVector3Array,
+  receiveQuaternion,
+  receiveQuaternionArray,
+  receiveColor,
+  receiveColorArray,
+  receiveJson,
+  unregister,
+  // for better compatibility with Unity Colibri
+  // sendInt and sendIntArray still send the float commands (JS cannot tell 5 from 5.0), so a
+  // Unity client has to listen for float, not int.
+  sendFloat: sendNumber,
+  sendInt: sendNumber,
+  sendFloatArray: sendNumberArray,
+  sendIntArray: sendNumberArray
 };
+
 // src/RemoteLogger.ts
-var RemoteLogger = /*#__PURE__*/ function() {
-    "use strict";
-    function _RemoteLogger() {
-        var enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
-        var _this = this;
-        _class_call_check(this, _RemoteLogger);
-        this.enabled = enabled;
-        this.consoleDebug = console.debug;
-        this.consoleLog = console.log;
-        this.consoleInfo = console.info;
-        this.consoleWarn = console.warn;
-        this.consoleError = console.error;
-        console.debug = function() {
-            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-                args[_key] = arguments[_key];
-            }
-            _this.consoleDebug.apply(_this, _to_consumable_array(args));
-            _this.sendMessage("debug", args);
-        };
-        console.log = function() {
-            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-                args[_key] = arguments[_key];
-            }
-            _this.consoleLog.apply(_this, _to_consumable_array(args));
-            _this.sendMessage("info", args);
-        };
-        console.info = function() {
-            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-                args[_key] = arguments[_key];
-            }
-            _this.consoleInfo.apply(_this, _to_consumable_array(args));
-            _this.sendMessage("info", args);
-        };
-        console.warn = function() {
-            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-                args[_key] = arguments[_key];
-            }
-            _this.consoleWarn.apply(_this, _to_consumable_array(args));
-            _this.sendMessage("warn", args);
-        };
-        console.error = function() {
-            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-                args[_key] = arguments[_key];
-            }
-            _this.consoleError.apply(_this, _to_consumable_array(args));
-            _this.sendMessage("error", args);
-        };
-    }
-    _create_class(_RemoteLogger, [
-        {
-            key: "sendMessage",
-            value: function sendMessage(level, args) {
-                if (!this.enabled) return;
-                SendMessage("log", level, _to_consumable_array(args).map(stringify).join().trim());
-            }
-        },
-        {
-            key: "enable",
-            value: function enable() {
-                this.enabled = true;
-            }
-        },
-        {
-            key: "disable",
-            value: function disable() {
-                this.enabled = false;
-            }
-        }
-    ], [
-        {
-            key: "init",
-            value: /**
+var MAX_EARLY_LINES = 100;
+var RemoteLogger = class _RemoteLogger {
+  /**
+   * Forwards everything logged through `console` to the server's log. Create one, at startup.
+   * A further instance warns once and does not patch again; its `enabled` argument, `enable()` and
+   * `disable()` act on the first one.
+   * @param enabled whether to forward from the start
+   */
+  constructor(enabled = true) {
+    this.enabled = enabled;
+    const patched = _RemoteLogger.patched;
+    if (patched) {
+      this.forwarder = patched;
+      patched.enabled = enabled;
+      if (!patched.hasWarnedOfAnotherInstance) {
+        patched.hasWarnedOfAnotherInstance = true;
+        console.warn(
+          "RemoteLogger: the console is already forwarded by an earlier new RemoteLogger(), so this one controls that instead of forwarding every line a second time. Create one, at startup."
+        );
+      }
+      return;
+    }
+    _RemoteLogger.patched = this;
+    this.forwarder = this;
+    console.debug = (...args) => {
+      this.consoleDebug(...args);
+      this.sendMessage("debug", args);
+    };
+    console.log = (...args) => {
+      this.consoleLog(...args);
+      this.sendMessage("info", args);
+    };
+    console.info = (...args) => {
+      this.consoleInfo(...args);
+      this.sendMessage("info", args);
+    };
+    console.warn = (...args) => {
+      this.consoleWarn(...args);
+      this.sendMessage("warn", args);
+    };
+    console.error = (...args) => {
+      this.consoleError(...args);
+      this.sendMessage("error", args);
+    };
+  }
+  // The instance that patched the console. Later instances delegate to it, since patching again
+  // would forward every line once per instance (StrictMode and hot reload create extras).
+  static patched = null;
+  // Itself, or the instance that patched the console.
+  forwarder;
+  hasWarnedOfAnotherInstance = false;
+  consoleDebug = console.debug;
+  consoleLog = console.log;
+  consoleInfo = console.info;
+  consoleWarn = console.warn;
+  consoleError = console.error;
+  // Recursion guard: lines logged while forwarding (by Colibri, or by a getter that JSON.stringify
+  // runs) go to the console only.
+  forwarding = false;
+  // Lines logged before `new Colibri()`.
+  earlyLines = [];
+  droppedEarlyLines = 0;
+  waitingForColibri = false;
+  /**
    * @deprecated use new class constructor directly
-   */ function init() {
-                var enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
-                return new _RemoteLogger(enabled);
-            }
-        }
-    ]);
-    return _RemoteLogger;
-}();
-var stringify = function stringify(obj) {
-    if (_instanceof(obj, Error)) {
-        return obj.message + "\n" + obj.stack;
-    }
-    if (typeof obj === "string") return obj;
-    var cache = [];
-    var str = JSON.stringify(obj, function(_, value) {
-        if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && value !== null) {
-            if (cache.indexOf(value) !== -1) {
-                return;
-            }
-            cache.push(value);
+   */
+  static init(enabled = true) {
+    return new _RemoteLogger(enabled);
+  }
+  sendMessage(level, args) {
+    if (!this.enabled || this.forwarding) return;
+    this.forwarding = true;
+    try {
+      const message = [...args].map(stringify).join().trim();
+      const colibri = Colibri.getInstance(false);
+      if (colibri) colibri.sendMessage("log", level, message);
+      else this.keepUntilColibriExists(level, message);
+    } catch (error) {
+      this.consoleError("RemoteLogger: could not forward a log line.", error);
+    } finally {
+      this.forwarding = false;
+    }
+  }
+  keepUntilColibriExists(level, message) {
+    if (this.earlyLines.length >= MAX_EARLY_LINES) {
+      this.droppedEarlyLines++;
+      return;
+    }
+    this.earlyLines.push({ level, message });
+    if (!this.waitingForColibri) {
+      this.waitingForColibri = true;
+      whenColibriCreated((colibri) => {
+        this.sendEarlyLines(colibri);
+      });
+    }
+  }
+  // Socket.IO buffers emits until connected, so there is no need to wait for the connection.
+  sendEarlyLines(colibri) {
+    this.waitingForColibri = false;
+    for (const { level, message } of this.earlyLines.splice(0)) {
+      colibri.sendMessage("log", level, message);
+    }
+    if (this.droppedEarlyLines > 0) {
+      colibri.sendMessage(
+        "log",
+        "warn",
+        `RemoteLogger: ${this.droppedEarlyLines} more line(s) logged before new Colibri() were not kept, only the first ${MAX_EARLY_LINES}.`
+      );
+      this.droppedEarlyLines = 0;
+    }
+  }
+  /** Starts forwarding console output to the server's log. */
+  enable() {
+    this.forwarder.enabled = true;
+  }
+  /** Stops forwarding to the server's log; the console still prints. */
+  disable() {
+    this.forwarder.enabled = false;
+  }
+};
+var stringify = (obj) => {
+  if (obj instanceof Error) {
+    return obj.message + "\n" + (obj.stack ?? "");
+  }
+  if (typeof obj === "string") return obj;
+  const cache = [];
+  let str;
+  try {
+    str = JSON.stringify(
+      obj,
+      (_, value) => {
+        if (typeof value === "bigint") return value.toString();
+        if (typeof value === "object" && value !== null) {
+          if (cache.indexOf(value) !== -1) {
+            return;
+          }
+          cache.push(value);
         }
         return value;
-    }, 2);
-    return str;
+      },
+      2
+    );
+  } catch {
+    str = String(obj);
+  }
+  return str;
 };
+
 // src/ModelSynchronization.ts
 import { BehaviorSubject } from "rxjs";
-var RegisterModelSync = function RegisterModelSync(registration) {
-    var name = registration.name || registration.type.name.toLowerCase();
-    SendMessage(name, "model::request");
-    console.log("Registering model '".concat(name, "'"));
-    RegisterChannel("".concat(name), function(payload) {
-        var msg = payload;
-        if (msg.command === "model::update") {
-            onUpdate(msg.payload);
-        } else if (msg.command === "model::delete") {
-            onDelete(msg.payload.id);
-        } else {
-            console.error("Unknown model command: ".concat(msg.command));
+
+// src/SyncModel.ts
+import { Subject as Subject2, auditTime, buffer, filter, map, share } from "rxjs";
+var SyncModel = class _SyncModel {
+  id;
+  // True while update() applies a remote update, so the setters do not echo it.
+  applyingRemoteUpdate = false;
+  modelChanges = new Subject2();
+  modelChanges$ = this.modelChanges.pipe(
+    // auditTime arms its timer on the first change only; bufferTime keeps an interval running while idle.
+    buffer(this.modelChanges.pipe(auditTime(1))),
+    map((changes) => changes.filter(this.uniq)),
+    filter((changes) => changes.length > 0),
+    share()
+  );
+  // Emits once on delete(), which RegisterModelSync sends on as model::delete. Public only for RegisterModelSync.
+  deletions = new Subject2();
+  // ES private: a subclass may have a `deleted` of its own.
+  #deleted = false;
+  constructor(id) {
+    this.id = id;
+  }
+  uniq(value, index, array) {
+    return array.indexOf(value) === index;
+  }
+  onModelChanges(prop) {
+    this.modelChanges.next(prop);
+  }
+  /**
+   * Deletes the model for every client of the app (Unity destroys its GameObject) and removes it
+   * from this client's list. The model stops syncing.
+   */
+  delete() {
+    if (this.#deleted) return;
+    this.#deleted = true;
+    if (!this.deletions.observed) {
+      console.warn(
+        `Colibri: delete() of '${this.id}', which no RegisterModelSync lists. Register it, or take it from the list RegisterModelSync gives, to delete it for every client.`
+      );
+    }
+    _SyncModel.prototype.detach.call(this);
+    this.deletions.next();
+    this.deletions.complete();
+  }
+  /**
+   * Stops syncing the model on this client only; every other client keeps it. RegisterModelSync
+   * calls it on a remote delete and when registerModel replaces a listed copy.
+   */
+  detach() {
+    this.modelChanges.complete();
+  }
+  registerSyncedProperty(name, prop) {
+    let syncedProperties = this.__syncedProperties;
+    if (syncedProperties === void 0) {
+      syncedProperties = {};
+      Object.defineProperty(this, "__syncedProperties", {
+        value: syncedProperties,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    }
+    syncedProperties[name] = prop;
+  }
+  getSyncedProperties() {
+    return this.__syncedProperties ?? {};
+  }
+  update(updates) {
+    const syncedProps = this.getSyncedProperties();
+    this.applyingRemoteUpdate = true;
+    try {
+      for (const key of Object.keys(updates)) {
+        if (key !== "id") {
+          const localKey = syncedProps[key];
+          if (localKey) {
+            this[localKey] = updates[key];
+          } else {
+            console.warn(`Unknown property ${key} in ${this.constructor.name}`);
+          }
         }
+      }
+    } finally {
+      this.applyingRemoteUpdate = false;
+    }
+  }
+  toJson(attributes = []) {
+    const json = { id: this.id };
+    const syncedProps = this.getSyncedProperties();
+    for (const key of Object.keys(syncedProps)) {
+      const localKey = syncedProps[key];
+      if (attributes.length === 0 || attributes.includes(localKey)) {
+        json[key] = this[localKey];
+      }
+    }
+    return json;
+  }
+};
+
+// src/ModelSynchronization.ts
+var toJsonOf = (model, attributes) => SyncModel.prototype.toJson.call(model, attributes);
+var updateOf = (model, updates) => {
+  SyncModel.prototype.update.call(model, updates);
+};
+var detachOf = (model) => {
+  if (model) SyncModel.prototype.detach.call(model);
+};
+var withColibri = (action) => {
+  const colibri = Colibri.getInstance(false);
+  if (colibri) action(colibri);
+  else whenColibriCreated(action);
+};
+var warnedMinifiedNames = /* @__PURE__ */ new Set();
+var warnIfMinified = (className, channel) => {
+  if (channel.length > 2 && !channel.includes("$") || warnedMinifiedNames.has(channel)) return;
+  warnedMinifiedNames.add(channel);
+  console.warn(
+    `Colibri: RegisterModelSync is syncing on channel '${channel}', derived from the class name '${className}', which looks minified. A minified build renames classes, so this will not sync with another build or with Unity. Pass the channel explicitly: RegisterModelSync({ name: '...', type: ${className || "YourModel"} }).`
+  );
+};
+var isBare = (modelData) => Object.keys(modelData).every((key) => key === "id");
+var ownOnChannel = /* @__PURE__ */ new Map();
+var guardsOnChannel = /* @__PURE__ */ new Map();
+var END_CHANNEL = "colibri::reconnect";
+var endRequests = 0;
+var askForEnd = (colibri) => {
+  const id = `colibri-web-${++endRequests}`;
+  colibri.sendMessage(END_CHANNEL, "model::request", { id, again: true });
+  return id;
+};
+var KNOWN_VALUES_KEPT = 8;
+var KNOWN_VALUES_MS = 1e4;
+var DELETED_HERE_MS = 6e4;
+var AFRESH_ANSWER_MS = 1e4;
+var RegisterModelSync = (registration) => {
+  const name = registration.name || registration.type.name.toLowerCase();
+  if (!registration.name) warnIfMinified(registration.type.name, name);
+  const models = new BehaviorSubject([]);
+  const deletedHere = /* @__PURE__ */ new Map();
+  const rememberDeletedHere = (id) => {
+    const now = Date.now();
+    for (const [old, at] of deletedHere) {
+      if (now - at < DELETED_HERE_MS) break;
+      deletedHere.delete(old);
+    }
+    deletedHere.delete(id);
+    deletedHere.set(id, now);
+  };
+  const afresh = /* @__PURE__ */ new Map();
+  const recentlyDeletedHere = (id) => {
+    const at = deletedHere.get(id);
+    if (at === void 0) return false;
+    if (Date.now() - at < DELETED_HERE_MS) return true;
+    deletedHere.delete(id);
+    return false;
+  };
+  const ownModels = /* @__PURE__ */ new WeakSet();
+  const awaitingAnswer = /* @__PURE__ */ new Map();
+  const answered = /* @__PURE__ */ new WeakSet();
+  let catchingUpThrough;
+  const deletedWhileAwaited = /* @__PURE__ */ new Set();
+  const heldChanges = /* @__PURE__ */ new WeakMap();
+  const changesToSend = /* @__PURE__ */ new WeakMap();
+  const noteChangeToSend = (model, change) => {
+    const toSend = changesToSend.get(model);
+    if (toSend) toSend.add(change);
+    else changesToSend.set(model, /* @__PURE__ */ new Set([change]));
+  };
+  const confirming = /* @__PURE__ */ new Map();
+  const endConfirmation = (id) => {
+    const confirmation = confirming.get(id);
+    confirming.delete(id);
+    return confirmation;
+  };
+  const knownValues = /* @__PURE__ */ new WeakMap();
+  const askedAfterOutage = /* @__PURE__ */ new Map();
+  let roundEnd;
+  let guardEnds = [];
+  let keptOut = /* @__PURE__ */ new WeakMap();
+  const answerMayFollow = /* @__PURE__ */ new Map();
+  let lastHeardBeforeOutage = 0;
+  let disconnected = false;
+  const hasOwn = (id) => models.value.some((m) => m.id === id && ownModels.has(m));
+  const onChannel = ownOnChannel.get(name);
+  if (onChannel) onChannel.add(hasOwn);
+  else ownOnChannel.set(name, /* @__PURE__ */ new Set([hasOwn]));
+  const guard = (end) => {
+    guardEnds.push(end);
+  };
+  const guards = guardsOnChannel.get(name);
+  if (guards) guards.add(guard);
+  else guardsOnChannel.set(name, /* @__PURE__ */ new Set([guard]));
+  const askFor = (colibri, model) => {
+    awaitingAnswer.set(model.id, colibri);
+    colibri.sendMessage(
+      name,
+      "model::request",
+      answered.has(model) ? { id: model.id, again: true } : { id: model.id }
+    );
+  };
+  const sendAfresh = (colibri, model) => {
+    colibri.sendMessage(name, "model::request", { id: model.id });
+    afresh.set(model.id, Date.now());
+    answered.add(model);
+    releaseHeldChanges(model);
+    sendUpdate(colibri, model, toJsonOf(model));
+  };
+  const catchUpOnceAnswered = () => {
+    if (!catchingUpThrough || awaitingAnswer.size > 0) return false;
+    const colibri = catchingUpThrough;
+    catchingUpThrough = void 0;
+    colibri.sendMessage(name, "model::request");
+    guardFrom(colibri);
+    return true;
+  };
+  const guardFrom = (colibri) => {
+    const end = askForEnd(colibri);
+    for (const guardOnChannel of guardsOnChannel.get(name) ?? []) guardOnChannel(end);
+  };
+  const keepOut = (model, update) => {
+    const end = guardEnds.at(-1);
+    if (end === void 0) return;
+    let kept = keptOut.get(model);
+    if (!kept) keptOut.set(model, kept = /* @__PURE__ */ new Map());
+    for (const key of Object.keys(update)) if (key !== "id") kept.set(key, end);
+  };
+  const keptOutOf = (model) => [...keptOut.get(model) ?? []].filter(([, end]) => guardEnds.includes(end)).map(([key]) => key);
+  const endGuard = (end) => {
+    guardEnds = end === void 0 ? [] : guardEnds.slice(guardEnds.indexOf(end) + 1);
+    if (guardEnds.length > 0) return;
+    keptOut = /* @__PURE__ */ new WeakMap();
+    answerMayFollow.clear();
+  };
+  withColibri((colibri) => {
+    catchingUpThrough = colibri;
+    setTimeout(catchUpOnceAnswered, 0);
+    onColibriDisconnected(colibri, () => {
+      disconnected = true;
+      endGuard();
+      if (askedAfterOutage.size === 0) lastHeardBeforeOutage = lastHeardFrom(colibri) ?? Date.now();
+      const since = (lastHeardFrom(colibri) ?? Date.now()) - 1e3;
+      for (const [id, at] of deletedHere) {
+        if (at >= since) colibri.sendMessage(name, "model::delete", { id });
+      }
     });
-    var models = new BehaviorSubject([]);
-    var onUpdate = function onUpdate(modelData) {
-        var model = models.value.find(function(m) {
-            return m.id === modelData.id;
-        });
-        if (model) {
-            model.update(modelData);
-            models.next(_to_consumable_array(models.value));
-        } else if (modelData.id) {
-            var newModel = new registration.type(modelData.id);
-            newModel.modelChanges$.subscribe(function(changes) {
-                if (!newModel.ignoreNextChange) {
-                    SendMessage("".concat(name), "model::update", newModel.toJson(changes));
-                }
-                newModel.ignoreNextChange = false;
-                models.next(_to_consumable_array(models.value));
-            });
-            newModel.update(modelData);
-            models.next(_to_consumable_array(models.value).concat([
-                newModel
-            ]));
+    onColibriReconnected(colibri, () => {
+      disconnected = false;
+      awaitingAnswer.clear();
+      deletedWhileAwaited.clear();
+      askedAfterOutage.clear();
+      afresh.clear();
+      for (const id of [...confirming.keys()]) {
+        const confirmation = endConfirmation(id);
+        const model = models.value.find((m) => m.id === id);
+        if (confirmation && model && ownModels.has(model)) holdChanges(model, confirmation.props);
+      }
+      catchingUpThrough = colibri;
+      for (const model of models.value) {
+        if (!ownModels.has(model)) continue;
+        if (answered.has(model)) askedAfterOutage.set(model.id, { shown: /* @__PURE__ */ new Map(), lost: /* @__PURE__ */ new Set() });
+        askFor(colibri, model);
+      }
+      roundEnd = askedAfterOutage.size > 0 ? askForEnd(colibri) : void 0;
+      catchUpOnceAnswered();
+    });
+  });
+  RegisterChannel(name, (payload) => {
+    if (payload.command === "model::update") {
+      onUpdate(payload.payload);
+    } else if (payload.command === "model::delete") {
+      onDelete(payload.payload.id);
+    } else {
+      console.error(`Unknown model command: ${payload.command}`);
+    }
+  });
+  RegisterChannel(END_CHANNEL, (message) => {
+    if (message.command !== "model::update") return;
+    const id = message.payload?.id;
+    if (typeof id !== "string") return;
+    if (id === roundEnd) endRound();
+    if (guardEnds.includes(id)) endGuard(id);
+    const confirmed = [...confirming].find(([, confirmation]) => confirmation.end === id);
+    if (confirmed) endWait(confirmed[0]);
+  });
+  const onUpdate = (modelData) => {
+    const model = models.value.find((m) => m.id === modelData.id);
+    const id = modelData.id;
+    const afreshSince = id === void 0 ? void 0 : afresh.get(id);
+    if (id !== void 0 && afreshSince !== void 0) {
+      const waiting = Date.now() - afreshSince < AFRESH_ANSWER_MS;
+      if (isBare(modelData) || !waiting) afresh.delete(id);
+      if (isBare(modelData) || waiting) return;
+    }
+    if (id !== void 0 && deletedWhileAwaited.delete(id) && !model && isBare(modelData)) return;
+    const asker = id === void 0 ? void 0 : awaitingAnswer.get(id);
+    if (id !== void 0 && asker) {
+      takeAnswer(id, asker, model, modelData);
+      return;
+    }
+    if (!model && id !== void 0 && isBare(modelData) && ownElsewhere(id)) return;
+    applyUpdate(model, modelData);
+  };
+  const ownElsewhere = (id) => [...ownOnChannel.get(name) ?? []].some((has) => has !== hasOwn && has(id));
+  const takeAnswer = (id, asker, model, modelData) => {
+    if (model) answered.add(model);
+    if (model && !ownModels.has(model)) {
+      askedAfterOutage.delete(id);
+      awaitingAnswer.delete(id);
+      endConfirmation(id);
+      if (!isBare(modelData)) applyUpdate(model, modelData);
+      catchUpOnceAnswered();
+      return;
+    }
+    if (!model || isBare(modelData)) {
+      askedAfterOutage.delete(id);
+      awaitingAnswer.delete(id);
+      endConfirmation(id);
+      if (model) {
+        heldChanges.delete(model);
+        sendUpdate(asker, model, toJsonOf(model));
+      } else if (!isBare(modelData)) {
+        applyUpdate(model, modelData);
+      }
+      catchUpOnceAnswered();
+      return;
+    }
+    const afterOutage = askedAfterOutage.get(id);
+    if (afterOutage) {
+      const held2 = [...heldChanges.get(model) ?? []];
+      for (const key of lostChanges(model, modelData, held2)) afterOutage.lost.add(key);
+      for (const [key, value] of Object.entries(modelData)) afterOutage.shown.set(key, value);
+      applyUpdate(model, withoutKeys(withoutChanges(modelData, model, held2), afterOutage.lost));
+      return;
+    }
+    const confirmation = confirming.get(id);
+    if (confirmation) {
+      for (const key of confirmation.sent.keys()) {
+        if (key in modelData) confirmation.shown.set(key, modelData[key]);
+      }
+      const held2 = [...heldChanges.get(model) ?? []];
+      applyUpdate(model, withoutKeys(withoutChanges(modelData, model, held2), confirmation.sent.keys()));
+      return;
+    }
+    awaitingAnswer.delete(id);
+    const held = releaseHeldChanges(model);
+    applyUpdate(model, withoutChanges(modelData, model, held));
+    if (!models.value.includes(model)) {
+      catchUpOnceAnswered();
+      return;
+    }
+    if (sendOnTop(id, asker, model, modelData, held, [])) return;
+    if (!catchUpOnceAnswered()) guardFrom(asker);
+    const end = guardEnds.at(-1);
+    if (end !== void 0) answerMayFollow.set(id, end);
+  };
+  const endRound = () => {
+    roundEnd = void 0;
+    const asked = [...askedAfterOutage];
+    askedAfterOutage.clear();
+    for (const [id, { shown, lost }] of asked) {
+      const asker = awaitingAnswer.get(id);
+      const model = models.value.find((m) => m.id === id);
+      if (!asker || !model) continue;
+      awaitingAnswer.delete(id);
+      if (!ownModels.has(model)) continue;
+      const held = releaseHeldChanges(model);
+      if (lost.size > 0)
+        remember(model, Object.fromEntries([...lost].map((key) => [key, shown.get(key)])));
+      sendOnTop(id, asker, model, Object.fromEntries(shown), held, [...lost]);
+    }
+    catchUpOnceAnswered();
+  };
+  const sendOnTop = (id, asker, model, shown, held, lost) => {
+    if (held.length === 0 && lost.length === 0) return false;
+    const current = toJsonOf(model);
+    const sent = held.length > 0 ? toJsonOf(model, held) : { id };
+    for (const key of lost) sent[key] = current[key];
+    sendUpdate(asker, model, sent);
+    const differs = /* @__PURE__ */ new Map();
+    for (const [key, value] of Object.entries(sent)) {
+      const json = JSON.stringify(value);
+      if (key === "id" || json === void 0) continue;
+      if (!(key in shown) || JSON.stringify(shown[key]) !== json) differs.set(key, json);
+    }
+    if (differs.size === 0) return false;
+    const replaced = /* @__PURE__ */ new Map();
+    for (const key of differs.keys()) {
+      replaced.set(key, key in shown ? JSON.stringify(shown[key]) : void 0);
+    }
+    askFor(asker, model);
+    confirming.set(id, { sent: differs, replaced, props: held, shown: /* @__PURE__ */ new Map(), end: askForEnd(asker) });
+    return true;
+  };
+  const endWait = (id) => {
+    const confirmation = endConfirmation(id);
+    const asker = awaitingAnswer.get(id);
+    const model = models.value.find((m) => m.id === id);
+    if (!confirmation || !asker || !model) return;
+    awaitingAnswer.delete(id);
+    const held = releaseHeldChanges(model);
+    const theirs = { id };
+    const again = [];
+    for (const [key, json] of confirmation.sent) {
+      const shown = confirmation.shown.has(key) ? JSON.stringify(confirmation.shown.get(key)) : void 0;
+      if (shown === json) continue;
+      if (shown === void 0 || shown === confirmation.replaced.get(key)) again.push(key);
+      else theirs[key] = confirmation.shown.get(key);
+    }
+    applyUpdate(model, withoutChanges(theirs, model, held));
+    const current = toJsonOf(model);
+    const update = held.length > 0 ? toJsonOf(model, held) : { id };
+    for (const key of again) update[key] = current[key];
+    if (ownModels.has(model) && Object.keys(update).length > 1) sendUpdate(asker, model, update);
+    catchUpOnceAnswered();
+  };
+  const sendUpdate = (colibri, model, update) => {
+    colibri.sendMessage(name, "model::update", update);
+    remember(model, update, lastHeardFrom(colibri) ?? Number.POSITIVE_INFINITY);
+    keepOut(model, update);
+  };
+  const remember = (model, fields, heardAt) => {
+    let known = knownValues.get(model);
+    if (!known) knownValues.set(model, known = /* @__PURE__ */ new Map());
+    const at = Date.now();
+    for (const [key, field] of Object.entries(fields)) {
+      const json = JSON.stringify(field);
+      if (key === "id" || json === void 0) continue;
+      const value = { json, at, sent: heardAt !== void 0 };
+      known.set(key, heardAt === void 0 ? [value] : keepKnown([...known.get(key) ?? [], value], heardAt));
+    }
+  };
+  const keepKnown = (values, heardAt) => {
+    const split = values.findIndex((v) => v.at > heardAt);
+    if (split < 0) return values.slice(-KNOWN_VALUES_KEPT);
+    const after = values.slice(split);
+    const newest = after.slice(KNOWN_VALUES_KEPT).slice(-1);
+    return [...values.slice(0, split).slice(-KNOWN_VALUES_KEPT), ...after.slice(0, KNOWN_VALUES_KEPT), ...newest];
+  };
+  const lostChanges = (model, modelData, held) => {
+    const known = knownValues.get(model);
+    if (!known) return [];
+    const since = lastHeardBeforeOutage - KNOWN_VALUES_MS;
+    const heldKeys = new Set(held.length > 0 ? Object.keys(toJsonOf(model, held)) : []);
+    const current = toJsonOf(model);
+    return Object.entries(modelData).filter(([key, value]) => {
+      const values = known.get(key) ?? [];
+      const last = values.at(-1);
+      if (!last?.sent || heldKeys.has(key) || !(key in current)) return false;
+      const json = JSON.stringify(value);
+      const earlier = values.filter((_, i) => i + 1 < values.length && values[i + 1].at >= since);
+      return json !== last.json && earlier.some((v) => v.json === json) && // Nothing to send when this client has what the server has anyway.
+      JSON.stringify(current[key]) !== json;
+    }).map(([key]) => key);
+  };
+  const withoutKeys = (modelData, keys) => {
+    const drop = new Set(keys);
+    return Object.fromEntries(Object.entries(modelData).filter(([key]) => !drop.has(key)));
+  };
+  const applyUpdate = (model, modelData) => {
+    if (model) {
+      const unsent = [...changesToSend.get(model) ?? []];
+      const update = withoutKeys(withoutChanges(modelData, model, unsent), keptOutOf(model));
+      if (ownModels.has(model)) remember(model, update);
+      updateOf(model, update);
+      models.next([...models.value]);
+    } else if (modelData.id) {
+      if (recentlyDeletedHere(modelData.id)) return;
+      const newModel = new registration.type(modelData.id);
+      newModel.deletions.subscribe(() => {
+        deleteHere(newModel);
+      });
+      newModel.modelChanges.subscribe((change) => {
+        noteChangeToSend(newModel, change);
+      });
+      newModel.modelChanges$.subscribe((changes) => {
+        changesToSend.delete(newModel);
+        const update = toJsonOf(newModel, changes);
+        SendMessage(name, "model::update", update);
+        keepOut(newModel, update);
+        models.next([...models.value]);
+      });
+      updateOf(newModel, modelData);
+      models.next([...models.value, newModel]);
+    }
+  };
+  const holdChanges = (model, changes) => {
+    const held = heldChanges.get(model);
+    if (held) for (const change of changes) held.add(change);
+    else heldChanges.set(model, new Set(changes));
+  };
+  const releaseHeldChanges = (model) => {
+    const held = [...heldChanges.get(model) ?? []];
+    heldChanges.delete(model);
+    return held;
+  };
+  const withoutChanges = (modelData, model, changes) => {
+    if (changes.length === 0) return modelData;
+    const changed = new Set(Object.keys(toJsonOf(model, changes)).filter((key) => key !== "id"));
+    return Object.fromEntries(Object.entries(modelData).filter(([key]) => !changed.has(key)));
+  };
+  const onDelete = (id) => {
+    const model = models.value.find((m) => m.id === id);
+    detachOf(model);
+    forget(id, model);
+  };
+  const deleteHere = (model) => {
+    if (models.value.find((m) => m.id === model.id) !== model) return;
+    rememberDeletedHere(model.id);
+    forget(model.id, model);
+    withColibri((colibri) => {
+      colibri.sendMessage(name, "model::delete", { id: model.id });
+    });
+  };
+  const forget = (id, model) => {
+    if (model) heldChanges.delete(model);
+    askedAfterOutage.delete(id);
+    models.next(models.value.filter((m) => m.id !== id));
+    endConfirmation(id);
+    const answerEnd = answerMayFollow.get(id);
+    answerMayFollow.delete(id);
+    if (awaitingAnswer.delete(id)) {
+      deletedWhileAwaited.add(id);
+      catchUpOnceAnswered();
+    } else if (answerEnd !== void 0 && guardEnds.includes(answerEnd)) {
+      deletedWhileAwaited.add(id);
+    }
+  };
+  const registerModel = (model) => {
+    const listed = models.value.find((m) => m.id === model.id);
+    if (listed === model) return;
+    if (listed && ownModels.has(listed)) {
+      console.warn(
+        `Colibri: registerModel was given a second model with the id '${model.id}' on channel '${name}'. It replaces the first one, which no longer syncs.`
+      );
+    }
+    const mustHold = () => !Colibri.getInstance(false) || disconnected || awaitingAnswer.has(model.id);
+    model.modelChanges.subscribe((change) => {
+      if (mustHold()) holdChanges(model, [change]);
+      else noteChangeToSend(model, change);
+    });
+    model.modelChanges$.subscribe({
+      next: () => {
+        const changes = [...changesToSend.get(model) ?? []];
+        changesToSend.delete(model);
+        if (changes.length > 0) {
+          const colibri = Colibri.getInstance(false);
+          if (!colibri || mustHold()) holdChanges(model, changes);
+          else sendUpdate(colibri, model, toJsonOf(model, changes));
         }
-    };
-    var onDelete = function onDelete(id) {
-        var model = models.value.find(function(m) {
-            return m.id === id;
-        });
-        model === null || model === void 0 ? void 0 : model.delete();
-        models.next(models.value.filter(function(m) {
-            return m.id !== id;
-        }));
-    };
-    var registerModel = function registerModel(model) {
-        model.modelChanges$.subscribe(function(changes) {
-            if (!model.ignoreNextChange) {
-                SendMessage("".concat(name), "model::update", model.toJson(changes));
-            }
-            model.ignoreNextChange = false;
-        });
-        SendMessage("".concat(name), "model::update", model.toJson());
-        models.next(_to_consumable_array(models.value).concat([
-            model
-        ]));
-    };
-    return [
-        models.asObservable(),
-        registerModel
-    ];
+        if (models.value.includes(model)) models.next([...models.value]);
+      },
+      // delete() and detach() end the stream: nothing more is sent for the model, neither held changes
+      // nor the whole model after a reconnect.
+      complete: () => {
+        ownModels.delete(model);
+        heldChanges.delete(model);
+        changesToSend.delete(model);
+      }
+    });
+    model.deletions.subscribe(() => {
+      deleteHere(model);
+    });
+    const reused = recentlyDeletedHere(model.id);
+    deletedHere.delete(model.id);
+    ownModels.add(model);
+    if (listed) {
+      endConfirmation(model.id);
+      askedAfterOutage.delete(model.id);
+      detachOf(listed);
+      models.next(models.value.map((m) => m === listed ? model : m));
+    } else {
+      models.next([...models.value, model]);
+    }
+    withColibri((colibri) => {
+      if (disconnected || !ownModels.has(model)) return;
+      if (reused) sendAfresh(colibri, model);
+      else askFor(colibri, model);
+    });
+  };
+  return [models.asObservable(), registerModel];
 };
-// src/SyncModel.ts
-import { Subject as Subject2, bufferTime, filter, map, share } from "rxjs";
-var SyncModel = /*#__PURE__*/ function() {
-    "use strict";
-    function SyncModel(id) {
-        var _this = this;
-        _class_call_check(this, SyncModel);
-        // TODO: move to ModelSynchronization or use a much better structure or something like that?
-        this.ignoreNextChange = false;
-        this.modelChanges = new Subject2();
-        this.modelChanges$ = this.modelChanges.pipe(bufferTime(1), map(function(changes) {
-            return changes.filter(_this.uniq);
-        }), filter(function(changes) {
-            return changes.length > 0;
-        }), share());
-        this.id = id;
-    }
-    _create_class(SyncModel, [
-        {
-            key: "uniq",
-            value: function uniq(value, index, array) {
-                return array.indexOf(value) === index;
-            }
-        },
-        {
-            key: "onModelChanges",
-            value: function onModelChanges(prop) {
-                this.modelChanges.next(prop);
-            }
-        },
-        {
-            key: "delete",
-            value: function _delete() {
-                this.modelChanges.complete();
-            }
-        },
-        {
-            key: "registerSyncedProperty",
-            value: function registerSyncedProperty(name, prop) {
-                if (!this.syncedProperties) {
-                    this.syncedProperties = {};
-                }
-                this.syncedProperties[name] = prop;
-            }
-        },
-        {
-            key: "update",
-            value: function update(updates) {
-                var syncedProps = Object.getPrototypeOf(this).syncedProperties;
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    for(var _iterator = Object.keys(updates)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var key = _step.value;
-                        if (key !== "id") {
-                            var localKey = syncedProps[key];
-                            if (localKey) {
-                                this[localKey] = updates[key];
-                                this.ignoreNextChange = true;
-                            } else {
-                                console.warn("Unknown property ".concat(key, " in ").concat(this.constructor.name));
-                            }
-                        }
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
-                }
-            }
-        },
-        {
-            key: "toJson",
-            value: function toJson() {
-                var attributes = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
-                var json = {
-                    id: this.id
-                };
-                var syncedProps = Object.getPrototypeOf(this).syncedProperties;
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    for(var _iterator = Object.keys(syncedProps)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var key = _step.value;
-                        var localKey = syncedProps[key];
-                        if (attributes.length === 0 || attributes.includes(localKey)) {
-                            json[key] = this[localKey];
-                        }
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
-                }
-                return json;
-            }
-        }
-    ]);
-    return SyncModel;
-}();
+
 // src/Synced.ts
-var Synced = function Synced() {
-    var syncedName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
-    return function(target, key, descriptor) {
-        if (!syncedName) syncedName = key.toString();
-        syncedName = syncedName.toLowerCase();
-        if (!_instanceof(target, SyncModel)) {
-            console.error("Synced decorator can only be used on SyncModel properties");
-            return;
-        }
-        var original = target[key];
-        target.registerSyncedProperty(syncedName, key);
-        if (!(descriptor === null || descriptor === void 0 ? void 0 : descriptor.get)) {
-            Reflect.deleteProperty(target, key);
-            Reflect.defineProperty(target, key, {
-                get: function get() {
-                    return original;
-                },
-                set: function set(newVal) {
-                    console.log("Set ".concat(key.toString(), " to ").concat(newVal));
-                    original = newVal;
-                },
-                enumerable: true,
-                configurable: true
-            });
-        } else {
-            var originalAccessors = {
-                get: descriptor.get,
-                set: descriptor.set
-            };
-            descriptor.get = function() {
-                var ret = originalAccessors.get.call(this);
-                return ret;
-            };
-            descriptor.set = function(newval) {
-                var model = this;
-                model.modelChanges.next(String(key));
-                if (originalAccessors.set) {
-                    originalAccessors.set.call(this, newval);
-                }
-            };
+function Synced(syncedName = "") {
+  return function(value, context) {
+    if (context.kind !== "accessor") {
+      throw new Error("@Synced() must decorate an `accessor` member");
+    }
+    const key = String(context.name);
+    const name = (syncedName || key).toLowerCase();
+    context.addInitializer(function() {
+      this.registerSyncedProperty(name, key);
+    });
+    return {
+      get() {
+        return value.get.call(this);
+      },
+      set(newVal) {
+        value.set.call(this, newVal);
+        if (!this.applyingRemoteUpdate) {
+          this.modelChanges.next(key);
         }
+      }
     };
+  };
+}
+function synced(model, values, names = {}) {
+  for (const [key, initial] of Object.entries(values)) {
+    if (initial === void 0) {
+      throw new Error(`synced(): '${key}' has no start value. undefined is not JSON: use null for none.`);
+    }
+    if (key in model) {
+      throw new Error(
+        `synced(): '${key}' is already a member of ${model.constructor.name}, a synced property or one of SyncModel's. Give it another name.`
+      );
+    }
+    let value = initial;
+    model.registerSyncedProperty((names[key] || key).toLowerCase(), key);
+    Object.defineProperty(model, key, {
+      enumerable: true,
+      get: () => value,
+      set: (newValue) => {
+        value = newValue;
+        if (!model.applyingRemoteUpdate) model.modelChanges.next(key);
+      }
+    });
+  }
+}
+
+// src/SyncTransform.ts
+var _physicsId_dec, _scale_dec, _rotation_dec, _position_dec, _active_dec, _a, _init, _active, _position, _rotation, _scale, _physicsId;
+var SyncTransform = class extends (_a = SyncModel, _active_dec = [Synced()], _position_dec = [Synced()], _rotation_dec = [Synced()], _scale_dec = [Synced()], _physicsId_dec = [Synced()], _a) {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _active, __runInitializers(_init, 8, this, true)), __runInitializers(_init, 11, this);
+    __privateAdd(this, _position, __runInitializers(_init, 12, this, [0, 0, 0])), __runInitializers(_init, 15, this);
+    __privateAdd(this, _rotation, __runInitializers(_init, 16, this, [0, 0, 0, 1])), __runInitializers(_init, 19, this);
+    __privateAdd(this, _scale, __runInitializers(_init, 20, this, [1, 1, 1])), __runInitializers(_init, 23, this);
+    __privateAdd(this, _physicsId, __runInitializers(_init, 24, this, "")), __runInitializers(_init, 27, this);
+  }
+};
+_init = __decoratorStart(_a);
+_active = new WeakMap();
+_position = new WeakMap();
+_rotation = new WeakMap();
+_scale = new WeakMap();
+_physicsId = new WeakMap();
+__decorateElement(_init, 4, "active", _active_dec, SyncTransform, _active);
+__decorateElement(_init, 4, "position", _position_dec, SyncTransform, _position);
+__decorateElement(_init, 4, "rotation", _rotation_dec, SyncTransform, _rotation);
+__decorateElement(_init, 4, "scale", _scale_dec, SyncTransform, _scale);
+__decorateElement(_init, 4, "physicsId", _physicsId_dec, SyncTransform, _physicsId);
+__decoratorMetadata(_init, SyncTransform);
+var RegisterSyncTransforms = (modelId = "") => RegisterModelSync({
+  name: modelId ? `synctransform_${modelId}` : "synctransform",
+  type: SyncTransform
+});
+export {
+  Colibri,
+  ColibriError,
+  DeleteRestApi,
+  GetRestApi,
+  PROTOCOL_VERSION,
+  ProtocolMismatchError,
+  PutRestApi,
+  RegisterChannel,
+  RegisterModelSync,
+  RegisterOnce,
+  RegisterSyncTransforms,
+  RemoteLogger,
+  SendMessage,
+  Sync,
+  SyncModel,
+  SyncTransform,
+  Synced,
+  UnregisterChannel,
+  synced,
+  toHexColor,
+  toRgbaColor
 };
-export { Colibri, GetRestApi, PutRestApi, RegisterChannel, RegisterModelSync, RegisterOnce, RemoteLogger, SendMessage, Sync, SyncModel, Synced, UnregisterChannel };
 //# sourceMappingURL=index.js.map