@hocuspocus/provider 2.5.0-rc.0 → 2.6.0

package/dist/packages/extension-redis/src/Redis.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import RedisClient, { ClusterNode, ClusterOptions, RedisOptions } from 'ioredis';
 import Redlock from 'redlock';
 import { Extension, afterLoadDocumentPayload, afterStoreDocumentPayload, onDisconnectPayload, onStoreDocumentPayload, onAwarenessUpdatePayload, onChangePayload, Debugger, onConfigurePayload, beforeBroadcastStatelessPayload, Hocuspocus } from '@hocuspocus/server';
@@ -56,18 +57,22 @@ export declare class Redis implements Extension {
      */
     priority: number;
     configuration: Configuration;
+    redisTransactionOrigin: string;
     pub: RedisInstance;
     sub: RedisInstance;
     instance: Hocuspocus;
     redlock: Redlock;
     locks: Map<string, Redlock.Lock>;
     logger: Debugger;
+    messagePrefix: Buffer;
     constructor(configuration: Partial<Configuration>);
     onConfigure({ instance }: onConfigurePayload): Promise<void>;
     private getKey;
     private pubKey;
     private subKey;
     private lockKey;
+    private encodeMessage;
+    private decodeMessage;
     /**
      * Once a document is loaded, subscribe to the channel in Redis.
      */
@@ -94,7 +99,7 @@ export declare class Redis implements Extension {
      */
     onAwarenessUpdate({ documentName, awareness, added, updated, removed, }: onAwarenessUpdatePayload): Promise<number>;
     /**
-     * Handle incoming messages published on all subscribed document channels.
+     * Handle incoming messages published on subscribed document channels.
      * Note that this will also include messages from ourselves as it is not possible
      * in Redis to filter these.
     */

package/dist/packages/provider/src/HocuspocusProviderWebsocket.d.ts

@@ -4,6 +4,9 @@ import { Event } from 'ws';
 import EventEmitter from './EventEmitter.js';
 import { HocuspocusProvider } from './HocuspocusProvider.js';
 import { WebSocketStatus, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters } from './types.js';
+export type HocusPocusWebSocket = WebSocket & {
+    identifier: string;
+};
 export type HocuspocusProviderWebsocketConfiguration = Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>> & Partial<CompleteHocuspocusProviderWebsocketConfiguration>;
 export interface CompleteHocuspocusProviderWebsocketConfiguration {
     /**
@@ -79,10 +82,14 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     private messageQueue;
     configuration: CompleteHocuspocusProviderWebsocketConfiguration;
     subscribedToBroadcastChannel: boolean;
-    webSocket: WebSocket | null;
+    webSocket: HocusPocusWebSocket | null;
+    webSocketHandlers: {
+        [key: string]: any;
+    };
     shouldConnect: boolean;
     status: WebSocketStatus;
     lastMessageReceived: number;
+    identifier: number;
     mux: mutex.mutex;
     intervals: any;
     connectionAttempt: {
@@ -100,6 +107,8 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     boundConnect: () => Promise<unknown>;
     cancelWebsocketRetry?: () => void;
     connect(): Promise<unknown>;
+    attachWebSocketListeners(ws: HocusPocusWebSocket, reject: Function): void;
+    cleanupWebSocket(): void;
     createWebSocketConnection(): Promise<unknown>;
     onMessage(event: MessageEvent): void;
     resolveConnectionAttempt(): void;
@@ -107,7 +116,6 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     rejectConnectionAttempt(): void;
     closeTries: number;
     checkConnection(): void;
-    registerEventListeners(): void;
     get serverUrl(): string;
     get url(): string;
     disconnect(): void;

package/dist/packages/provider/src/TiptapCollabProvider.d.ts

@@ -1,6 +1,7 @@
 import type { AbstractType, YArrayEvent } from 'yjs';
 import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js';
+import type { THistoryVersion } from './types';
 export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & (Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'websocketProvider'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>>);
 export interface AdditionalTiptapCollabProviderConfiguration {
     /**
@@ -9,19 +10,29 @@ export interface AdditionalTiptapCollabProviderConfiguration {
     appId?: string;
     websocketProvider?: TiptapCollabProviderWebsocket;
 }
-export type AuditHistoryVersion = {
-    name?: string;
-    version: number;
-    date: number;
-};
 export declare class TiptapCollabProvider extends HocuspocusProvider {
     tiptapCollabConfigurationPrefix: string;
     constructor(configuration: TiptapCollabProviderConfiguration);
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     */
     createVersion(name?: string): void;
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     */
     revertToVersion(targetVersion: number): void;
-    getVersions(): AuditHistoryVersion[];
-    watchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['observe']>[0]): void;
-    unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['unobserve']>[0]): void;
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     *
+     * The server will reply with a stateless message (THistoryVersionPreviewEvent)
+     */
+    previewVersion(targetVersion: number): void;
+    /**
+     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+     */
+    getVersions(): THistoryVersion[];
+    watchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['observe']>[0]): void;
+    unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['unobserve']>[0]): void;
     isAutoVersioning(): boolean;
     enableAutoVersioning(): 1;
     disableAutoVersioning(): 0;

