@meshagent/meshagent 0.37.1 → 0.38.0

package/dist/esm/room-event.d.ts

@@ -2,6 +2,17 @@ export declare abstract class RoomEvent {
     abstract get name(): string;
     abstract get description(): string;
 }
+export declare class RoomStatusEvent extends RoomEvent {
+    readonly status: string;
+    readonly message: string;
+    constructor({ status, message }: {
+        status: string;
+        message: string;
+    });
+    get name(): string;
+    get description(): string;
+    static fromJson(json: Record<string, unknown>): RoomStatusEvent;
+}
 export declare class RoomMessage {
     fromParticipantId: string;
     type: string;

package/dist/esm/room-event.js

@@ -1,5 +1,24 @@
 export class RoomEvent {
 }
+export class RoomStatusEvent extends RoomEvent {
+    constructor({ status, message }) {
+        super();
+        this.status = status;
+        this.message = message;
+    }
+    get name() {
+        return this.status;
+    }
+    get description() {
+        return this.message;
+    }
+    static fromJson(json) {
+        return new RoomStatusEvent({
+            status: String(json["status"]),
+            message: String(json["message"]),
+        });
+    }
+}
 export class RoomMessage {
     constructor({ fromParticipantId, type, message, local = false, attachment }) {
         this.fromParticipantId = fromParticipantId;

package/dist/esm/room-server-client.d.ts

@@ -13,6 +13,8 @@ export declare class MeshDocument extends RuntimeDocument {
     });
     onSendUpdateToBackend: (base64: string) => void;
     onSendUpdateToClient: (base64: string) => void;
+    getState(vector?: string): string;
+    getStateVector(): string;
     get synchronized(): Promise<boolean>;
     get isSynchronized(): boolean;
     setSynchronizedComplete(): void;

package/dist/esm/room-server-client.js

@@ -1,7 +1,7 @@
 import { v4 as uuidv4 } from "uuid";
 import { RuntimeDocument } from "./document";
 import { Completer } from "./completer";
-import { registerDocument, unregisterDocument, applyChanges, } from "./runtime";
+import { registerDocument, unregisterDocument, applyChanges, getState, getStateVector, } from "./runtime";
 export class RoomServerException extends Error {
     constructor(message, code) {
         super(message);
@@ -30,6 +30,12 @@ export class MeshDocument extends RuntimeDocument {
         };
         registerDocument(this.id, null, false, this.onSendUpdateToBackend, this.onSendUpdateToClient);
     }
+    getState(vector) {
+        return getState(this.id, vector ?? null);
+    }
+    getStateVector() {
+        return getStateVector(this.id);
+    }
     get synchronized() {
         return this._synchronized.fut;
     }

package/dist/esm/runtime.d.ts

@@ -1,4 +1,4 @@
-export { applyBackendChanges, applyChanges, registerDocument, unregisterDocument, } from './entrypoint.js';
+export { applyBackendChanges, applyChanges, getState, getStateVector, registerDocument, unregisterDocument, } from './entrypoint.js';
 export type SendUpdateFn = (msg: string) => void;
 export interface UpdatePayload {
     documentID: string;

package/dist/esm/runtime.js

@@ -1 +1 @@
-export { applyBackendChanges, applyChanges, registerDocument, unregisterDocument, } from './entrypoint.js';
+export { applyBackendChanges, applyChanges, getState, getStateVector, registerDocument, unregisterDocument, } from './entrypoint.js';

package/dist/esm/secrets-client.js

@@ -73,7 +73,9 @@ export class SecretsClient {
         };
     }
     async _handleClientOAuthTokenRequest(protocol, messageId, type, bytes) {
-        void protocol;
+        if (!this.client.isActiveProtocol(protocol)) {
+            return;
+        }
         void messageId;
         void type;
         if (bytes == null) {
@@ -109,7 +111,9 @@ export class SecretsClient {
         });
     }
     async _handleClientSecretRequest(protocol, messageId, type, bytes) {
-        void protocol;
+        if (!this.client.isActiveProtocol(protocol)) {
+            return;
+        }
         void messageId;
         void type;
         if (bytes == null) {

package/dist/esm/storage-client.d.ts

@@ -4,6 +4,7 @@ import { RoomEvent } from "./room-event";
 import { BinaryContent, FileContent } from "./response";
 import { EventEmitter } from "./event-emitter";
 type StorageClientRoom = Pick<RoomClient, "invoke" | "invokeStream" | "emit"> & {
+    isActiveProtocol(protocol: Protocol): boolean;
     protocol: Pick<Protocol, "addHandler">;
 };
 export declare class FileHandle {

package/dist/esm/storage-client.js

@@ -84,18 +84,27 @@ export class StorageClient extends EventEmitter {
         this.client.protocol.addHandler("storage.file.updated", this._handleFileUpdated.bind(this));
     }
     async _handleFileUpdated(protocol, messageId, type, bytes) {
+        if (!this.client.isActiveProtocol(protocol)) {
+            return;
+        }
         const [data, _] = unpackMessage(bytes || new Uint8Array());
         const event = new FileUpdatedEvent({ path: data["path"], participantId: data["participant_id"] });
         this.client.emit(event);
         this.emit('file.updated', event);
     }
     async _handleFileDeleted(protocol, messageId, type, bytes) {
+        if (!this.client.isActiveProtocol(protocol)) {
+            return;
+        }
         const [data, _] = unpackMessage(bytes || new Uint8Array());
         const event = new FileDeletedEvent({ path: data["path"], participantId: data["participant_id"] });
         this.client.emit(event);
         this.emit('file.deleted', event);
     }
     async _handleFileMoved(protocol, messageId, type, bytes) {
+        if (!this.client.isActiveProtocol(protocol)) {
+            return;
+        }
         const [data, _] = unpackMessage(bytes || new Uint8Array());
         const event = new FileMovedEvent({
             sourcePath: data["source_path"],

package/dist/esm/sync-client.d.ts

@@ -1,36 +1,38 @@
 import { EventEmitter } from "./event-emitter";
-import { RoomClient } from "./room-client";
 import { MeshSchema } from "./schema";
+import { RoomClient } from "./room-client";
 import { MeshDocument } from "./room-server-client";
 export interface SyncClientEvent {
     type: string;
     doc?: MeshDocument;
-    status?: unknown;
 }
 export declare class SyncClient extends EventEmitter<SyncClientEvent> {
-    private readonly client;
-    private _connectingDocuments;
-    private _connectedDocuments;
-    private _documentStreams;
+    private readonly room;
+    private readonly _connectingDocuments;
+    private readonly _closingDocuments;
+    private readonly _connectedDocuments;
+    private readonly _documentStreams;
+    private readonly _documentConfigs;
+    private _started;
     constructor({ room }: {
         room: RoomClient;
     });
+    start(): void;
+    dispose(): void;
     private _unexpectedResponseError;
     private _invoke;
-    start({ onDone, onError }?: {
-        onDone?: () => void;
-        onError?: (error: Error) => void;
-    }): void;
-    dispose(): void;
     private _applySyncPayload;
-    private _handleStatus;
-    create(path: string, json?: Record<string, any>): Promise<void>;
+    create(path: string, json?: Record<string, unknown>): Promise<void>;
     open(path: string, { create, initialJson, schema, }?: {
         create?: boolean;
-        initialJson?: Record<string, any>;
+        initialJson?: Record<string, unknown>;
         schema?: MeshSchema;
     }): Promise<MeshDocument>;
     close(path: string): Promise<void>;
     sync(path: string, data: Uint8Array): Promise<void>;
     private _consumeOpenStream;
+    private _openStream;
+    private _attachStreamConsumer;
+    _onRoomDisconnect(): Promise<void>;
+    _onRoomReconnect(): Promise<void>;
 }

package/dist/esm/sync-client.js

@@ -1,10 +1,10 @@
+import { Completer } from "./completer";
 import { EventEmitter } from "./event-emitter";
 import { MeshSchema } from "./schema";
-import { MeshDocument, RoomServerException } from "./room-server-client";
 import { BinaryContent, ControlContent, ErrorContent } from "./response";
-import { decoder, encoder, RefCount, unpackMessage } from "./utils";
-import { unregisterDocument, applyBackendChanges } from "./runtime";
-import { Completer } from "./completer";
+import { MeshDocument, RoomServerException } from "./room-server-client";
+import { applyBackendChanges, unregisterDocument } from "./runtime";
+import { decoder, encoder, RefCount } from "./utils";
 function normalizeSyncPath(path) {
     let normalized = path;
     while (normalized.startsWith("./")) {
@@ -22,7 +22,8 @@ function parseSyncOpenStateChunkHeaders(headers) {
     if (headers["kind"] !== "state" ||
         typeof headers["path"] !== "string" ||
         typeof headers["schema"] !== "object" ||
-        headers["schema"] == null) {
+        headers["schema"] == null ||
+        Array.isArray(headers["schema"])) {
         throw new RoomServerException("unexpected return type from sync.open");
     }
     return {
@@ -33,8 +34,7 @@ function parseSyncOpenStateChunkHeaders(headers) {
 }
 function parseSyncOpenOutputChunkHeaders(headers) {
     const kind = headers["kind"];
-    if ((kind !== "state" && kind !== "sync") ||
-        typeof headers["path"] !== "string") {
+    if ((kind !== "state" && kind !== "sync") || typeof headers["path"] !== "string") {
         throw new RoomServerException("unexpected return type from sync.open");
     }
     return {
@@ -51,7 +51,7 @@ class SyncOpenStreamState {
     }
     _enqueueChunk(chunk) {
         const waiter = this._inputWaiters.shift();
-        if (waiter) {
+        if (waiter != null) {
             waiter(chunk);
             return;
         }
@@ -129,54 +129,52 @@ export class SyncClient extends EventEmitter {
     constructor({ room }) {
         super();
         this._connectingDocuments = {};
+        this._closingDocuments = {};
         this._connectedDocuments = {};
         this._documentStreams = {};
-        this.client = room;
-        this.client.protocol.addHandler("room.status", this._handleStatus.bind(this));
+        this._documentConfigs = {};
+        this._started = false;
+        this.room = room;
+    }
+    start() {
+        if (this._started) {
+            throw new RoomServerException("client already started");
+        }
+        this._started = true;
+    }
+    dispose() {
+        super.dispose();
+        for (const streamState of Object.values(this._documentStreams)) {
+            streamState.closeInputStream();
+        }
+        for (const doc of Object.values(this._connectedDocuments)) {
+            unregisterDocument(doc.ref.id);
+        }
+        Object.keys(this._documentStreams).forEach((key) => delete this._documentStreams[key]);
+        Object.keys(this._documentConfigs).forEach((key) => delete this._documentConfigs[key]);
+        Object.keys(this._connectedDocuments).forEach((key) => delete this._connectedDocuments[key]);
+        Object.keys(this._connectingDocuments).forEach((key) => delete this._connectingDocuments[key]);
+        Object.keys(this._closingDocuments).forEach((key) => delete this._closingDocuments[key]);
+        this._started = false;
     }
     _unexpectedResponseError(operation) {
         return new RoomServerException(`unexpected return type from sync.${operation}`);
     }
     async _invoke(operation, input) {
-        return await this.client.invoke({
+        return await this.room.invoke({
             toolkit: "sync",
             tool: operation,
             input,
         });
     }
-    start({ onDone, onError } = {}) {
-        this.client.protocol.start({ onDone, onError });
-    }
-    dispose() {
-        super.dispose();
-        for (const streamState of Object.values(this._documentStreams)) {
-            streamState.closeInputStream();
-        }
-        this._documentStreams = {};
-        for (const rc of Object.values(this._connectedDocuments)) {
-            unregisterDocument(rc.ref.id);
-        }
-        this._connectedDocuments = {};
-        this._connectingDocuments = {};
-    }
     _applySyncPayload(rc, payload) {
-        const doc = rc.ref;
         if (payload.length > 0) {
-            const base64 = decoder.decode(payload);
-            applyBackendChanges(doc.id, base64);
+            applyBackendChanges(rc.ref.id, decoder.decode(payload));
         }
-        this.emit("synced", { type: "sync", doc });
-        if (!doc.isSynchronized) {
-            doc.setSynchronizedComplete();
+        if (!rc.ref.isSynchronized) {
+            rc.ref.setSynchronizedComplete();
         }
     }
-    async _handleStatus(_protocol, _messageId, _type, bytes) {
-        if (!bytes) {
-            return;
-        }
-        const [header] = unpackMessage(bytes);
-        this.emit("status", { type: "status", status: header.status });
-    }
     async create(path, json) {
         const normalizedPath = normalizeSyncPath(path);
         await this._invoke("create", {
@@ -187,129 +185,126 @@ export class SyncClient extends EventEmitter {
         });
     }
     async open(path, { create = true, initialJson, schema, } = {}) {
-        path = normalizeSyncPath(path);
-        const pending = this._connectingDocuments[path];
-        if (pending) {
+        const normalizedPath = normalizeSyncPath(path);
+        const closing = this._closingDocuments[normalizedPath];
+        if (closing != null) {
+            await closing;
+        }
+        const pending = this._connectingDocuments[normalizedPath];
+        if (pending != null) {
             await pending;
         }
-        const connected = this._connectedDocuments[path];
-        if (connected) {
-            connected.count++;
+        const connected = this._connectedDocuments[normalizedPath];
+        if (connected != null) {
+            connected.count += 1;
             return connected.ref;
         }
         const connecting = new Completer();
-        this._connectingDocuments[path] = connecting.fut;
-        let streamState;
-        let iterator;
+        this._connectingDocuments[normalizedPath] = connecting.fut;
         try {
-            streamState = new SyncOpenStreamState({
-                path,
+            const config = {
                 create,
-                vector: null,
-                schemaJson: schema == null ? null : schema.toJson(),
+                schemaJson: schema?.toJson() ?? null,
                 schemaPath: null,
+            };
+            const openResult = await this._openStream({
+                path: normalizedPath,
+                config,
+                vector: null,
                 initialJson: initialJson ?? null,
             });
-            const responseStream = await this.client.invokeStream({
-                toolkit: "sync",
-                tool: "open",
-                input: streamState.inputStream(),
-            });
-            iterator = responseStream[Symbol.asyncIterator]();
-            const first = await iterator.next();
-            if (first.done || first.value === undefined) {
-                throw new RoomServerException("sync.open stream closed before the initial document state was returned");
-            }
-            const firstChunk = first.value;
-            if (firstChunk instanceof ErrorContent) {
-                throw new RoomServerException(firstChunk.text, firstChunk.code);
-            }
-            if (!(firstChunk instanceof BinaryContent)) {
-                throw this._unexpectedResponseError("open");
-            }
-            const stateHeaders = parseSyncOpenStateChunkHeaders(firstChunk.headers);
-            if (normalizeSyncPath(stateHeaders.path) !== path) {
-                throw new RoomServerException("sync.open stream returned a mismatched path");
-            }
+            const resolvedSchema = MeshSchema.fromJson(openResult.stateHeaders.schema);
             const doc = new MeshDocument({
-                schema: MeshSchema.fromJson(stateHeaders.schema),
+                schema: resolvedSchema,
                 sendChangesToBackend: (base64) => {
+                    const currentStream = this._documentStreams[normalizedPath];
+                    if (currentStream == null) {
+                        return;
+                    }
                     try {
-                        streamState?.queueSync(encoder.encode(base64));
+                        currentStream.queueSync(encoder.encode(base64));
                     }
                     catch {
                     }
                 },
             });
             const rc = new RefCount(doc);
-            this._connectedDocuments[path] = rc;
-            this._documentStreams[path] = streamState;
-            this._applySyncPayload(rc, firstChunk.data);
-            streamState.attachTask(this._consumeOpenStream({
-                path,
-                rc,
-                iterator,
-                streamState,
-            }));
+            this._connectedDocuments[normalizedPath] = rc;
+            this._documentConfigs[normalizedPath] = config;
+            this._documentStreams[normalizedPath] = openResult.streamState;
+            this._applySyncPayload(rc, openResult.firstChunk.data);
+            this._attachStreamConsumer({
+                path: normalizedPath,
+                doc: rc,
+                streamState: openResult.streamState,
+                iterator: openResult.iterator,
+            });
             this.emit("connected", { type: "connect", doc });
             connecting.complete(rc);
             await doc.synchronized;
             return doc;
         }
         catch (error) {
-            streamState?.closeInputStream();
-            if (iterator) {
-                await iterator.return?.();
-            }
             connecting.completeError(error);
             throw error;
         }
         finally {
-            delete this._connectingDocuments[path];
+            delete this._connectingDocuments[normalizedPath];
         }
     }
     async close(path) {
-        path = normalizeSyncPath(path);
-        const rc = this._connectedDocuments[path];
-        if (!rc) {
-            throw new RoomServerException(`Not connected to ${path}`);
+        const normalizedPath = normalizeSyncPath(path);
+        const rc = this._connectedDocuments[normalizedPath];
+        if (rc == null) {
+            throw new RoomServerException(`Not connected to ${normalizedPath}`);
         }
-        const doc = rc.ref;
-        rc.count--;
+        rc.count -= 1;
         if (rc.count === 0) {
-            delete this._connectedDocuments[path];
-            const streamState = this._documentStreams[path];
-            delete this._documentStreams[path];
-            if (streamState) {
-                streamState.closeInputStream();
-                try {
-                    await streamState.wait();
+            delete this._connectedDocuments[normalizedPath];
+            delete this._documentConfigs[normalizedPath];
+            const streamState = this._documentStreams[normalizedPath];
+            delete this._documentStreams[normalizedPath];
+            const closeFuture = (async () => {
+                if (streamState != null) {
+                    streamState.closeInputStream();
+                    try {
+                        await streamState.wait();
+                    }
+                    finally {
+                        unregisterDocument(rc.ref.id);
+                    }
                 }
-                finally {
-                    unregisterDocument(doc.id);
+                else {
+                    unregisterDocument(rc.ref.id);
                 }
+            })();
+            this._closingDocuments[normalizedPath] = closeFuture;
+            try {
+                await closeFuture;
             }
-            else {
-                unregisterDocument(doc.id);
+            finally {
+                if (this._closingDocuments[normalizedPath] === closeFuture) {
+                    delete this._closingDocuments[normalizedPath];
+                }
             }
         }
-        this.emit("closed", { type: "close", doc });
+        this.emit("closed", { type: "close", doc: rc.ref });
     }
     async sync(path, data) {
-        path = normalizeSyncPath(path);
-        if (!this._connectedDocuments[path]) {
+        const normalizedPath = normalizeSyncPath(path);
+        if (this._connectedDocuments[normalizedPath] == null) {
             throw new RoomServerException("attempted to sync to a document that is not connected");
         }
-        const streamState = this._documentStreams[path];
-        if (!streamState) {
+        const streamState = this._documentStreams[normalizedPath];
+        if (streamState == null) {
             throw new RoomServerException("attempted to sync to a document that is not connected");
         }
         streamState.queueSync(data);
     }
-    async _consumeOpenStream(params) {
+    async _consumeOpenStream({ path, rc, iterator, streamState, }) {
         try {
             while (true) {
-                const next = await params.iterator.next();
+                const next = await iterator.next();
                 if (next.done || next.value === undefined) {
                     return;
                 }
@@ -327,15 +322,99 @@ export class SyncClient extends EventEmitter {
                     throw this._unexpectedResponseError("open");
                 }
                 const headers = parseSyncOpenOutputChunkHeaders(chunk.headers);
-                if (normalizeSyncPath(headers.path) !== params.path) {
+                if (normalizeSyncPath(headers.path) !== path) {
                     throw new RoomServerException("sync.open stream returned a mismatched path");
                 }
-                this._applySyncPayload(params.rc, chunk.data);
+                this._applySyncPayload(rc, chunk.data);
             }
         }
         finally {
-            params.streamState.closeInputStream();
-            await params.iterator.return?.();
+            streamState.closeInputStream();
+            await iterator.return?.();
+        }
+    }
+    async _openStream({ path, config, vector, initialJson, }) {
+        const streamState = new SyncOpenStreamState({
+            path,
+            create: config.create,
+            vector,
+            schemaJson: config.schemaJson,
+            schemaPath: config.schemaPath,
+            initialJson,
+        });
+        let iterator;
+        try {
+            const responseStream = await this.room.invokeStream({
+                toolkit: "sync",
+                tool: "open",
+                input: streamState.inputStream(),
+            });
+            iterator = responseStream[Symbol.asyncIterator]();
+            const first = await iterator.next();
+            if (first.done || first.value === undefined) {
+                throw new RoomServerException("sync.open stream closed before the initial document state was returned");
+            }
+            const firstChunk = first.value;
+            if (firstChunk instanceof ErrorContent) {
+                throw new RoomServerException(firstChunk.text, firstChunk.code);
+            }
+            if (!(firstChunk instanceof BinaryContent)) {
+                throw this._unexpectedResponseError("open");
+            }
+            const stateHeaders = parseSyncOpenStateChunkHeaders(firstChunk.headers);
+            if (normalizeSyncPath(stateHeaders.path) !== path) {
+                throw new RoomServerException("sync.open stream returned a mismatched path");
+            }
+            return {
+                streamState,
+                iterator,
+                stateHeaders,
+                firstChunk,
+            };
+        }
+        catch (error) {
+            streamState.closeInputStream();
+            if (iterator != null) {
+                await iterator.return?.();
+            }
+            throw error;
+        }
+    }
+    _attachStreamConsumer({ path, doc, streamState, iterator, }) {
+        streamState.attachTask(this._consumeOpenStream({
+            path,
+            rc: doc,
+            iterator,
+            streamState,
+        }));
+    }
+    async _onRoomDisconnect() {
+        const openStreams = Object.values(this._documentStreams);
+        Object.keys(this._documentStreams).forEach((key) => delete this._documentStreams[key]);
+        for (const streamState of openStreams) {
+            streamState.closeInputStream();
+        }
+    }
+    async _onRoomReconnect() {
+        for (const [path, ref] of Object.entries(this._connectedDocuments)) {
+            const config = this._documentConfigs[path];
+            if (config == null) {
+                continue;
+            }
+            const openResult = await this._openStream({
+                path,
+                config,
+                vector: ref.ref.getStateVector(),
+                initialJson: null,
+            });
+            this._documentStreams[path] = openResult.streamState;
+            this._applySyncPayload(ref, openResult.firstChunk.data);
+            this._attachStreamConsumer({
+                path,
+                doc: ref,
+                streamState: openResult.streamState,
+                iterator: openResult.iterator,
+            });
         }
     }
 }