@fiduswriter/editor 0.1.20 → 0.1.21

package/src/collab/{doc.js → doc.ts}

@@ -1,22 +1,67 @@
 import {SchemaExport} from "@fiduswriter/document/schema/export"
+import type {BibDB, ImageDB} from "@fiduswriter/document"
 import {Dialog, activateWait, deactivateWait, makeWorker} from "fwtoolkit"
-import {receiveTransaction, sendableSteps} from "prosemirror-collab"
-import {EditorState} from "prosemirror-state"
-import {Step} from "prosemirror-transform"
 import {E2EEEncryptor} from "fwtoolkit/e2ee/encryptor"
 import {E2EEKeyManager} from "fwtoolkit/e2ee/key-manager"
 import {enterPassphraseDialog} from "fwtoolkit/e2ee/passphrase-dialog"
 import {PassphraseManager} from "fwtoolkit/e2ee/passphrase-manager"
 import {enterPasswordDialog} from "fwtoolkit/e2ee/password-dialog"
+import {receiveTransaction, sendableSteps} from "prosemirror-collab"
+import type {Node} from "prosemirror-model"
+import {EditorState} from "prosemirror-state"
+import type {Transaction} from "prosemirror-state"
+import {Step} from "prosemirror-transform"
+
 import {
     getSelectionUpdate,
     removeCollaboratorSelection,
     updateCollaboratorSelection
 } from "../state_plugins/index.js"
 import {Merge} from "./merge/index.js"