package/dist/packages/provider/src/types.d.ts

@@ -84,3 +84,48 @@ export type StatesArray = {
     clientId: number;
     [key: string | number]: any;
 }[];
+export type THistoryVersion = {
+    name?: string;
+    version: number;
+    date: number;
+};
+export type THistoryConfiguration = {
+    autoVersioning: boolean;
+    currentVersion: number;
+    stateCaptured: number;
+};
+export type THistoryAction = THistoryDocumentRevertAction | THistoryVersionCreateAction | THistoryVersionPreviewAction;
+export type THistoryDocumentRevertAction = {
+    action: 'document.revert';
+    /**
+     * if changes havent been persisted to a version yet, we'll create one with the specified name,
+     * expect when `false` is passed.
+     */
+    currentVersionName?: string | false;
+    /**
+     * Name of the version that is created after the revert. Pass `false` to avoid generating a new version.
+     */
+    newVersionName?: string | false;
+};
+export type THistoryVersionCreateAction = {
+    action: 'version.create';
+    name?: string;
+};
+export type THistoryVersionPreviewAction = {
+    action: 'version.preview';
+    version: number;
+};
+export type THistoryEvent = THistoryVersionPreviewEvent | THistoryVersionCreatedEvent | THistoryDocumentRevertedEvent;
+export type THistoryVersionCreatedEvent = {
+    event: 'version.created';
+    version: number;
+};
+export type THistoryVersionPreviewEvent = {
+    event: 'version.preview';
+    version: number;
+    ydoc: string;
+};
+export type THistoryDocumentRevertedEvent = {
+    event: 'document.reverted';
+    version: number;
+};

package/dist/packages/server/src/Hocuspocus.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { IncomingMessage } from 'http';
 import WebSocket, { AddressInfo } from 'ws';
 import { Server as HocuspocusServer } from './Server';
