@kokimoki/app 1.3.2 → 1.4.0

package/dist/kokimoki.min.js

@@ -634,7 +634,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 var eventsExports = events.exports;
 var EventEmitter$1 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
 
-const KOKIMOKI_APP_VERSION = "1.3.2";
+const KOKIMOKI_APP_VERSION = "1.4.0";
 
 /**
  * Utility module to work with key-value stores.
@@ -11401,6 +11401,7 @@ class KokimokiTransaction {
     _clones = new Map();
     _updates = new Map();
     _consumeMessagesInRooms = new Set();
+    _queueMessageCounter = 0;
     constructor(kmClient) {
         this.kmClient = kmClient;
     }
@@ -11468,11 +11469,10 @@ class KokimokiTransaction {
         obj[key].push(value);
     }
     queueMessage(queue, payload) {
-        const messageId = Math.random().toString(36);
-        this.set(queue.root[messageId], {
-            timestamp: this.kmClient.serverTimestamp(),
-            payload,
-        });
+        const messageId = `${this.kmClient.serverTimestamp()}/${this
+            ._queueMessageCounter++}/${Math.random().toString(36).slice(2)}`;
+        this.set(queue.root[messageId], payload);
+        return messageId;
     }
     consumeMessage(queue, messageId) {
         if (!queue.proxy[messageId]) {
@@ -11499,6 +11499,175 @@ class KokimokiTransaction {
     }
 }
 
+function parsePath(text) {
+  return text.split('.')
+}
+
+function push(arr, el) {
+  const newArr = arr.slice();
+  newArr.push(el);
+  return newArr;
+}
+
+// names of the traps that can be registered with ES6's Proxy object
+const trapNames = [
+  'apply',
+  'construct',
+  'defineProperty',
+  'deleteProperty',
+  'enumerate', // deprecated
+  'get',
+  'getOwnPropertyDescriptor',
+  'getPrototypeOf',
+  'has',
+  'isExtensible',
+  'ownKeys',
+  'preventExtensions',
+  'set',
+  'setPrototypeOf',
+];
+
+// a list of paramer indexes that indicate that the a recieves a key at that parameter
+// this information will be used to update the path accordingly
+const keys = {
+  get: 1,
+  set: 1,
+  deleteProperty: 1,
+  has: 1,
+  defineProperty: 1,
+  getOwnPropertyDescriptor: 1,
+};
+
+function DeepProxy(rootTarget, traps, options) {
+
+  let path = [];
+  let userData = {};
+
+  if (options !== undefined && typeof options.path !== 'undefined') {
+    path = parsePath(options.path);
+  }
+  if (options !== undefined && typeof options.userData !== 'undefined') {
+    userData = options.userData;
+  }
+
+  function createProxy(target, path) {
+
+    // avoid creating a new object between two traps
+    const context = { rootTarget, path };
+    Object.assign(context, userData);
+
+    const realTraps = {};
+
+    for (const trapName of trapNames) {
+      const keyParamIdx = keys[trapName]
+          , trap = traps[trapName];
+
+      if (typeof trap !== 'undefined') {
+
+        if (typeof keyParamIdx !== 'undefined') {
+
+          realTraps[trapName] = function () {
+
+            const key = arguments[keyParamIdx];
+
+            // update context for this trap
+            context.nest = function (nestedTarget) {
+              if (nestedTarget === undefined)
+                nestedTarget = rootTarget;
+              return createProxy(nestedTarget, push(path, key)); 
+            };
+
+            return trap.apply(context, arguments);
+          };
+        } else {
+
+          realTraps[trapName] = function () {
+
+            // update context for this trap
+            context.nest = function (nestedTarget) {
+              if (nestedTarget === undefined)
+                nestedTarget = {};
+              return createProxy(nestedTarget, path);
+            };
+
+            return trap.apply(context, arguments);
+          };
+        }
+      }
+    }
+
+    return new Proxy(target, realTraps);
+  }
+
+  return createProxy(rootTarget, path);
+
+}
+
+var RoomSubscriptionMode;
+(function (RoomSubscriptionMode) {
+    RoomSubscriptionMode["Read"] = "r";
+    RoomSubscriptionMode["Write"] = "w";
+    RoomSubscriptionMode["ReadWrite"] = "b";
+})(RoomSubscriptionMode || (RoomSubscriptionMode = {}));
+
+class KokimokiStore {
+    roomName;
+    mode;
+    doc;
+    proxy;
+    root;
+    defaultValue;
+    docRoot;
+    constructor(roomName, schema, mode = RoomSubscriptionMode.ReadWrite) {
+        this.roomName = roomName;
+        this.mode = mode;
+        // Construct Y doc
+        this.doc = new Doc();
+        this.docRoot = this.doc.getMap("root");
+        // Construct proxy object
+        this.proxy = proxy();
+        // @ts-ignore
+        f(this.proxy, this.docRoot);
+        // Create root proxy
+        const store = this;
+        // @ts-ignore
+        this.root = new DeepProxy(this.proxy, {
+            get() {
+                return this.nest(function () { });
+            },
+            apply() {
+                let obj = store.proxy;
+                for (let i = 0; i < this.path.length - 1; i++) {
+                    obj = obj[this.path[i]];
+                }
+                return {
+                    roomName: store.roomName,
+                    doc: store.doc,
+                    path: this.path,
+                    obj,
+                    key: this.path[this.path.length - 1],
+                };
+            },
+        });
+        // Set default value
+        this.defaultValue = schema.defaultValue;
+    }
+    get() {
+        return this.proxy;
+    }
+    subscribe(set) {
+        // @ts-ignore
+        const handler = () => set(this.proxy);
+        this.doc.on("update", handler);
+        // @ts-ignore
+        set(this.proxy);
+        return () => this.doc.off("update", handler);
+    }
+    async onJoin(client) { }
+    async onBeforeLeave(client) { }
+    async onLeave(client) { }
+}
+
 var WsMessageType;
 (function (WsMessageType) {
     WsMessageType[WsMessageType["SubscribeReq"] = 1] = "SubscribeReq";
@@ -11595,13 +11764,6 @@ class WsMessageReader {
     }
 }
 
-var RoomSubscriptionMode;
-(function (RoomSubscriptionMode) {
-    RoomSubscriptionMode["Read"] = "r";
-    RoomSubscriptionMode["Write"] = "w";
-    RoomSubscriptionMode["ReadWrite"] = "b";
-})(RoomSubscriptionMode || (RoomSubscriptionMode = {}));
-
 class RoomSubscription {
     kmClient;
     store;
@@ -11650,925 +11812,937 @@ class RoomSubscription {
     }
 }
 
-class KokimokiClient extends EventEmitter$1 {
-    host;
-    appId;
-    code;
-    _wsUrl;
-    _apiUrl;
-    _id;
-    _connectionId;
-    _token;
-    _apiHeaders;
-    _serverTimeOffset = 0;
-    _clientContext;
-    _ws;
-    _subscriptionsByName = new Map();
-    _subscriptionsByHash = new Map();
-    _subscribeReqPromises = new Map();
-    _unsubscribeReqPromises = new Map();
-    _transactionPromises = new Map();
-    _connected = false;
-    _connectPromise;
-    _messageId = 0;
-    _autoReconnect = true;
-    _reconnectTimeout = 0;
-    _pingInterval;
-    constructor(host, appId, code = "") {
-        super();
-        this.host = host;
-        this.appId = appId;
-        this.code = code;
-        // Set up the URLs
-        const secure = this.host.indexOf(":") === -1;
-        this._wsUrl = `ws${secure ? "s" : ""}://${this.host}`;
-        this._apiUrl = `http${secure ? "s" : ""}://${this.host}`;
-        // Set up ping interval
-        const pingMsg = new WsMessageWriter();
-        pingMsg.writeInt32(WsMessageType.Ping);
-        const pingBuffer = pingMsg.getBuffer();
-        this._pingInterval = setInterval(() => {
-            if (this.connected) {
-                this.ws.send(pingBuffer);
-            }
-        }, 5000);
-    }
-    get id() {
-        if (!this._id) {
-            throw new Error("Client not connected");
-        }
-        return this._id;
+var KokimokiSchema;
+(function (KokimokiSchema) {
+    class Generic {
     }
-    get connectionId() {
-        if (!this._connectionId) {
-            throw new Error("Client not connected");
+    KokimokiSchema.Generic = Generic;
+    class Number extends Generic {
+        defaultValue;
+        constructor(defaultValue = 0) {
+            super();
+            this.defaultValue = defaultValue;
         }
-        return this._connectionId;
     }
-    get token() {
-        if (!this._token) {
-            throw new Error("Client not connected");
-        }
-        return this._token;
+    KokimokiSchema.Number = Number;
+    function number(defaultValue = 0) {
+        return new Number(defaultValue);
     }
-    get apiUrl() {
-        if (!this._apiUrl) {
-            throw new Error("Client not connected");
+    KokimokiSchema.number = number;
+    class String extends Generic {
+        defaultValue;
+        constructor(defaultValue = "") {
+            super();
+            this.defaultValue = defaultValue;
         }
-        return this._apiUrl;
     }
-    get apiHeaders() {
-        if (!this._apiHeaders) {
-            throw new Error("Client not connected");
-        }
-        return this._apiHeaders;
+    KokimokiSchema.String = String;
+    function string(defaultValue = "") {
+        return new String(defaultValue);
     }
-    get clientContext() {
-        if (this._clientContext === undefined) {
-            throw new Error("Client not connected");
+    KokimokiSchema.string = string;
+    class Boolean extends Generic {
+        defaultValue;
+        constructor(defaultValue = false) {
+            super();
+            this.defaultValue = defaultValue;
         }
-        return this._clientContext;
-    }
-    get connected() {
-        return this._connected;
     }
-    get ws() {
-        if (!this._ws) {
-            throw new Error("Not connected");
-        }
-        return this._ws;
+    KokimokiSchema.Boolean = Boolean;
+    function boolean(defaultValue = false) {
+        return new Boolean(defaultValue);
     }
-    async connect() {
-        if (this._connectPromise) {
-            return await this._connectPromise;
-        }
-        this._ws = new WebSocket(`${this._wsUrl}/apps/${this.appId}?clientVersion=${KOKIMOKI_APP_VERSION}`);
-        this._ws.binaryType = "arraybuffer";
-        // Close previous connection in hot-reload scenarios
-        if (window) {
-            if (!window.__KOKIMOKI_WS__) {
-                window.__KOKIMOKI_WS__ = {};
-            }
-            if (this.appId in window.__KOKIMOKI_WS__) {
-                console.log(`[Kokimoki] Closing previous connection for ${this.appId}`);
-                window.__KOKIMOKI_WS__[this.appId].close();
-            }
-            window.__KOKIMOKI_WS__[this.appId] = this;
+    KokimokiSchema.boolean = boolean;
+    class Struct extends Generic {
+        fields;
+        constructor(fields) {
+            super();
+            this.fields = fields;
         }
-        // Wait for connection
-        this._connectPromise = new Promise((onInit) => {
-            // Fetch the auth token
-            let clientToken = localStorage.getItem("KM_TOKEN");
-            // Send the app token on first connect
-            this.ws.onopen = () => {
-                this.ws.send(JSON.stringify({ type: "auth", code: this.code, token: clientToken }));
-            };
-            this.ws.onclose = () => {
-                this._connected = false;
-                this._connectPromise = undefined;
-                this._ws.onmessage = null;
-                this._ws = undefined;
-                if (window && window.__KOKIMOKI_WS__) {
-                    delete window.__KOKIMOKI_WS__[this.appId];
-                }
-                // Clean up
-                this._subscribeReqPromises.clear();
-                this._transactionPromises.clear();
-                // Attempt to reconnect
-                if (!this._autoReconnect) {
-                    return;
-                }
-                console.log(`[Kokimoki] Connection lost, attempting to reconnect in ${this._reconnectTimeout} seconds...`);
-                setTimeout(async () => await this.connect(), this._reconnectTimeout * 1000);
-                this._reconnectTimeout = Math.min(3, this._reconnectTimeout + 1);
-                // Emit disconnected event
-                this.emit("disconnected");
-            };
-            this.ws.onmessage = (e) => {
-                // console.log(`Received WS message: ${e.data}`);
-                // Handle JSON messages
-                if (typeof e.data === "string") {
-                    const message = JSON.parse(e.data);
-                    switch (message.type) {
-                        case "init":
-                            this.handleInitMessage(message);
-                            onInit();
-                            break;
-                    }
-                    return;
-                }
-                // Handle binary messages
-                this.handleBinaryMessage(e.data);
-            };
-        });
-        await this._connectPromise;
-        this._connected = true;
-        // Connection established
-        console.log(`[Kokimoki] Client id: ${this.id}`);
-        console.log(`[Kokimoki] Client context:`, this.clientContext);
-        // Restore subscriptions if reconnected
-        const roomNames = Array.from(this._subscriptionsByName.keys()).map((name) => `"${name}"`);
-        if (roomNames.length) {
-            console.log(`[Kokimoki] Restoring subscriptions: ${roomNames}`);
+        get defaultValue() {
+            return Object.entries(this.fields).reduce((acc, [key, field]) => {
+                acc[key] = field.defaultValue;
+                return acc;
+            }, {});
         }
-        for (const subscription of this._subscriptionsByName.values()) {
-            try {
-                await this.join(subscription.store);
-            }
-            catch (err) {
-                console.error(`[Kokimoki] Failed to restore subscription for "${subscription.roomName}":`, err);
+        set defaultValue(value) {
+            for (const [key, field] of Object.entries(this.fields)) {
+                field.defaultValue = value[key];
             }
         }
-        // Emit connected event
-        this._reconnectTimeout = 0;
-        this.emit("connected");
     }
-    handleInitMessage(message) {
-        localStorage.setItem("KM_TOKEN", message.clientToken);
-        this._id = message.clientId;
-        this._connectionId = message.id;
-        this._token = message.appToken;
-        this._clientContext = message.clientContext;
-        // Set up the auth headers
-        this._apiHeaders = new Headers({
-            Authorization: `Bearer ${this.token}`,
-            "Content-Type": "application/json",
-        });
+    KokimokiSchema.Struct = Struct;
+    function struct(schema) {
+        return new Struct(schema);
     }
-    handleBinaryMessage(data) {
-        const reader = new WsMessageReader(data);
-        const type = reader.readInt32();
-        switch (type) {
-            case WsMessageType.SubscribeRes:
-                this.handleSubscribeResMessage(reader);
-                break;
-            case WsMessageType.UnsubscribeRes:
-                this.handleUnsubscribeResMessage(reader);
-                break;
-            case WsMessageType.RoomUpdate:
-                this.handleRoomUpdateMessage(reader);
-                break;
-            case WsMessageType.Error:
-                this.handleErrorMessage(reader);
-                break;
-            case WsMessageType.Pong: {
-                const s = reader.readInt32();
-                const ms = reader.readInt32();
-                this._serverTimeOffset = Date.now() - s * 1000 - ms;
-                break;
-            }
+    KokimokiSchema.struct = struct;
+    class Dict {
+        schema;
+        defaultValue;
+        constructor(schema, defaultValue = {}) {
+            this.schema = schema;
+            this.defaultValue = defaultValue;
         }
     }
-    handleErrorMessage(msg) {
-        const reqId = msg.readInt32();
-        const error = msg.readString();
-        const subscribeReqPromise = this._subscribeReqPromises.get(reqId);
-        const transactionPromise = this._transactionPromises.get(reqId);
-        if (subscribeReqPromise) {
-            this._subscribeReqPromises.delete(reqId);
-            subscribeReqPromise.reject(error);
-        }
-        else if (transactionPromise) {
-            this._transactionPromises.delete(reqId);
-            transactionPromise.reject(error);
-        }
-        else {
-            console.warn(`Received error for unknown request ${reqId}: ${error}`);
-        }
+    KokimokiSchema.Dict = Dict;
+    function dict(schema, defaultValue = {}) {
+        return new Dict(schema, defaultValue);
     }
-    handleSubscribeResMessage(msg) {
-        const reqId = msg.readInt32();
-        const roomHash = msg.readUint32();
-        const promise = this._subscribeReqPromises.get(reqId);
-        if (promise) {
-            this._subscribeReqPromises.delete(reqId);
-            // In Write mode, no initial state is sent
-            if (!msg.end) {
-                promise.resolve(roomHash, msg.readUint8Array());
-            }
-            else {
-                promise.resolve(roomHash);
-            }
+    KokimokiSchema.dict = dict;
+    class List extends Generic {
+        schema;
+        defaultValue;
+        constructor(schema, defaultValue = []) {
+            super();
+            this.schema = schema;
+            this.defaultValue = defaultValue;
         }
     }
-    handleUnsubscribeResMessage(msg) {
-        const reqId = msg.readInt32();
-        const promise = this._unsubscribeReqPromises.get(reqId);
-        if (promise) {
-            this._unsubscribeReqPromises.delete(reqId);
-            promise.resolve();
-        }
+    KokimokiSchema.List = List;
+    function list(schema, defaultValue = []) {
+        return new List(schema, defaultValue);
     }
-    handleRoomUpdateMessage(msg) {
-        const appliedId = msg.readInt32();
-        const roomHash = msg.readUint32();
-        // Apply update if not in Write mode
-        if (!msg.end) {
-            const subscription = this._subscriptionsByHash.get(roomHash);
-            if (subscription) {
-                applyUpdate(subscription.store.doc, msg.readUint8Array(), this);
-            }
-            else {
-                console.warn(`Received update for unknown room ${roomHash}`);
-            }
-        }
-        // Check transaction resolves
-        for (const [transactionId, { resolve },] of this._transactionPromises.entries()) {
-            if (appliedId >= transactionId) {
-                this._transactionPromises.delete(transactionId);
-                resolve();
-            }
+    KokimokiSchema.list = list;
+    /**
+     * Nullable
+     */
+    class Nullable extends Generic {
+        schema;
+        defaultValue;
+        constructor(schema, defaultValue) {
+            super();
+            this.schema = schema;
+            this.defaultValue = defaultValue;
         }
     }
