@hocuspocus/extension-database 3.0.0-rc.0 → 3.0.6-rc.0

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

@@ -1,4 +1,4 @@
-export * from './auth.js';
-export * from './CloseEvents.js';
-export * from './awarenessStatesToArray.js';
-export * from './types.js';
+export * from './auth.ts';
+export * from './CloseEvents.ts';
+export * from './awarenessStatesToArray.ts';
+export * from './types.ts';

package/dist/packages/extension-database/src/index.d.ts

@@ -1 +1 @@
-export * from './Database.js';
+export * from './Database.ts';

package/dist/packages/extension-logger/src/index.d.ts

@@ -1 +1 @@
-export * from './Logger.js';
+export * from './Logger.ts';

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

@@ -2,7 +2,6 @@ import type { ClusterNode, ClusterOptions, RedisOptions } from 'ioredis';
 import RedisClient from 'ioredis';
 import Redlock from 'redlock';
 import type { Extension, afterLoadDocumentPayload, afterStoreDocumentPayload, onDisconnectPayload, onStoreDocumentPayload, onAwarenessUpdatePayload, onChangePayload, onConfigurePayload, beforeBroadcastStatelessPayload, Hocuspocus } from '@hocuspocus/server';
-import { Debugger } from '@hocuspocus/server';
 export type RedisInstance = RedisClient.Cluster | RedisClient.Redis;
 export interface Configuration {
     /**
@@ -64,8 +63,13 @@ export declare class Redis implements Extension {
     instance: Hocuspocus;
     redlock: Redlock;
     locks: Map<string, Redlock.Lock>;
-    logger: Debugger;
     messagePrefix: Buffer;
+    /**
+     * When we have a high frequency of updates to a document we don't need tons of setTimeouts
+     * piling up, so we'll track them to keep it to the most recent per document.
+     */
+    private pendingDisconnects;
+    private pendingAfterStoreDocumentResolves;
     constructor(configuration: Partial<Configuration>);
     onConfigure({ instance }: onConfigurePayload): Promise<void>;
     private getKey;

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

@@ -1 +1 @@
-export * from './Redis.js';
+export * from './Redis.ts';

package/dist/packages/extension-sqlite/src/index.d.ts

@@ -1 +1 @@
-export * from './SQLite.js';
+export * from './SQLite.ts';

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

@@ -1,11 +1,10 @@
-import * as mutex from 'lib0/mutex';
-import type { CloseEvent, Event, MessageEvent } from 'ws';
+import type { Event, MessageEvent } from 'ws';
 import { Awareness } from 'y-protocols/awareness';
 import * as Y from 'yjs';
-import EventEmitter from './EventEmitter.js';
-import type { CompleteHocuspocusProviderWebsocketConfiguration } from './HocuspocusProviderWebsocket.js';
-import { HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
-import type { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSyncedParameters } from './types.js';
+import EventEmitter from './EventEmitter.ts';
+import type { CompleteHocuspocusProviderWebsocketConfiguration } from './HocuspocusProviderWebsocket.ts';
+import { HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.ts';
+import type { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onSyncedParameters } from './types.ts';
 export type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, 'name'>> & Partial<CompleteHocuspocusProviderConfiguration> & (Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>> | Required<Pick<CompleteHocuspocusProviderConfiguration, 'websocketProvider'>>);
 export interface CompleteHocuspocusProviderConfiguration {
     /**
@@ -16,10 +15,6 @@ export interface CompleteHocuspocusProviderConfiguration {
      * The actual Y.js document
      */
     document: Y.Doc;
-    /**
-     * Pass false to disable broadcasting between browser tabs.
-     */
-    broadcast: boolean;
     /**
      * An Awareness instance to keep the presence state of all clients.
      *
@@ -33,12 +28,6 @@ export interface CompleteHocuspocusProviderConfiguration {
      * A token that’s sent to the backend for authentication purposes.
      */
     token: string | (() => string) | (() => Promise<string>) | null;
-    /**
-     * URL parameters that should be added.
-     */
-    parameters: {
-        [key: string]: any;
-    };
     /**
      * Hocuspocus websocket provider
      */
@@ -53,7 +42,6 @@ export interface CompleteHocuspocusProviderConfiguration {
     onConnect: () => void;
     onMessage: (data: onMessageParameters) => void;
     onOutgoingMessage: (data: onOutgoingMessageParameters) => void;
-    onStatus: (data: onStatusParameters) => void;
     onSynced: (data: onSyncedParameters) => void;
     onDisconnect: (data: onDisconnectParameters) => void;
     onClose: (data: onCloseParameters) => void;
@@ -61,37 +49,26 @@ export interface CompleteHocuspocusProviderConfiguration {
     onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
     onAwarenessChange: (data: onAwarenessChangeParameters) => void;
     onStateless: (data: onStatelessParameters) => void;
-    /**
-     * Don’t output any warnings.
-     */
-    quiet: boolean;
-    /**
-     * Pass `false` to start the connection manually.
-     */
-    connect: boolean;
-    /**
-     * Pass `false` to close the connection manually.
-     */
-    preserveConnection: boolean;
 }
 export declare class AwarenessError extends Error {
     code: number;
 }
 export declare class HocuspocusProvider extends EventEmitter {
     configuration: CompleteHocuspocusProviderConfiguration;
-    subscribedToBroadcastChannel: boolean;
     isSynced: boolean;
     unsyncedChanges: number;
     isAuthenticated: boolean;
     authorizedScope: string | undefined;
-    mux: mutex.mutex;
+    manageSocket: boolean;
+    private isAttached;
     intervals: any;
     constructor(configuration: HocuspocusProviderConfiguration);
+    boundDocumentUpdateHandler: (update: Uint8Array, origin: any) => void;
+    boundAwarenessUpdateHandler: ({ added, updated, removed }: any, origin: any) => void;
     boundPageHide: () => void;
     boundOnOpen: (event: Event) => Promise<void>;
-    boundOnClose: (event: CloseEvent) => void;
+    boundOnClose: () => void;
     forwardConnect: (e: any) => this;
-    forwardOpen: (e: any) => this;
     forwardClose: (e: any) => this;
     forwardDisconnect: (e: any) => this;
     forwardDestroy: (e: any) => this;
@@ -117,16 +94,17 @@ export declare class HocuspocusProvider extends EventEmitter {
     get synced(): boolean;
     set synced(state: boolean);
     receiveStateless(payload: string): void;
-    get isAuthenticationRequired(): boolean;
     connect(): Promise<void>;
     disconnect(): void;
     onOpen(event: Event): Promise<void>;
     getToken(): Promise<string | null>;
     startSync(): void;
-    send(message: ConstructableOutgoingMessage, args: any, broadcast?: boolean): void;
+    send(message: ConstructableOutgoingMessage, args: any): void;
     onMessage(event: MessageEvent): void;
-    onClose(event: CloseEvent): void;
+    onClose(): void;
     destroy(): void;
+    detach(): void;
+    attach(): void;
     permissionDeniedHandler(reason: string): void;
     authenticatedHandler(scope: string): void;
     setAwarenessField(key: string, value: any): void;

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

@@ -1,8 +1,8 @@
 import type { MessageEvent, Event } from 'ws';
-import EventEmitter from './EventEmitter.js';
-import type { HocuspocusProvider } from './HocuspocusProvider.js';
-import type { onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters } from './types.js';
-import { WebSocketStatus } from './types.js';
+import EventEmitter from './EventEmitter.ts';
+import type { HocuspocusProvider } from './HocuspocusProvider.ts';
+import type { onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters } from './types.ts';
+import { WebSocketStatus } from './types.ts';
 export type HocusPocusWebSocket = WebSocket & {
     identifier: string;
 };
@@ -72,10 +72,6 @@ export interface CompleteHocuspocusProviderWebsocketConfiguration {
     onDestroy: () => void;
     onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
     onAwarenessChange: (data: onAwarenessChangeParameters) => void;
-    /**
-     * Don’t output any warnings.
-     */
-    quiet: boolean;
     /**
      * Map of attached providers keyed by documentName.
      */

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

@@ -1,6 +1,6 @@
 import type { Decoder } from 'lib0/decoding';
 import type { Encoder } from 'lib0/encoding';
-import type { MessageType } from './types.js';
+import type { MessageType } from './types.ts';
 export declare class IncomingMessage {
     data: any;
     encoder: Encoder;
@@ -9,7 +9,7 @@ export declare class IncomingMessage {
     peekVarString(): string;
     readVarUint(): MessageType;
     readVarString(): string;
-    readVarUint8Array(): Uint8Array;
+    readVarUint8Array(): Uint8Array<ArrayBufferLike>;
     writeVarUint(type: MessageType): void;
     writeVarString(string: string): void;
     writeVarUint8Array(data: Uint8Array): void;

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

@@ -1,10 +1,8 @@
-import type { HocuspocusProvider } from './HocuspocusProvider.js';
-import type { IncomingMessage } from './IncomingMessage.js';
+import type { HocuspocusProvider } from './HocuspocusProvider.ts';
+import type { IncomingMessage } from './IncomingMessage.ts';
 export declare class MessageReceiver {
     message: IncomingMessage;
-    broadcasted: boolean;
     constructor(message: IncomingMessage);
-    setBroadcasted(value: boolean): this;
     apply(provider: HocuspocusProvider, emitSynced: boolean): void;
     private applySyncMessage;
     applySyncStatusMessage(provider: HocuspocusProvider, applied: boolean): void;

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

@@ -1,10 +1,10 @@
 import type { Encoder } from 'lib0/encoding';
-import type { ConstructableOutgoingMessage } from './types.js';
+import type { ConstructableOutgoingMessage } from './types.ts';
 export declare class MessageSender {
     encoder: Encoder;
     message: any;
     constructor(Message: ConstructableOutgoingMessage, args?: any);
-    create(): Uint8Array;
+    create(): Uint8Array<ArrayBufferLike>;
     send(webSocket: any): void;
     broadcast(channel: string): void;
 }

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

@@ -1,9 +1,9 @@
 import type { Encoder } from 'lib0/encoding';
-import type { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types.js';
+import type { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types.ts';
 export declare class OutgoingMessage implements OutgoingMessageInterface {
     encoder: Encoder;
     type?: MessageType;
     constructor();
     get(args: Partial<OutgoingMessageArguments>): Encoder | undefined;
-    toUint8Array(): Uint8Array;
+    toUint8Array(): Uint8Array<ArrayBufferLike>;
 }

package/dist/packages/provider/src/OutgoingMessages/AuthenticationMessage.d.ts

@@ -1,6 +1,6 @@
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+import type { OutgoingMessageArguments } from '../types.ts';
+import { MessageType } from '../types.ts';
+import { OutgoingMessage } from '../OutgoingMessage.ts';
 export declare class AuthenticationMessage extends OutgoingMessage {
     type: MessageType;
     description: string;

package/dist/packages/provider/src/OutgoingMessages/AwarenessMessage.d.ts

@@ -1,7 +1,7 @@
 import * as encoding from 'lib0/encoding';
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+import type { OutgoingMessageArguments } from '../types.ts';
+import { MessageType } from '../types.ts';
+import { OutgoingMessage } from '../OutgoingMessage.ts';
 export declare class AwarenessMessage extends OutgoingMessage {
     type: MessageType;
     description: string;

package/dist/packages/provider/src/OutgoingMessages/CloseMessage.d.ts

@@ -1,7 +1,7 @@
 import * as encoding from 'lib0/encoding';
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+import type { OutgoingMessageArguments } from '../types.ts';
+import { MessageType } from '../types.ts';
+import { OutgoingMessage } from '../OutgoingMessage.ts';
 export declare class CloseMessage extends OutgoingMessage {
     type: MessageType;
     description: string;

package/dist/packages/provider/src/OutgoingMessages/QueryAwarenessMessage.d.ts

@@ -1,7 +1,7 @@
 import * as encoding from 'lib0/encoding';
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+import type { OutgoingMessageArguments } from '../types.ts';
+import { MessageType } from '../types.ts';
+import { OutgoingMessage } from '../OutgoingMessage.ts';
 export declare class QueryAwarenessMessage extends OutgoingMessage {
     type: MessageType;
     description: string;

package/dist/packages/provider/src/OutgoingMessages/StatelessMessage.d.ts

@@ -1,6 +1,6 @@
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+import type { OutgoingMessageArguments } from '../types.ts';
+import { MessageType } from '../types.ts';
+import { OutgoingMessage } from '../OutgoingMessage.ts';
 export declare class StatelessMessage extends OutgoingMessage {
     type: MessageType;
     description: string;

package/dist/packages/provider/src/OutgoingMessages/SyncStepOneMessage.d.ts

@@ -1,7 +1,7 @@
 import * as encoding from 'lib0/encoding';
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+import type { OutgoingMessageArguments } from '../types.ts';
+import { MessageType } from '../types.ts';
+import { OutgoingMessage } from '../OutgoingMessage.ts';
 export declare class SyncStepOneMessage extends OutgoingMessage {
     type: MessageType;
     description: string;

package/dist/packages/provider/src/OutgoingMessages/SyncStepTwoMessage.d.ts

@@ -1,7 +1,7 @@
 import * as encoding from 'lib0/encoding';
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+import type { OutgoingMessageArguments } from '../types.ts';
+import { MessageType } from '../types.ts';
+import { OutgoingMessage } from '../OutgoingMessage.ts';
 export declare class SyncStepTwoMessage extends OutgoingMessage {
     type: MessageType;
     description: string;

package/dist/packages/provider/src/OutgoingMessages/UpdateMessage.d.ts

@@ -1,6 +1,6 @@
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+import type { OutgoingMessageArguments } from '../types.ts';
+import { MessageType } from '../types.ts';
+import { OutgoingMessage } from '../OutgoingMessage.ts';
 export declare class UpdateMessage extends OutgoingMessage {
     type: MessageType;
     description: string;

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

@@ -1,5 +1,3 @@
-export * from './HocuspocusProvider.js';
-export * from './TiptapCollabProvider.js';
-export * from './TiptapCollabProviderWebsocket.js';
-export * from './HocuspocusProviderWebsocket.js';
-export * from './types.js';
+export * from './HocuspocusProvider.ts';
+export * from './HocuspocusProviderWebsocket.ts';
+export * from './types.ts';

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

@@ -3,14 +3,14 @@ import type { Event, MessageEvent } from 'ws';
 import type { Awareness } from 'y-protocols/awareness';
 import type * as Y from 'yjs';
 import type { CloseEvent } from '@hocuspocus/common';
-import type { IncomingMessage } from './IncomingMessage.js';
-import type { OutgoingMessage } from './OutgoingMessage.js';
-import type { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js';
-import type { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.js';
-import type { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.js';
-import type { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.js';
-import type { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.js';
-import type { UpdateMessage } from './OutgoingMessages/UpdateMessage.js';
+import type { IncomingMessage } from './IncomingMessage.ts';
+import type { OutgoingMessage } from './OutgoingMessage.ts';
+import type { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.ts';
+import type { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.ts';
+import type { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.ts';
+import type { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.ts';
+import type { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.ts';
+import type { UpdateMessage } from './OutgoingMessages/UpdateMessage.ts';
 export declare enum MessageType {
     Sync = 0,
     Awareness = 1,
@@ -88,14 +88,17 @@ export type TCollabThread<Data = any, CommentData = any> = {
     id: string;
     createdAt: number;
     updatedAt: number;
+    deletedAt: number | null;
     resolvedAt?: string;
     comments: TCollabComment<CommentData>[];
+    deletedComments: TCollabComment<CommentData>[];
     data: Data;
 };
 export type TCollabComment<Data = any> = {
     id: string;
-    createdAt: number;
-    updatedAt: number;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string;
     data: Data;
     content: any;
 };
@@ -144,3 +147,40 @@ export type THistoryDocumentRevertedEvent = {
     event: 'document.reverted';
     version: number;
 };
+export type DeleteCommentOptions = {
+    /**
+     * If `true`, the thread will also be deleted if the deleted comment was the first comment in the thread.
+     */
+    deleteThread?: boolean;
+    /**
+     * If `true`, will remove the content of the deleted comment
+     */
+    deleteContent?: boolean;
+};
+export type DeleteThreadOptions = {
+    /**
+     * If `true`, will remove the comments on the thread,
+     * otherwise will only mark the thread as deleted
+     * and keep the comments
+     * @default false
+     */
+    deleteComments?: boolean;
+    /**
+     * If `true`, will forcefully remove the thread and all comments,
+     * otherwise will only mark the thread as deleted
+     * and keep the comments
+     * @default false
+     */
+    force?: boolean;
+};
+/**
+ * The type of thread
+ */
+export type ThreadType = 'archived' | 'unarchived';
+export type GetThreadsOptions = {
+    /**
+     * The types of threads to get
+     * @default ['unarchived']
+     */
+    types?: Array<ThreadType>;
+};

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

@@ -1,9 +1,9 @@
 import type { IncomingMessage } from 'http';
+import { type CloseEvent } from '@hocuspocus/common';
 import type WebSocket from 'ws';
-import type { Debugger } from './Debugger.js';
-import type Document from './Document.js';
-import type { Hocuspocus } from './Hocuspocus.js';
-import type { onDisconnectPayload } from './types.js';
+import type Document from './Document.ts';
+import type { Hocuspocus } from './Hocuspocus.ts';
+import type { onDisconnectPayload } from './types.ts';
 /**
  * The `ClientConnection` class is responsible for handling an incoming WebSocket
  *
@@ -15,7 +15,6 @@ export declare class ClientConnection {
     private readonly request;
     private readonly documentProvider;
     private readonly hooks;
-    private readonly debuggerTool;
     private readonly opts;
     private readonly defaultContext;
     private readonly documentConnections;
@@ -23,8 +22,10 @@ export declare class ClientConnection {
     private readonly documentConnectionsEstablished;
     private readonly hookPayloads;
     private readonly callbacks;
-    private readonly closeIdleConnectionTimeout;
     private readonly socketId;
+    timeout: number;
+    pingInterval: NodeJS.Timeout;
+    pongReceived: boolean;
     /**
       * The `ClientConnection` class receives incoming WebSocket connections,
       * runs all hooks:
@@ -37,10 +38,17 @@ export declare class ClientConnection {
       */
     constructor(websocket: WebSocket, request: IncomingMessage, documentProvider: {
         createDocument: Hocuspocus['createDocument'];
-    }, hooks: Hocuspocus['hooks'], debuggerTool: Debugger, opts: {
-        requiresAuthentication: boolean;
+    }, hooks: Hocuspocus['hooks'], opts: {
         timeout: number;
     }, defaultContext?: any);
+    private handleWebsocketClose;
+    close(event?: CloseEvent): void;
+    handlePong: () => void;
+    /**
+     * Check if pong was received and close the connection otherwise
+     * @private
+     */
+    private check;
     /**
      * Set a callback that will be triggered when the connection is closed
      */

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

@@ -1,30 +1,25 @@
 import type { IncomingMessage as HTTPIncomingMessage } from 'http';
-import AsyncLock from 'async-lock';
+import { type CloseEvent } from '@hocuspocus/common';
 import type WebSocket from 'ws';
-import type { CloseEvent } from '@hocuspocus/common';
-import type Document from './Document.js';
-import type { Debugger } from './Debugger.js';
-import type { onStatelessPayload } from './types.js';
+import type Document from './Document.ts';
+import type { beforeSyncPayload, onStatelessPayload } from './types.ts';
 export declare class Connection {
     webSocket: WebSocket;
     context: any;
     document: Document;
-    pingInterval: NodeJS.Timeout;
-    pongReceived: boolean;
     request: HTTPIncomingMessage;
-    timeout: number;
-    callbacks: any;
+    callbacks: {
+        onClose: ((document: Document, event?: CloseEvent) => void)[];
+        beforeHandleMessage: (connection: Connection, update: Uint8Array) => Promise<void>;
+        beforeSync: (connection: Connection, payload: Pick<beforeSyncPayload, "type" | "payload">) => Promise<void>;
+        statelessCallback: (payload: onStatelessPayload) => Promise<void>;
+    };
     socketId: string;
-    lock: AsyncLock;
     readOnly: boolean;
-    logger: Debugger;
     /**
      * Constructor.
      */
-    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly: boolean | undefined, logger: Debugger);
-    boundClose: (event?: CloseEvent) => void;
-    boundHandlePong: () => void;
-    handlePong(): void;
+    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, socketId: string, context: any, readOnly?: boolean);
     /**
      * Set a callback that will be triggered when the connection is closed
      */
@@ -37,6 +32,10 @@ export declare class Connection {
      * Set a callback that will be triggered before an message is handled
      */
     beforeHandleMessage(callback: (connection: Connection, update: Uint8Array) => Promise<any>): Connection;
+    /**
+     * Set a callback that will be triggered before a sync message is handled
+     */
+    beforeSync(callback: (connection: Connection, payload: Pick<beforeSyncPayload, 'type' | 'payload'>) => Promise<any>): Connection;
     /**
      * Send the given message
      */
@@ -49,11 +48,6 @@ export declare class Connection {
      * Graceful wrapper around the WebSocket close method.
      */
     close(event?: CloseEvent): void;
-    /**
-     * Check if pong was received and close the connection otherwise
-     * @private
-     */
-    private check;
     /**
      * Send the current document awareness to the client, if any
      * @private

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

@@ -1,6 +1,6 @@
-import type Document from './Document.js';
-import type { Hocuspocus } from './Hocuspocus.js';
-import type { DirectConnection as DirectConnectionInterface } from './types.js';
+import type Document from './Document.ts';
+import type { Hocuspocus } from './Hocuspocus.ts';
+import type { DirectConnection as DirectConnectionInterface } from './types.ts';
 export declare class DirectConnection implements DirectConnectionInterface {
     document: Document | null;
     instance: Hocuspocus;
@@ -9,6 +9,6 @@ export declare class DirectConnection implements DirectConnectionInterface {
      * Constructor.
      */
     constructor(document: Document, instance: Hocuspocus, context?: any);
-    transact(transaction: (document: Document) => void, transactionOrigin?: any): Promise<void>;
+    transact(transaction: (document: Document) => void): Promise<void>;
     disconnect(): Promise<void>;
 }

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

@@ -1,9 +1,7 @@
 import type WebSocket from 'ws';
 import { Awareness } from 'y-protocols/awareness';
 import { Doc } from 'yjs';
-import type { mutex } from 'lib0/mutex.js';
-import type Connection from './Connection.js';
-import type { Debugger } from './Debugger.js';
+import type Connection from './Connection.ts';
 export declare class Document extends Doc {
     awareness: Awareness;
     callbacks: {
@@ -16,14 +14,12 @@ export declare class Document extends Doc {
     }>;
     directConnectionsCount: number;
     name: string;
-    mux: mutex;
-    logger?: Debugger;
     isLoading: boolean;
     isDestroyed: boolean;
     /**
      * Constructor.
      */
-    constructor(name: string, logger?: Debugger, yDocOptions?: object);
+    constructor(name: string, yDocOptions?: object);
     /**
      * Check if the Document (XMLFragment or Map) is empty
      */