+import type {ModCollab} from "./index.js"
+
+interface IncomingDoc {
+    v: number
+    content: unknown
+    comments: unknown
+    bibliography: unknown
+    images?: Record<string, {copyright?: unknown}>
+    template?: {content: unknown}
+}
+
+interface DiffData {
+    type?: string
+    v?: number
+    rid?: number
+    cid?: string | number
+    ds?: unknown[]
+    fs?: unknown[]
+    cu?: unknown[]
+    bu?: unknown[]
+    iu?: unknown[]
+    footnoterender?: boolean
+    reject_request_id?: number
+    ep?: string
+    e2ee_salt?: string
+}
 
 export class ModCollabDoc {
-    constructor(mod) {
+    mod: ModCollab
+    merge: Merge
+    unconfirmedDiffs: Record<number, any>
+    confirmStepsRequestCounter: number
+    awaitingDiffResponse: boolean
+    receiving: boolean
+    currentlyCheckingVersion: boolean
+    enableCheckVersion?: number
+    footnoteRender: boolean
+    initialVersionConfirmed: boolean
+    initialDocLoaded: boolean
+    templateAdjustmentPending: boolean
+    sendNextDiffTimer?: number
+    lastSelectionUpdateState?: EditorState
+
+    constructor(mod: ModCollab) {
         mod.doc = this
         this.mod = mod
         this.merge = new Merge(mod)
@@ -31,18 +76,19 @@ export class ModCollabDoc {
         this.templateAdjustmentPending = false
     }
 
-    cancelCurrentlyCheckingVersion() {
+    cancelCurrentlyCheckingVersion(): void {
         this.currentlyCheckingVersion = false
         window.clearTimeout(this.enableCheckVersion)
     }
 
-    checkVersion(offline = false) {
+    checkVersion(offline = false): void {
         // Guard: WebSocket may not be initialized yet (e.g. during
         // loadDocument before the WS connector is created).
         if (!this.mod.editor.ws) {
             return
         }
-        this.mod.editor.ws.send(() => {
+        const ws = this.mod.editor.ws
+        ws.send(() => {
             if (
                 this.currentlyCheckingVersion ||
                 this.mod.editor.docInfo.version === undefined
@@ -53,11 +99,11 @@ export class ModCollabDoc {
             this.enableCheckVersion = window.setTimeout(() => {
                 this.currentlyCheckingVersion = false
             }, 1000)
-            if (this.mod.editor.ws.connected) {
+            if (ws.connected) {
                 this.disableDiffSending()
             }
 
-            const msg = {
+            const msg: Record<string, unknown> = {
                 type: "check_version",
                 v: this.mod.editor.docInfo.version
             }
@@ -68,7 +114,7 @@ export class ModCollabDoc {
         })
     }
 
-    disableDiffSending() {
+    disableDiffSending(): void {
         this.awaitingDiffResponse = true
         // If no answer has been received from the server within 2 seconds,
         // check the version
@@ -78,25 +124,25 @@ export class ModCollabDoc {
         }, 8000)
     }
 
-    enableDiffSending() {
+    enableDiffSending(): void {
         window.clearTimeout(this.sendNextDiffTimer)
         this.awaitingDiffResponse = false
         this.sendToCollaborators()
     }
 
-    receiveDocument(data) {
+    receiveDocument(data: {doc: IncomingDoc}): void {
         this.cancelCurrentlyCheckingVersion()
         if (
             this.mod.editor.docInfo.confirmedDoc &&
             !this.mod.editor.e2ee?.encrypted
         ) {
-            this.merge.adjustDocument(data)
+            this.merge.adjustDocument(data as any)
         } else {
-            this.loadDocument(data)
+            this.loadDocument(data as any)
         }
     }
 
-    finishInitialLoad() {
+    finishInitialLoad(): void {
         if (
             this.initialDocLoaded &&
             this.initialVersionConfirmed &&
@@ -107,7 +153,7 @@ export class ModCollabDoc {
         }
     }
 
-    confirmVersion(version) {
+    confirmVersion(version: number): void {
         if (!this.mod.editor.docInfo.confirmedDoc) {
             return
         }
@@ -119,7 +165,11 @@ export class ModCollabDoc {
         }
     }
 
-    loadDocument({doc, time, doc_info}) {
+    loadDocument(data: {
+        doc: IncomingDoc
+        time: number
+        doc_info: Record<string, any>
+    }): void {
         const isInitialLoad = !this.mod.editor.docInfo.confirmedDoc
         // Reset collaboration
         this.unconfirmedDiffs = {}
@@ -127,10 +177,10 @@ export class ModCollabDoc {
             this.enableDiffSending()
         }
 
-        this.mod.editor.clientTimeAdjustment = Date.now() - time
+        this.mod.editor.clientTimeAdjustment = Date.now() - data.time
 
         const token = this.mod.editor.docInfo.token
-        this.mod.editor.docInfo = doc_info
+        this.mod.editor.docInfo = data.doc_info as any
         this.mod.editor.docInfo.token = token
         // For guests, update user object with the token UUID (stable identity)
         // and session_id (for display). Token UUID persists across reconnections.
@@ -138,28 +188,28 @@ export class ModCollabDoc {
         // the session_info WebSocket message). Only update if available.
         if (
             !this.mod.editor.user.is_authenticated &&
-            doc_info.session_id !== undefined
+            data.doc_info.session_id !== undefined
         ) {
-            const sessionId = doc_info.session_id
+            const sessionId = data.doc_info.session_id as string
             this.mod.editor.user = {
-                id: token, // stable — same token UUID even after reconnect
+                id: token as unknown as number, // stable — same token UUID even after reconnect
                 username: `guest${sessionId}`, // display name per session
                 name: `Guest ${sessionId}`,
                 is_authenticated: false
-            }
+            } as any
         }
         this.mod.editor.docInfo.token = token
-        this.mod.editor.docInfo.version = doc.v
+        this.mod.editor.docInfo.version = data.doc.v
         this.mod.editor.docInfo.updated = new Date()
 
         // Check if this is an E2EE document. If so, we need to decrypt
         // the content before loading it into ProseMirror.
-        const isE2EE = doc_info.e2ee === true
+        const isE2EE = data.doc_info.e2ee === true
         if (isE2EE) {
-            this._loadE2EEDocument(doc, doc_info, isInitialLoad)
+            this._loadE2EEDocument(data.doc, data.doc_info, isInitialLoad)
         } else {
             this.mod.editor.e2ee = {encrypted: false}
-            this._loadUnencryptedDocument(doc, isInitialLoad)
+            this._loadUnencryptedDocument(data.doc, isInitialLoad)
         }
     }
 
@@ -168,12 +218,16 @@ export class ModCollabDoc {
      * per-document password prompt, decrypt, then load.
      * @private
      */
-    async _loadE2EEDocument(doc, doc_info, isInitialLoad) {
+    async _loadE2EEDocument(
+        doc: IncomingDoc,
+        doc_info: Record<string, any>,
+        isInitialLoad: boolean,
+        urlFragmentPassword = ""
+    ): Promise<void> {
         // Extract password from URL fragment if present (share link format:
         // https://example.com/share/TOKEN/#target?password=PASSWORD). The fragment is never
         // sent to the server, so this is safe.
         const locationHash = window.location.hash
-        let urlFragmentPassword = ""
         if (locationHash && locationHash.includes("?")) {
             urlFragmentPassword = decodeURIComponent(
                 new URLSearchParams(locationHash.split("?")[1]).get(
@@ -185,7 +239,7 @@ export class ModCollabDoc {
         // Get the salt and iterations. These may come from the REST response
         // (doc_info) or from the WebSocket session_info message (already
         // stored in this.mod.editor.e2ee).
-        let salt, iterations
+        let salt: string | undefined, iterations: number | undefined
         if (this.mod.editor.e2ee) {
             salt = this.mod.editor.e2ee.encryptionSalt
             iterations = this.mod.editor.e2ee.encryptionIterations
@@ -197,11 +251,11 @@ export class ModCollabDoc {
             iterations = doc_info.e2ee_iterations
         }
 
-        const docId = this.mod.editor.docInfo.id
+        const docId = this.mod.editor.docInfo.id as number as number
 
         // Helper to save password for passphrase users after successful decryption
         // (migrates per-document-password docs into the passphrase system)
-        const maybeSavePasswordForPassphrase = async password => {
+        const maybeSavePasswordForPassphrase = async (password: string) => {
             if (!PassphraseManager.hasKeysInSession()) {
                 return
             }
@@ -212,7 +266,7 @@ export class ModCollabDoc {
                     await PassphraseManager.saveDocumentPassword(
                         docId,
                         password,
-                        null,
+                        null as any,
                         "user",
                         true
                     )
@@ -226,7 +280,7 @@ export class ModCollabDoc {
         }
 
         // Helper to resolve a password to a key and attempt decryption
-        const tryPassword = async password => {
+        const tryPassword = async (password: string) => {
             const key = await E2EEKeyManager.resolvePasswordToKey(
                 password,
                 salt
@@ -235,7 +289,7 @@ export class ModCollabDoc {
                               .split("")
                               .map(c => c.charCodeAt(0))
                       )
-                    : null,
+                    : (null as any),
                 iterations || 600000
             )
             await this._decryptAndLoadDoc(
@@ -280,9 +334,13 @@ export class ModCollabDoc {
                 let errorMessage = ""
                 let unlocked = false
                 while (!unlocked) {
-                    const result = await new Promise(resolve => {
+                    const result = await new Promise<{
+                        action: string
+                        passphrase?: string
+                    }>(resolve => {
                         enterPassphraseDialog(
-                            pwd => resolve({action: "unlock", passphrase: pwd}),
+                            (pwd: string) =>
+                                resolve({action: "unlock", passphrase: pwd}),
                             () => resolve({action: "recover"}),
                             {errorMessage}
                         )
@@ -314,20 +372,23 @@ export class ModCollabDoc {
                         const {recoverWithKeyDialog} = await import(
                             "fwtoolkit/e2ee/passphrase-dialog"
                         )
-                        const recoverResult = await new Promise(resolve => {
+                        const recoverResult = await new Promise<{
+                            recoveryKey: string
+                            newPassphrase: string
+                        } | null>(resolve => {
                             recoverWithKeyDialog(resolve)
                         })
                         if (recoverResult) {
                             try {
                                 const {newRecoveryKey} =
-                                    await PassphraseManager.recoverWithRecoveryKey(
+                                    (await PassphraseManager.recoverWithRecoveryKey(
                                         recoverResult.recoveryKey,
                                         recoverResult.newPassphrase
-                                    )
+                                    )) as {newRecoveryKey: string}
                                 const {showRecoveryKeyDialog} = await import(
                                     "fwtoolkit/e2ee/passphrase-dialog"
                                 )
-                                await new Promise(resolve => {
+                                await new Promise<void>(resolve => {
                                     showRecoveryKeyDialog(
                                         newRecoveryKey,
                                         resolve
@@ -431,7 +492,7 @@ export class ModCollabDoc {
                     error
                 )
                 if (this.mod.editor.e2ee) {
-                    this.mod.editor.e2ee.key = null
+                    this.mod.editor.e2ee.key = null as any
                 }
                 await this._promptPasswordAndDecrypt(
                     doc,
@@ -461,15 +522,15 @@ export class ModCollabDoc {
      * @private
      */
     async _promptPasswordAndDecrypt(
-        doc,
-        doc_info,
-        salt,
-        iterations,
-        isInitialLoad,
-        urlFragmentPassword
-    ) {
+        doc: IncomingDoc,
+        doc_info: Record<string, any>,
+        salt: string | undefined,
+        iterations: number | undefined,
+        isInitialLoad: boolean,
+        urlFragmentPassword = ""
+    ): Promise<void> {
         // Decode the salt from Base64 to Uint8Array
-        let saltBytes = null
+        let saltBytes: Uint8Array | null = null
         if (salt) {
             const binary = atob(salt)
             saltBytes = new Uint8Array(binary.length)
@@ -495,11 +556,11 @@ export class ModCollabDoc {
         }
 
         await enterPasswordDialog(
-            async password => {
+            async (password: string) => {
                 try {
                     const key = await E2EEKeyManager.resolvePasswordToKey(
                         password,
-                        saltBytes,
+                        saltBytes as any,
                         iterations || 600000
                     )
                     await this._decryptAndLoadDoc(
@@ -512,11 +573,11 @@ export class ModCollabDoc {
                     )
                     // Cache password and key for this session
                     E2EEKeyManager.storePasswordInSession(
-                        this.mod.editor.docInfo.id,
+                        this.mod.editor.docInfo.id as number,
                         password
                     )
                     await E2EEKeyManager.storeKeyInSession(
-                        this.mod.editor.docInfo.id,
+                        this.mod.editor.docInfo.id as number,
                         key
                     )
                     if (this.mod.editor.e2ee) {
@@ -528,13 +589,13 @@ export class ModCollabDoc {
                         try {
                             const existing =
                                 await PassphraseManager.getDocumentPassword(
-                                    this.mod.editor.docInfo.id
+                                    this.mod.editor.docInfo.id as number
                                 )
                             if (!existing) {
                                 await PassphraseManager.saveDocumentPassword(
-                                    this.mod.editor.docInfo.id,
+                                    this.mod.editor.docInfo.id as number,
                                     password,
-                                    null,
+                                    null as any,
                                     "user",
                                     true
                                 )
@@ -584,7 +645,7 @@ export class ModCollabDoc {
                 }
             },
             urlFragmentPassword,
-            goBack
+            goBack as any
         )
     }
 
@@ -601,13 +662,13 @@ export class ModCollabDoc {
      * @private
      */
     async _decryptAndLoadDoc(
-        doc,
-        key,
-        salt,
-        iterations,
-        isInitialLoad,
-        urlFragmentPassword
-    ) {
+        doc: IncomingDoc,
+        key: CryptoKey,
+        salt: string | undefined,
+        iterations: number | undefined,
+        isInitialLoad: boolean,
+        urlFragmentPassword: string
+    ): Promise<void> {
         let decryptedContent = doc.content
         if (typeof doc.content === "string") {
             decryptedContent = await E2EEEncryptor.decryptObject(
@@ -649,13 +710,13 @@ export class ModCollabDoc {
                 this.mod.editor
             )
         }
-        this.mod.editor.e2ee.snapshotManager.setKey(key)
+        ;(this.mod.editor.e2ee.snapshotManager as any).setKey(key)
 
         // Cache the key in sessionStorage so the user doesn't have to
         // re-enter the password when reopening the document this session.
         try {
             await E2EEKeyManager.storeKeyInSession(
-                this.mod.editor.docInfo.id,
+                this.mod.editor.docInfo.id as number,
                 key
             )
         } catch (_e) {
@@ -687,14 +748,15 @@ export class ModCollabDoc {
             decryptedImages = {}
             const {E2EEEncryptor} = await import("fwtoolkit/e2ee/encryptor")
             for (const [id, image] of Object.entries(doc.images)) {
-                decryptedImages[id] = image
+                ;(decryptedImages as Record<string, any>)[id] = image
                 if (typeof image.copyright === "string") {
                     try {
-                        decryptedImages[id].copyright =
-                            await E2EEEncryptor.decryptObject(
-                                image.copyright,
-                                key
-                            )
+                        ;(decryptedImages as Record<string, any>)[
+                            id
+                        ].copyright = await E2EEEncryptor.decryptObject(
+                            image.copyright,
+                            key
+                        )
                     } catch (_e) {
                         // If decryption fails, leave as-is (legacy plaintext)
                     }
@@ -710,18 +772,18 @@ export class ModCollabDoc {
             bibliography: decryptedBibliography,
             images: decryptedImages
         }
-        this._loadUnencryptedDocument(decryptedDoc, isInitialLoad)
+        this._loadUnencryptedDocument(decryptedDoc as IncomingDoc, isInitialLoad)
 
         // Cache the decrypted title in sessionStorage so the document overview
         // can display the real title without prompting for the password again.
         let title = ""
-        this.mod.editor.view.state.doc.firstChild.forEach(child => {
+        this.mod.editor.view.state.doc.firstChild?.forEach(child => {
             if (!child.marks.find(mark => mark.type.name === "deletion")) {
                 title += child.textContent
             }
         })
         sessionStorage.setItem(
-            `e2ee_title_${this.mod.editor.docInfo.id}`,
+            `e2ee_title_${this.mod.editor.docInfo.id as number}`,
             title
         )
 
@@ -733,7 +795,7 @@ export class ModCollabDoc {
         const isNewE2EEDocument =
             isInitialLoad && typeof doc.content !== "string"
         if (isNewE2EEDocument && this.mod.editor.e2ee.snapshotManager) {
-            this.mod.editor.e2ee.snapshotManager.sendInitialSnapshot(
+            ;(this.mod.editor.e2ee.snapshotManager as any).sendInitialSnapshot(
                 decryptedContent,
                 decryptedComments,
                 decryptedBibliography,
@@ -749,7 +811,7 @@ export class ModCollabDoc {
         } else if (!this.mod.editor.ws) {
             // Non-collaborative mode: mark version as confirmed so the editor
             // finishes loading and periodic saves can begin.
-            this.mod.editor.mod.collab.doc.confirmVersion(
+            ;(this.mod.editor.mod.collab as any).doc.confirmVersion(
                 this.mod.editor.docInfo.version
             )
         }
@@ -760,17 +822,19 @@ export class ModCollabDoc {
      * This is the original loadDocument logic, extracted for reuse.
      * @private
      */
-    _loadUnencryptedDocument(doc, isInitialLoad) {
+    _loadUnencryptedDocument(doc: IncomingDoc, isInitialLoad: boolean): void {
         // Remember location hash to scroll there subsequently.
         const [locationHash, _queryString] = window.location.hash.split("?")
-        this.mod.editor.mod.db.bibDB.setDB(doc.bibliography)
-        this.mod.editor.mod.db.imageDB.setDB(doc.images)
-        const stateDoc = this.mod.editor.schema.nodeFromJSON(doc.content)
+        this.mod.editor.mod.db!.bibDB.setDB(doc.bibliography as unknown as BibDB)
+        this.mod.editor.mod.db!.imageDB.setDB(doc.images as unknown as ImageDB)
+        const stateDoc = this.mod.editor.schema.nodeFromJSON(
+            doc.content as Record<string, unknown>
+        )
         const plugins = this.mod.editor.statePlugins.map(plugin => {
             if (plugin[1]) {
-                return plugin[0](plugin[1](doc))
+                return (plugin[0] as (...args: any[]) => any)(plugin[1]())
             } else {
-                return plugin[0]()
+                return (plugin[0] as (...args: any[]) => any)()
             }
         })
 
@@ -781,18 +845,20 @@ export class ModCollabDoc {
         }
 
         // Set document in prosemirror
-        this.mod.editor.view.setProps({state: EditorState.create(stateConfig)})
+        this.mod.editor.view.setProps({
+            state: EditorState.create(stateConfig)
+        })
         this.mod.editor.view.setProps({nodeViews: {}}) // Needed to initialize nodeViews in plugins
         // Set initial confirmed doc
         this.mod.editor.docInfo.confirmedDoc = this.mod.editor.view.state.doc
 
         // Render footnotes based on main doc
-        this.mod.editor.mod.footnotes.fnEditor.renderAllFootnotes()
+        ;(this.mod.editor.mod.footnotes as any).fnEditor.renderAllFootnotes()
 
         //  Setup comment handling
-        this.mod.editor.mod.comments.store.reset()
-        this.mod.editor.mod.comments.store.loadComments(doc.comments)
-        this.mod.editor.mod.marginboxes.view(this.mod.editor.view)
+        ;(this.mod.editor.mod.comments as any).store.reset()
+        ;(this.mod.editor.mod.comments as any).store.loadComments(doc.comments)
+        ;(this.mod.editor.mod.marginboxes as any).view(this.mod.editor.view)
         if (locationHash && locationHash.length) {
             this.mod.editor.scrollIdIntoView(locationHash.slice(1))
         }
@@ -801,7 +867,9 @@ export class ModCollabDoc {
         // runs before loadDocument(), so the header still shows "Untitled"
         // from the empty initial document.
         if (this.mod.editor.menu.headerView) {
-            this.mod.editor.menu.headerView.update()
+            ;(
+                this.mod.editor.menu.headerView as {update: () => void}
+            ).update()
         }
         if (isInitialLoad) {
             this.initialDocLoaded = true
@@ -829,11 +897,11 @@ export class ModCollabDoc {
             const adjustWorker = makeWorker(
                 staticUrl("js/adjust_doc_to_template_worker.js")
             )
-            adjustWorker.onmessage = message => {
+            adjustWorker.onmessage = (message: MessageEvent) => {
                 if (message.data.type === "result") {
                     if (message.data.steps.length) {
                         const tr = this.mod.editor.view.state.tr
-                        message.data.steps.forEach(step =>
+                        message.data.steps.forEach((step: unknown) =>
                             tr.step(Step.fromJSON(this.mod.editor.schema, step))
                         )
                         tr.setMeta("remote", true)
@@ -850,16 +918,15 @@ export class ModCollabDoc {
                     this.setDocSettings()
                 }
             }
-            adjustWorker.onerror = error => console.error(error)
+            adjustWorker.onerror = (error: ErrorEvent) => console.error(error)
             const schemaExporter = new SchemaExport()
             adjustWorker.postMessage({
                 schemaSpec: JSON.parse(schemaExporter.init()),
                 doc: doc.content,
                 template: doc.template.content,
-                documentStyleSlugs:
-                    this.mod.editor.mod.documentTemplate.documentStyles.map(
-                        style => style.slug
-                    )
+                documentStyleSlugs: (
+                    this.mod.editor.mod.documentTemplate as any
+                ).documentStyles.map((style: {slug: string}) => style.slug)
             })
         } else {
             this.setDocSettings()
@@ -869,13 +936,13 @@ export class ModCollabDoc {
         }
     }
 
-    setDocSettings() {
+    setDocSettings(): void {
         // Set part specific settings
-        this.mod.editor.mod.documentTemplate.addDocPartSettings()
-        this.mod.editor.mod.documentTemplate.addCitationStylesMenuEntries()
+        ;(this.mod.editor.mod.documentTemplate as any).addDocPartSettings()
+        ;(this.mod.editor.mod.documentTemplate as any).addCitationStylesMenuEntries()
     }
 
-    sendToCollaborators() {
+    sendToCollaborators(): void {
         // Guard: WebSocket may not be initialized yet (e.g. during
         // loadDocument before the WS connector is created).
         if (!this.mod.editor.ws) {
@@ -905,20 +972,26 @@ export class ModCollabDoc {
                 return false
             } else if (
                 sendableSteps(this.mod.editor.view.state) ||
-                this.mod.editor.mod.comments.store.unsentEvents().length ||
-                this.mod.editor.mod.db.bibDB.unsentEvents().length ||
-                this.mod.editor.mod.db.imageDB.unsentEvents().length
+                (this.mod.editor.mod.comments as any).store
+                    .unsentEvents()
+                    .length ||
+                (this.mod.editor.mod.db!.bibDB as any).unsentEvents().length ||
+                (this.mod.editor.mod.db!.imageDB as any).unsentEvents().length
             ) {
                 this.disableDiffSending()
                 const stepsToSend = sendableSteps(this.mod.editor.view.state),
                     fnStepsToSend = sendableSteps(
-                        this.mod.editor.mod.footnotes.fnEditor.view.state
+                        (this.mod.editor.mod.footnotes as any).fnEditor.view
+                            .state
                     ),
-                    commentUpdates =
-                        this.mod.editor.mod.comments.store.unsentEvents(),
-                    bibliographyUpdates =
-                        this.mod.editor.mod.db.bibDB.unsentEvents(),
-                    imageUpdates = this.mod.editor.mod.db.imageDB.unsentEvents()
+                    commentUpdates = (this.mod.editor.mod.comments as any).store
+                        .unsentEvents(),
+                    bibliographyUpdates = (
+                        this.mod.editor.mod.db!.bibDB as any
+                    ).unsentEvents(),
+                    imageUpdates = (
+                        this.mod.editor.mod.db!.imageDB as any
+                    ).unsentEvents()
 
                 if (
                     !stepsToSend &&
@@ -931,7 +1004,7 @@ export class ModCollabDoc {
                     return
                 }
                 const rid = this.confirmStepsRequestCounter++,
-                    unconfirmedDiff = {
+                    unconfirmedDiff: Record<string, any> = {
                         type: "diff",
                         v: this.mod.editor.docInfo.version,
                         rid
@@ -947,28 +1020,30 @@ export class ModCollabDoc {
                     // update the title field instantly - important for the
                     // document overview page.
                     let newTitle = ""
-                    this.mod.editor.view.state.doc.firstChild.forEach(child => {
-                        if (
-                            !child.marks.find(
-                                mark => mark.type.name === "deletion"
-                            )
-                        ) {
-                            newTitle += child.textContent
-                        }
-                    })
-                    newTitle = newTitle.slice(0, 255)
-                    let oldTitle = ""
-                    this.mod.editor.docInfo.confirmedDoc.firstChild.forEach(
+                    this.mod.editor.view.state.doc.firstChild?.forEach(
                         child => {
                             if (
                                 !child.marks.find(
                                     mark => mark.type.name === "deletion"
                                 )
                             ) {
-                                oldTitle += child.textContent
+                                newTitle += child.textContent
                             }
                         }
                     )
+                    newTitle = newTitle.slice(0, 255)
+                    let oldTitle = ""
+                    ;(
+                        this.mod.editor.docInfo.confirmedDoc as Node
+                    ).firstChild?.forEach(child => {
+                        if (
+                            !child.marks.find(
+                                mark => mark.type.name === "deletion"
+                            )
+                        ) {
+                            oldTitle += child.textContent
+                        }
+                    })
                     oldTitle = oldTitle.slice(0, 255)
                     if (newTitle !== oldTitle) {
                         unconfirmedDiff["ti"] = newTitle
@@ -1012,7 +1087,9 @@ export class ModCollabDoc {
                 }
                 this.lastSelectionUpdateState = currentView.state
                 // Create a new caret as the current user
-                const selectionUpdate = getSelectionUpdate(currentView.state)
+                const selectionUpdate = getSelectionUpdate(
+                    currentView.state
+                ) as {anchor: number; head: number}
                 return {
                     type: "selection_change",
                     id: this.mod.editor.user.id,
@@ -1045,7 +1122,7 @@ export class ModCollabDoc {
      *
      * @private
      */
-    async _sendE2EEDiff() {
+    async _sendE2EEDiff(): Promise<void> {
         // Check if there's anything to send
         if (
             this.awaitingDiffResponse ||
@@ -1063,9 +1140,9 @@ export class ModCollabDoc {
 
         if (
             !sendableSteps(this.mod.editor.view.state) &&
-            !this.mod.editor.mod.comments.store.unsentEvents().length &&
-            !this.mod.editor.mod.db.bibDB.unsentEvents().length &&
-            !this.mod.editor.mod.db.imageDB.unsentEvents().length
+            !(this.mod.editor.mod.comments as any).store.unsentEvents().length &&
+            !(this.mod.editor.mod.db!.bibDB as any).unsentEvents().length &&
+            !(this.mod.editor.mod.db!.imageDB as any).unsentEvents().length
         ) {
             // No diff, check for selection update
             if (this.mod.editor.view) {
@@ -1078,11 +1155,14 @@ export class ModCollabDoc {
 
         const stepsToSend = sendableSteps(this.mod.editor.view.state),
             fnStepsToSend = sendableSteps(
-                this.mod.editor.mod.footnotes.fnEditor.view.state
+                (this.mod.editor.mod.footnotes as any).fnEditor.view.state
             ),
-            commentUpdates = this.mod.editor.mod.comments.store.unsentEvents(),
-            bibliographyUpdates = this.mod.editor.mod.db.bibDB.unsentEvents(),
-            imageUpdates = this.mod.editor.mod.db.imageDB.unsentEvents()
+            commentUpdates = (this.mod.editor.mod.comments as any).store
+                .unsentEvents(),
+            bibliographyUpdates = (this.mod.editor.mod.db!.bibDB as any)
+                .unsentEvents(),
+            imageUpdates = (this.mod.editor.mod.db!.imageDB as any)
+                .unsentEvents()
 
         if (
             !stepsToSend &&
@@ -1097,7 +1177,7 @@ export class ModCollabDoc {
         }
 
         const rid = this.confirmStepsRequestCounter++,
-            unconfirmedDiff = {
+            unconfirmedDiff: Record<string, any> = {
                 type: "diff",
                 v: this.mod.editor.docInfo.version,
                 rid
@@ -1106,24 +1186,30 @@ export class ModCollabDoc {
         unconfirmedDiff["cid"] = this.mod.editor.client_id
 
         // Collect the payload fields that need encryption
-        const encryptedPayload = {}
+        const encryptedPayload: Record<string, any> = {}
 
         if (stepsToSend) {
             encryptedPayload["ds"] = stepsToSend.steps.map(s => s.toJSON())
             // Track title changes for the document overview
             let newTitle = ""
-            this.mod.editor.view.state.doc.firstChild.forEach(child => {
+            this.mod.editor.view.state.doc.firstChild?.forEach(child => {
                 if (!child.marks.find(mark => mark.type.name === "deletion")) {
                     newTitle += child.textContent
                 }
             })
             newTitle = newTitle.slice(0, 255)
             let oldTitle = ""
-            this.mod.editor.docInfo.confirmedDoc.firstChild.forEach(child => {
-                if (!child.marks.find(mark => mark.type.name === "deletion")) {
-                    oldTitle += child.textContent
+            ;(this.mod.editor.docInfo.confirmedDoc as Node).firstChild?.forEach(
+                child => {
+                    if (
+                        !child.marks.find(
+                            mark => mark.type.name === "deletion"
+                        )
+                    ) {
+                        oldTitle += child.textContent
+                    }
                 }
-            })
+            )
             oldTitle = oldTitle.slice(0, 255)
             if (newTitle !== oldTitle) {
                 // For E2EE documents, the title is encrypted too.
@@ -1160,25 +1246,25 @@ export class ModCollabDoc {
 
         try {
             // Encrypt the payload fields as a single blob
-            const key = this.mod.editor.e2ee.key
+            const key = this.mod.editor.e2ee!.key as CryptoKey
             const ep = await E2EEEncryptor.encryptObject(encryptedPayload, key)
 
             // Build the wire-format diff: metadata in plaintext,
             // payload encrypted
-            const wireDiff = {
+            const wireDiff: Record<string, any> = {
                 type: "diff",
                 v: unconfirmedDiff.v,
                 rid: unconfirmedDiff.rid,
                 cid: unconfirmedDiff.cid,
                 ep, // encrypted payload
-                e2ee_salt: this.mod.editor.e2ee.encryptionSalt
+                e2ee_salt: this.mod.editor.e2ee!.encryptionSalt
             }
             if (unconfirmedDiff.footnoterender) {
                 wireDiff.footnoterender = true
             }
 
             // Send the encrypted diff
-            this.mod.editor.ws.send(() => wireDiff)
+            this.mod.editor.ws!.send(() => wireDiff)
         } catch (error) {
             console.error("E2EE: Failed to encrypt diff", error)
             // Re-enable diff sending so we can try again
@@ -1192,7 +1278,7 @@ export class ModCollabDoc {
      *
      * @private
      */
-    _sendE2EESelectionChange() {
+    _sendE2EESelectionChange(): void {
         if (
             !this.mod.editor.currentView ||
             !this.mod.editor.currentView.state
@@ -1207,8 +1293,11 @@ export class ModCollabDoc {
             return
         }
         this.lastSelectionUpdateState = currentView.state
-        const selectionUpdate = getSelectionUpdate(currentView.state)
-        this.mod.editor.ws.send(() => ({
+        const selectionUpdate = getSelectionUpdate(currentView.state) as {
+            anchor: number
+            head: number
+        }
+        this.mod.editor.ws!.send(() => ({
             type: "selection_change",
             id: this.mod.editor.user.id,
             v: this.mod.editor.docInfo.version,
@@ -1219,30 +1308,36 @@ export class ModCollabDoc {
         }))
     }
 
-    receiveSelectionChange(data) {
+    receiveSelectionChange(data: {
+        id: number
+        editor: string
+        session_id: string
+        anchor: number
+        head: number
+    }): void {
         const participant = this.mod.participants.find(
             par => par.id === data.id
         )
-        let tr, fnTr
+        let tr: Transaction | false, fnTr: Transaction | false
         if (!participant) {
             // participant is still unknown to us. Ignore
             return
         }
         if (data.editor === "footnotes") {
             fnTr = updateCollaboratorSelection(
-                this.mod.editor.mod.footnotes.fnEditor.view.state,
-                participant,
+                (this.mod.editor.mod.footnotes as any).fnEditor.view.state,
+                participant as {id: number; name: string},
                 data
             )
             tr = removeCollaboratorSelection(this.mod.editor.view.state, data)
         } else {
             tr = updateCollaboratorSelection(
                 this.mod.editor.view.state,
-                participant,
+                participant as {id: number; name: string},
                 data
             )
             fnTr = removeCollaboratorSelection(
-                this.mod.editor.mod.footnotes.fnEditor.view.state,
+                (this.mod.editor.mod.footnotes as any).fnEditor.view.state,
                 data
             )
         }
@@ -1250,11 +1345,11 @@ export class ModCollabDoc {
             this.mod.editor.view.dispatch(tr)
         }
         if (fnTr) {
-            this.mod.editor.mod.footnotes.fnEditor.view.dispatch(fnTr)
+            ;(this.mod.editor.mod.footnotes as any).fnEditor.view.dispatch(fnTr)
         }
     }
 
-    receiveDiff(data, serverFix = false) {
+    receiveDiff(data: DiffData, serverFix = false): void {
         // Check if this is an encrypted diff for an E2EE document.
         // Encrypted diffs have an "ep" (encrypted payload) field instead
         // of plaintext ds/fs/cu/bu/iu fields. We decrypt the payload
@@ -1270,19 +1365,19 @@ export class ModCollabDoc {
      * Process a diff (unencrypted or already decrypted).
      * @private
      */
-    _processDiff(data, serverFix = false) {
-        this.mod.editor.docInfo.version++
+    _processDiff(data: DiffData, serverFix = false): void {
+        this.mod.editor.docInfo.version!++
         if (data["bu"]) {
             // bibliography updates
-            this.mod.editor.mod.db.bibDB.receive(data["bu"])
+            (this.mod.editor.mod.db!.bibDB as any).receive(data["bu"])
         }
         if (data["iu"]) {
             // images updates
-            this.mod.editor.mod.db.imageDB.receive(data["iu"])
+            (this.mod.editor.mod.db!.imageDB as any).receive(data["iu"])
         }
         if (data["cu"]) {
             // comment updates
-            this.mod.editor.mod.comments.store.receive(data["cu"])
+            (this.mod.editor.mod.comments as any).store.receive(data["cu"])
         }
         if (data["ds"]) {
             // document steps
@@ -1290,20 +1385,20 @@ export class ModCollabDoc {
         }
         if (data["fs"]) {
             // footnote steps
-            this.mod.editor.mod.footnotes.fnEditor.applyDiffs(
+            ;(this.mod.editor.mod.footnotes as any).fnEditor.applyDiffs(
                 data["fs"],
                 data["cid"]
             )
         }
         if (data["footnoterender"]) {
             // re-render footnotes properly
-            this.mod.editor.mod.footnotes.fnEditor.renderAllFootnotes()
+            ;(this.mod.editor.mod.footnotes as any).fnEditor.renderAllFootnotes()
         }
 
         if (serverFix) {
             // Diff is a fix created by server due to missing diffs.
             if ("reject_request_id" in data) {
-                delete this.unconfirmedDiffs[data.reject_request_id]
+                delete this.unconfirmedDiffs[data.reject_request_id as number]
             }
             this.cancelCurrentlyCheckingVersion()
 
@@ -1322,21 +1417,24 @@ export class ModCollabDoc {
      * image updates. This method decrypts the payload and then processes
      * the diff using the standard _processDiff path.
      *
-     * @param {Object} data - The diff message with "ep" field
-     * @param {boolean} serverFix - Whether this is a server-generated fix
+     * @param data - The diff message with "ep" field
+     * @param serverFix - Whether this is a server-generated fix
      * @private
      */
-    async _receiveE2EEDiff(data, serverFix = false) {
+    async _receiveE2EEDiff(
+        data: DiffData,
+        serverFix = false
+    ): Promise<void> {
         try {
-            const key = this.mod.editor.e2ee.key
+            const key = this.mod.editor.e2ee!.key as CryptoKey
             const decryptedPayload = await E2EEEncryptor.decryptObject(
-                data["ep"],
+                data["ep"] as string,
                 key
             )
 
             // Merge the decrypted payload with the metadata fields
             // that were sent in plaintext (cid, rid, footnoterender)
-            const mergedData = {
+            const mergedData: DiffData = {
                 cid: data["cid"],
                 rid: data["rid"],
                 footnoterender: data["footnoterender"],
@@ -1351,30 +1449,30 @@ export class ModCollabDoc {
             // If decryption fails, we still need to increment the version
             // to stay in sync with the server, but we skip applying the
             // diff content.
-            this.mod.editor.docInfo.version++
+            this.mod.editor.docInfo.version!++
         }
     }
 
-    setConfirmedDoc(tr, stepsLength) {
+    setConfirmedDoc(tr: Transaction, stepsLength: number): void {
         // Find the latest version of the doc without any unconfirmed local changes
 
-        const rebased = tr.getMeta("rebased"),
+        const rebased = tr.getMeta("rebased") as number,
             docNumber = rebased + stepsLength
 
         this.mod.editor.docInfo.confirmedDoc =
             docNumber === tr.docs.length ? tr.doc : tr.docs[docNumber]
     }
 
-    confirmDiff(request_id) {
+    confirmDiff(request_id: number): void {
         const unconfirmedDiffs = this.unconfirmedDiffs[request_id]
         if (!unconfirmedDiffs) {
             return
         }
-        this.mod.editor.docInfo.version++
+        this.mod.editor.docInfo.version!++
 
         const sentSteps = unconfirmedDiffs["ds"] // document steps
         if (sentSteps) {
-            const ourIds = sentSteps.map(_step => this.mod.editor.client_id)
+            const ourIds = sentSteps.map((_step: any) => this.mod.editor.client_id)
             const tr = receiveTransaction(
                 this.mod.editor.view.state,
                 sentSteps,
@@ -1387,41 +1485,49 @@ export class ModCollabDoc {
         const sentFnSteps = unconfirmedDiffs["fs"] // footnote steps
         if (sentFnSteps) {
             const fnTr = receiveTransaction(
-                this.mod.editor.mod.footnotes.fnEditor.view.state,
+                (this.mod.editor.mod.footnotes as any).fnEditor.view.state,
                 sentFnSteps,
-                sentFnSteps.map(_step => this.mod.editor.client_id)
+                sentFnSteps.map((_step: any) => this.mod.editor.client_id)
             )
-            this.mod.editor.mod.footnotes.fnEditor.view.dispatch(fnTr)
+            ;(this.mod.editor.mod.footnotes as any).fnEditor.view.dispatch(fnTr)
         }
 
         const sentComments = unconfirmedDiffs["cu"] // comment updates
         if (sentComments) {
-            this.mod.editor.mod.comments.store.eventsSent(sentComments)
+            ;(this.mod.editor.mod.comments as any).store.eventsSent(
+                sentComments
+            )
         }
 
         const sentBibliographyUpdates = unconfirmedDiffs["bu"] // bibliography updates
         if (sentBibliographyUpdates) {
-            this.mod.editor.mod.db.bibDB.eventsSent(sentBibliographyUpdates)
+            ;(this.mod.editor.mod.db!.bibDB as any).eventsSent(
+                sentBibliographyUpdates
+            )
         }
 
         const sentImageUpdates = unconfirmedDiffs["iu"] // image updates
         if (sentImageUpdates) {
-            this.mod.editor.mod.db.imageDB.eventsSent(sentImageUpdates)
+            ;(this.mod.editor.mod.db!.imageDB as any).eventsSent(
+                sentImageUpdates
+            )
         }
 
         delete this.unconfirmedDiffs[request_id]
         this.enableDiffSending()
     }
 
-    rejectDiff(request_id) {
+    rejectDiff(request_id: number): void {
         delete this.unconfirmedDiffs[request_id]
         this.enableDiffSending()
     }
 
-    applyDiffs(diffs, cid) {
+    applyDiffs(diffs: unknown[], cid: string | number | undefined): void {
         this.receiving = true
         const steps = diffs.map(j => Step.fromJSON(this.mod.editor.schema, j))
-        const clientIds = diffs.map(_ => cid)
+        const clientIds = diffs
+            .map(_ => cid)
+            .filter((id): id is string | number => id !== undefined)
         const tr = receiveTransaction(
             this.mod.editor.view.state,
             steps,