teamplay 0.4.0-alpha.84 → 0.4.0-alpha.86

package/orm/Doc.js

@@ -176,29 +176,162 @@ class Doc {
 export class DocSubscriptions {
   constructor (DocClass = Doc) {
     this.DocClass = DocClass
-    this.subCount = new Map() // transportHash -> total ref count (owners + retained docs)
-    this.ownerFetchCount = new Map() // ownerKey -> fetch intent count
-    this.ownerSubscribeCount = new Map() // ownerKey -> subscribe intent count
-    this.ownerMeta = new Map() // ownerKey -> { hash, segments, rootId }
-    this.ownerKeysByHash = new Map() // transportHash -> Set(ownerKey)
-    this.docs = new Map()
-    this.pendingDestroyTimers = new Map()
-    this.transportTasks = new Map()
+    this.ownerRecords = new Map() // ownerKey -> owner record
+    this.entries = new Map() // transportHash -> transport entry
     this.fr = new FinalizationRegistry(({ hash, ownerKey }) => this.destroyByOwnerKey(ownerKey, { hash, force: true }))
+    this.subCount = createReadonlyMapView({
+      get: hash => this.getTrackedCount(hash),
+      has: hash => this.getTrackedCount(hash) !== undefined,
+      size: () => this.getTrackedHashCountSize(),
+      keys: () => getTrackedHashes(this.entries)
+    })
+    this.ownerFetchCount = createReadonlyMapView({
+      get: ownerKey => {
+        const count = this.ownerRecords.get(ownerKey)?.fetchCount
+        return count > 0 ? count : undefined
+      },
+      has: ownerKey => !!this.ownerRecords.get(ownerKey)?.fetchCount,
+      size: () => countMapLike(this.ownerRecords, record => record.fetchCount > 0),
+      keys: () => filterMapKeys(this.ownerRecords, record => record.fetchCount > 0)
+    })
+    this.ownerSubscribeCount = createReadonlyMapView({
+      get: ownerKey => {
+        const count = this.ownerRecords.get(ownerKey)?.subscribeCount
+        return count > 0 ? count : undefined
+      },
+      has: ownerKey => !!this.ownerRecords.get(ownerKey)?.subscribeCount,
+      size: () => countMapLike(this.ownerRecords, record => record.subscribeCount > 0),
+      keys: () => filterMapKeys(this.ownerRecords, record => record.subscribeCount > 0)
+    })
+    this.ownerMeta = createReadonlyMapView({
+      get: ownerKey => this.getOwnerMeta(ownerKey),
+      has: ownerKey => this.ownerRecords.has(ownerKey),
+      size: () => this.ownerRecords.size,
+      keys: () => this.ownerRecords.keys()
+    })
+    this.ownerKeysByHash = createReadonlyMapView({
+      get: hash => this.getOwnerKeys(hash),
+      has: hash => !!this.getOwnerKeys(hash),
+      size: () => countMapLike(this.entries, entry => entry.owners.size > 0),
+      keys: () => filterMapKeys(this.entries, entry => entry.owners.size > 0)
+    })
+    this.docs = createReadonlyMapView({
+      get: hash => this.getRuntime(hash),
+      has: hash => this.hasRuntime(hash),
+      size: () => this.getRuntimeCount(),
+      keys: () => filterMapKeys(this.entries, entry => !!entry.runtime)
+    })
+    this.pendingDestroyTimers = createReadonlyMapView({
+      get: hash => this.entries.get(hash)?.pendingDestroy,
+      has: hash => !!this.entries.get(hash)?.pendingDestroy,
+      size: () => countMapLike(this.entries, entry => !!entry.pendingDestroy),
+      keys: () => filterMapKeys(this.entries, entry => !!entry.pendingDestroy)
+    })
+  }
+
+  getOrCreateOwnerRecord (ownerKey, meta) {
+    let record = this.ownerRecords.get(ownerKey)
+    if (!record) {
+      record = {
+        ownerKey,
+        rootId: meta.rootId,
+        hash: meta.hash,
+        segments: meta.segments ? [...meta.segments] : parseDocHash(meta.hash),
+        fetchCount: 0,
+        subscribeCount: 0
+      }
+      this.ownerRecords.set(ownerKey, record)
+    } else {
+      if (meta.rootId != null) record.rootId = meta.rootId
+      if (meta.hash != null) record.hash = meta.hash
+      if (meta.segments != null) record.segments = [...meta.segments]
+    }
+    return record
+  }
+
+  getOrCreateEntry (hash, segments) {
+    let entry = this.entries.get(hash)
+    if (!entry) {
+      entry = {
+        hash,
+        segments: segments ? [...segments] : parseDocHash(hash),
+        mode: 'idle',
+        targetMode: 'idle',
+        phase: 'stable',
+        runtime: null,
+        owners: new Set(),
+        retainCount: 0,
+        pendingDestroy: null,
+        reconcilePromise: null
+      }
+      this.entries.set(hash, entry)
+    } else if (segments && !entry.segments?.length) {
+      entry.segments = [...segments]
+    }
+    return entry
+  }
+
+  getEntry (hash) {
+    return this.entries.get(hash)
+  }
+
+  getEntryTotalCount (entry) {
+    if (!entry) return 0
+    let count = entry.retainCount
+    for (const ownerKey of entry.owners) {
+      count += this.getOwnerTotalCount(ownerKey)
+    }
+    return count
+  }
+
+  syncOwnerMirror () {}
+
+  clearOwnerMirror () {}
+
+  syncEntryMirror () {}
+
+  deleteEntryIfEmpty (hash) {
+    const entry = this.entries.get(hash)
+    if (!entry) return
+    if (entry.owners.size > 0) return
+    if (entry.retainCount > 0) return
+    if (entry.pendingDestroy) return
+    if (entry.runtime) return
+    if (entry.phase === 'transition') return
+    this.entries.delete(hash)
+  }
+
+  ensureRuntime (hash, segments) {
+    const entry = this.getOrCreateEntry(hash, segments)
+    if (!entry.runtime) {
+      const runtimeSegments = entry.segments?.length ? entry.segments : parseDocHash(hash)
+      entry.runtime = new this.DocClass(...runtimeSegments)
+    }
+    entry.runtime.init()
+    entry.mode = entry.runtime.activeTransportMode || entry.mode
+    this.syncEntryMirror(entry)
+    return entry.runtime
+  }
+
+  addOwnerToEntry (record) {
+    const entry = this.getOrCreateEntry(record.hash, record.segments)
+    entry.owners.add(record.ownerKey)
+    this.syncEntryMirror(entry)
+    return entry
+  }
+
+  removeOwnerFromEntry (record) {
+    const entry = this.entries.get(record.hash)
+    if (!entry) return
+    entry.owners.delete(record.ownerKey)
+    this.syncEntryMirror(entry)
   }
 
   init ($doc) {
     const segments = [...$doc[SEGMENTS]]
     const hash = hashDoc(segments)
-    let doc = this.docs.get(hash)
-    if (doc) {
-      if (doc.initialized) return
-      doc.init()
-    } else {
-      doc = new this.DocClass(...segments)
-      this.docs.set(hash, doc)
-      doc.init()
-    }
+    this.getOrCreateEntry(hash, segments)
+    this.ensureRuntime(hash, segments)
   }
 
   subscribe ($doc, { intent = 'subscribe' } = {}) {
@@ -207,23 +340,22 @@ export class DocSubscriptions {
     const rootId = getOwningRootId($doc)
     const ownerKey = getDocOwnerKey(rootId, hash)
     const token = getDocFinalizationToken($doc)
-    const previousCount = this.subCount.get(hash) || 0
+    const entry = this.getOrCreateEntry(hash, segments)
+    const previousCount = this.getEntryTotalCount(entry)
     this.cancelDestroy(hash)
-    this.incrementOwnerIntent(ownerKey, intent)
-    this.addOwnerMeta(ownerKey, hash, segments, rootId)
-    this.subCount.set(hash, previousCount + 1)
+    const record = this.getOrCreateOwnerRecord(ownerKey, { hash, segments, rootId })
+    this.incrementOwnerIntent(record, intent)
+    this.addOwnerToEntry(record)
     if (rootId) {
       registerRootOwnedDirectDocSubscription(rootId, hash, segments, token)
     }
     this.fr.register($doc, { hash, ownerKey }, token)
-
-    this.init($doc)
-    const doc = this.docs.get(hash)
+    this.ensureRuntime(hash, segments)
+    const doc = entry.runtime
     if (
       previousCount > 0 &&
       doc &&
-      !doc._subscribing &&
-      !this.transportTasks.get(hash) &&
+      entry.phase === 'stable' &&
       this.getDesiredTransportMode(hash) === doc.activeTransportMode
     ) return
     return this.reconcileTransport(hash)
@@ -232,10 +364,11 @@ export class DocSubscriptions {
   retain ($doc) {
     const segments = [...$doc[SEGMENTS]]
     const hash = hashDoc(segments)
+    const entry = this.getOrCreateEntry(hash, segments)
     this.cancelDestroy(hash)
-    const count = this.subCount.get(hash) || 0
-    this.subCount.set(hash, count + 1)
-    this.init($doc)
+    entry.retainCount += 1
+    this.ensureRuntime(hash, segments)
+    this.syncEntryMirror(entry)
   }
 
   async unsubscribe ($doc, { intent = 'subscribe' } = {}) {
@@ -244,23 +377,26 @@ export class DocSubscriptions {
     const rootId = getOwningRootId($doc)
     const ownerKey = getDocOwnerKey(rootId, hash)
     const token = getDocFinalizationToken($doc)
-    const currentIntentCount = this.getOwnerIntentCount(ownerKey, intent)
+    const record = this.ownerRecords.get(ownerKey)
+    const currentIntentCount = this.getOwnerIntentCount(record, intent)
     if (currentIntentCount <= 0) {
       if (ERROR_ON_EXCESSIVE_UNSUBSCRIBES) throw ERRORS.notSubscribed($doc)
       return
     }
-    this.setOwnerIntentCount(ownerKey, intent, currentIntentCount - 1)
-    const nextOwnerCount = this.getOwnerTotalCount(ownerKey)
-    const count = Math.max((this.subCount.get(hash) || 0) - 1, 0)
-    if (count > 0) this.subCount.set(hash, count)
-    else this.subCount.set(hash, 0)
+    this.setOwnerIntentCount(record, intent, currentIntentCount - 1)
+    const nextOwnerCount = this.getOwnerTotalCount(record)
     if (rootId) {
       unregisterRootOwnedDirectDocSubscription(rootId, hash, token)
     }
+    const entry = this.getOrCreateEntry(hash, segments)
     if (nextOwnerCount === 0) {
       this.fr.unregister(token)
-      this.removeOwnerMeta(ownerKey, hash)
+      if (record) {
+        this.removeOwnerFromEntry(record)
+      }
+      this.ownerRecords.delete(ownerKey)
     }
+    const count = this.getEntryTotalCount(entry)
     const destroyPromise = count === 0 ? this.scheduleDestroy(segments) : undefined
     await this.reconcileTransport(hash)
     if (count > 0) return
@@ -270,17 +406,17 @@ export class DocSubscriptions {
   async release ($doc) {
     const segments = [...$doc[SEGMENTS]]
     const hash = hashDoc(segments)
-    let count = this.subCount.get(hash) || 0
-    count -= 1
-    if (count < 0) {
+    const entry = this.entries.get(hash)
+    if (!entry) {
       if (ERROR_ON_EXCESSIVE_UNSUBSCRIBES) throw ERRORS.notSubscribed($doc)
       return
     }
-    if (count > 0) {
-      this.subCount.set(hash, count)
+    if (entry.retainCount <= 0) {
+      if (ERROR_ON_EXCESSIVE_UNSUBSCRIBES) throw ERRORS.notSubscribed($doc)
       return
     }
-    this.subCount.set(hash, 0)
+    entry.retainCount -= 1
+    if ((this.getTrackedCount(hash) || 0) > 0) return
     await this.scheduleDestroy(segments)
   }
 
@@ -290,18 +426,12 @@ export class DocSubscriptions {
   }
 
   async clear () {
-    const hashes = new Set([
-      ...this.pendingDestroyTimers.keys(),
-      ...this.docs.keys()
-    ])
+    const hashes = new Set(this.entries.keys())
     for (const hash of hashes) {
       await this.destroyByHash(hash, { force: true })
     }
-    this.subCount.clear()
-    this.ownerFetchCount.clear()
-    this.ownerSubscribeCount.clear()
-    this.ownerMeta.clear()
-    this.ownerKeysByHash.clear()
+    this.entries.clear()
+    this.ownerRecords.clear()
   }
 
   async releaseRootOwnedSubscriptions (rootId) {
@@ -317,7 +447,7 @@ export class DocSubscriptions {
   }
 
   async flushPendingDestroys () {
-    const hashes = Array.from(this.pendingDestroyTimers.keys())
+    const hashes = Array.from(filterMapKeys(this.entries, entry => !!entry.pendingDestroy))
     for (const hash of hashes) {
       await this.destroyByHash(hash)
     }
@@ -330,18 +460,19 @@ export class DocSubscriptions {
       await this.destroyByHash(hash, options)
       return
     }
-    const existing = this.pendingDestroyTimers.get(hash)
+    const entry = this.getOrCreateEntry(hash, segments)
+    const existing = entry.pendingDestroy
     if (existing) {
       if (options.force) existing.force = true
       return existing.promise
     }
-    const entry = createPendingDestroyEntry()
-    if (options.force) entry.force = true
-    entry.timer = setTimeout(() => {
-      this.destroyByHash(hash, { force: entry.force }).catch(ignoreDestroyError)
+    const pendingDestroy = createPendingDestroyEntry()
+    if (options.force) pendingDestroy.force = true
+    pendingDestroy.timer = setTimeout(() => {
+      this.destroyByHash(hash, { force: pendingDestroy.force }).catch(ignoreDestroyError)
     }, delay)
-    this.pendingDestroyTimers.set(hash, entry)
-    return entry.promise
+    entry.pendingDestroy = pendingDestroy
+    return pendingDestroy.promise
   }
 
   cancelDestroy (hash) {
@@ -351,36 +482,50 @@ export class DocSubscriptions {
   }
 
   async reconcileTransport (hash) {
-    const previous = this.transportTasks.get(hash) || Promise.resolve()
-    const next = previous
+    const entry = this.getOrCreateEntry(hash)
+    entry.targetMode = this.getDesiredTransportMode(hash)
+    if (entry.phase === 'transition' && entry.reconcilePromise) return entry.reconcilePromise
+    const next = Promise.resolve()
       .catch(ignoreDestroyError)
       .then(() => this.reconcileTransportNow(hash))
-    this.transportTasks.set(hash, next)
+    entry.phase = 'transition'
+    entry.reconcilePromise = next
     try {
       await next
     } finally {
-      if (this.transportTasks.get(hash) === next) this.transportTasks.delete(hash)
+      const currentEntry = this.entries.get(hash)
+      if (currentEntry?.reconcilePromise === next) {
+        currentEntry.reconcilePromise = null
+        currentEntry.phase = 'stable'
+      }
+      this.deleteEntryIfEmpty(hash)
     }
   }
 
   async reconcileTransportNow (hash) {
-    const doc = this.docs.get(hash)
-    if (!doc) return
+    const entry = this.getOrCreateEntry(hash)
     while (true) {
-      const desiredMode = this.getDesiredTransportMode(hash)
-      const currentMode = doc.activeTransportMode
+      let doc = entry.runtime
+      const desiredMode = entry.targetMode = this.getDesiredTransportMode(hash)
+      const currentMode = doc?.activeTransportMode ?? entry.mode
+      entry.mode = currentMode
       if (desiredMode === currentMode) return
       if (desiredMode === 'idle') {
-        if (currentMode === 'idle') return
-        await doc.unsubscribe()
+        if (doc && currentMode !== 'idle') {
+          await doc.unsubscribe()
+        }
+        entry.mode = 'idle'
         continue
       }
-      if (currentMode !== 'idle') {
+      if (currentMode !== 'idle' && doc) {
         await doc.unsubscribe()
+        entry.mode = 'idle'
         continue
       }
-      doc._subscribing = doc.subscribe({ mode: desiredMode }).then(() => { doc._subscribing = undefined })
-      await doc._subscribing
+      doc = this.ensureRuntime(hash)
+      await doc.subscribe({ mode: desiredMode })
+      entry.runtime = doc
+      entry.mode = doc.activeTransportMode || desiredMode
     }
   }
 
@@ -397,33 +542,51 @@ export class DocSubscriptions {
     }
 
     try {
-      const count = this.subCount.get(hash) || 0
+      const entry = this.entries.get(hash)
+      if (options.force && entry?.owners.size) {
+        this.removeAllOwnersFromEntry(hash)
+      }
+      const count = entry ? this.getEntryTotalCount(entry) : (this.getTrackedCount(hash) || 0)
       if (!options.force && count > 0) {
         settlePending()
         return
       }
-      const doc = this.docs.get(hash)
+      const doc = entry?.runtime
       if (!doc) {
-        this.subCount.delete(hash)
+        if (entry) {
+          entry.mode = 'idle'
+          entry.runtime = null
+          this.deleteEntryIfEmpty(hash)
+        }
         settlePending()
         return
       }
       await this.reconcileTransport(hash)
-      if (!options.force && (this.subCount.get(hash) || 0) > 0) {
+      const nextEntry = this.entries.get(hash)
+      const nextCount = nextEntry ? this.getEntryTotalCount(nextEntry) : (this.getTrackedCount(hash) || 0)
+      if (!options.force && nextCount > 0) {
         settlePending()
         return
       }
-      if (doc.activeTransportMode !== 'idle') {
-        await doc.unsubscribe()
+      const activeDoc = nextEntry?.runtime || doc
+      if (activeDoc.activeTransportMode !== 'idle') {
+        await activeDoc.unsubscribe()
       }
-      if (!options.force && (this.subCount.get(hash) || 0) > 0) {
+      const finalEntryBeforeDestroy = this.entries.get(hash)
+      const finalCountBeforeDestroy = finalEntryBeforeDestroy
+        ? this.getEntryTotalCount(finalEntryBeforeDestroy)
+        : (this.getTrackedCount(hash) || 0)
+      if (!options.force && finalCountBeforeDestroy > 0) {
         settlePending()
         return
       }
-      if (typeof doc.hasPending === 'function' && doc.hasPending()) {
-        if (typeof doc.whenNothingPending === 'function') {
-          if (pendingDestroy) this.pendingDestroyTimers.set(hash, pendingDestroy)
-          doc.whenNothingPending(() => {
+      if (typeof activeDoc.hasPending === 'function' && activeDoc.hasPending()) {
+        if (typeof activeDoc.whenNothingPending === 'function') {
+          if (pendingDestroy) {
+            const nextEntry = this.getOrCreateEntry(hash)
+            nextEntry.pendingDestroy = pendingDestroy
+          }
+          activeDoc.whenNothingPending(() => {
             const nextOptions = pendingDestroy ? { ...options, _pendingDestroy: pendingDestroy } : options
             this.destroyByHash(hash, nextOptions).catch(ignoreDestroyError)
           })
@@ -432,11 +595,14 @@ export class DocSubscriptions {
         }
         return
       }
-      if (typeof doc.destroy === 'function') await doc.destroy()
-      if (typeof doc.dispose === 'function') doc.dispose()
-      this.docs.delete(hash)
-      this.subCount.delete(hash)
-      this.ownerKeysByHash.delete(hash)
+      if (typeof activeDoc.destroy === 'function') await activeDoc.destroy()
+      if (typeof activeDoc.dispose === 'function') activeDoc.dispose()
+      const finalEntry = this.entries.get(hash)
+      if (finalEntry) {
+        finalEntry.runtime = null
+        finalEntry.mode = 'idle'
+        this.deleteEntryIfEmpty(hash)
+      }
       settlePending()
     } catch (err) {
       settlePending(err)
@@ -445,65 +611,72 @@ export class DocSubscriptions {
   }
 
   takePendingDestroy (hash, expectedEntry) {
-    const entry = this.pendingDestroyTimers.get(hash)
-    if (!entry) return
-    if (expectedEntry && entry !== expectedEntry) return
-    clearTimeout(entry.timer)
-    this.pendingDestroyTimers.delete(hash)
-    return entry
+    const transportEntry = this.entries.get(hash)
+    const pendingDestroy = transportEntry?.pendingDestroy
+    if (!pendingDestroy) return
+    if (expectedEntry && pendingDestroy !== expectedEntry) return
+    clearTimeout(pendingDestroy.timer)
+    transportEntry.pendingDestroy = null
+    this.deleteEntryIfEmpty(hash)
+    return pendingDestroy
   }
 
-  getOwnerIntentCount (ownerKey, intent) {
-    const store = intent === 'fetch' ? this.ownerFetchCount : this.ownerSubscribeCount
-    return store.get(ownerKey) || 0
+  getOwnerIntentCount (recordOrOwnerKey, intent) {
+    const record = typeof recordOrOwnerKey === 'string'
+      ? this.ownerRecords.get(recordOrOwnerKey)
+      : recordOrOwnerKey
+    if (!record) return 0
+    return intent === 'fetch' ? record.fetchCount : record.subscribeCount
   }
 
-  setOwnerIntentCount (ownerKey, intent, count) {
-    const store = intent === 'fetch' ? this.ownerFetchCount : this.ownerSubscribeCount
-    if (count > 0) store.set(ownerKey, count)
-    else store.delete(ownerKey)
+  setOwnerIntentCount (record, intent, count) {
+    if (!record) return
+    if (intent === 'fetch') record.fetchCount = Math.max(count, 0)
+    else record.subscribeCount = Math.max(count, 0)
+    this.syncOwnerMirror(record)
   }
 
-  incrementOwnerIntent (ownerKey, intent) {
-    this.setOwnerIntentCount(ownerKey, intent, this.getOwnerIntentCount(ownerKey, intent) + 1)
+  incrementOwnerIntent (record, intent) {
+    this.setOwnerIntentCount(record, intent, this.getOwnerIntentCount(record, intent) + 1)
   }
 
-  getOwnerTotalCount (ownerKey) {
-    return (this.ownerFetchCount.get(ownerKey) || 0) + (this.ownerSubscribeCount.get(ownerKey) || 0)
+  getOwnerTotalCount (recordOrOwnerKey) {
+    const record = typeof recordOrOwnerKey === 'string'
+      ? this.ownerRecords.get(recordOrOwnerKey)
+      : recordOrOwnerKey
+    if (!record) return 0
+    return record.fetchCount + record.subscribeCount
   }
 
   addOwnerMeta (ownerKey, hash, segments, rootId) {
-    if (this.ownerMeta.has(ownerKey)) return
-    this.ownerMeta.set(ownerKey, { hash, segments: [...segments], rootId })
-    let ownerKeys = this.ownerKeysByHash.get(hash)
-    if (!ownerKeys) {
-      ownerKeys = new Set()
-      this.ownerKeysByHash.set(hash, ownerKeys)
-    }
-    ownerKeys.add(ownerKey)
+    const record = this.getOrCreateOwnerRecord(ownerKey, { hash, segments, rootId })
+    this.addOwnerToEntry(record)
   }
 
   removeOwnerMeta (ownerKey, hash) {
-    const meta = this.ownerMeta.get(ownerKey)
-    const knownHash = hash ?? meta?.hash
-    this.ownerMeta.delete(ownerKey)
-    this.ownerFetchCount.delete(ownerKey)
-    this.ownerSubscribeCount.delete(ownerKey)
+    const record = this.ownerRecords.get(ownerKey)
+    const knownHash = hash ?? record?.hash
+    if (record) {
+      this.removeOwnerFromEntry(record)
+      this.ownerRecords.delete(ownerKey)
+    }
     if (!knownHash) return
-    const ownerKeys = this.ownerKeysByHash.get(knownHash)
+    const ownerKeys = this.entries.get(knownHash)?.owners
     if (!ownerKeys) return
     ownerKeys.delete(ownerKey)
-    if (ownerKeys.size === 0) this.ownerKeysByHash.delete(knownHash)
+    this.deleteEntryIfEmpty(knownHash)
   }
 
   getDesiredTransportMode (hash) {
-    const ownerKeys = this.ownerKeysByHash.get(hash)
+    const entry = this.entries.get(hash)
+    const ownerKeys = entry?.owners
     if (!ownerKeys || ownerKeys.size === 0) return 'idle'
     let hasFetchBackedOwner = false
     for (const ownerKey of ownerKeys) {
-      const subscribeCount = this.ownerSubscribeCount.get(ownerKey) || 0
-      const fetchCount = this.ownerFetchCount.get(ownerKey) || 0
-      const rootId = this.ownerMeta.get(ownerKey)?.rootId
+      const record = this.ownerRecords.get(ownerKey)
+      const subscribeCount = record?.subscribeCount || 0
+      const fetchCount = record?.fetchCount || 0
+      const rootId = record?.rootId
       const subscribeMode = getRootTransportMode(rootId, 'subscribe')
       if (subscribeCount > 0 && subscribeMode === 'subscribe') return 'subscribe'
       if (fetchCount > 0 || (subscribeCount > 0 && subscribeMode === 'fetch')) {
@@ -513,21 +686,123 @@ export class DocSubscriptions {
     return hasFetchBackedOwner ? 'fetch' : 'idle'
   }
 
+  removeAllOwnersFromEntry (hash) {
+    const entry = this.entries.get(hash)
+    if (!entry) return
+    for (const ownerKey of Array.from(entry.owners)) {
+      const record = this.ownerRecords.get(ownerKey)
+      if (record) this.removeOwnerFromEntry(record)
+      else entry.owners.delete(ownerKey)
+      this.ownerRecords.delete(ownerKey)
+    }
+  }
+
+  async destroyTransportEntry (hash, runtime) {
+    const activeDoc = this.entries.get(hash)?.runtime || runtime
+    if (!activeDoc) {
+      const entry = this.entries.get(hash)
+      if (entry) {
+        entry.runtime = null
+        entry.mode = 'idle'
+      }
+      this.deleteEntryIfEmpty(hash)
+      return
+    }
+    if (activeDoc.activeTransportMode !== 'idle') {
+      await activeDoc.unsubscribe()
+    }
+    if (typeof activeDoc.hasPending === 'function' && activeDoc.hasPending()) {
+      if (typeof activeDoc.whenNothingPending === 'function') {
+        await new Promise(resolve => activeDoc.whenNothingPending(resolve))
+      }
+    }
+    if (typeof activeDoc.destroy === 'function') await activeDoc.destroy()
+    if (typeof activeDoc.dispose === 'function') activeDoc.dispose()
+    const finalEntry = this.entries.get(hash)
+    if (finalEntry && finalEntry.owners.size > 0) return
+    if (finalEntry) {
+      finalEntry.runtime = null
+      finalEntry.mode = 'idle'
+    }
+    this.deleteEntryIfEmpty(hash)
+  }
+
   async destroyByOwnerKey (ownerKey, options = {}) {
-    const meta = this.ownerMeta.get(ownerKey)
-    if (!meta) return
-    const { hash, segments } = meta
-    const ownerCount = this.getOwnerTotalCount(ownerKey)
+    const record = this.ownerRecords.get(ownerKey)
+    const hash = record?.hash ?? options.hash
+    if (!hash) return
+    const segments = record?.segments ?? parseDocHash(hash)
+    const ownerCount = this.getOwnerTotalCount(record || ownerKey)
     if (!options.force && ownerCount > 0) return
 
-    const currentCount = this.subCount.get(hash) || 0
-    const nextCount = Math.max(currentCount - ownerCount, 0)
-    if (nextCount > 0) this.subCount.set(hash, nextCount)
-    else this.subCount.set(hash, 0)
-    this.removeOwnerMeta(ownerKey, hash)
+    const entry = this.entries.get(hash)
+    if (record) {
+      this.removeOwnerFromEntry(record)
+      this.ownerRecords.delete(ownerKey)
+    } else if (entry?.owners.has(ownerKey)) {
+      entry.owners.delete(ownerKey)
+    }
+
+    if (!entry && !this.getRuntime(hash)) {
+      return
+    }
+
     await this.reconcileTransport(hash)
-    if (nextCount > 0) return
-    await this.scheduleDestroy(segments, { force: !!options.force })
+    const nextEntry = this.entries.get(hash)
+    const nextCount = nextEntry ? this.getEntryTotalCount(nextEntry) : (this.getTrackedCount(hash) || 0)
+    if (nextCount > 0) {
+      this.deleteEntryIfEmpty(hash)
+      return
+    }
+    if (options.force) {
+      await this.destroyTransportEntry(hash, nextEntry?.runtime || entry?.runtime)
+      return
+    }
+    await this.scheduleDestroy(segments, { force: false })
+  }
+
+  getRuntime (hash) {
+    return this.entries.get(hash)?.runtime
+  }
+
+  hasRuntime (hash) {
+    return !!this.getRuntime(hash)
+  }
+
+  getRuntimeCount () {
+    return countMapLike(this.entries, entry => !!entry.runtime)
+  }
+
+  getTrackedCount (hash) {
+    const entry = this.entries.get(hash)
+    if (entry) {
+      const total = this.getEntryTotalCount(entry)
+      if (total > 0 || entry.pendingDestroy) return total
+    }
+    return undefined
+  }
+
+  getTrackedHashCountSize () {
+    return countMapLike(this.entries, entry => {
+      const total = this.getEntryTotalCount(entry)
+      return total > 0 || !!entry.pendingDestroy
+    })
+  }
+
+  getOwnerMeta (ownerKey) {
+    const record = this.ownerRecords.get(ownerKey)
+    if (!record) return undefined
+    return {
+      hash: record.hash,
+      segments: [...record.segments],
+      rootId: record.rootId
+    }
+  }
+
+  getOwnerKeys (hash) {
+    const owners = this.entries.get(hash)?.owners
+    if (!owners?.size) return undefined
+    return new Set(owners)
   }
 }
 
@@ -537,6 +812,10 @@ function hashDoc (segments) {
   return JSON.stringify(segments)
 }
 
+function parseDocHash (hash) {
+  return JSON.parse(hash)
+}
+
 function getDocOwnerKey (rootId, hash) {
   return JSON.stringify({ owner: [rootId, hash] })
 }
@@ -611,3 +890,43 @@ function has (obj, key) {
 const ERRORS = {
   notSubscribed: $doc => Error('trying to unsubscribe when not subscribed. Doc: ' + $doc.path())
 }
+
+function createReadonlyMapView ({ get, has, size, keys }) {
+  return {
+    get,
+    has,
+    get size () {
+      return size()
+    },
+    * keys () {
+      yield * keys()
+    },
+    * values () {
+      for (const key of keys()) yield get(key)
+    },
+    * entries () {
+      for (const key of keys()) yield [key, get(key)]
+    },
+    [Symbol.iterator] () {
+      return this.entries()
+    }
+  }
+}
+
+function countMapLike (iterableMap, predicate) {
+  let count = 0
+  for (const value of iterableMap.values()) {
+    if (predicate(value)) count++
+  }
+  return count
+}
+
+function * filterMapKeys (iterableMap, predicate) {
+  for (const [key, value] of iterableMap.entries()) {
+    if (predicate(value)) yield key
+  }
+}
+
+function * getTrackedHashes (entries) {
+  yield * entries.keys()
+}