@@ -29,6 +28,7 @@ export declare class Hocuspocus {
     documents: Map<string, Document>;
     server?: HocuspocusServer;
     debugger: Debugger;
+    debounce: (id: string, func: Function, debounce: number, maxDebounce: number) => void;
     constructor(configuration?: Partial<Configuration>);
     /**
      * Configure the server
@@ -78,14 +78,6 @@ export declare class Hocuspocus {
      * the update is incoming from the provider, but can be anything if the updates is originated from an extension.
      */
     private handleDocumentUpdate;
-    timers: Map<string, {
-        timeout: NodeJS.Timeout;
-        start: number;
-    }>;
-    /**
-     * debounce the given function, using the given identifier
-     */
-    debounce(id: string, func: Function, immediately?: boolean): void;
     /**
      * Create a new document by the given request
      */

package/dist/packages/server/src/MessageReceiver.d.ts

@@ -5,7 +5,8 @@ import { IncomingMessage } from './IncomingMessage.js';
 export declare class MessageReceiver {
     message: IncomingMessage;
     logger: Debugger;
-    constructor(message: IncomingMessage, logger: Debugger);
+    defaultTransactionOrigin?: string;
+    constructor(message: IncomingMessage, logger: Debugger, defaultTransactionOrigin?: string);
     apply(document: Document, connection?: Connection, reply?: (message: Uint8Array) => void): void;
     readSyncMessage(message: IncomingMessage, document: Document, connection?: Connection, reply?: (message: Uint8Array) => void, requestFirstSync?: boolean): 0 | 1 | 2;
     applyQueryAwarenessMessage(document: Document, reply?: (message: Uint8Array) => void): void;

package/dist/packages/server/src/index.d.ts

@@ -6,3 +6,4 @@ export * from './IncomingMessage.js';
 export * from './MessageReceiver.js';
 export * from './OutgoingMessage.js';
 export * from './types.js';
+export * from './util/debounce.js';

package/dist/packages/server/src/types.d.ts

@@ -39,7 +39,7 @@ export interface Extension {
     connected?(data: connectedPayload): Promise<any>;
     onAuthenticate?(data: onAuthenticatePayload): Promise<any>;
     onLoadDocument?(data: onLoadDocumentPayload): Promise<any>;
-    afterLoadDocument?(data: onLoadDocumentPayload): Promise<any>;
+    afterLoadDocument?(data: afterLoadDocumentPayload): Promise<any>;
     beforeHandleMessage?(data: beforeHandleMessagePayload): Promise<any>;
     beforeBroadcastStateless?(data: beforeBroadcastStatelessPayload): Promise<any>;
     onStateless?(payload: onStatelessPayload): Promise<any>;
@@ -49,7 +49,7 @@ export interface Extension {
     onAwarenessUpdate?(data: onAwarenessUpdatePayload): Promise<any>;
     onRequest?(data: onRequestPayload): Promise<any>;
     onDisconnect?(data: onDisconnectPayload): Promise<any>;
-    afterUnloadDocument?(data: onLoadDocumentPayload): Promise<any>;
+    afterUnloadDocument?(data: afterUnloadDocumentPayload): Promise<any>;
     onDestroy?(data: onDestroyPayload): Promise<any>;
 }
 export type HookName = 'onConfigure' | 'onListen' | 'onUpgrade' | 'onConnect' | 'connected' | 'onAuthenticate' | 'onLoadDocument' | 'afterLoadDocument' | 'beforeHandleMessage' | 'beforeBroadcastStateless' | 'onStateless' | 'onChange' | 'onStoreDocument' | 'afterStoreDocument' | 'onAwarenessUpdate' | 'onRequest' | 'onDisconnect' | 'afterUnloadDocument' | 'onDestroy';
@@ -61,7 +61,7 @@ export type HookPayloadByName = {
     connected: connectedPayload;
     onAuthenticate: onAuthenticatePayload;
     onLoadDocument: onLoadDocumentPayload;
-    afterLoadDocument: onLoadDocumentPayload;
+    afterLoadDocument: afterLoadDocumentPayload;
     beforeHandleMessage: beforeHandleMessagePayload;
     beforeBroadcastStateless: beforeBroadcastStatelessPayload;
     onStateless: onStatelessPayload;
@@ -123,15 +123,6 @@ export interface Configuration extends Extension {
         gc: boolean;
         gcFilter: () => boolean;
     };
-    /**
-     * Function which returns the (customized) document name based on the request
-     */
-    getDocumentName?(data: getDocumentNamePayload): string | Promise<string>;
-}
-export interface getDocumentNamePayload {
-    documentName: string;
-    request: IncomingMessage;
-    requestParameters: URLSearchParams;
 }
 export interface onStatelessPayload {
     connection: Connection;
@@ -149,6 +140,7 @@ export interface onAuthenticatePayload {
     connection: ConnectionConfiguration;
 }
 export interface onConnectPayload {
+    context: any;
     documentName: string;
     instance: Hocuspocus;
     request: IncomingMessage;

package/dist/packages/server/src/util/debounce.d.ts

@@ -0,0 +1 @@
+export declare const useDebounce: () => (id: string, func: Function, debounce: number, maxDebounce: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hocuspocus/provider",
-  "version": "2.5.0-rc.0",
+  "version": "2.6.0",
   "description": "hocuspocus provider",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
@@ -29,7 +29,7 @@
     "dist"
   ],
   "dependencies": {
-    "@hocuspocus/common": "^2.5.0-rc.0",
+    "@hocuspocus/common": "^2.6.0",
     "@lifeomic/attempt": "^3.0.2",
     "lib0": "^0.2.47",
     "ws": "^7.5.9"

package/src/HocuspocusProvider.ts

@@ -367,6 +367,10 @@ export class HocuspocusProvider extends EventEmitter {
 
   // not needed, but provides backward compatibility with e.g. lexicla/yjs
   async connect() {
+    if (this.configuration.broadcast) {
+      this.subscribeToBroadcastChannel()
+    }
+
     return this.configuration.websocketProvider.connect()
   }
 

package/src/HocuspocusProviderWebsocket.ts

@@ -15,6 +15,8 @@ import {
   onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters,
 } from './types.js'
 
+export type HocusPocusWebSocket = WebSocket & { identifier: string };
+
 export type HocuspocusProviderWebsocketConfiguration =
   Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>>
   & Partial<CompleteHocuspocusProviderWebsocketConfiguration>
@@ -136,7 +138,9 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
   subscribedToBroadcastChannel = false
 
-  webSocket: WebSocket | null = null
+  webSocket: HocusPocusWebSocket | null = null
+
+  webSocketHandlers: { [key: string]: any } = {}
 
   shouldConnect = true
 
@@ -144,6 +148,8 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
   lastMessageReceived = 0
 
+  identifier = 0
+
   mux = mutex.createMutex()
 
   intervals: any = {
@@ -152,15 +158,17 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
   }
 
   connectionAttempt: {
-    resolve: (value?: any) => void
-    reject: (reason?: any) => void
+    resolve: (value?: any) => void;
+    reject: (reason?: any) => void;
   } | null = null
 
   constructor(configuration: HocuspocusProviderWebsocketConfiguration) {
     super()
     this.setConfiguration(configuration)
 
-    this.configuration.WebSocketPolyfill = configuration.WebSocketPolyfill ? configuration.WebSocketPolyfill : WebSocket
+    this.configuration.WebSocketPolyfill = configuration.WebSocketPolyfill
+      ? configuration.WebSocketPolyfill
+      : WebSocket
 
     this.on('open', this.configuration.onOpen)
     this.on('open', this.onOpen.bind(this))
@@ -178,8 +186,6 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     this.on('close', this.onClose.bind(this))
     this.on('message', this.onMessage.bind(this))
 
-    this.registerEventListeners()
-
     this.intervals.connectionChecker = setInterval(
       this.checkConnection.bind(this),
       this.configuration.messageReconnectTimeout / 10,
@@ -224,10 +230,11 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
   detach(provider: HocuspocusProvider) {
     // tell the server to remove the listener
-
   }
 
-  public setConfiguration(configuration: Partial<HocuspocusProviderWebsocketConfiguration> = {}): void {
+  public setConfiguration(
+    configuration: Partial<HocuspocusProviderWebsocketConfiguration> = {},
+  ): void {
     this.configuration = { ...this.configuration, ...configuration }
   }
 
@@ -289,23 +296,60 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     return retryPromise
   }
 
+  attachWebSocketListeners(ws: HocusPocusWebSocket, reject: Function) {
+    const { identifier } = ws
+    const onMessageHandler = (payload: any) => this.emit('message', payload)
+    const onCloseHandler = (payload: any) => this.emit('close', { event: payload })
+    const onOpenHandler = (payload: any) => this.emit('open', payload)
+    const onErrorHandler = (err: any) => {
+      reject(err)
+    }
+
+    this.webSocketHandlers[identifier] = {
+      message: onMessageHandler,
+      close: onCloseHandler,
+      open: onOpenHandler,
+      error: onErrorHandler,
+    }
+
+    const handlers = this.webSocketHandlers[ws.identifier]
+
+    Object.keys(handlers).forEach(name => {
+      ws.addEventListener(name, handlers[name])
+    })
+  }
+
+  cleanupWebSocket() {
+    if (!this.webSocket) {
+      return
+    }
+    const { identifier } = this.webSocket
+    const handlers = this.webSocketHandlers[identifier]
+
+    Object.keys(handlers).forEach(name => {
+      this.webSocket?.removeEventListener(name, handlers[name])
+      delete this.webSocketHandlers[identifier]
+    })
+    this.webSocket.close()
+    this.webSocket = null
+  }
+
   createWebSocketConnection() {
     return new Promise((resolve, reject) => {
       if (this.webSocket) {
         this.messageQueue = []
-        this.webSocket.close()
-        this.webSocket = null
+        this.cleanupWebSocket()
       }
+      this.lastMessageReceived = 0
+      this.identifier += 1
 
       // Init the WebSocket connection
       const ws = new this.configuration.WebSocketPolyfill(this.url)
       ws.binaryType = 'arraybuffer'
-      ws.onmessage = (payload: any) => this.emit('message', payload)
-      ws.onclose = (payload: any) => this.emit('close', { event: payload })
-      ws.onopen = (payload: any) => this.emit('open', payload)
-      ws.onerror = (err: any) => {
-        reject(err)
-      }
+      ws.identifier = this.identifier
+
+      this.attachWebSocketListeners(ws, reject)
+
       this.webSocket = ws
 
       // Reset the status
@@ -362,7 +406,10 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
     }
 
     // Don’t close the connection when a message was received recently
-    if (this.configuration.messageReconnectTimeout >= time.getUnixTime() - this.lastMessageReceived) {
+    if (
+      this.configuration.messageReconnectTimeout
+      >= time.getUnixTime() - this.lastMessageReceived
+    ) {
       return
     }
 
@@ -383,15 +430,6 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
       this.webSocket?.close()
       this.messageQueue = []
     }
-
-  }
-
-  registerEventListeners() {
-    if (typeof window === 'undefined') {
-      return
-    }
-
-    window.addEventListener('online', this.boundConnect)
   }
 
   // Ensure that the URL always ends with /
@@ -434,7 +472,7 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
   onClose({ event }: onCloseParameters) {
     this.closeTries = 0
-    this.webSocket = null
+    this.cleanupWebSocket()
 
     if (this.status === WebSocketStatus.Connected) {
       this.status = WebSocketStatus.Disconnected
@@ -444,9 +482,13 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
     if (event.code === Unauthorized.code) {
       if (event.reason === Unauthorized.reason) {
-        console.warn('[HocuspocusProvider] An authentication token is required, but you didn’t send one. Try adding a `token` to your HocuspocusProvider configuration. Won’t try again.')
+        console.warn(
+          '[HocuspocusProvider] An authentication token is required, but you didn’t send one. Try adding a `token` to your HocuspocusProvider configuration. Won’t try again.',
+        )
       } else {
-        console.warn(`[HocuspocusProvider] Connection closed with status Unauthorized: ${event.reason}`)
+        console.warn(
+          `[HocuspocusProvider] Connection closed with status Unauthorized: ${event.reason}`,
+        )
       }
 
       this.shouldConnect = false
@@ -454,13 +496,17 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
     if (event.code === Forbidden.code) {
       if (!this.configuration.quiet) {
-        console.warn('[HocuspocusProvider] The provided authentication token isn’t allowed to connect to this server. Will try again.')
+        console.warn(
+          '[HocuspocusProvider] The provided authentication token isn’t allowed to connect to this server. Will try again.',
+        )
         return // TODO REMOVE ME
       }
     }
 
     if (event.code === MessageTooBig.code) {
-      console.warn(`[HocuspocusProvider] Connection closed with status MessageTooBig: ${event.reason}`)
+      console.warn(
+        `[HocuspocusProvider] Connection closed with status MessageTooBig: ${event.reason}`,
+      )
       this.shouldConnect = false
     }
 
@@ -506,11 +552,6 @@ export class HocuspocusProviderWebsocket extends EventEmitter {
 
     this.removeAllListeners()
 
-    if (typeof window === 'undefined') {
-      return
-    }
-
-    window.removeEventListener('online', this.boundConnect)
+    this.cleanupWebSocket()
   }
-
 }

package/src/TiptapCollabProvider.ts

@@ -5,6 +5,7 @@ import {
 } from './HocuspocusProvider.js'
 
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js'
+import type { THistoryVersion } from './types'
 
 export type TiptapCollabProviderConfiguration =
   Required<Pick<HocuspocusProviderConfiguration, 'name'>> &
@@ -21,12 +22,6 @@ export interface AdditionalTiptapCollabProviderConfiguration {
   websocketProvider?: TiptapCollabProviderWebsocket
 }
 
-export type AuditHistoryVersion = {
-  name?: string;
-  version: number;
-  date: number;
-}
-
 export class TiptapCollabProvider extends HocuspocusProvider {
   tiptapCollabConfigurationPrefix = '__tiptapcollab__'
 
@@ -42,43 +37,53 @@ export class TiptapCollabProvider extends HocuspocusProvider {
     super(configuration as HocuspocusProviderConfiguration)
   }
 
+  /**
+   * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+   */
   createVersion(name?: string) {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
     return this.sendStateless(JSON.stringify({ action: 'version.create', name }))
   }
 
+  /**
+   * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+   */
   revertToVersion(targetVersion: number) {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
-    return this.sendStateless(JSON.stringify({ action: 'version.revert', version: targetVersion }))
+    return this.sendStateless(JSON.stringify({ action: 'document.revert', version: targetVersion }))
   }
 
-  getVersions(): AuditHistoryVersion[] {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
-    return this.configuration.document.getArray<AuditHistoryVersion>(`${this.tiptapCollabConfigurationPrefix}versions`).toArray()
+  /**
+   * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+   *
+   * The server will reply with a stateless message (THistoryVersionPreviewEvent)
+   */
+  previewVersion(targetVersion: number) {
+    return this.sendStateless(JSON.stringify({ action: 'version.preview', version: targetVersion }))
+  }
+
+  /**
+   * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
+   */
+  getVersions(): THistoryVersion[] {
+    return this.configuration.document.getArray<THistoryVersion>(`${this.tiptapCollabConfigurationPrefix}versions`).toArray()
   }
 
-  watchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['observe']>[0]) {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
-    return this.configuration.document.getArray<AuditHistoryVersion>('__tiptapcollab__versions').observe(callback)
+  watchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['observe']>[0]) {
+    return this.configuration.document.getArray<THistoryVersion>('__tiptapcollab__versions').observe(callback)
   }
 
-  unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<AuditHistoryVersion>>['unobserve']>[0]) {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
-    return this.configuration.document.getArray<AuditHistoryVersion>('__tiptapcollab__versions').unobserve(callback)
+  unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['unobserve']>[0]) {
+    return this.configuration.document.getArray<THistoryVersion>('__tiptapcollab__versions').unobserve(callback)
   }
 
   isAutoVersioning(): boolean {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
     return !!this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).get('autoVersioning')
   }
 
   enableAutoVersioning() {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
     return this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 1)
   }
 
   disableAutoVersioning() {
-    console.error('This doesnt work yet! If you want to join as a beta tester, send an email to humans@tiptap.dev')
     return this.configuration.document.getMap<number>(`${this.tiptapCollabConfigurationPrefix}config`).set('autoVersioning', 0)
   }