@pluv/client 0.15.0 → 0.16.1

package/.turbo/turbo-build.log

@@ -1,18 +1,18 @@
 
-> @pluv/client@0.15.0 build /home/runner/work/pluv/pluv/packages/client
+> @pluv/client@0.16.1 build /home/runner/work/pluv/pluv/packages/client
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
-CLI tsup v8.0.1
+CLI tsup v8.0.2
 CLI Target: es6
 ESM Build start
 CJS Build start
-CJS dist/index.js 44.17 KB
-CJS ⚡️ Build success in 80ms
-ESM dist/index.mjs 42.92 KB
-ESM ⚡️ Build success in 82ms
+ESM dist/index.mjs 41.52 KB
+ESM ⚡️ Build success in 144ms
+CJS dist/index.js 42.79 KB
+CJS ⚡️ Build success in 156ms
 DTS Build start
-DTS ⚡️ Build success in 2982ms
-DTS dist/index.d.mts 14.31 KB
-DTS dist/index.d.ts  14.31 KB
+DTS ⚡️ Build success in 3486ms
+DTS dist/index.d.mts 13.94 KB
+DTS dist/index.d.ts  13.94 KB

package/CHANGELOG.md

@@ -1,5 +1,163 @@
 # @pluv/client
 
+## 0.16.1
+
+### Patch Changes
+
+- @pluv/crdt@0.16.1
+- @pluv/types@0.16.1
+
+## 0.16.0
+
+### Minor Changes
+
+- 4280220: ## Breaking Changes
+
+  - Storage types are now kept on the root of the document.
+    - Previously, `@pluv/crdt-yjs` kept all shared-types on a hidden Yjs Map called `storage` on the root of the Yjs Doc. Now all shared-types are kept on the root of the Yjs Doc instead. This behavior should be more in-line with how shared-types are documented to be used from Yjs.
+  - `@pluv/client` and `@pluv/react` no-longer re-export `@pluv/crdt-yjs`. This package will now need to be installed separately.
+
+    ```bash
+    # if installing @pluv/client
+    npm install @pluv/client @pluv/crdt-yjs
+    # if installing @pluv/react
+    npm install @pluv/react @pluv/crdt-yjs
+    ```
+
+    ```ts
+    // Before:
+    import { createClient, y } from "@pluv/client";
+    // After:
+    import { createClient } from "@pluv/client";
+    import { yjs } from "@pluv/crdt-yjs"; // y renamed to yjs
+    ```
+
+  - The `y` import has been renamed to `yjs`.
+    ```ts
+    // Before:
+    import { y } from "@pluv/crdt-yjs";
+    // After:
+    import { yjs } from "@pluv/crdt-yjs";
+    ```
+  - `@pluv/crdt-yjs` functions no-longer return Yjs shared-types directly, but instead return an `AbstractCrdtType` from `@pluv/crdt` (new package). This also affects methods that return storage shared types in both `@pluv/client` and `@pluv/react` from functions like `PluvRoom.getStorage` and `PluvRoom.useStorage`.
+
+    ```ts
+    // Before:
+    import { y } from "@pluv/crdt-yjs";
+    import type { Array as YArray, Map as YMap } from "yjs";
+
+    const array: YArray<YMap<{ message: string }>> = y.array([
+      y.object({ message: "Hello" }),
+    ]);
+
+    array.push([y.object({ message: "World!" })]);
+
+    // After:
+    import type { CrdtYjsArray, CrdtYjsObject } from "@pluv/crdt-yjs";
+    import { yjs } from "@pluv/crdt-yjs";
+    import type { Array as YArray } from "yjs";
+
+    const array: CrdtYjsArray<CrdtYjsObject<{ message: string }>> = yjs.array([
+      yjs.object({ message: "Hello" }),
+    ]);
+
+    array.push(yjs.object({ message: "World!" }));
+
+    // use .value to get the underlying yjs type
+    const yarray: YArray<YMap<{ message: string }>> = array.value;
+    ```
+
+  - `initialStorage` must now use the `doc` function from `@pluv/crdt-yjs` to be defined. This also affects `@pluv/react`.
+
+    ```ts
+    // Before:
+    import { createClient, y } from "@pluv/client";
+
+    const client = createClient({
+      /* ... */
+    });
+
+    client.createRoom({
+      // ...
+      initialStorage: () => ({
+        messages: y.array([y.object({ message: "Hello world!" })]),
+      }),
+    });
+
+    // After:
+    import { createClient } from "@pluv/client";
+    // This is now imported separately
+    import { yjs } from "@pluv/crdt-yjs";
+
+    const client = createClient({
+      /* ... */
+    });
+
+    client.createRoom({
+      // ...
+      initialStorage: yjs.doc(() => ({
+        messages: yjs.array([yjs.object({ message: "Hello world!" })]),
+      })),
+    });
+    ```
+
+  - `@pluv/client` can now instead use [loro](https://github.com/loro-dev/loro) instead of [yjs](https://github.com/yjs/yjs).
+    ```bash
+    npm install @pluv/client @pluv/crdt-loro loro-crdt
+    ```
+  - If you are using storage features with pluv, `@pluv/io` must now specify which crdt library (i.e. `@pluv/crdt-yjs` or `@pluv/crdt-loro`) it is meant to use.
+
+    ```ts
+    import { loro } from "@pluv/crdt-loro";
+    import { yjs } from "@pluv/crdt-yjs";
+    import { createIO } from "@pluv/io";
+
+    const io = createIO({
+      // ...
+      // If using loro
+      crdt: loro,
+      // If using yjs
+      crdt: yjs,
+    });
+    ```
+
+  - `PluvRoom.getDoc()` from `@pluv/client` no-longer returns the Yjs Doc instance, but rather a `AbstractCrdtDoc` instance from `@pluv/crdt`. This also affects the hook from `@pluv/react`.
+
+    ```ts
+    // Before:
+    import { Doc as YDoc } from "yjs";
+
+    const room: PluvRoom = client.createRoom({
+      /* ... */
+    });
+
+    const doc: YDoc = room.getDoc();
+
+    // After:
+    import { CrdtYjsDoc } from "@pluv/crdt-yjs";
+    import { Doc as YDoc } from "yjs";
+
+    const room: PluvRoom = client.createRoom({
+      /* ... */
+    });
+
+    const doc: CrdtYjsDoc<any> = room.getDoc();
+    const ydoc: YDoc = doc.value;
+    ```
+
+  - `@pluv/client` and `@pluv/react` now may return `null` when retrieving storage while storage is being initialized.
+
+    ```ts
+    const sharedType = room.getStorage("messages"); // This may be null
+
+    const [data, sharedType] = useStorage("messages"); // data and sharedType may both be null
+    ```
+
+### Patch Changes
+
+- @pluv/crdt@0.16.0
+- @pluv/types@0.16.0
+
 ## 0.15.0
 
 ### Patch Changes
@@ -218,7 +376,7 @@
 
   ## @pluv/react
 
-  `@pluv/react`'s `createRoomBundle` now exposes 5 new react hooks: `usePluvCanRedo`, `usePluvCanUndo`, `usePluvRedo`, `usePluvUndo` and `usePluvTransact`.
+  `@pluv/react`'s `createRoomBundle` now exposes 5 new react hooks: `useCanRedo`, `useCanUndo`, `useRedo`, `useUndo` and `useTransact`.
 
   Refer to the code-example below to better understand how to undo and redo with your `createRoomBundle`.
 
@@ -230,47 +388,41 @@
 
   const { createRoomBundle } = createBundle(client);
 
-  const {
-    usePluvCanRedo,
-    usePluvCanUndo,
-    usePluvRedo,
-    usePluvStorage,
-    usePluvTransact,
-    usePluvUndo,
-  } = createRoomBundle({
-    initialStorage: () => ({
-      messages: y.array<string>([]),
-    }),
-    /**
-     * @description This is the same `captureTimeout` option from yjs's UndoManager.
-     * This specifies a number in ms, during which edits are merged together to be
-     * undone together. Set this to 0, to track each transacted change individually.
-     * @see (@link https://docs.yjs.dev/api/undo-manager)
-     * @default 500
-     */
-    captureTimeout: 500,
-    /**
-     * @desription This is the same `trackedOrigins` option from yjs's UndoManager.
-     * This specifies transaction origins (strings only) to filter which transactions
-     * can be undone.
-     * When omitted, the user's connection id will be tracked. When provided,
-     * specifies additional tracked origins besides the user's connection id.
-     * @see (@link https://docs.yjs.dev/api/undo-manager)
-     * @default undefined
-     */
-    trackedOrigins: ["user-123"],
-  });
+  const { useCanRedo, useCanUndo, useRedo, useStorage, useTransact, useUndo } =
+    createRoomBundle({
+      initialStorage: () => ({
+        messages: y.array<string>([]),
+      }),
+      /**
+       * @description This is the same `captureTimeout` option from yjs's UndoManager.
+       * This specifies a number in ms, during which edits are merged together to be
+       * undone together. Set this to 0, to track each transacted change individually.
+       * @see (@link https://docs.yjs.dev/api/undo-manager)
+       * @default 500
+       */
+      captureTimeout: 500,
+      /**
+       * @desription This is the same `trackedOrigins` option from yjs's UndoManager.
+       * This specifies transaction origins (strings only) to filter which transactions
+       * can be undone.
+       * When omitted, the user's connection id will be tracked. When provided,
+       * specifies additional tracked origins besides the user's connection id.
+       * @see (@link https://docs.yjs.dev/api/undo-manager)
+       * @default undefined
+       */
+      trackedOrigins: ["user-123"],
+    });
 
   /**
    * @description Check whether calling undo will mutate storage
    */
-  const canUndo: boolean = usePluvCanUndo();
+  const canUndo: boolean = useCanUndo();
   /**
    * @description Check whether calling redo will mutate storage
    */
-  const canRedo: boolean = usePluvCanRedo();
+  const canRedo: boolean = useCanRedo();
 
-  const [messages, sharedType] = usePluvStorage("messages");
+  const [messages, sharedType] = useStorage("messages");
 
   /**
    * @description Calling transact will enable a storage mutation to be undone/redone.
@@ -279,7 +431,7 @@
    *
    * You can specify a 2nd parameter to transact with a different transaction origin.
    */
-  const transact = usePluvTransact();
+  const transact = useTransact();
 
   transact(() => {
     sharedType.push(["hello world!"]);
@@ -293,14 +445,14 @@
   /**
    * @description Undoes the last valid mutation to storage
    */
-  const undo = usePluvUndo();
+  const undo = useUndo();
 
   undo();
 
   /**
    * @description Re-applies the last undone mutation to storage
    */
-  const redo = usePluvRedo();
+  const redo = useRedo();
 
   redo();
   ```

package/README.md

@@ -5,12 +5,12 @@
   <br />
   <img src="https://github.com/pluv-io/pluv/blob/master/assets/pluv-icon-192x192.png?raw=true" alt="Pluv.IO" width="180" style="border-radius:16px" />
   <br />
-  Pluv.IO (preview)
+  <a href="https://pluv.io/docs/introduction">Pluv.IO (preview)</a>
   <br />
 </h1>
 
 <h3 align="center">Multi-platform, E2E type-safe realtime packages</h3>
-<h4 align="center">💕 Inspired by <a href="https://trpc.io">trpc</a> 💕 Built with <a href="https://docs.yjs.dev/">yjs</a> 💕</h4>
+<h4 align="center">💕 Inspired by <a href="https://trpc.io">trpc</a> 💕 <a href="https://docs.yjs.dev/">yjs</a> 💕 and <a href="https://developers.cloudflare.com/">Cloudflare</a> 💕 </h4>
 
 <p align="center">
   <a href="https://www.npmjs.com/package/@pluv/client">
@@ -19,14 +19,10 @@
   <a href="https://github.com/pluv-io/pluv/blob/master/LICENSE">
     <img alt="GitHub" src="https://img.shields.io/github/license/pluv-io/pluv" alt="License MIT" />
   </a>
-  <img src="https://badgen.net/badge/-/TypeScript?icon=typescript&label&labelColor=blue&color=555555" alt="TypeScript" />
   <a href="https://commitizen.github.io/cz-cli/">
     <img src="https://img.shields.io/badge/commitizen-friendly-brightgreen.svg" alt="Commitizen friendly" />
   </a>
-</p>
-
-<p align="center">
-  <img src="https://github.com/pluv-io/pluv/blob/master/assets/demo-events.gif?raw=true" alt="Demo" />
+  <img src="https://badgen.net/badge/-/TypeScript?icon=typescript&label&labelColor=blue&color=555555" alt="TypeScript" />
 </p>
 
 ## `@pluv/client`
@@ -39,13 +35,13 @@
 
 ```bash
 # npm
-npm install @pluv/client yjs
+npm install @pluv/client @pluv/crdt-yjs yjs
 
 # yarn
-yarn add @pluv/client yjs
+yarn add @pluv/client @pluv/crdt-yjs yjs
 
 # pnpm
-pnpm add @pluv/client yjs
+pnpm add @pluv/client @pluv/crdt-yjs yjs
 ```
 
 If you plan on using presence and/or storage, make sure to also install `zod`.
@@ -53,7 +49,8 @@ If you plan on using presence and/or storage, make sure to also install `zod`.
 ## Basic Example
 
 ```ts
-import { createClient, y } from "@pluv/client";
+import { createClient } from "@pluv/client";
+import { yjs } from "@pluv/crdt-yjs";
 import { z } from "zod";
 // Import the PluvIO instance as a type from your server file
 import { type io } from "./server";
@@ -79,7 +76,7 @@ interface Storage {
 // Create a room to join
 const room = client.createRoom<Presence, Storage>("my-room", {
     initialPresence: { cursor: null },
-    initialStorage: () => ({ messages: y.array([]) }),
+    initialStorage: yjs.doc(() => ({ messages: yjs.array([]) })),
     onAuthorizationFail: (error) => {
         console.log(error.message);
     },

package/dist/index.d.mts

@@ -1,10 +1,8 @@
-import { InferYjsSharedTypeJson, TrackOriginOptions, array, map, object, text, xmlElement, xmlFragment, xmlText } from '@pluv/crdt-yjs';
-export { InferYjsSharedTypeJson, TrackOriginOptions } from '@pluv/crdt-yjs';
+import { AbstractCrdtType, AbstractCrdtDoc, InferCrdtStorageJson, AbstractCrdtDocFactory } from '@pluv/crdt';
+export { AbstractCrdtType, InferCrdtStorageJson } from '@pluv/crdt';
 import * as _pluv_types from '@pluv/types';
 import { IOLike, InferIOOutput, Id, IOEventMessage, JsonObject, InferIOAuthorizeUser, InferIOAuthorize, InferIOInput, InputZodLike, InferIOAuthorizeRequired } from '@pluv/types';
 export { BaseUser, EventMessage, EventRecord, IOEventMessage } from '@pluv/types';
-import { AbstractType, Doc } from 'yjs';
-export { AbstractType } from 'yjs';
 import { Subject } from 'wonka';
 
 type EventNotifierSubscriptionCallback<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
@@ -43,29 +41,31 @@ interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject
     "my-presence": Subject<TPresence | null>;
     myself: Subject<Readonly<Id<UserInfo<TIO>>> | null>;
     others: Subject<readonly Id<UserInfo<TIO>>[]>;
+    "storage-loaded": Subject<boolean>;
 }
 type InferSubjectValue<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue> ? Id<IValue> : never;
 type SubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
 
-declare abstract class AbstractRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> {
+declare abstract class AbstractRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractCrdtType<any, any>> = {}> {
     readonly id: string;
     constructor(room: string);
+    abstract storageLoaded: boolean;
     abstract broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
     abstract canRedo(): boolean;
     abstract canUndo(): boolean;
-    abstract getDoc(): Doc;
+    abstract getDoc(): AbstractCrdtDoc<TStorage>;
     abstract event<TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>): () => void;
     abstract getConnection(): WebSocketConnection;
     abstract getMyPresence(): TPresence;
     abstract getMyself(): Id<UserInfo<TIO, TPresence>> | null;
     abstract getOther(connectionId: string): Id<UserInfo<TIO, TPresence>> | null;
     abstract getOthers(): readonly Id<UserInfo<TIO, TPresence>>[];
-    abstract getStorage<TKey extends keyof TStorage>(key: TKey): TStorage[TKey];
+    abstract getStorage<TKey extends keyof TStorage>(key: TKey): TStorage[TKey] | null;
     abstract other(connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>): () => void;
     abstract redo(): void;
-    abstract storage<TKey extends keyof TStorage>(key: TKey, fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void): () => void;
+    abstract storage<TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtStorageJson<TStorage[TKey]>) => void): () => void;
     abstract storageRoot(fn: (value: {
-        [P in keyof TStorage]: InferYjsSharedTypeJson<TStorage[P]>;
+        [P in keyof TStorage]: InferCrdtStorageJson<TStorage[P]>;
     }) => void): () => void;
     abstract subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>): () => void;
     abstract transact(fn: (storage: TStorage) => void, origin?: string): void;
@@ -84,16 +84,56 @@ declare abstract class AbstractStorageStore {
     abstract initialize(): Promise<void>;
 }
 
-type CrdtManagerOptions<TStorage extends Record<string, AbstractType<any>> = {}> = {
+type CrdtManagerOptions<TStorage extends Record<string, AbstractCrdtType<any, any>> = {}> = {
     encodedState?: string | Uint8Array | null;
-    initialStorage?: () => TStorage;
-} & TrackOriginOptions;
+    initialStorage?: AbstractCrdtDocFactory<TStorage>;
+};
 
 type UsersManagerConfig<TPresence extends JsonObject = {}> = {
     initialPresence?: TPresence;
     presence?: InputZodLike<TPresence>;
 };
 
+type MockedRoomEvents<TIO extends IOLike> = Partial<{
+    [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>>;
+}>;
+type MockedRoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractCrdtType<any, any>> = {}> = {
+    events?: MockedRoomEvents<TIO>;
+} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
+declare class MockedRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractCrdtType<any, any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
+    private _crdtManager;
+    private _crdtNotifier;
+    private _eventNotifier;
+    private _events?;
+    private _otherNotifier;
+    private _state;
+    private _stateNotifier;
+    private _subscriptions;
+    private _usersManager;
+    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage>);
+    get storageLoaded(): boolean;
+    broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
+    canRedo: () => boolean;
+    canUndo: () => boolean;
+    event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
+    getConnection(): WebSocketConnection;
+    getDoc(): AbstractCrdtDoc<TStorage>;
+    getMyPresence: () => TPresence;
+    getMyself: () => Id<UserInfo<TIO, TPresence>> | null;
+    getOther: (connectionId: string) => Id<UserInfo<TIO, TPresence>> | null;
+    getOthers: () => readonly Id<UserInfo<TIO, TPresence>>[];
+    getStorage: <TKey extends keyof TStorage>(key: TKey) => TStorage[TKey] | null;
+    other: (connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>) => (() => void);
+    redo: () => void;
+    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtStorageJson<TStorage[TKey]>) => void) => (() => void);
+    storageRoot: (fn: (value: { [P in keyof TStorage]: InferCrdtStorageJson<TStorage[P]>; }) => void) => (() => void);
+    subscribe: <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => (() => void);
+    transact: (fn: (storage: TStorage) => void, origin?: string) => void;
+    undo: () => void;
+    updateMyPresence: (presence: Partial<TPresence>) => void;
+    private _observeCrdt;
+}
+
 declare global {
     var process: {
         env: {
@@ -114,8 +154,8 @@ type RoomEndpoints<TIO extends IOLike> = {
 } : {
     authEndpoint?: undefined;
 });
-type PluvRoomAddon<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = (input: PluvRoomAddonInput<TIO, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
-interface PluvRoomAddonInput<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> {
+type PluvRoomAddon<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractCrdtType<any, any>> = {}> = (input: PluvRoomAddonInput<TIO, TPresence, TStorage>) => Partial<PluvRoomAddonResult>;
+interface PluvRoomAddonInput<TIO extends IOLike = IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractCrdtType<any, any>> = {}> {
     room: PluvRoom<TIO, TPresence, TStorage>;
 }
 interface PluvRoomAddonResult {
@@ -125,15 +165,14 @@ type PluvRoomDebug<TIO extends IOLike> = Id<{
     output: readonly (keyof InferIOOutput<TIO>)[];
     input: readonly (keyof InferIOInput<TIO>)[];
 }>;
-type PluvRoomOptions<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = {
+type PluvRoomOptions<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractCrdtType<any, any>> = {}> = {
     addons?: readonly PluvRoomAddon<TIO, TPresence, TStorage>[];
     debug?: boolean | PluvRoomDebug<TIO>;
     onAuthorizationFail?: (error: Error) => void;
 } & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
-type RoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = RoomEndpoints<TIO> & PluvRoomOptions<TIO, TPresence, TStorage> & TrackOriginOptions;
-declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
+type RoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractCrdtType<any, any>> = {}> = RoomEndpoints<TIO> & PluvRoomOptions<TIO, TPresence, TStorage>;
+declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractCrdtType<any, any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
     readonly _endpoints: RoomEndpoints<TIO>;
-    private _captureTimeout;
     private _crdtManager;
     private _crdtNotifier;
     private _debug;
@@ -146,11 +185,11 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     private _storageStore;
     private _subscriptions;
     private _timeouts;
-    private _trackedOrigins;
     private _windowListeners;
     private _wsListeners;
     private _usersManager;
     constructor(room: string, options: RoomConfig<TIO, TPresence, TStorage>);
+    get storageLoaded(): boolean;
     get webSocket(): WebSocket | null;
     broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
     canRedo: () => boolean;
@@ -159,16 +198,16 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     disconnect(): Promise<void>;
     event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
     getConnection(): WebSocketConnection;
-    getDoc(): Doc;
+    getDoc(): AbstractCrdtDoc<TStorage>;
     getMyPresence: () => TPresence;
     getMyself: () => Id<UserInfo<TIO, TPresence>> | null;
     getOther: (connectionId: string) => Id<UserInfo<TIO, TPresence>> | null;
     getOthers: () => readonly Id<UserInfo<TIO, TPresence>>[];
-    getStorage: <TKey extends keyof TStorage>(key: TKey) => TStorage[TKey];
+    getStorage: <TKey extends keyof TStorage>(key: TKey) => TStorage[TKey] | null;
     other: (connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>) => (() => void);
     redo: () => void;
-    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void) => (() => void);
-    storageRoot: (fn: (value: { [P in keyof TStorage]: InferYjsSharedTypeJson<TStorage[P]>; }) => void) => (() => void);
+    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtStorageJson<TStorage[TKey]>) => void) => (() => void);
+    storageRoot: (fn: (value: { [P in keyof TStorage]: InferCrdtStorageJson<TStorage[P]>; }) => void) => (() => void);
     subscribe: <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => (() => void);
     transact: (fn: (storage: TStorage) => void, origin?: string) => void;
     undo: () => void;
@@ -187,7 +226,6 @@ declare class PluvRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TS
     private _getAddon;
     private _getAuthFetchOptions;
     private _getAuthorization;
-    private _getTrackedOrigins;
     private _getWsEndpoint;
     private _handleExit;
     private _handlePresenceUpdatedMessage;
@@ -234,9 +272,9 @@ declare class PluvClient<TIO extends IOLike = IOLike> {
     private _wsEndpoint;
     private _rooms;
     constructor(options: PluvClientOptions<TIO>);
-    createRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}>(room: string, options?: PluvRoomOptions<TIO, TPresence, TStorage>) => PluvRoom<TIO, TPresence, TStorage>;
+    createRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractCrdtType<any, any>> = {}>(room: string, options: PluvRoomOptions<TIO, TPresence, TStorage>) => PluvRoom<TIO, TPresence, TStorage>;
     enter: (room: string | PluvRoom<TIO, any, any>) => Promise<PluvRoom<TIO, JsonObject, any>>;
-    getRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}>(room: string) => PluvRoom<TIO, TPresence, TStorage> | null;
+    getRoom: <TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractCrdtType<any, any>> = {}>(room: string) => PluvRoom<TIO, TPresence, TStorage> | null;
     getRooms: () => readonly PluvRoom<TIO, JsonObject, any>[];
     leave: (room: string | PluvRoom<TIO, any, any>) => Promise<void>;
     private _logDebug;
@@ -244,54 +282,4 @@ declare class PluvClient<TIO extends IOLike = IOLike> {
 
 declare const createClient: <TIO extends IOLike<_pluv_types.IOAuthorize<any, any>, {}, {}, {}, {}> = IOLike<_pluv_types.IOAuthorize<any, any>, {}, {}, {}, {}>>(options: PluvClientOptions<TIO>) => PluvClient<TIO>;
 
-type MockedRoomEvents<TIO extends IOLike> = Partial<{
-    [P in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>[P]>) => Partial<InferIOOutput<TIO>>;
-}>;
-type MockedRoomConfig<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> = {
-    events?: MockedRoomEvents<TIO>;
-} & Omit<CrdtManagerOptions<TStorage>, "encodedState"> & UsersManagerConfig<TPresence>;
-declare class MockedRoom<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, AbstractType<any>> = {}> extends AbstractRoom<TIO, TPresence, TStorage> {
-    private _crdtManager;
-    private _crdtNotifier;
-    private _eventNotifier;
-    private _events?;
-    private _otherNotifier;
-    private _state;
-    private _stateNotifier;
-    private _subscriptions;
-    private _usersManager;
-    constructor(room: string, options: MockedRoomConfig<TIO, TPresence, TStorage>);
-    broadcast<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>): void;
-    canRedo: () => boolean;
-    canUndo: () => boolean;
-    event: <TEvent extends keyof InferIOOutput<TIO>>(event: TEvent, callback: EventNotifierSubscriptionCallback<TIO, TEvent>) => (() => void);
-    getConnection(): WebSocketConnection;
-    getDoc(): Doc;
-    getMyPresence: () => TPresence;
-    getMyself: () => Id<UserInfo<TIO, TPresence>> | null;
-    getOther: (connectionId: string) => Id<UserInfo<TIO, TPresence>> | null;
-    getOthers: () => readonly Id<UserInfo<TIO, TPresence>>[];
-    getStorage: <TKey extends keyof TStorage>(key: TKey) => TStorage[TKey];
-    other: (connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO>) => (() => void);
-    redo: () => void;
-    storage: <TKey extends keyof TStorage>(key: TKey, fn: (value: InferYjsSharedTypeJson<TStorage[TKey]>) => void) => (() => void);
-    storageRoot: (fn: (value: { [P in keyof TStorage]: InferYjsSharedTypeJson<TStorage[P]>; }) => void) => (() => void);
-    subscribe: <TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>) => (() => void);
-    transact: (fn: (storage: TStorage) => void, origin?: string) => void;
-    undo: () => void;
-    updateMyPresence: (presence: Partial<TPresence>) => void;
-    private _observeCrdt;
-}
-
-declare const y_array: typeof array;
-declare const y_map: typeof map;
-declare const y_object: typeof object;
-declare const y_text: typeof text;
-declare const y_xmlElement: typeof xmlElement;
-declare const y_xmlFragment: typeof xmlFragment;
-declare const y_xmlText: typeof xmlText;
-declare namespace y {
-  export { y_array as array, y_map as map, y_object as object, y_text as text, y_xmlElement as xmlElement, y_xmlFragment as xmlFragment, y_xmlText as xmlText };
-}
-
-export { AbstractRoom, AbstractStorageStore, ConnectionState, MockedRoom, type MockedRoomConfig, type MockedRoomEvents, PluvClient, type PluvClientOptions, PluvRoom, type PluvRoomAddon, type PluvRoomAddonInput, type PluvRoomAddonResult, type PluvRoomDebug, type UserInfo, type WebSocketConnection, type WebSocketState, createClient, y };
+export { AbstractRoom, AbstractStorageStore, ConnectionState, MockedRoom, type MockedRoomConfig, type MockedRoomEvents, PluvClient, type PluvClientOptions, PluvRoom, type PluvRoomAddon, type PluvRoomAddonInput, type PluvRoomAddonResult, type PluvRoomDebug, type UserInfo, type WebSocketConnection, type WebSocketState, createClient };