@cuboapp/crdt 1.0.23 → 1.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuboapp/crdt",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "description": "CRDT for CUBO",
   "main": "src/index.ts",
   "repository": {

package/src/client/index.ts

@@ -1,19 +1,16 @@
 import { keyBy, pick, uuid } from '@cuboapp/utils'
 import { WsClientEvent } from '@cuboapp/ws'
-import { computed, reactive, shallowReactive } from 'vue'
+import { computed, reactive } from 'vue'
 import { applyAwarenessUpdate, Awareness, encodeAwarenessUpdate, removeAwarenessStates } from 'y-protocols/awareness'
-import { applyUpdate, Doc, encodeStateAsUpdate, encodeStateVector } from 'yjs'
+import { applyUpdate, Doc } from 'yjs'
 
 import { CUBO_CRDT_EVENT } from '../constants'
 import { CuboCrdtServerDocumentIncomingAction } from '../server'
-import {
-  CuboCrdtKey,
-  CuboCrdtListSyncData,
-  CuboCrdtSubscriptionStatus
-} from '../types'
+import { CuboCrdtKey, CuboCrdtListSyncData, CuboCrdtSubscriptionStatus } from '../types'
 
 import { AsyncSerialQueue } from './queue'
 import {
+  CuboCrdtClientDoc,
   CuboCrdtClientDocOrigin,
   CuboCrdtClientDocUpdateOptions,
   CuboCrdtClientList,
@@ -28,6 +25,7 @@ export * from './types'
 
 export class CuboCrdtClient<M> {
   public store: CuboCrdtClientStore<M> = {}
+  public docs = new Map<string, CuboCrdtClientDoc>()
 
   private listeners: Map<string, Map<string, (ctx: CuboCrdtClientSubscribeEvent) => void | Promise<void>>> = new Map()
 
@@ -234,8 +232,7 @@ export class CuboCrdtClient<M> {
 
       this.store[storeKey] = {
         state,
-        docs: shallowReactive(new Map()),
-        awarenesses: shallowReactive(new Map())
+        awarenesses: new Map()
       }
     }
 
@@ -260,6 +257,7 @@ export class CuboCrdtClient<M> {
       }
 
       // подписываемся на фронте
+      // console.log('subscribe', opts)
       this.listeners.get(entity)?.set(subscribe_id, async (ctx) => {
         await this.onIncomingUpdate(ctx, {
           subscribe_id,
@@ -330,13 +328,11 @@ export class CuboCrdtClient<M> {
 
       // отписываемся на бэке
       if (this.ws.connected) {
-        void this.ws
-          .request({ method: CUBO_CRDT_EVENT.UNSUBSCRIBE, data: { subscribe_id } })
-          .catch((e) => {
-            if (this.debug) {
-              console.warn('[CRDT] unsubscribe request failed (socket down)', subscribe_id, e)
-            }
-          })
+        void this.ws.request({ method: CUBO_CRDT_EVENT.UNSUBSCRIBE, data: { subscribe_id } }).catch((e) => {
+          if (this.debug) {
+            console.warn('[CRDT] unsubscribe request failed (socket down)', subscribe_id, e)
+          }
+        })
       }
 
       // отписываемся на фронте
@@ -358,8 +354,18 @@ export class CuboCrdtClient<M> {
             a.destroy()
           })
           item.awarenesses?.clear()
-          item.docs?.forEach((d) => d.destroy())
-          item.docs?.clear()
+
+          item.state.rows?.map((row) => {
+            const doc = this.docs.get(`${entity}:${(row as any).id}`)
+            if (doc) {
+              doc.subscribes.delete(subscribe_id)
+
+              if (doc.subscribes?.size === 0) {
+                doc.doc.destroy()
+                this.docs.delete(`${entity}:${(row as any).id}`)
+              }
+            }
+          })
         }
 
         this.store[storeKey] = undefined
@@ -383,7 +389,6 @@ export class CuboCrdtClient<M> {
       subscribe,
       upgrade,
       unsubscribe,
-      docs: computed(() => this.store[storeKey]?.docs),
       awarenesses: opts?.awareness ? computed(() => this.store[storeKey]?.awarenesses) : undefined,
       subscribed: () => computed(() => this.store[storeKey]?.state.subscribed || false),
       loading: () => computed(() => this.store[storeKey]?.state.loading || false),
@@ -404,30 +409,18 @@ export class CuboCrdtClient<M> {
   ): CuboCrdtClientRow<T> {
     // console.log('store key', opts?.storeKey ?? `${entity}:${id}`)
 
-    const {
-      subscribe_id,
-      storeKey,
-      docs,
-      awarenesses,
-      subscribe,
-      upgrade,
-      unsubscribe,
-      subscribed,
-      loading,
-      ready,
-      status,
-      error
-    } = this.useList(entity, {
-      ...opts,
-      filters: opts?.filters ?? { id },
-      storeKey: opts?.storeKey ?? `${entity}:${id}`
-    })
+    const { subscribe_id, storeKey, awarenesses, subscribe, upgrade, unsubscribe, subscribed, loading, ready, status, error } =
+      this.useList(entity, {
+        ...opts,
+        filters: opts?.filters ?? { id },
+        storeKey: opts?.storeKey ?? `${entity}:${id}`
+      })
 
     return {
       subscribe_id,
       storeKey,
-      doc: computed(() => docs.value?.get(id)),
-      awareness: opts?.awareness ? computed(() => awarenesses?.value?.get(id)) : undefined,
+      doc: this.docs.get(`${entity}:${id}`)?.doc,
+      awareness: computed(() => awarenesses?.value?.get(id)),
       subscribe,
       upgrade,
       unsubscribe,
@@ -450,92 +443,48 @@ export class CuboCrdtClient<M> {
     dto: K extends Extract<keyof M, string> ? Partial<M[K]> : object,
     opts?: CuboCrdtClientDocOrigin
   ) {
-    // Если строка открыта через useRow, mutating API работает только с её
-    // каноническим документом. Списки могут содержать тот же id, но не должны
-    // становиться источником записи для карточки.
-    const rowStore = this.store[`${entity}:${entity_id}`]
-    const store = rowStore?.state.status === 'ready' && rowStore.docs.has(entity_id)
-      ? rowStore
-      : [...this.subscriptions.values()]
-          .filter((subscription) => subscription.entity === entity)
-          .map((subscription) => this.store[subscription.storeKey])
-          .find((candidate) => candidate?.docs.has(entity_id) && candidate.state.status === 'ready')
-    const document = store?.docs.get(entity_id)
-
-    if (!store || !document) {
-      return false
-    }
-
-    const map = document.getMap()
-    const toUpdate = Object.fromEntries(
-      Object.entries(dto).filter(([key, value]) => map.get(key) !== value)
-    )
-
-    if (!Object.keys(toUpdate).length) {
-      // Состояние уже совпадает (например, update успел прийти из другой
-      // вкладки). Это успешный no-op, а не ошибка изменения.
-      return true
-    }
-
-    const origin: CuboCrdtClientDocOrigin = {
-      store: opts?.store ?? true,
-      expose: opts?.expose ?? 'other',
-      keys: opts?.keys ?? Object.keys(toUpdate),
-      // update() сам отправляет ровно один пакет ниже. Общий listener остаётся
-      // для изменений, которые создаются напрямую сторонними Yjs-binding'ами.
-      react: false
-    }
-
-    const stateVector = encodeStateVector(document)
-
-    // Одна сущность может присутствовать в нескольких подписках с разными
-    // storeKey. Мутацию отправляем только из одного документа: остальные
-    // подписки получат подтверждённый update через обычную CRDT-рассылку.
-    document.transact(() => {
-      Object.entries(toUpdate).forEach(([key, value]) => {
-        map.set(key, value)
-      })
-    }, origin)
-
-    const update = encodeStateAsUpdate(document, stateVector)
-    const receipt = this.ws
-      .request(
-        {
-          method: CUBO_CRDT_EVENT.EVENT,
-          data: {
-            action: 'update',
-            entity,
-            entity_id,
-            data: Array.from(update),
-            origin: {
-              ...pick(origin, ['store', 'keys', 'expose']),
-              subscribe_id: [...this.subscriptions.entries()]
-                .find(([, subscription]) => this.store[subscription.storeKey] === store)?.[0]
-            }
-          }
-        },
-        { wait: true, timeout: 10_000 }
-      )
-      .then(() => true)
-      .catch((error) => {
-        console.error('[CRDT] update request failed', error)
-        return false
-      })
+    const storeKey = `${entity}:${entity_id}`
+
+    const cardRow = this.store[storeKey]?.state.rows?.[0]
+    const listRow = this.store[entity]?.state?.rows.find((r: any) => r.id === entity_id)
+    const doc = this.docs.get(storeKey)
+
+    // обновляем документ
+    if (doc) {
+      const map = doc.doc.getMap()
+
+      // "или" - потому что они синхронизированы (без разницы какой брать)
+      const row = (cardRow || listRow) as any
+      const toUpdate = Object.fromEntries(Object.entries(dto).filter(([key, value]) => row[key] !== value))
+
+      if (Object.keys(toUpdate).length) {
+        const origin: CuboCrdtClientDocOrigin = {
+          store: opts?.store ?? true,
+          expose: opts?.expose ?? 'other',
+          keys: opts?.keys ?? Object.keys(toUpdate),
+          react: true // отправляем на бэк
+        }
 
-    // Этот документ является каноническим локальным состоянием строки. Обновляем
-    // его реактивную строку сразу, а другие подписки получат тот же Yjs-update
-    // через серверную рассылку.
-    this.applyRowJson(`${entity}:${entity_id}`, entity_id, document)
+        doc.doc.transact(() => {
+          Object.entries(toUpdate).forEach(([key, value]) => {
+            map.set(key, value)
+          })
+        }, origin)
+      }
+    }
 
-    const row = store.state.rows.find((item: any) => Number(item.id) === Number(entity_id))
+    // обновляем реактивку
+    for (const row of [cardRow, listRow]) {
+      if (row) {
+        const toUpdate = Object.fromEntries(Object.entries(dto).filter(([key, value]) => row[key as keyof typeof row] !== value))
 
-    if (row) {
-      Object.entries(toUpdate).forEach(([key, value]) => {
-        row[key] = value
-      })
+        if (Object.keys(toUpdate).length) {
+          Object.entries(toUpdate).forEach(([key, value]) => {
+            row[key as keyof typeof row] = value
+          })
+        }
+      }
     }
-
-    return receipt
   }
 
   public upgrade(subscribe_id: string, filters?: Record<string, any>) {
@@ -595,54 +544,13 @@ export class CuboCrdtClient<M> {
     }
   }
 
-  private ensureDocumentAwareness(
-    ctx: CuboCrdtClientSubscribeEvent,
-    opts: CuboCrdtClientDocUpdateOptions,
-    doc: Doc,
-    entity_id: number
-  ) {
-    if (!opts.awareness) {
-      return
-    }
-
-    let awareness = this.store[opts.storeKey]?.awarenesses.get(entity_id)
-
-    if (awareness) {
-      return
-    }
-
-    awareness = new Awareness(doc)
-
-    awareness.on('update', ({ added, updated, removed }, origin) => {
-      if (origin === 'remote') {
-        return
-      }
-
-      const changed = added.concat(updated).concat(removed)
-      const update = encodeAwarenessUpdate(awareness!, changed)
-
-      this.ws.request({
-        method: CUBO_CRDT_EVENT.EVENT,
-        data: {
-          action: 'awareness',
-          entity: ctx.entity,
-          entity_id,
-          data: Array.from(update),
-          origin: { expose: 'other', subscribe_id: opts.subscribe_id }
-        }
-      })
-    })
-
-    this.store[opts.storeKey]?.awarenesses.set(entity_id, awareness)
-  }
-
   private async onDocumentCreate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
     const entity_id = ctx.entity_id
     if (entity_id === undefined) {
       return
     }
 
-    const existing = this.store[opts.storeKey]?.docs.get(entity_id)
+    const existing = this.docs.get(`${ctx.entity}:${ctx.entity_id}`)
     if (existing) {
       // документ уже есть локально (типичный кейс — повторный SUBSCRIBE после реконнекта).
       // вместо игнорирования вмёрживаем входящее состояние в существующий yjs-документ
@@ -651,13 +559,12 @@ export class CuboCrdtClient<M> {
         console.log('[CRDT] onDocumentCreate: doc already exists, merging state', { ctx, opts })
       }
 
-      applyUpdate(existing, new Uint8Array(ctx.data as any), { react: false })
-      this.applyRowJson(opts.storeKey, entity_id, existing)
-      this.ensureDocumentAwareness(ctx, opts, existing, entity_id)
+      applyUpdate(existing.doc, new Uint8Array(ctx.data as any), { react: false })
+      this.applyRowJson(opts.storeKey, entity_id, existing.doc)
       return
     }
 
-    const doc = new Doc()
+    const yjsDoc = new Doc()
 
     const update = new Uint8Array(ctx.data as any)
 
@@ -668,10 +575,10 @@ export class CuboCrdtClient<M> {
       }
     }
 
-    applyUpdate(doc, update, { react: false })
+    applyUpdate(yjsDoc, update, { react: false })
 
     // подписываемся на обновления документа
-    doc.on('update', (update, origin: CuboCrdtClientDocOrigin) => {
+    yjsDoc.on('update', (update, origin: CuboCrdtClientDocOrigin) => {
       // react = false, если это апдейт с бэка
       if (origin?.react !== false) {
         const data: CuboCrdtServerDocumentIncomingAction = {
@@ -689,18 +596,19 @@ export class CuboCrdtClient<M> {
           }
         }
 
-        void this.ws.request({
+        this.ws.request({
           method: CUBO_CRDT_EVENT.EVENT,
           data
-        }).catch((error) => console.error('[CRDT] update request failed', error))
+        })
       }
     })
 
     // добавляем документ в хранилище документов
-    this.store[opts.storeKey]?.docs.set(entity_id, doc)
+    const doc: CuboCrdtClientDoc = { doc: yjsDoc, subscribes: new Set() }
+    this.docs.set(`${ctx.entity}:${ctx.entity_id}`, doc)
 
     // добавляем документ в реактивное хранилище
-    const json: any = doc.getMap().toJSON()
+    const json: any = yjsDoc.getMap().toJSON()
     const index = this.store[opts.storeKey]?.state.rows.findIndex((r: any) => r.id === entity_id)
     if (index !== undefined && index >= 0) {
       if (this.debug) {
@@ -713,10 +621,41 @@ export class CuboCrdtClient<M> {
     }
 
     if (opts?.onAfterCreate) {
-      await opts.onAfterCreate(doc, update, ctx, opts)
+      await opts.onAfterCreate(yjsDoc, update, ctx, opts)
     }
 
-    this.ensureDocumentAwareness(ctx, opts, doc, entity_id)
+    if (opts?.awareness) {
+      let awareness = this.store[opts.storeKey]?.awarenesses.get(entity_id)
+
+      if (!awareness) {
+        awareness = new Awareness(yjsDoc)
+
+        awareness.on('update', ({ added, updated, removed }, origin) => {
+          // console.log('[CRDT] awarness update', origin)
+
+          if (origin === 'remote') {
+            return
+          }
+
+          const changed = added.concat(updated).concat(removed)
+          const update = encodeAwarenessUpdate(awareness, changed)
+
+          this.ws.request({
+            method: CUBO_CRDT_EVENT.EVENT,
+            data: {
+              action: 'awareness',
+              entity: ctx.entity,
+              entity_id,
+              data: Array.from(update),
+              // 'other' — не шлём свой же курсор обратно исходной подписке
+              origin: { expose: 'other', subscribe_id: opts.subscribe_id }
+            }
+          })
+        })
+
+        this.store[opts.storeKey]?.awarenesses.set(entity_id, awareness)
+      }
+    }
   }
 
   private async onDocumentUpdate(ctx: CuboCrdtClientSubscribeEvent, opts: CuboCrdtClientDocUpdateOptions) {
@@ -725,7 +664,7 @@ export class CuboCrdtClient<M> {
       return
     }
 
-    const doc = this.store[opts.storeKey]?.docs.get(entity_id)
+    const doc = this.docs.get(`${ctx.entity}:${ctx.entity_id}`)
     if (!doc) {
       console.warn('[CRDT] onDocumentUpdate: doc not exists', { ctx, opts })
       return
@@ -734,20 +673,20 @@ export class CuboCrdtClient<M> {
     const update = new Uint8Array(ctx.data as any)
 
     if (opts?.onBeforeUpdate) {
-      const result = await opts.onBeforeUpdate(doc, update, ctx, opts)
+      const result = await opts.onBeforeUpdate(doc.doc, update, ctx, opts)
       if (!result) {
         return
       }
     }
 
     // обновляем yjs-ный документ
-    applyUpdate(doc, update, { react: false })
+    applyUpdate(doc.doc, update, { react: false })
 
     // обновляем документ в реактивном хранилище
-    this.applyRowJson(opts.storeKey, entity_id, doc)
+    this.applyRowJson(opts.storeKey, entity_id, doc.doc)
 
     if (opts?.onAfterUpdate) {
-      await opts.onAfterUpdate(doc, update, ctx, opts)
+      await opts.onAfterUpdate(doc.doc, update, ctx, opts)
     }
   }
 
@@ -757,23 +696,21 @@ export class CuboCrdtClient<M> {
       return
     }
 
-    const doc = this.store[opts.storeKey]?.docs.get(entity_id)
+    const doc = this.docs.get(`${ctx.entity}:${ctx.entity_id}`)
     if (!doc) {
       console.warn('[CRDT] onDocumentDelete: doc not exists', { ctx, opts })
       return
     }
 
     if (opts?.onBeforeDelete) {
-      const result = await opts.onBeforeDelete(doc, ctx, opts)
+      const result = await opts.onBeforeDelete(doc.doc, ctx, opts)
       if (!result) {
         return
       }
     }
 
-    // console.log('onDocumentDelete', ctx, opts)
-
-    doc.destroy()
-    this.store[opts.storeKey]?.docs.delete(entity_id)
+    doc.doc.destroy()
+    this.docs.delete(`${ctx.entity}:${ctx.entity_id}`)
 
     const index = this.store[opts.storeKey]?.state.rows.findIndex((r: any) => r.id === entity_id)
     if (index !== undefined && index >= 0) {
@@ -793,7 +730,7 @@ export class CuboCrdtClient<M> {
     }
 
     if (opts?.onAfterDelete) {
-      await opts.onAfterDelete(doc, ctx, opts)
+      await opts.onAfterDelete(doc.doc, ctx, opts)
     }
   }
 
@@ -828,7 +765,9 @@ export class CuboCrdtClient<M> {
     const ids = data.ids.filter((id) => Number.isFinite(id))
     const idsSet = new Set(ids)
 
-    for (const [entity_id, doc] of item.docs) {
+    for (const row of item.state.rows) {
+      const entity_id = (row as any).id
+
       if (idsSet.has(entity_id)) {
         continue
       }
@@ -841,14 +780,15 @@ export class CuboCrdtClient<M> {
         item.awarenesses.delete(entity_id)
       }
 
-      doc.destroy()
-      item.docs.delete(entity_id)
+      const doc = this.docs.get(`${ctx.entity}:${entity_id}`)
+      if (doc) {
+        doc.doc.destroy()
+        this.docs.delete(`${ctx.entity}:${entity_id}`)
+      }
     }
 
     const rowsById = new Map(item.state.rows.map((row: any) => [Number(row.id), row]))
-    const orderedRows = ids
-      .map((id) => rowsById.get(id))
-      .filter((row) => row !== undefined)
+    const orderedRows = ids.map((id) => rowsById.get(id)).filter((row) => row !== undefined)
 
     item.state.rows.splice(0, item.state.rows.length, ...orderedRows)
     item.state.totals = data.totals || {}

package/src/client/types/document.ts

@@ -1,8 +1,14 @@
+import { Doc } from 'yjs'
 import { CuboCrdtClientUseOptions } from '..'
 import { CuboCrdtExposeStrategy } from '../../types'
 
 import { CuboCrdtClientBaseOptions } from './utils'
 
+export type CuboCrdtClientDoc = {
+  doc: Doc
+  subscribes: Set<string>
+}
+
 export type CuboCrdtClientDocOrigin = {
   // сохранять ли на бэке в дебаунсе
   store?: boolean

package/src/client/types/index.ts

@@ -1,15 +1,10 @@
 import { type WsClient } from '@cuboapp/ws'
 import { ComputedRef } from 'vue'
 import { Awareness } from 'y-protocols/awareness'
-import { type Doc } from 'yjs'
 
-import {
-  CuboCrdtAction,
-  CuboCrdtListSyncData,
-  CuboCrdtListTotals,
-  CuboCrdtSubscriptionStatus
-} from '../../types'
+import { CuboCrdtAction, CuboCrdtListSyncData, CuboCrdtListTotals, CuboCrdtSubscriptionStatus } from '../../types'
 
+import { Doc } from 'yjs'
 import { CuboCrdtClientBaseOptions } from './utils'
 
 export * from './document'
@@ -45,7 +40,6 @@ export type CuboCrdtClientSubscribeEvent = {
 export type CuboCrdtClientList<T> = {
   subscribe_id: string
   storeKey: string
-  docs: ComputedRef<Map<number, Doc> | undefined>
   awarenesses?: ComputedRef<Map<number, Awareness> | undefined>
   subscribe: (filters?: any) => void
   upgrade: (filters?: any) => void
@@ -64,7 +58,7 @@ export type CuboCrdtClientList<T> = {
 export type CuboCrdtClientRow<T> = {
   subscribe_id: string
   storeKey: string
-  doc: ComputedRef<Doc | undefined>
+  doc: Doc
   awareness?: ComputedRef<Awareness | undefined>
   subscribe: () => void
   upgrade: (filters?: any) => void

package/src/client/types/store.ts

@@ -1,12 +1,7 @@
 import { Reactive } from 'vue'
-import { Doc } from 'yjs'
 import { Awareness } from 'y-protocols/awareness'
 
-import {
-  CuboCrdtKey,
-  CuboCrdtListTotals,
-  CuboCrdtSubscriptionStatus
-} from '../../types'
+import { CuboCrdtKey, CuboCrdtListTotals, CuboCrdtSubscriptionStatus } from '../../types'
 
 export type CuboCrdtClientStoreItem<T> = {
   state: Reactive<{
@@ -18,7 +13,6 @@ export type CuboCrdtClientStoreItem<T> = {
     totals: CuboCrdtListTotals
     revision: number
   }>
-  docs: Map<number, Doc>
   awarenesses: Map<number, Awareness>
 }
 export type CuboCrdtClientStore<M> = Partial<{

package/src/server/document/index.ts

@@ -1,23 +1,12 @@
-import { cloneDeep, pick } from '@cuboapp/utils'
+import { cloneDeep, debounce, pick } from '@cuboapp/utils'
 import { applyUpdate, Doc, encodeStateAsUpdate } from 'yjs'
 import { Awareness, encodeAwarenessUpdate } from 'y-protocols/awareness'
 
-import {
-  CuboCrdtServerDocumentOptions,
-  CuboCrdtServerDocumentOrigin,
-  CuboCrdtServerDocumentPendingStore
-} from '../types'
-import { getCrdtStoreChangeKey } from '../utils'
-
-const STORE_DEBOUNCE_MS = 300
+import { CuboCrdtServerDocumentOptions, CuboCrdtServerDocumentOrigin } from '../types'
 
 export class CuboCrdtServerDocument {
   private ydoc: Doc
   private persistedState: object = {}
-  private observedState: object = {}
-  private storeQueue?: Promise<void>
-  private pendingStore?: CuboCrdtServerDocumentPendingStore
-  private storeTimeout?: ReturnType<typeof setTimeout>
   public awareness: Awareness
   public awarenessBySubscribe = new Map<string, Set<number>>()
 
@@ -30,11 +19,31 @@ export class CuboCrdtServerDocument {
     })
 
     if (opts.awareness) {
-      this.enableAwareness()
+      this.awareness = new Awareness(this.ydoc)
+      this.awareness.setLocalState(null)
+
+      this.awareness.on('update', ({ added, updated, removed }, origin: CuboCrdtServerDocumentOrigin) => {
+        const subId = origin?.subscribe_id
+
+        if (subId) {
+          let set = this.awarenessBySubscribe.get(subId)
+          if (!set) {
+            set = new Set()
+            this.awarenessBySubscribe.set(subId, set)
+          }
+
+          added.concat(updated).forEach((id) => set!.add(id))
+          removed.forEach((id) => set!.delete(id))
+        }
+
+        const changed = added.concat(updated).concat(removed)
+        const update = encodeAwarenessUpdate(this.awareness!, changed)
+
+        this.opts?.onAwarenessUpdate?.(update, origin)
+      })
     }
 
     this.persistedState = cloneDeep(opts.initialState ?? {})
-    this.observedState = cloneDeep(opts.initialState ?? {})
 
     // записываем исходное состояние
     this.write(opts.initialState ?? {})
@@ -49,8 +58,7 @@ export class CuboCrdtServerDocument {
       this.opts?.onUpdate?.(data, origin)
       // }
 
-      // Состояние отслеживается синхронно с Y.Doc. Для клиентских изменений
-      // debounceStore сам обновит observedState после вычисления leaf-diff.
+      // если нужно сохранять стейт документа - вызываем store по дебаунсу
       if (origin?.store) {
         const row = this.getJson()
         const body = pick(row, origin.keys ?? Object.keys(row))
@@ -60,41 +68,10 @@ export class CuboCrdtServerDocument {
             console.error('[CRDT] store document', this.name, error)
           })
         }
-      } else {
-        this.observedState = cloneDeep(this.getJson())
       }
     })
   }
 
-  public enableAwareness() {
-    if (this.awareness) {
-      return
-    }
-
-    this.awareness = new Awareness(this.ydoc)
-    this.awareness.setLocalState(null)
-
-    this.awareness.on('update', ({ added, updated, removed }, origin: CuboCrdtServerDocumentOrigin) => {
-      const subId = origin?.subscribe_id
-
-      if (subId) {
-        let set = this.awarenessBySubscribe.get(subId)
-        if (!set) {
-          set = new Set()
-          this.awarenessBySubscribe.set(subId, set)
-        }
-
-        added.concat(updated).forEach((id) => set!.add(id))
-        removed.forEach((id) => set!.delete(id))
-      }
-
-      const changed = added.concat(updated).concat(removed)
-      const update = encodeAwarenessUpdate(this.awareness!, changed)
-
-      this.opts?.onAwarenessUpdate?.(update, origin)
-    })
-  }
-
   public get name() {
     return this.opts.name
   }
@@ -156,138 +133,13 @@ export class CuboCrdtServerDocument {
     this.ydoc.destroy()
   }
 
-  /**
-   * Немедленно передаёт trailing-пакет в очередь и ждёт все уже принятые
-   * сохранения документа. Используется перед вытеснением Y.Doc из серверного
-   * кэша, чтобы refresh последнего клиента не потерял его update.
-   */
-  public async flushStoreQueue() {
-    this.flushPendingStore()
-
-    while (this.storeQueue) {
-      await this.storeQueue
-      this.flushPendingStore()
-    }
-  }
-
-  /** Есть ли принятое клиентское изменение в debounce или очереди записи. */
-  public hasPendingStore() {
-    return !!this.pendingStore || !!this.storeQueue
-  }
-
-  public store(body: object, origin: CuboCrdtServerDocumentOrigin, row = this.getJson()) {
-    const queuedBody = cloneDeep(body)
-    const queuedRow = cloneDeep(row)
-    // debounce ограничивает частоту вызовов, но не сериализует async store.
-    // Без очереди следующий PATCH мог завершиться раньше предыдущего и затем
-    // быть затёрт старым полным снимком составного поля (например case.extra).
-    const previous = this.storeQueue?.catch(() => undefined) ?? Promise.resolve()
-    const current = previous
-      .then(async () => {
-        const previousRow = this.getPersistedState()
-
-        await this.opts?.onStore?.(queuedBody, origin, {
-          previousRow,
-          row: queuedRow
-        })
-        this.setPersistedState(queuedRow)
-      })
-
-    const queued = current.finally(() => {
-      // Если после этой записи не добавилась следующая, очередь опустела.
-      // Сама Promise-цепочка является источником истины — отдельный счётчик не нужен.
-      if (this.storeQueue === queued) {
-        this.storeQueue = undefined
-      }
-    })
-    this.storeQueue = queued
-
-    return queued
-  }
-
-  /**
-   * Схлопывает только соседние изменения одного origin и одного набора
-   * leaf-путей. Смена пользователя или поля немедленно фиксирует предыдущий
-   * пакет, сохраняя фактический порядок collaborative-обновлений.
-   */
-  public debounceStore(body: object, origin: CuboCrdtServerDocumentOrigin) {
-    const row = cloneDeep(this.getJson())
-    const bodyKeys = Object.keys(body)
-    const previousBody = pick(this.observedState, bodyKeys)
-    const changeKey = getCrdtStoreChangeKey(previousBody, body)
-    const originKey = `${origin.client_id || ''}:${origin.subscribe_id || ''}`
-
-    this.observedState = cloneDeep(row)
-
-    if (!changeKey) {
-      return Promise.resolve()
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      const sameBatch = this.pendingStore?.originKey === originKey &&
-        this.pendingStore.changeKey === changeKey
-
-      if (this.pendingStore && !sameBatch) {
-        this.flushPendingStore()
-      }
+  public async store(body: object, origin: CuboCrdtServerDocumentOrigin) {
+    const previousRow = this.getPersistedState()
+    const row = this.getJson()
 
-      if (!this.pendingStore) {
-        this.pendingStore = {
-          body: cloneDeep(body),
-          changeKey,
-          origin: cloneDeep(origin),
-          originKey,
-          row,
-          waiters: []
-        }
-      } else {
-        const keys = new Set([
-          ...(this.pendingStore.origin.keys || []),
-          ...(origin.keys || [])
-        ])
-
-        this.pendingStore.body = {
-          ...this.pendingStore.body,
-          ...cloneDeep(body)
-        }
-        this.pendingStore.origin = {
-          ...cloneDeep(origin),
-          keys: [...keys]
-        }
-        this.pendingStore.row = row
-      }
-
-      this.pendingStore.waiters.push({ resolve, reject })
-      this.schedulePendingStore()
-    })
+    await this.opts?.onStore?.(body, origin, { previousRow, row })
+    this.setPersistedState(row)
   }
 
-  /** Перезапускает trailing debounce для текущего однородного пакета. */
-  private schedulePendingStore() {
-    if (this.storeTimeout) {
-      clearTimeout(this.storeTimeout)
-    }
-
-    this.storeTimeout = setTimeout(() => this.flushPendingStore(), STORE_DEBOUNCE_MS)
-  }
-
-  /** Передаёт накопленный пакет в общую последовательную очередь записи. */
-  private flushPendingStore() {
-    if (!this.pendingStore) {
-      return
-    }
-
-    if (this.storeTimeout) {
-      clearTimeout(this.storeTimeout)
-      this.storeTimeout = undefined
-    }
-
-    const pending = this.pendingStore
-    this.pendingStore = undefined
-
-    this.store(pending.body, pending.origin, pending.row).then(
-      () => pending.waiters.forEach(({ resolve }) => resolve()),
-      (error) => pending.waiters.forEach(({ reject }) => reject(error))
-    )
-  }
+  public debounceStore = debounce(this.store.bind(this), 300)
 }

package/src/server/index.ts

@@ -4,11 +4,7 @@ import { applyAwarenessUpdate, encodeAwarenessUpdate, removeAwarenessStates } fr
 
 import { CUBO_CRDT_EVENT } from '../constants'
 import { CuboCrdtAction, CuboCrdtListSyncData, CuboCrdtMutation } from '../types'
-import {
-  areCrdtListIdsEqual,
-  areCrdtListTotalsEqual,
-  checkRowIsSutable
-} from '../utils'
+import { areCrdtListIdsEqual, areCrdtListTotalsEqual, checkRowIsSutable } from '../utils'
 
 import { CuboCrdtClientDocOrigin } from '../client'
 import { CuboCrdtServerDocument } from './document'
@@ -40,7 +36,6 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
   private subscribeGenerations = new Map<string, number>()
 
   private documents = new Map<string, CuboCrdtServerDocument>()
-  private documentEvictions = new Map<string, object>()
   private subscribesByDocument = new Map<string, Set<string>>()
   // обратный индекс: подписка -> имена документов, к которым она привязана.
   // Нужен, чтобы отписка/очистка не сканировала ВСЕ документы сервера (O(subs x docs)).
@@ -112,53 +107,34 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
       this.cleanSubscribe(subscribe_id)
     })
 
-    this.ws.registerHandler(CUBO_CRDT_EVENT.EVENT, async ({ client, message }) => {
+    this.ws.registerHandler(CUBO_CRDT_EVENT.EVENT, async ({ message }) => {
       let data = message.data as any
       if (!Array.isArray(data)) {
         data = [data]
       }
 
       if (this.debug) {
-        console.log('[CRDT] incoming event', data.map((row: any) => ({
-          action: row.action,
-          entity: row.entity,
-          entity_id: row.entity_id,
-          keys: row.origin?.keys,
-          subscribe_id: row.origin?.subscribe_id
-        })))
+        console.log('[CRDT] incoming event', data)
       }
 
       for (const row of data) {
         const update = new Uint8Array(row.data)
-        const origin: CuboCrdtServerDocumentOrigin = {
-          ...(row.origin || {}),
-          client_id: client.id,
-          store_context: {
-            client_id: client.id,
-            auth: cloneDeep(client.auth)
-          }
-        }
-        const action = { ...row, origin }
 
         switch (row.action) {
           case 'create':
-            this.onDocumentExternalCreate(update, action)
+            this.onDocumentExternalCreate(update, row)
             break
           case 'update':
-            this.onDocumentExternalUpdate(update, action)
+            this.onDocumentExternalUpdate(update, row)
             break
           case 'delete':
-            this.onDocumentExternalDelete(update, action)
+            this.onDocumentExternalDelete(update, row)
             break
           case 'awareness':
-            this.onAwarenessExternalUpdate(update, action)
+            this.onAwarenessExternalUpdate(update, row)
             break
         }
       }
-
-      // Ответ означает только «update применён к живому серверному Y.Doc».
-      // Debounce и последовательная запись в БД продолжаются независимо.
-      return { accepted: true }
     })
 
     this.ws.registerHttpHandler('GET', '/stats', () => {
@@ -194,7 +170,6 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     this.subscribeRefreshStates.forEach((state) => clearTimeout(state.timer))
     this.subscribeRefreshStates.clear()
     this.subscribeGenerations.clear()
-    this.documentEvictions.clear()
 
     this.subscribes.forEach((sub) => this.ws.deleteHandler(sub.id))
   }
@@ -307,10 +282,6 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
 
   // привязываем подписку к документу (в обоих индексах)
   private linkSubscribeToDocument(subscribe_id: string, docName: string) {
-    // Новая подписка снова использует живой Y.Doc. Асинхронный flush может
-    // продолжаться, но больше не имеет права уничтожить этот документ.
-    this.documentEvictions.delete(docName)
-
     let byDoc = this.subscribesByDocument.get(docName)
     if (!byDoc) {
       byDoc = new Set()
@@ -334,56 +305,17 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
 
   // если у документа нет подписок - сносим его
   private checkDocumentNeedRemove(name: string) {
-    if (this.subscribesByDocument.get(name)?.size || this.documentEvictions.has(name)) {
-      return
-    }
+    if (!this.subscribesByDocument.get(name)?.size) {
+      if (this.debug) {
+        console.log('[CRDT] delete document', name)
+      }
 
-    const document = this.documents.get(name)
-    if (!document) {
+      this.documents.get(name)?.destroy()
+      this.documents.delete(name)
+      // не оставляем пустой Set в индексе (иначе — медленная утечка записей мапы);
+      // getOrCreateDocument пересоздаст его при повторном появлении документа
       this.subscribesByDocument.delete(name)
-      return
-    }
-
-    // Последний клиент мог закрыться сразу после update (обычный refresh).
-    // Сначала сохраняем всю принятую очередь, а до её завершения оставляем Y.Doc
-    // доступным повторной подписке. Никакого фиксированного ожидания здесь нет.
-    const eviction = {}
-    this.documentEvictions.set(name, eviction)
-
-    if (this.debug) {
-      console.log('[CRDT] flush document before eviction', name)
     }
-
-    void document.flushStoreQueue()
-      .then(() => {
-        if (
-          this.documentEvictions.get(name) !== eviction ||
-          this.subscribesByDocument.get(name)?.size ||
-          this.documents.get(name) !== document
-        ) {
-          return
-        }
-
-        this.documentEvictions.delete(name)
-
-        if (this.debug) {
-          console.log('[CRDT] delete document', name)
-        }
-
-        document.destroy()
-        this.documents.delete(name)
-        this.subscribesByDocument.delete(name)
-      })
-      .catch((error) => {
-        // Не уничтожаем единственную живую копию документа, если запись в БД
-        // не завершилась. Снимаем eviction, чтобы следующая отписка или явная
-        // проверка могла повторно инициировать flush.
-        if (this.documentEvictions.get(name) === eviction) {
-          this.documentEvictions.delete(name)
-        }
-
-        console.error('[CRDT] flush document before eviction', name, error)
-      })
   }
 
   // очистка подписки (при отписке клиента - через emit-метод или options-хук).
@@ -501,12 +433,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
         const generation = this.subscribeGenerations.get(subscribe_id) || 0
         const forceSync = state.forceSync
         state.forceSync = false
-        const reconciled = await this.reconcileSubscribe(
-          client,
-          subscribe,
-          generation,
-          forceSync
-        )
+        const reconciled = await this.reconcileSubscribe(client, subscribe, generation, forceSync)
         if (!reconciled && forceSync) {
           state.forceSync = true
         }
@@ -518,11 +445,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     return state.running
   }
 
-  private requestSubscribeRefresh(
-    subscribe_id: string,
-    immediate = false,
-    forceSync = immediate
-  ) {
+  private requestSubscribeRefresh(subscribe_id: string, immediate = false, forceSync = immediate) {
     const state = this.getSubscribeRefreshState(subscribe_id)
     state.dirty = true
     state.forceSync ||= forceSync
@@ -608,16 +531,8 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     }
 
     if (mutation.previousRow) {
-      const previousSuitable = this.checkRowIsSutable(
-        mutation.previousRow,
-        subscribe,
-        entity
-      )
-      const currentSuitable = this.checkRowIsSutable(
-        mutation.row,
-        subscribe,
-        entity
-      )
+      const previousSuitable = this.checkRowIsSutable(mutation.previousRow, subscribe, entity)
+      const currentSuitable = this.checkRowIsSutable(mutation.row, subscribe, entity)
 
       if (previousSuitable !== currentSuitable) {
         return true
@@ -669,9 +584,20 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
 
     let document = this.documents.get(documentName)
     if (document) {
-      if (awareness) {
-        document.enableAwareness()
-      }
+      // Освежаем существующий документ строкой из БД.
+      //
+      // Раньше документ возвращался как есть, а подписка отправляла клиенту его
+      // stateAsUpdate — то есть КЭШ документа, а не только что прочитанную строку.
+      // Документ, проспавший мутацию, оставался устаревшим навсегда: даже перезагрузка
+      // страницы отдавала старое значение, потому что reconcile брал его же.
+      //
+      // Стало заметно после того, как документы без подписчиков начали удаляться:
+      // документ может быть создан, остаться без подписок, пропустить мутации и
+      // «воскреснуть» на новой подписке уже неактуальным.
+      //
+      // store: false — это не правка от клиента, а синхронизация с БД, писать обратно нечего.
+      document.write(row, { expose: 'all', store: false })
+      document.setPersistedState(row)
 
       return document
     }
@@ -688,13 +614,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
       },
       onStore: (item: object, origin: CuboCrdtServerDocumentOrigin, store) => {
         const subscribe = origin.subscribe_id && this.subscribes.get(origin.subscribe_id)
-        const liveClient = subscribe && this.clients.get(subscribe.client_id)
-        const client = liveClient || (origin.store_context
-          ? ({
-              id: origin.store_context.client_id,
-              auth: origin.store_context.auth
-            } as CuboCrdtSocketClient<A>)
-          : undefined)
+        const client = subscribe && this.clients.get(subscribe.client_id)
 
         if (client) {
           return this.options?.storeRow?.(entity as any, entity_id, item as any, {
@@ -730,13 +650,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     const existed = this.documents.has(documentName)
     const document = this.getOrCreateDocument(entity, row, awareness)
 
-    if (existed && !document.hasPendingStore()) {
-      // Только внешний CRUD является подтверждённым источником из БД.
-      // Обычная повторная подписка не должна применять потенциально старую строку
-      // поверх живого документа с ещё не сохранённым collaborative update.
-      document.write(row, { expose: 'all', store: false })
-      document.setPersistedState(row)
-    } else {
+    if (!existed) {
       this.pushDocumentAction('create', entity, document, document.stateAsUpdate)
     }
 
@@ -901,13 +815,9 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
 
         const subscribeSutable = this.checkSubscribeIsSutable(origin, subscribe)
         const documentExistsInSubscribe = this.subscribesByDocument.get(document.name)?.has(subscribe.id)
-        const rowSutable = subscribe.paginated
-          ? documentExistsInSubscribe
-          : this.checkRowIsSutable(row, subscribe, entity)
+        const rowSutable = subscribe.paginated ? documentExistsInSubscribe : this.checkRowIsSutable(row, subscribe, entity)
 
-        const sutable = subscribeSutable && (subscribe.paginated
-          ? documentExistsInSubscribe
-          : rowSutable || documentExistsInSubscribe)
+        const sutable = subscribeSutable && (subscribe.paginated ? documentExistsInSubscribe : rowSutable || documentExistsInSubscribe)
 
         if (sutable) {
           if (this.debug && !rowSutable) {
@@ -1008,21 +918,13 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     }
   }
 
-  private async reconcileSubscribe(
-    client: WsServerSocket,
-    subscribe: CuboCrdtServerSubscribe,
-    generation: number,
-    forceSync: boolean
-  ) {
+  private async reconcileSubscribe(client: WsServerSocket, subscribe: CuboCrdtServerSubscribe, generation: number, forceSync: boolean) {
     const fetched = await this.options.fetchRows?.(client, subscribe)
     const result = Array.isArray(fetched)
       ? { rows: fetched, totals: subscribe.totals }
       : { rows: fetched?.rows || [], totals: fetched?.totals || subscribe.totals }
 
-    if (
-      this.subscribes.get(subscribe.id) !== subscribe ||
-      this.subscribeGenerations.get(subscribe.id) !== generation
-    ) {
+    if (this.subscribes.get(subscribe.id) !== subscribe || this.subscribeGenerations.get(subscribe.id) !== generation) {
       return false
     }
 
@@ -1095,10 +997,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     }
 
     const idsChanged = !areCrdtListIdsEqual(subscribe.row_ids, nextIds)
-    const totalsChanged = !areCrdtListTotalsEqual(
-      subscribe.totals,
-      result.totals
-    )
+    const totalsChanged = !areCrdtListTotalsEqual(subscribe.totals, result.totals)
 
     subscribe.row_ids = nextIds
     subscribe.totals = result.totals
@@ -1137,10 +1036,7 @@ export class CuboCrdtServer<M, A = {}, E extends Extract<keyof M, string> = Extr
     if (upgrade.filters !== undefined) {
       subscribe.filters = cloneDeep(upgrade.filters || {})
     }
-    subscribe.paginated = this.resolvePaginated(
-      subscribe.filters,
-      upgrade.paginated
-    )
+    subscribe.paginated = this.resolvePaginated(subscribe.filters, upgrade.paginated)
 
     return this.requestSubscribeRefresh(subscribe.id, true)
   }

package/src/server/types/document.ts

@@ -5,20 +5,6 @@ export type CuboCrdtServerDocumentStoreContext = {
   row: object
 }
 
-export type CuboCrdtServerDocumentStoreWaiter = {
-  resolve: () => void
-  reject: (reason?: unknown) => void
-}
-
-export type CuboCrdtServerDocumentPendingStore = {
-  body: object
-  changeKey: string
-  origin: CuboCrdtServerDocumentOrigin
-  originKey: string
-  row: object
-  waiters: CuboCrdtServerDocumentStoreWaiter[]
-}
-
 export type CuboCrdtServerDocumentOptions = {
   name: string
   onStore?: (
@@ -77,16 +63,4 @@ export type CuboCrdtServerDocumentOrigin = {
 
   // id клиента
   client_id?: string
-
-  /**
-   * Снимок серверного контекста автора в момент получения update.
-   *
-   * Он нужен только для отложенного сохранения: исходная подписка и сокет могут
-   * закрыться при refresh раньше, чем сработает debounce. Клиентское значение
-   * этого поля сервер всегда перезаписывает собственными данными.
-   */
-  store_context?: {
-    client_id: string
-    auth?: unknown
-  }
 }

package/src/server/utils/index.ts

@@ -1,41 +0,0 @@
-const isObject = (value: unknown): value is Record<string, unknown> => {
-  return value !== null && typeof value === 'object'
-}
-
-const collectChangedPaths = (
-  previous: unknown,
-  current: unknown,
-  path: string,
-  result: string[]
-) => {
-  if (Object.is(previous, current)) {
-    return
-  }
-
-  if (!isObject(previous) || !isObject(current)) {
-    result.push(path || '$')
-    return
-  }
-
-  const keys = new Set([
-    ...Object.keys(previous),
-    ...Object.keys(current)
-  ])
-
-  for (const key of [...keys].sort()) {
-    const nextPath = Array.isArray(previous) || Array.isArray(current)
-      ? `${path}[${key}]`
-      : path ? `${path}.${key}` : key
-
-    collectChangedPaths(previous[key], current[key], nextPath, result)
-  }
-}
-
-/** Возвращает стабильный ключ фактически изменённых leaf-путей объекта. */
-export const getCrdtStoreChangeKey = (previous: object, current: object) => {
-  const paths: string[] = []
-
-  collectChangedPaths(previous, current, '', paths)
-
-  return paths.join('|')
-}