-    serverTimestamp() {
-        return Date.now() - this._serverTimeOffset;
+    KokimokiSchema.Nullable = Nullable;
+    function nullable(schema, defaultValue = null) {
+        return new Nullable(schema, defaultValue);
     }
-    // Send Y update to room
-    async patchRoomState(room, update) {
-        const res = await fetch(`${this._apiUrl}/rooms/${room}`, {
-            method: "PATCH",
-            headers: this.apiHeaders,
-            body: update,
-        });
-        return await res.json();
-    }
-    // Storage
-    async createUpload(name, blob, tags) {
-        const res = await fetch(`${this._apiUrl}/uploads`, {
-            method: "POST",
-            headers: this.apiHeaders,
-            body: JSON.stringify({
-                name,
-                size: blob.size,
-                mimeType: blob.type,
-                tags,
-            }),
-        });
-        return await res.json();
-    }
-    async uploadChunks(blob, chunkSize, signedUrls) {
-        return await Promise.all(signedUrls.map(async (url, index) => {
-            const start = index * chunkSize;
-            const end = Math.min(start + chunkSize, blob.size);
-            const chunk = blob.slice(start, end);
-            const res = await fetch(url, { method: "PUT", body: chunk });
-            return JSON.parse(res.headers.get("ETag") || '""');
-        }));
-    }
-    async completeUpload(id, etags) {
-        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
-            method: "PUT",
-            headers: this.apiHeaders,
-            body: JSON.stringify({ etags }),
-        });
-        return await res.json();
-    }
-    async upload(name, blob, tags = []) {
-        const { id, chunkSize, urls } = await this.createUpload(name, blob, tags);
-        const etags = await this.uploadChunks(blob, chunkSize, urls);
-        return await this.completeUpload(id, etags);
-    }
-    async updateUpload(id, update) {
-        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
-            method: "PUT",
-            headers: this.apiHeaders,
-            body: JSON.stringify(update),
-        });
-        return await res.json();
-    }
-    async listUploads(filter = {}, skip = 0, limit = 100) {
-        const url = new URL("/uploads", this._apiUrl);
-        url.searchParams.set("skip", skip.toString());
-        url.searchParams.set("limit", limit.toString());
-        if (filter.clientId) {
-            url.searchParams.set("clientId", filter.clientId);
-        }
-        if (filter.mimeTypes) {
-            url.searchParams.set("mimeTypes", filter.mimeTypes.join());
-        }
-        if (filter.tags) {
-            url.searchParams.set("tags", filter.tags.join());
-        }
-        const res = await fetch(url.href, {
-            headers: this.apiHeaders,
-        });
-        return await res.json();
-    }
-    async deleteUpload(id) {
-        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
-            method: "DELETE",
-            headers: this.apiHeaders,
-        });
-        return await res.json();
-    }
-    async exposeScriptingContext(context) {
-        // @ts-ignore
-        window.KM_SCRIPTING_CONTEXT = context;
-        // @ts-ignore
-        window.dispatchEvent(new CustomEvent("km:scriptingContextExposed"));
-    }
-    async sendSubscribeReq(roomName, mode) {
-        // Set up sync resolver
-        const reqId = ++this._messageId;
-        return await new Promise((resolve, reject) => {
-            this._subscribeReqPromises.set(reqId, {
-                resolve: (roomHash, initialUpdate) => {
-                    resolve({ roomHash, initialUpdate });
-                },
-                reject,
-            });
-            // Send subscription request
-            const msg = new WsMessageWriter();
-            msg.writeInt32(WsMessageType.SubscribeReq);
-            msg.writeInt32(reqId);
-            msg.writeString(roomName);
-            msg.writeChar(mode);
-            this.ws.send(msg.getBuffer());
-        });
-    }
-    async sendUnsubscribeReq(roomHash) {
-        const reqId = ++this._messageId;
-        return await new Promise((resolve, reject) => {
-            this._unsubscribeReqPromises.set(reqId, {
-                resolve,
-                reject,
-            });
-            // Send unsubscribe request
-            const msg = new WsMessageWriter();
-            msg.writeInt32(WsMessageType.UnsubscribeReq);
-            msg.writeInt32(reqId);
-            msg.writeUint32(roomHash);
-            this.ws.send(msg.getBuffer());
-        });
-    }
-    async join(store) {
-        let subscription = this._subscriptionsByName.get(store.roomName);
-        if (!subscription) {
-            subscription = new RoomSubscription(this, store);
-            this._subscriptionsByName.set(store.roomName, subscription);
-        }
-        // Send subscription request if connected to server
-        if (!subscription.joined) {
-            const res = await this.sendSubscribeReq(store.roomName, store.mode);
-            this._subscriptionsByHash.set(res.roomHash, subscription);
-            await subscription.applyInitialResponse(res.roomHash, res.initialUpdate);
-            // Trigger onJoin event
-            store.onJoin(this);
-        }
-    }
-    async leave(store) {
-        const subscription = this._subscriptionsByName.get(store.roomName);
-        if (subscription) {
-            await store.onBeforeLeave(this);
-            await this.sendUnsubscribeReq(subscription.roomHash);
-            this._subscriptionsByName.delete(store.roomName);
-            this._subscriptionsByHash.delete(subscription.roomHash);
-            // Trigger onLeave event
-            store.onLeave(this);
-        }
-    }
-    async transact(handler) {
-        if (!this._connected) {
-            throw new Error("Client not connected");
-        }
-        const transaction = new KokimokiTransaction(this);
-        handler(transaction);
-        const { updates, consumedMessages } = await transaction.getUpdates();
-        if (!updates.length) {
-            return;
-        }
-        // Construct buffer
-        const writer = new WsMessageWriter();
-        // Write message type
-        writer.writeInt32(WsMessageType.Transaction);
-        // Update and write transaction ID
-        const transactionId = ++this._messageId;
-        writer.writeInt32(transactionId);
-        // Write room hashes where messages were consumed
-        writer.writeInt32(consumedMessages.size);
-        for (const roomName of consumedMessages) {
-            const subscription = this._subscriptionsByName.get(roomName);
-            if (!subscription) {
-                throw new Error(`Cannot consume message in "${roomName}" because it hasn't been joined`);
-            }
-            writer.writeUint32(subscription.roomHash);
-        }
-        // Write updates
-        for (const { roomName, update } of updates) {
-            const subscription = this._subscriptionsByName.get(roomName);
-            if (!subscription) {
-                throw new Error(`Cannot send update to "${roomName}" because it hasn't been joined`);
-            }
-            writer.writeUint32(subscription.roomHash);
-            writer.writeUint8Array(update);
-        }
-        const buffer = writer.getBuffer();
-        // Wait for server to apply transaction
-        await new Promise((resolve, reject) => {
-            this._transactionPromises.set(transactionId, { resolve, reject });
-            // Send update to server
-            try {
-                this.ws.send(buffer);
-            }
-            catch (e) {
-                // Not connected
-                console.log("Failed to send update to server:", e);
-                // TODO: merge updates or something
-                throw e;
-            }
-        });
-        /* // Reset doc in Write-only mode
-        for (const { roomName, update } of updates) {
-          const mode = this._subscriptions.get(roomName);
-    
-          if (mode === RoomSubscriptionMode.Write) {
-            // @ts-ignore
-            // this._stores.get(this._roomHashes.get(roomName)!)!.doc = new Y.Doc();
-          }
-        } */
-    }
-    async close() {
-        this._autoReconnect = false;
-        if (this._ws) {
-            this._ws.close();
-        }
-        if (this._pingInterval) {
-            clearInterval(this._pingInterval);
+    KokimokiSchema.nullable = nullable;
+    class StringEnum extends Generic {
+        options;
+        defaultValue;
+        constructor(options, defaultValue) {
+            super();
+            this.options = options;
+            this.defaultValue = defaultValue;
         }
     }
-}
-
-var KokimokiSchema;
-(function (KokimokiSchema) {
-    class Generic {
+    KokimokiSchema.StringEnum = StringEnum;
+    function stringEnum(options, defaultValue) {
+        return new StringEnum(options, defaultValue);
     }
-    KokimokiSchema.Generic = Generic;
-    class Number extends Generic {
+    KokimokiSchema.stringEnum = stringEnum;
+    class StringConst extends Generic {
         defaultValue;
-        constructor(defaultValue = 0) {
+        constructor(defaultValue) {
             super();
             this.defaultValue = defaultValue;
         }
     }
-    KokimokiSchema.Number = Number;
-    function number(defaultValue = 0) {
-        return new Number(defaultValue);
+    KokimokiSchema.StringConst = StringConst;
+    function stringConst(defaultValue) {
+        return new StringConst(defaultValue);
     }
-    KokimokiSchema.number = number;
-    class String extends Generic {
+    KokimokiSchema.stringConst = stringConst;
+    class AnyOf extends Generic {
+        schemas;
         defaultValue;
-        constructor(defaultValue = "") {
+        constructor(schemas, defaultValue) {
             super();
+            this.schemas = schemas;
             this.defaultValue = defaultValue;
         }
     }
-    KokimokiSchema.String = String;
-    function string(defaultValue = "") {
-        return new String(defaultValue);
+    KokimokiSchema.AnyOf = AnyOf;
+    function anyOf(schemas, defaultValue) {
+        return new AnyOf(schemas, defaultValue);
     }
-    KokimokiSchema.string = string;
-    class Boolean extends Generic {
+    KokimokiSchema.anyOf = anyOf;
+    class Optional extends Generic {
+        schema;
         defaultValue;
-        constructor(defaultValue = false) {
+        constructor(schema, defaultValue = undefined) {
             super();
+            this.schema = schema;
             this.defaultValue = defaultValue;
         }
     }
-    KokimokiSchema.Boolean = Boolean;
-    function boolean(defaultValue = false) {
-        return new Boolean(defaultValue);
+    KokimokiSchema.Optional = Optional;
+    function optional(schema, defaultValue = undefined) {
+        return new Optional(schema, defaultValue);
     }
-    KokimokiSchema.boolean = boolean;
-    class Struct extends Generic {
-        fields;
-        constructor(fields) {
-            super();
-            this.fields = fields;
-        }
-        get defaultValue() {
-            return Object.entries(this.fields).reduce((acc, [key, field]) => {
-                acc[key] = field.defaultValue;
-                return acc;
-            }, {});
-        }
-        set defaultValue(value) {
-            for (const [key, field] of Object.entries(this.fields)) {
-                field.defaultValue = value[key];
+    KokimokiSchema.optional = optional;
+})(KokimokiSchema || (KokimokiSchema = {}));
+
+class KokimokiQueue extends KokimokiStore {
+    payloadSchema;
+    _emitter = new EventEmitter$1();
+    on = this._emitter.on.bind(this._emitter);
+    off = this._emitter.off.bind(this._emitter);
+    constructor(roomName, payloadSchema, mode) {
+        super(`/q/${roomName}`, KokimokiSchema.dict(payloadSchema), mode);
+        this.payloadSchema = payloadSchema;
+        const emittedMessageIds = new Set();
+        this.doc.on("update", () => {
+            const newMessages = [];
+            for (const id in this.proxy) {
+                if (emittedMessageIds.has(id)) {
+                    continue;
+                }
+                emittedMessageIds.add(id);
+                newMessages.push({ id, payload: this.proxy[id] });
             }
-        }
-    }
-    KokimokiSchema.Struct = Struct;
-    function struct(schema) {
-        return new Struct(schema);
-    }
-    KokimokiSchema.struct = struct;
-    class Dict {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue = {}) {
-            this.schema = schema;
-            this.defaultValue = defaultValue;
-        }
-    }
-    KokimokiSchema.Dict = Dict;
-    function dict(schema, defaultValue = {}) {
-        return new Dict(schema, defaultValue);
-    }
-    KokimokiSchema.dict = dict;
-    class List extends Generic {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue = []) {
-            super();
-            this.schema = schema;
-            this.defaultValue = defaultValue;
-        }
-    }
-    KokimokiSchema.List = List;
-    function list(schema, defaultValue = []) {
-        return new List(schema, defaultValue);
+            if (newMessages.length > 0) {
+                this._emitter.emit("messages", newMessages);
+            }
+        });
     }
-    KokimokiSchema.list = list;
-    /**
-     * Nullable
-     */
-    class Nullable extends Generic {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue) {
-            super();
-            this.schema = schema;
-            this.defaultValue = defaultValue;
-        }
+}
+
+class KokimokiAwareness extends KokimokiStore {
+    dataSchema;
+    _data;
+    _pingInterval = null;
+    _kmClients = new Set();
+    constructor(roomName, dataSchema, _data, mode = RoomSubscriptionMode.ReadWrite, pingTimeout = 3000) {
+        super(`/a/${roomName}`, KokimokiSchema.dict(KokimokiSchema.struct({
+            clientId: KokimokiSchema.string(),
+            lastPing: KokimokiSchema.number(),
+            data: dataSchema,
+        })), mode);
+        this.dataSchema = dataSchema;
+        this._data = _data;
+        this._pingInterval = setInterval(async () => {
+            const kmClients = Array.from(this._kmClients);
+            await Promise.all(kmClients.map(async (client) => {
+                try {
+                    await client.transact((t) => {
+                        const timestamp = client.serverTimestamp();
+                        // Update self
+                        if (this.proxy[client.connectionId]) {
+                            t.set(this.root[client.connectionId].lastPing, timestamp);
+                        }
+                        else {
+                            t.set(this.root[client.connectionId], {
+                                clientId: client.id,
+                                lastPing: timestamp,
+                                data: this._data,
+                            });
+                        }
+                        // Delete clients that haven't pinged in a while
+                        for (const connectionId in this.proxy) {
+                            const { lastPing } = this.proxy[connectionId];
+                            if (timestamp - lastPing > pingTimeout * 2) {
+                                t.delete(this.root[connectionId]);
+                            }
+                        }
+                    });
+                }
+                catch (e) { }
+            }));
+        }, pingTimeout);
     }
-    KokimokiSchema.Nullable = Nullable;
-    function nullable(schema, defaultValue = null) {
-        return new Nullable(schema, defaultValue);
+    async onJoin(client) {
+        this._kmClients.add(client);
+        await client.transact((t) => {
+            t.set(this.root[client.connectionId], {
+                clientId: client.id,
+                lastPing: client.serverTimestamp(),
+                data: this._data,
+            });
+        });
     }
-    KokimokiSchema.nullable = nullable;
-    class StringEnum extends Generic {
-        options;
-        defaultValue;
-        constructor(options, defaultValue) {
-            super();
-            this.options = options;
-            this.defaultValue = defaultValue;
-        }
+    async onBeforeLeave(client) {
+        await client.transact((t) => {
+            t.delete(this.root[client.connectionId]);
+        });
     }
-    KokimokiSchema.StringEnum = StringEnum;
-    function stringEnum(options, defaultValue) {
-        return new StringEnum(options, defaultValue);
+    async onLeave(client) {
+        this._kmClients.delete(client);
     }
-    KokimokiSchema.stringEnum = stringEnum;
-    class StringConst extends Generic {
-        defaultValue;
-        constructor(defaultValue) {
-            super();
-            this.defaultValue = defaultValue;
+    getClients() {
+        const clients = {};
+        for (const connectionId in this.proxy) {
+            clients[this.proxy[connectionId].clientId] =
+                this.proxy[connectionId].data;
         }
+        return clients;
     }
-    KokimokiSchema.StringConst = StringConst;
-    function stringConst(defaultValue) {
-        return new StringConst(defaultValue);
+    async setData(data) {
+        this._data = data;
+        const kmClients = Array.from(this._kmClients);
+        await Promise.all(kmClients.map(async (client) => {
+            await client.transact((t) => {
+                t.set(this.root[client.connectionId].data, this._data);
+            });
+        }));
     }
-    KokimokiSchema.stringConst = stringConst;
-    class AnyOf extends Generic {
-        schemas;
-        defaultValue;
-        constructor(schemas, defaultValue) {
-            super();
-            this.schemas = schemas;
-            this.defaultValue = defaultValue;
-        }
+}
+
+class KokimokiReqRes {
+    kmClient;
+    serviceName;
+    reqSchema;
+    resSchema;
+    handleRequest;
+    _reqQueueSchema;
+    _resQueueSchema;
+    // Request queues are linked to client ids
+    _reqQueues = {};
+    // Response queues are linked to specific connection ids
+    _resQueues = {};
+    _reqPromises = {};
+    async _getReqQueue(clientId, mode = RoomSubscriptionMode.Write) {
+        if (!this._reqQueues.hasOwnProperty(clientId)) {
+            this._reqQueues[clientId] = this.kmClient.queue(`/r/${clientId}/req/${this.serviceName}`, this._reqQueueSchema, mode, false);
+            await this.kmClient.join(this._reqQueues[clientId]);
+        }
+        return this._reqQueues[clientId];
+    }
+    async _getResQueue(connectionId, mode = RoomSubscriptionMode.Write) {
+        if (!this._resQueues.hasOwnProperty(connectionId)) {
+            this._resQueues[connectionId] = this.kmClient.queue(`/r/${connectionId}/res/${this.serviceName}`, this._resQueueSchema, mode, false);
+            await this.kmClient.join(this._resQueues[connectionId]);
+        }
+        return this._resQueues[connectionId];
+    }
+    constructor(kmClient, serviceName, reqSchema, resSchema, handleRequest) {
+        this.kmClient = kmClient;
+        this.serviceName = serviceName;
+        this.reqSchema = reqSchema;
+        this.resSchema = resSchema;
+        this.handleRequest = handleRequest;
+        this._reqQueueSchema = KokimokiSchema.struct({
+            connectionId: KokimokiSchema.string(),
+            //   roomHash: S.number(),
+            payload: reqSchema,
+        });
+        this._resQueueSchema = KokimokiSchema.struct({
+            reqId: KokimokiSchema.string(),
+            error: KokimokiSchema.optional(KokimokiSchema.string()),
+            payload: resSchema,
+        });
+        // Set up queues on connect
+        kmClient.on("connected", async () => {
+            // Handle responses to self
+            const resQueue = await this._getResQueue(kmClient.connectionId, RoomSubscriptionMode.ReadWrite);
+            let handlingResponses = false;
+            let rehandleResponses = false;
+            resQueue.subscribe(async (messages) => {
+                // console.log("RES", Object.keys(messages));
+                if (handlingResponses) {
+                    rehandleResponses = true;
+                    return;
+                }
+                handlingResponses = true;
+                await this.handleResponses(resQueue, messages);
+                if (rehandleResponses) {
+                    rehandleResponses = false;
+                    await this.handleResponses(resQueue, messages);
+                }
+                handlingResponses = false;
+            });
+            // Handle requests to self
+            const reqQueue = await this._getReqQueue(kmClient.id, RoomSubscriptionMode.ReadWrite);
+            let handlingRequests = false;
+            let rehandleRequests = false;
+            reqQueue.subscribe(async (messages) => {
+                // console.log("REQ", Object.keys(messages));
+                if (handlingRequests) {
+                    rehandleRequests = true;
+                    return;
+                }
+                handlingRequests = true;
+                await this.handleRequests(reqQueue, messages);
+                if (rehandleRequests) {
+                    rehandleRequests = false;
+                    await this.handleRequests(reqQueue, messages);
+                }
+                handlingRequests = false;
+            });
+        });
     }
-    KokimokiSchema.AnyOf = AnyOf;
-    function anyOf(schemas, defaultValue) {
-        return new AnyOf(schemas, defaultValue);
+    async handleRequests(reqQueue, messages) {
+        // Send responses
+        await this.kmClient.transact(async (t) => {
+            for (const reqId in messages) {
+                const { connectionId, payload } = messages[reqId];
+                const resQueue = await this._getResQueue(connectionId);
+                t.consumeMessage(reqQueue, reqId);
+                try {
+                    t.queueMessage(resQueue, {
+                        reqId,
+                        error: undefined,
+                        payload: await this.handleRequest(payload),
+                    });
+                }
+                catch (e) {
+                    t.queueMessage(resQueue, {
+                        reqId,
+                        error: e.toString(),
+                        payload: null,
+                    });
+                }
+            }
+        });
     }
-    KokimokiSchema.anyOf = anyOf;
-    class Optional extends Generic {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue = undefined) {
-            super();
-            this.schema = schema;
-            this.defaultValue = defaultValue;
-        }
+    async handleResponses(resQueue, messages) {
+        // Handle responses
+        await this.kmClient.transact(async (t) => {
+            for (const resId in messages) {
+                const { reqId, error, payload } = messages[resId];
+                const promise = this._reqPromises[reqId];
+                t.consumeMessage(resQueue, resId);
+                if (promise) {
+                    if (error) {
+                        promise.reject(error);
+                    }
+                    else {
+                        promise.resolve(payload);
+                    }
+                    delete this._reqPromises[reqId];
+                }
+            }
+        });
     }
-    KokimokiSchema.Optional = Optional;
-    function optional(schema, defaultValue = undefined) {
-        return new Optional(schema, defaultValue);
+    async send(toClientId, payload, timeout) {
+        const toReqQueue = await this._getReqQueue(toClientId);
+        // Create a promise for the response
+        return await new Promise(async (resolve, reject) => {
+            await this.kmClient.transact((t) => {
+                const reqId = t.queueMessage(toReqQueue, {
+                    connectionId: this.kmClient.connectionId,
+                    payload,
+                    // roomHash,
+                });
+                this._reqPromises[reqId] = { resolve, reject };
+            });
+        });
     }
-    KokimokiSchema.optional = optional;
-})(KokimokiSchema || (KokimokiSchema = {}));
-
-function parsePath(text) {
-  return text.split('.')
-}
-
-function push(arr, el) {
-  const newArr = arr.slice();
-  newArr.push(el);
-  return newArr;
 }
 
-// names of the traps that can be registered with ES6's Proxy object
-const trapNames = [
-  'apply',
-  'construct',
-  'defineProperty',
-  'deleteProperty',
-  'enumerate', // deprecated
-  'get',
-  'getOwnPropertyDescriptor',
-  'getPrototypeOf',
-  'has',
-  'isExtensible',
-  'ownKeys',
-  'preventExtensions',
-  'set',
-  'setPrototypeOf',
-];
-
-// a list of paramer indexes that indicate that the a recieves a key at that parameter
-// this information will be used to update the path accordingly
-const keys = {
-  get: 1,
-  set: 1,
-  deleteProperty: 1,
-  has: 1,
-  defineProperty: 1,
-  getOwnPropertyDescriptor: 1,
-};
-
-function DeepProxy(rootTarget, traps, options) {
-
-  let path = [];
-  let userData = {};
-
-  if (options !== undefined && typeof options.path !== 'undefined') {
-    path = parsePath(options.path);
-  }
-  if (options !== undefined && typeof options.userData !== 'undefined') {
-    userData = options.userData;
-  }
-
-  function createProxy(target, path) {
-
-    // avoid creating a new object between two traps
-    const context = { rootTarget, path };
-    Object.assign(context, userData);
-
-    const realTraps = {};
-
-    for (const trapName of trapNames) {
-      const keyParamIdx = keys[trapName]
-          , trap = traps[trapName];
-
-      if (typeof trap !== 'undefined') {
-
-        if (typeof keyParamIdx !== 'undefined') {
-
-          realTraps[trapName] = function () {
-
-            const key = arguments[keyParamIdx];
-
-            // update context for this trap
-            context.nest = function (nestedTarget) {
-              if (nestedTarget === undefined)
-                nestedTarget = rootTarget;
-              return createProxy(nestedTarget, push(path, key)); 
+class KokimokiClient extends EventEmitter$1 {
+    host;
+    appId;
+    code;
+    _wsUrl;
+    _apiUrl;
+    _id;
+    _connectionId;
+    _token;
+    _apiHeaders;
+    _serverTimeOffset = 0;
+    _clientContext;
+    _ws;
+    _subscriptionsByName = new Map();
+    _subscriptionsByHash = new Map();
+    _subscribeReqPromises = new Map();
+    _unsubscribeReqPromises = new Map();
+    _transactionPromises = new Map();
+    _connected = false;
+    _connectPromise;
+    _messageId = 0;
+    _autoReconnect = true;
+    _reconnectTimeout = 0;
+    _pingInterval;
+    constructor(host, appId, code = "") {
+        super();
+        this.host = host;
+        this.appId = appId;
+        this.code = code;
+        // Set up the URLs
+        const secure = this.host.indexOf(":") === -1;
+        this._wsUrl = `ws${secure ? "s" : ""}://${this.host}`;
+        this._apiUrl = `http${secure ? "s" : ""}://${this.host}`;
+        // Set up ping interval
+        const pingMsg = new WsMessageWriter();
+        pingMsg.writeInt32(WsMessageType.Ping);
+        const pingBuffer = pingMsg.getBuffer();
+        this._pingInterval = setInterval(() => {
+            if (this.connected) {
+                this.ws.send(pingBuffer);
+            }
+        }, 5000);
+    }
+    get id() {
+        if (!this._id) {
+            throw new Error("Client not connected");
+        }
+        return this._id;
+    }
+    get connectionId() {
+        if (!this._connectionId) {
+            throw new Error("Client not connected");
+        }
+        return this._connectionId;
+    }
+    get token() {
+        if (!this._token) {
+            throw new Error("Client not connected");
+        }
+        return this._token;
+    }
+    get apiUrl() {
+        if (!this._apiUrl) {
+            throw new Error("Client not connected");
+        }
+        return this._apiUrl;
+    }
+    get apiHeaders() {
+        if (!this._apiHeaders) {
+            throw new Error("Client not connected");
+        }
+        return this._apiHeaders;
+    }
+    get clientContext() {
+        if (this._clientContext === undefined) {
+            throw new Error("Client not connected");
+        }
+        return this._clientContext;
+    }
+    get connected() {
+        return this._connected;
+    }
+    get ws() {
+        if (!this._ws) {
+            throw new Error("Not connected");
+        }
+        return this._ws;
+    }
+    async connect() {
+        if (this._connectPromise) {
+            return await this._connectPromise;
+        }
+        this._ws = new WebSocket(`${this._wsUrl}/apps/${this.appId}?clientVersion=${KOKIMOKI_APP_VERSION}`);
+        this._ws.binaryType = "arraybuffer";
+        // Close previous connection in hot-reload scenarios
+        if (window) {
+            if (!window.__KOKIMOKI_WS__) {
+                window.__KOKIMOKI_WS__ = {};
+            }
+            if (this.appId in window.__KOKIMOKI_WS__) {
+                console.log(`[Kokimoki] Closing previous connection for ${this.appId}`);
+                window.__KOKIMOKI_WS__[this.appId].close();
+            }
+            window.__KOKIMOKI_WS__[this.appId] = this;
+        }
+        // Wait for connection
+        this._connectPromise = new Promise((onInit) => {
+            // Fetch the auth token
+            let clientToken = localStorage.getItem("KM_TOKEN");
+            // Send the app token on first connect
+            this.ws.onopen = () => {
+                this.ws.send(JSON.stringify({ type: "auth", code: this.code, token: clientToken }));
             };
-
-            return trap.apply(context, arguments);
-          };
-        } else {
-
-          realTraps[trapName] = function () {
-
-            // update context for this trap
-            context.nest = function (nestedTarget) {
-              if (nestedTarget === undefined)
-                nestedTarget = {};
-              return createProxy(nestedTarget, path);
+            this.ws.onclose = () => {
+                this._connected = false;
+                this._connectPromise = undefined;
+                this._ws.onmessage = null;
+                this._ws = undefined;
+                if (window && window.__KOKIMOKI_WS__) {
+                    delete window.__KOKIMOKI_WS__[this.appId];
+                }
+                // Clean up
+                this._subscribeReqPromises.clear();
+                this._transactionPromises.clear();
+                // Attempt to reconnect
+                if (!this._autoReconnect) {
+                    return;
+                }
+                console.log(`[Kokimoki] Connection lost, attempting to reconnect in ${this._reconnectTimeout} seconds...`);
+                setTimeout(async () => await this.connect(), this._reconnectTimeout * 1000);
+                this._reconnectTimeout = Math.min(3, this._reconnectTimeout + 1);
+                // Emit disconnected event
+                this.emit("disconnected");
             };
-
-            return trap.apply(context, arguments);
-          };
+            this.ws.onmessage = (e) => {
+                // console.log(`Received WS message: ${e.data}`);
+                // Handle JSON messages
+                if (typeof e.data === "string") {
+                    const message = JSON.parse(e.data);
+                    switch (message.type) {
+                        case "init":
+                            this.handleInitMessage(message);
+                            onInit();
+                            break;
+                    }
+                    return;
+                }
+                // Handle binary messages
+                this.handleBinaryMessage(e.data);
+            };
+        });
+        await this._connectPromise;
+        this._connected = true;
+        // Connection established
+        console.log(`[Kokimoki] Client id: ${this.id}`);
+        console.log(`[Kokimoki] Client context:`, this.clientContext);
+        // Restore subscriptions if reconnected
+        const roomNames = Array.from(this._subscriptionsByName.keys()).map((name) => `"${name}"`);
+        if (roomNames.length) {
+            console.log(`[Kokimoki] Restoring subscriptions: ${roomNames}`);
         }
-      }
+        for (const subscription of this._subscriptionsByName.values()) {
+            try {
+                await this.join(subscription.store);
+            }
+            catch (err) {
+                console.error(`[Kokimoki] Failed to restore subscription for "${subscription.roomName}":`, err);
+            }
+        }
+        // Emit connected event
+        this._reconnectTimeout = 0;
+        this.emit("connected");
     }
-
-    return new Proxy(target, realTraps);
-  }
-
-  return createProxy(rootTarget, path);
-
-}
-
-class KokimokiStore {
-    roomName;
-    mode;
-    doc;
-    proxy;
-    root;
-    defaultValue;
-    docRoot;
-    constructor(roomName, schema, mode = RoomSubscriptionMode.ReadWrite) {
-        this.roomName = roomName;
-        this.mode = mode;
-        // Construct Y doc
-        this.doc = new Doc();
-        this.docRoot = this.doc.getMap("root");
-        // Construct proxy object
-        this.proxy = proxy();
-        // @ts-ignore
-        f(this.proxy, this.docRoot);
-        // Create root proxy
-        const store = this;
-        // @ts-ignore
-        this.root = new DeepProxy(this.proxy, {
-            get() {
-                return this.nest(function () { });
-            },
-            apply() {
-                let obj = store.proxy;
-                for (let i = 0; i < this.path.length - 1; i++) {
-                    obj = obj[this.path[i]];
-                }
-                return {
-                    roomName: store.roomName,
-                    doc: store.doc,
-                    path: this.path,
-                    obj,
-                    key: this.path[this.path.length - 1],
-                };
-            },
+    handleInitMessage(message) {
+        localStorage.setItem("KM_TOKEN", message.clientToken);
+        this._id = message.clientId;
+        this._connectionId = message.id;
+        this._token = message.appToken;
+        this._clientContext = message.clientContext;
+        // Set up the auth headers
+        this._apiHeaders = new Headers({
+            Authorization: `Bearer ${this.token}`,
+            "Content-Type": "application/json",
+        });
+    }
+    handleBinaryMessage(data) {
+        const reader = new WsMessageReader(data);
+        const type = reader.readInt32();
+        switch (type) {
+            case WsMessageType.SubscribeRes:
+                this.handleSubscribeResMessage(reader);
+                break;
+            case WsMessageType.UnsubscribeRes:
+                this.handleUnsubscribeResMessage(reader);
+                break;
+            case WsMessageType.RoomUpdate:
+                this.handleRoomUpdateMessage(reader);
+                break;
+            case WsMessageType.Error:
+                this.handleErrorMessage(reader);
+                break;
+            case WsMessageType.Pong: {
+                const s = reader.readInt32();
+                const ms = reader.readInt32();
+                this._serverTimeOffset = Date.now() - s * 1000 - ms;
+                break;
+            }
+        }
+    }
+    handleErrorMessage(msg) {
+        const reqId = msg.readInt32();
+        const error = msg.readString();
+        const subscribeReqPromise = this._subscribeReqPromises.get(reqId);
+        const transactionPromise = this._transactionPromises.get(reqId);
+        if (subscribeReqPromise) {
+            this._subscribeReqPromises.delete(reqId);
+            subscribeReqPromise.reject(error);
+        }
+        else if (transactionPromise) {
+            this._transactionPromises.delete(reqId);
+            transactionPromise.reject(error);
+        }
+        else {
+            console.warn(`Received error for unknown request ${reqId}: ${error}`);
+        }
+    }
+    handleSubscribeResMessage(msg) {
+        const reqId = msg.readInt32();
+        const roomHash = msg.readUint32();
+        const promise = this._subscribeReqPromises.get(reqId);
+        if (promise) {
+            this._subscribeReqPromises.delete(reqId);
+            // In Write mode, no initial state is sent
+            if (!msg.end) {
+                promise.resolve(roomHash, msg.readUint8Array());
+            }
+            else {
+                promise.resolve(roomHash);
+            }
+        }
+    }
+    handleUnsubscribeResMessage(msg) {
+        const reqId = msg.readInt32();
+        const promise = this._unsubscribeReqPromises.get(reqId);
+        if (promise) {
+            this._unsubscribeReqPromises.delete(reqId);
+            promise.resolve();
+        }
+    }
+    handleRoomUpdateMessage(msg) {
+        const appliedId = msg.readInt32();
+        const roomHash = msg.readUint32();
+        // Apply update if not in Write mode
+        if (!msg.end) {
+            const subscription = this._subscriptionsByHash.get(roomHash);
+            if (subscription) {
+                applyUpdate(subscription.store.doc, msg.readUint8Array(), this);
+            }
+            else {
+                console.warn(`Received update for unknown room ${roomHash}`);
+            }
+        }
+        // Check transaction resolves
+        for (const [transactionId, { resolve },] of this._transactionPromises.entries()) {
+            if (appliedId >= transactionId) {
+                this._transactionPromises.delete(transactionId);
+                resolve();
+            }
+        }
+    }
+    serverTimestamp() {
+        return Date.now() - this._serverTimeOffset;
+    }
+    // Send Y update to room
+    async patchRoomState(room, update) {
+        const res = await fetch(`${this._apiUrl}/rooms/${room}`, {
+            method: "PATCH",
+            headers: this.apiHeaders,
+            body: update,
+        });
+        return await res.json();
+    }
+    // Storage
+    async createUpload(name, blob, tags) {
+        const res = await fetch(`${this._apiUrl}/uploads`, {
+            method: "POST",
+            headers: this.apiHeaders,
+            body: JSON.stringify({
+                name,
+                size: blob.size,
+                mimeType: blob.type,
+                tags,
+            }),
+        });
+        return await res.json();
+    }
+    async uploadChunks(blob, chunkSize, signedUrls) {
+        return await Promise.all(signedUrls.map(async (url, index) => {
+            const start = index * chunkSize;
+            const end = Math.min(start + chunkSize, blob.size);
+            const chunk = blob.slice(start, end);
+            const res = await fetch(url, { method: "PUT", body: chunk });
+            return JSON.parse(res.headers.get("ETag") || '""');
+        }));
+    }
+    async completeUpload(id, etags) {
+        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
+            method: "PUT",
+            headers: this.apiHeaders,
+            body: JSON.stringify({ etags }),
+        });
+        return await res.json();
+    }
+    async upload(name, blob, tags = []) {
+        const { id, chunkSize, urls } = await this.createUpload(name, blob, tags);
+        const etags = await this.uploadChunks(blob, chunkSize, urls);
+        return await this.completeUpload(id, etags);
+    }
+    async updateUpload(id, update) {
+        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
+            method: "PUT",
+            headers: this.apiHeaders,
+            body: JSON.stringify(update),
         });
-        // Set default value
-        this.defaultValue = schema.defaultValue;
+        return await res.json();
     }
-    get() {
-        return this.proxy;
+    async listUploads(filter = {}, skip = 0, limit = 100) {
+        const url = new URL("/uploads", this._apiUrl);
+        url.searchParams.set("skip", skip.toString());
+        url.searchParams.set("limit", limit.toString());
+        if (filter.clientId) {
+            url.searchParams.set("clientId", filter.clientId);
+        }
+        if (filter.mimeTypes) {
+            url.searchParams.set("mimeTypes", filter.mimeTypes.join());
+        }
+        if (filter.tags) {
+            url.searchParams.set("tags", filter.tags.join());
+        }
+        const res = await fetch(url.href, {
+            headers: this.apiHeaders,
+        });
+        return await res.json();
     }
-    subscribe(set) {
+    async deleteUpload(id) {
+        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
+            method: "DELETE",
+            headers: this.apiHeaders,
+        });
+        return await res.json();
+    }
+    async exposeScriptingContext(context) {
         // @ts-ignore
-        const handler = () => set(this.proxy);
-        this.doc.on("update", handler);
+        window.KM_SCRIPTING_CONTEXT = context;
         // @ts-ignore
-        set(this.proxy);
-        return () => this.doc.off("update", handler);
+        window.dispatchEvent(new CustomEvent("km:scriptingContextExposed"));
     }
-    async onJoin(client) { }
-    async onBeforeLeave(client) { }
-    async onLeave(client) { }
-}
-
-class KokimokiQueue extends KokimokiStore {
-    payloadSchema;
-    _emitter = new EventEmitter$1();
-    on = this._emitter.on.bind(this._emitter);
-    off = this._emitter.off.bind(this._emitter);
-    constructor(roomName, payloadSchema, mode) {
-        super(`/q/${roomName}`, KokimokiSchema.dict(KokimokiSchema.struct({
-            timestamp: KokimokiSchema.number(),
-            payload: payloadSchema,
-        })), mode);
-        this.payloadSchema = payloadSchema;
-        const emittedMessageIds = new Set();
-        this.doc.on("update", () => {
-            const newMessages = [];
-            for (const id in this.proxy) {
-                if (emittedMessageIds.has(id)) {
-                    continue;
-                }
-                emittedMessageIds.add(id);
-                newMessages.push({ id, payload: this.proxy[id].payload });
-            }
-            if (newMessages.length > 0) {
-                this._emitter.emit("messages", newMessages);
-            }
+    async sendSubscribeReq(roomName, mode) {
+        // Set up sync resolver
+        const reqId = ++this._messageId;
+        return await new Promise((resolve, reject) => {
+            this._subscribeReqPromises.set(reqId, {
+                resolve: (roomHash, initialUpdate) => {
+                    resolve({ roomHash, initialUpdate });
+                },
+                reject,
+            });
+            // Send subscription request
+            const msg = new WsMessageWriter();
+            msg.writeInt32(WsMessageType.SubscribeReq);
+            msg.writeInt32(reqId);
+            msg.writeString(roomName);
+            msg.writeChar(mode);
+            this.ws.send(msg.getBuffer());
         });
     }
-}
-
-class KokimokiAwareness extends KokimokiStore {
-    dataSchema;
-    _data;
-    _pingInterval = null;
-    _kmClients = new Set();
-    constructor(roomName, dataSchema, _data, mode = RoomSubscriptionMode.ReadWrite, pingTimeout = 3000) {
-        super(`/a/${roomName}`, KokimokiSchema.dict(KokimokiSchema.struct({
-            clientId: KokimokiSchema.string(),
-            lastPing: KokimokiSchema.number(),
-            data: dataSchema,
-        })), mode);
-        this.dataSchema = dataSchema;
-        this._data = _data;
-        this._pingInterval = setInterval(async () => {
-            const kmClients = Array.from(this._kmClients);
-            await Promise.all(kmClients.map(async (client) => {
-                try {
-                    await client.transact((t) => {
-                        const timestamp = client.serverTimestamp();
-                        // Update self
-                        if (this.proxy[client.connectionId]) {
-                            t.set(this.root[client.connectionId].lastPing, timestamp);
-                        }
-                        else {
-                            t.set(this.root[client.connectionId], {
-                                clientId: client.id,
-                                lastPing: timestamp,
-                                data: this._data,
-                            });
-                        }
-                        // Delete clients that haven't pinged in a while
-                        for (const connectionId in this.proxy) {
-                            const { lastPing } = this.proxy[connectionId];
-                            if (timestamp - lastPing > pingTimeout * 2) {
-                                t.delete(this.root[connectionId]);
-                            }
-                        }
-                    });
-                }
-                catch (e) { }
-            }));
-        }, pingTimeout);
-    }
-    async onJoin(client) {
-        this._kmClients.add(client);
-        await client.transact((t) => {
-            t.set(this.root[client.connectionId], {
-                clientId: client.id,
-                lastPing: client.serverTimestamp(),
-                data: this._data,
+    async sendUnsubscribeReq(roomHash) {
+        const reqId = ++this._messageId;
+        return await new Promise((resolve, reject) => {
+            this._unsubscribeReqPromises.set(reqId, {
+                resolve,
+                reject,
             });
+            // Send unsubscribe request
+            const msg = new WsMessageWriter();
+            msg.writeInt32(WsMessageType.UnsubscribeReq);
+            msg.writeInt32(reqId);
+            msg.writeUint32(roomHash);
+            this.ws.send(msg.getBuffer());
         });
     }
-    async onBeforeLeave(client) {
-        await client.transact((t) => {
-            t.delete(this.root[client.connectionId]);
-        });
+    async join(store) {
+        let subscription = this._subscriptionsByName.get(store.roomName);
+        if (!subscription) {
+            subscription = new RoomSubscription(this, store);
+            this._subscriptionsByName.set(store.roomName, subscription);
+        }
+        // Send subscription request if connected to server
+        if (!subscription.joined) {
+            const res = await this.sendSubscribeReq(store.roomName, store.mode);
+            this._subscriptionsByHash.set(res.roomHash, subscription);
+            await subscription.applyInitialResponse(res.roomHash, res.initialUpdate);
+            // Trigger onJoin event
+            store.onJoin(this);
+        }
     }
-    async onLeave(client) {
-        this._kmClients.delete(client);
+    async leave(store) {
+        const subscription = this._subscriptionsByName.get(store.roomName);
+        if (subscription) {
+            await store.onBeforeLeave(this);
+            await this.sendUnsubscribeReq(subscription.roomHash);
+            this._subscriptionsByName.delete(store.roomName);
+            this._subscriptionsByHash.delete(subscription.roomHash);
+            subscription.close();
+            // Trigger onLeave event
+            store.onLeave(this);
+        }
     }
-    getClients() {
-        const clients = {};
-        for (const connectionId in this.proxy) {
-            clients[this.proxy[connectionId].clientId] =
-                this.proxy[connectionId].data;
+    async transact(handler) {
+        if (!this._connected) {
+            throw new Error("Client not connected");
         }
-        return clients;
+        const transaction = new KokimokiTransaction(this);
+        await handler(transaction);
+        const { updates, consumedMessages } = await transaction.getUpdates();
+        if (!updates.length) {
+            return;
+        }
+        // Construct buffer
+        const writer = new WsMessageWriter();
+        // Write message type
+        writer.writeInt32(WsMessageType.Transaction);
+        // Update and write transaction ID
+        const transactionId = ++this._messageId;
+        writer.writeInt32(transactionId);
+        // Write room hashes where messages were consumed
+        writer.writeInt32(consumedMessages.size);
+        for (const roomName of consumedMessages) {
+            const subscription = this._subscriptionsByName.get(roomName);
+            if (!subscription) {
+                throw new Error(`Cannot consume message in "${roomName}" because it hasn't been joined`);
+            }
+            writer.writeUint32(subscription.roomHash);
+        }
+        // Write updates
+        for (const { roomName, update } of updates) {
+            const subscription = this._subscriptionsByName.get(roomName);
+            if (!subscription) {
+                throw new Error(`Cannot send update to "${roomName}" because it hasn't been joined`);
+            }
+            writer.writeUint32(subscription.roomHash);
+            writer.writeUint8Array(update);
+        }
+        const buffer = writer.getBuffer();
+        // Wait for server to apply transaction
+        await new Promise((resolve, reject) => {
+            this._transactionPromises.set(transactionId, { resolve, reject });
+            // Send update to server
+            try {
+                this.ws.send(buffer);
+            }
+            catch (e) {
+                // Not connected
+                console.log("Failed to send update to server:", e);
+                // TODO: merge updates or something
+                throw e;
+            }
+        });
     }
-    async setData(data) {
-        this._data = data;
-        const kmClients = Array.from(this._kmClients);
-        await Promise.all(kmClients.map(async (client) => {
-            await client.transact((t) => {
-                t.set(this.root[client.connectionId].data, this._data);
-            });
-        }));
+    async close() {
+        this._autoReconnect = false;
+        if (this._ws) {
+            this._ws.close();
+        }
+        if (this._pingInterval) {
+            clearInterval(this._pingInterval);
+        }
+    }
+    // Get room hash value for store
+    getRoomHash(store) {
+        const subscription = this._subscriptionsByName.get(store.roomName);
+        if (!subscription) {
+            throw new Error(`Store "${store.roomName}" not joined`);
+        }
+        return subscription.roomHash;
+    }
+    /** Initializers */
+    // store
+    store(name, schema, autoJoin = true) {
+        const store = new KokimokiStore(name, schema);
+        if (autoJoin) {
+            this.join(store)
+                .then(() => { })
+                .catch(() => { });
+        }
+        return store;
+    }
+    // queue
+    queue(name, schema, mode, autoJoin = true) {
+        const queue = new KokimokiQueue(name, schema, mode);
+        if (autoJoin) {
+            this.join(queue)
+                .then(() => { })
+                .catch(() => { });
+        }
+        return queue;
+    }
+    // awareness
+    awareness(name, dataSchema, initialData = dataSchema.defaultValue, autoJoin = true) {
+        const awareness = new KokimokiAwareness(name, dataSchema, initialData);
+        if (autoJoin) {
+            this.join(awareness)
+                .then(() => { })
+                .catch(() => { });
+        }
+        return awareness;
+    }
+    // req-res
+    reqRes(serviceName, reqSchema, resSchema, handleRequest) {
+        return new KokimokiReqRes(this, serviceName, reqSchema, resSchema, handleRequest);
     }
 }