@meshagent/meshagent 0.37.2 → 0.38.1

package/dist/node/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/node/room-event.js

@@ -1,9 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoomLogEvent = exports.FileMovedEvent = exports.FileUpdatedEvent = exports.FileDeletedEvent = exports.FileCreatedEvent = exports.RoomMessageEvent = exports.RoomMessage = exports.RoomEvent = void 0;
+exports.RoomLogEvent = exports.FileMovedEvent = exports.FileUpdatedEvent = exports.FileDeletedEvent = exports.FileCreatedEvent = exports.RoomMessageEvent = exports.RoomMessage = exports.RoomStatusEvent = exports.RoomEvent = void 0;
 class RoomEvent {
 }
 exports.RoomEvent = RoomEvent;
+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"]),
+        });
+    }
+}
+exports.RoomStatusEvent = RoomStatusEvent;
 class RoomMessage {
     constructor({ fromParticipantId, type, message, local = false, attachment }) {
         this.fromParticipantId = fromParticipantId;

package/dist/node/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/node/room-server-client.js

@@ -34,6 +34,12 @@ class MeshDocument extends document_1.RuntimeDocument {
         };
         (0, runtime_1.registerDocument)(this.id, null, false, this.onSendUpdateToBackend, this.onSendUpdateToClient);
     }
+    getState(vector) {
+        return (0, runtime_1.getState)(this.id, vector ?? null);
+    }
+    getStateVector() {
+        return (0, runtime_1.getStateVector)(this.id);
+    }
     get synchronized() {
         return this._synchronized.fut;
     }

package/dist/node/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/node/runtime.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unregisterDocument = exports.registerDocument = exports.applyChanges = exports.applyBackendChanges = void 0;
+exports.unregisterDocument = exports.registerDocument = exports.getStateVector = exports.getState = exports.applyChanges = exports.applyBackendChanges = void 0;
 var entrypoint_js_1 = require("./entrypoint.js");
 Object.defineProperty(exports, "applyBackendChanges", { enumerable: true, get: function () { return entrypoint_js_1.applyBackendChanges; } });
 Object.defineProperty(exports, "applyChanges", { enumerable: true, get: function () { return entrypoint_js_1.applyChanges; } });
+Object.defineProperty(exports, "getState", { enumerable: true, get: function () { return entrypoint_js_1.getState; } });
+Object.defineProperty(exports, "getStateVector", { enumerable: true, get: function () { return entrypoint_js_1.getStateVector; } });
 Object.defineProperty(exports, "registerDocument", { enumerable: true, get: function () { return entrypoint_js_1.registerDocument; } });
 Object.defineProperty(exports, "unregisterDocument", { enumerable: true, get: function () { return entrypoint_js_1.unregisterDocument; } });

package/dist/node/secrets-client.js

@@ -76,7 +76,9 @@ class SecretsClient {
         };
     }
     async _handleClientOAuthTokenRequest(protocol, messageId, type, bytes) {
-        void protocol;
+        if (!this.client.isActiveProtocol(protocol)) {
+            return;
+        }
         void messageId;
         void type;
         if (bytes == null) {
@@ -112,7 +114,9 @@ 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/node/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/node/storage-client.js

@@ -89,18 +89,27 @@ class StorageClient extends event_emitter_1.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, _] = (0, utils_1.unpackMessage)(bytes || new Uint8Array());
         const event = new room_event_1.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, _] = (0, utils_1.unpackMessage)(bytes || new Uint8Array());
         const event = new room_event_1.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, _] = (0, utils_1.unpackMessage)(bytes || new Uint8Array());
         const event = new room_event_1.FileMovedEvent({
             sourcePath: data["source_path"],

package/dist/node/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/node/sync-client.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyncClient = void 0;
+const completer_1 = require("./completer");
 const event_emitter_1 = require("./event-emitter");
 const schema_1 = require("./schema");
-const room_server_client_1 = require("./room-server-client");
 const response_1 = require("./response");
-const utils_1 = require("./utils");
+const room_server_client_1 = require("./room-server-client");
 const runtime_1 = require("./runtime");
-const completer_1 = require("./completer");
+const utils_1 = require("./utils");
 function normalizeSyncPath(path) {
     let normalized = path;
     while (normalized.startsWith("./")) {
@@ -25,7 +25,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 room_server_client_1.RoomServerException("unexpected return type from sync.open");
     }
     return {
@@ -36,8 +37,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 room_server_client_1.RoomServerException("unexpected return type from sync.open");
     }
     return {
@@ -54,7 +54,7 @@ class SyncOpenStreamState {
     }
     _enqueueChunk(chunk) {
         const waiter = this._inputWaiters.shift();
-        if (waiter) {
+        if (waiter != null) {
             waiter(chunk);
             return;
         }
@@ -132,53 +132,51 @@ class SyncClient extends event_emitter_1.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 room_server_client_1.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)) {
+            (0, runtime_1.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 room_server_client_1.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)) {
-            (0, runtime_1.unregisterDocument)(rc.ref.id);
-        }
-        this._connectedDocuments = {};
-        this._connectingDocuments = {};
-    }
     _applySyncPayload(rc, payload) {
-        const doc = rc.ref;
         if (payload.length > 0) {
-            const base64 = utils_1.decoder.decode(payload);
-            (0, runtime_1.applyBackendChanges)(doc.id, base64);
+            (0, runtime_1.applyBackendChanges)(rc.ref.id, utils_1.decoder.decode(payload));
         }
-        this.emit("synced", { type: "sync", doc });
-        if (!doc.isSynchronized) {
-            doc.setSynchronizedComplete();
-        }
-    }
-    async _handleStatus(_protocol, _messageId, _type, bytes) {
-        if (!bytes) {
-            return;
+        if (!rc.ref.isSynchronized) {
+            rc.ref.setSynchronizedComplete();
         }
-        const [header] = (0, utils_1.unpackMessage)(bytes);
-        this.emit("status", { type: "status", status: header.status });
     }
     async create(path, json) {
         const normalizedPath = normalizeSyncPath(path);
@@ -190,129 +188,126 @@ class SyncClient extends event_emitter_1.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_1.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 room_server_client_1.RoomServerException("sync.open stream closed before the initial document state was returned");
-            }
-            const firstChunk = first.value;
-            if (firstChunk instanceof response_1.ErrorContent) {
-                throw new room_server_client_1.RoomServerException(firstChunk.text, firstChunk.code);
-            }
-            if (!(firstChunk instanceof response_1.BinaryContent)) {
-                throw this._unexpectedResponseError("open");
-            }
-            const stateHeaders = parseSyncOpenStateChunkHeaders(firstChunk.headers);
-            if (normalizeSyncPath(stateHeaders.path) !== path) {
-                throw new room_server_client_1.RoomServerException("sync.open stream returned a mismatched path");
-            }
+            const resolvedSchema = schema_1.MeshSchema.fromJson(openResult.stateHeaders.schema);
             const doc = new room_server_client_1.MeshDocument({
-                schema: schema_1.MeshSchema.fromJson(stateHeaders.schema),
+                schema: resolvedSchema,
                 sendChangesToBackend: (base64) => {
+                    const currentStream = this._documentStreams[normalizedPath];
+                    if (currentStream == null) {
+                        return;
+                    }
                     try {
-                        streamState?.queueSync(utils_1.encoder.encode(base64));
+                        currentStream.queueSync(utils_1.encoder.encode(base64));
                     }
                     catch {
                     }
                 },
             });
             const rc = new utils_1.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 room_server_client_1.RoomServerException(`Not connected to ${path}`);
+        const normalizedPath = normalizeSyncPath(path);
+        const rc = this._connectedDocuments[normalizedPath];
+        if (rc == null) {
+            throw new room_server_client_1.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 {
+                        (0, runtime_1.unregisterDocument)(rc.ref.id);
+                    }
                 }
-                finally {
-                    (0, runtime_1.unregisterDocument)(doc.id);
+                else {
+                    (0, runtime_1.unregisterDocument)(rc.ref.id);
                 }
+            })();
+            this._closingDocuments[normalizedPath] = closeFuture;
+            try {
+                await closeFuture;
             }
-            else {
-                (0, runtime_1.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 room_server_client_1.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 room_server_client_1.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;
                 }
@@ -330,15 +325,99 @@ class SyncClient extends event_emitter_1.EventEmitter {
                     throw this._unexpectedResponseError("open");
                 }
                 const headers = parseSyncOpenOutputChunkHeaders(chunk.headers);
-                if (normalizeSyncPath(headers.path) !== params.path) {
+                if (normalizeSyncPath(headers.path) !== path) {
                     throw new room_server_client_1.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 room_server_client_1.RoomServerException("sync.open stream closed before the initial document state was returned");
+            }
+            const firstChunk = first.value;
+            if (firstChunk instanceof response_1.ErrorContent) {
+                throw new room_server_client_1.RoomServerException(firstChunk.text, firstChunk.code);
+            }
+            if (!(firstChunk instanceof response_1.BinaryContent)) {
+                throw this._unexpectedResponseError("open");
+            }
+            const stateHeaders = parseSyncOpenStateChunkHeaders(firstChunk.headers);
+            if (normalizeSyncPath(stateHeaders.path) !== path) {
+                throw new room_server_client_1.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,
+            });
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent",
-    "version": "0.37.2",
+    "version": "0.38.1",
     "description": "Meshagent Client",
     "homepage": "https://github.com/meshagent/meshagent-ts",
     "scripts": {
@@ -11,10 +11,13 @@
     "author": "Meshagent Software",
     "license": "Apache-2.0",
     "main": "./dist/node/index.js",
+    "types": "./dist/node/index.d.ts",
     "exports": {
         ".": {
-            "module": "./dist/esm/index.js",
+            "types": "./dist/node/index.d.ts",
+            "import": "./dist/esm/index.js",
             "browser": "./dist/browser/index.js",
+            "require": "./dist/node/index.js",
             "default": "./dist/node/index.js"
         },
         "./package.json": "./package.json"
@@ -53,4 +56,4 @@
     "overrides": {
         "rollup": "4.52.5"
     }
-}
+}