edytor 3.0.0 → 5.0.0

package/dist/crdt/vendor/yjs/src/utils/BlockSet.js

@@ -37,7 +37,7 @@ export const readBlockSet = (decoder) => {
     clientRefs.clients.set(client, new BlockRange(refs))
     for (let i = 0; i < numberOfBlocks; i++) {
       const info = decoder.readInfo()
-      switch (binary.BITS5 & info) {
+      switch (binary.BITS4 & info) { // YP27: content refs fit four bits
         case 0: { // GC
           const len = decoder.readLen()
           refs[i] = new GC(createID(client, clock), len)
@@ -68,9 +68,9 @@ export const readBlockSet = (decoder) => {
             (info & binary.BIT8) === binary.BIT8 ? decoder.readLeftID() : null, // origin
             null, // right
             (info & binary.BIT7) === binary.BIT7 ? decoder.readRightID() : null, // right origin
-            cantCopyParentInfo ? (decoder.readParentInfo() ? decoder.readString() : decoder.readLeftID()) : null, // parent
-            cantCopyParentInfo && (info & binary.BIT6) === binary.BIT6 ? decoder.readString() : null, // parentSub
-            readItemContent(decoder, info) // item content
+            cantCopyParentInfo ? ((info & binary.BIT5) === binary.BIT5 ? decoder.readKey() : decoder.readLeftID()) : null, // parent (YP27: bit 5 a root's name, YP24: a key)
+            cantCopyParentInfo && (info & binary.BIT6) === binary.BIT6 ? decoder.readKey() : null, // parentSub (YP24: a key)
+            readItemContent(decoder, info, createID(client, clock)) // item content (YP25: with its id)
           )
           refs[i] = block
           clock += block.length
@@ -147,19 +147,28 @@ export class BlockSet {
     for (const client of clientids) {
       const range = exclude.clients.get(client)
       const structs = this.clients.get(client)?.refs
-      if (range == null || structs == null) return
-      const firstStruct = structs[0]
-      const lastStruct = structs[structs.length - 1]
+      if (range == null || structs == null) continue // YP23: the other clients are excluded too
       const idranges = range.getIds()
       for (let i = 0; i < idranges.length; i++) {
         const range = idranges[i]
-        let startIndex = 0
+        // YP23: read the bounds per range, and the last struct again after
+        // the start's split — `findIndexCleanStart` splits a struct in place
+        // (the struct shrinks, a new one holds the rest), so bounds read
+        // before a split are stale: the next range was skipped (an arriving
+        // GC spanning a skip, known ids and the state's end integrated whole
+        // over the known middle, and its delete-set entry outran the store),
+        // or the end's split was skipped and the range's skip replaced the
+        // struct's tail too.
+        const firstStruct = structs[0]
+        let lastStruct = structs[structs.length - 1]
         if (range.clock >= lastStruct.id.clock + lastStruct.length) continue
+        if (range.clock + range.len <= firstStruct.id.clock) continue
+        let startIndex = 0
         if (range.clock > firstStruct.id.clock) {
           startIndex = findIndexCleanStart(null, structs, range.clock)
         }
+        lastStruct = structs[structs.length - 1]
         let endIndex = structs.length // must be set here, after structs is modified
-        if (range.clock + range.len <= firstStruct.id.clock) continue
         if (range.clock + range.len < lastStruct.id.clock + lastStruct.length) {
           endIndex = findIndexCleanStart(null, structs, range.clock + range.len)
         }

package/dist/crdt/vendor/yjs/src/utils/Doc.js

@@ -21,6 +21,7 @@ import { YNode } from '../ynode.js'
  * @property {function(Uint8Array<ArrayBuffer>, any, Doc, Transaction):void} DocEvents.update
  * @property {function(Doc):void} DocEvents.beforeAllTransactions
  * @property {function(Transaction, Doc):void} DocEvents.beforeTransaction
+ * @property {function(Transaction, Doc):void} DocEvents.beforeCommit
  * @property {function(Transaction, Doc):void} DocEvents.commit
  * @property {function(Transaction, Doc):void} DocEvents.afterTransaction
  * @property {function(Doc, Array<Transaction>):void} DocEvents.afterAllTransactions
@@ -56,11 +57,12 @@ export class Doc extends ObservableV2 {
     this.keepReplaced = null
     this.clientID = generateNewClientId()
     /**
-     * YP13: the greatest Lamport timestamp of a paired mark this document
-     * integrated (see `utils/marks.js`).
+     * YP13, YP22: the greatest Lamport timestamp of a paired mark or a move
+     * record this document integrated (see `utils/marks.js`,
+     * `structs/Item.js` `ContentMove`); the next one it writes takes `_clock + 1`.
      * @type {number}
      */
-    this._markClock = 0
+    this._clock = 0
     /**
      * @type {Map<string, YNode>}
      */

package/dist/crdt/vendor/yjs/src/utils/StructStore.js

@@ -18,6 +18,11 @@ export class StructStore {
      * @type {null | Uint8Array<ArrayBuffer>}
      */
     this.pendingDs = null
+    /**
+     * YP20: holds whose items have not arrived, `client → [clock, len, delta, …]`.
+     * @type {Map<number, Array<number>>|null}
+     */
+    this.pendingHolds = null
     this.skips = createIdSet()
   }
 

package/dist/crdt/vendor/yjs/src/utils/Transaction.js

@@ -15,7 +15,8 @@ export const generateNewClientId = random.uint53
  * minimize the number of messages sent.
  *
  * YP19: a commit is told through the document's events (`commit`, then
- * `afterTransaction`); nodes have no observers.
+ * `afterTransaction`); nodes have no observers. YP30: `beforeCommit` runs
+ * before them, inside the transaction.
  *
  * @public
  */
@@ -39,6 +40,19 @@ export class Transaction {
      * Describes the set of inserted items by ids
      */
     this.insertSet = createIdSet()
+    /**
+     * YP20: the visibility changes hold records made, in order: per item,
+     * `client, clock, len` (`len > 0`: shown, `< 0`: hidden; an item removed
+     * while held is logged shown, as the delete set counts it hidden).
+     * @type {Array<number>}
+     */
+    this.holds = []
+    /**
+     * YP22: the units whose mover changed (a move record integrated or
+     * deleted, a moved unit removed), in order: per item `client, clock, len`.
+     * @type {Array<number>}
+     */
+    this.moves = []
     /**
      * All types that were directly modified (property added or child
      * inserted/deleted). New types are not included in this Set.
@@ -174,18 +188,27 @@ export const transact = (doc, f, origin = null, local = true) => {
     result = f(doc._transaction)
   } finally {
     if (initialCall) {
-      const finishCleanup = doc._transaction === transactionCleanups[0]
-      doc._transaction = null
-      if (finishCleanup) {
-        // The first transaction ended, now process observer calls.
-        // Observer call may create new transactions for which we need to call the observers and do cleanup.
-        // We don't want to nest these calls, so we execute these calls one after
-        // another.
-        // Also we need to ensure that all cleanups are called, even if the
-        // observes throw errors.
-        // This file is full of hacky try {} finally {} blocks to ensure that an
-        // event can throw errors and also that the cleanup is called.
-        cleanupTransactions(transactionCleanups, 0)
+      try {
+        // YP30 begin: the outermost function returned (or threw), the
+        // transaction still open: a `beforeCommit` listener's writes join it.
+        if (doc._observers.has('beforeCommit')) {
+          doc.emit('beforeCommit', [doc._transaction, doc])
+        }
+        // YP30 end
+      } finally {
+        const finishCleanup = doc._transaction === transactionCleanups[0]
+        doc._transaction = null
+        if (finishCleanup) {
+          // The first transaction ended, now process observer calls.
+          // Observer call may create new transactions for which we need to call the observers and do cleanup.
+          // We don't want to nest these calls, so we execute these calls one after
+          // another.
+          // Also we need to ensure that all cleanups are called, even if the
+          // observes throw errors.
+          // This file is full of hacky try {} finally {} blocks to ensure that an
+          // event can throw errors and also that the cleanup is called.
+          cleanupTransactions(transactionCleanups, 0)
+        }
       }
     }
   }

package/dist/crdt/vendor/yjs/src/utils/UpdateDecoder.js

@@ -1,6 +1,50 @@
 import * as decoding from 'lib0-v14/decoding'
+import * as error from 'lib0-v14/error' // YP24
 
 import { ID } from './ID.js'
+import { UPDATE_ENCODING } from './UpdateEncoder.js' // YP24
+
+// YP24 begin (edytor fork: one string table per update — see UPSTREAM.md YP24)
+/**
+ * Read a content value written by `writeValue` (lib0's `readAny` layout, its
+ * strings and object keys from the update's string table).
+ *
+ * @param {UpdateDecoder} decoder
+ * @return {any}
+ */
+const readValue = decoder => {
+  const rest = decoder.restDecoder
+  switch (rest.arr[rest.pos]) {
+    case 115: // YP28: a large integer
+      rest.pos++
+      return decoding.readVarUint(rest)
+    case 114: // YP28: a large integer, through the client table, and a clock
+      rest.pos++
+      return [decoder.readClient(), decoding.readVarUint(rest)]
+    case 119:
+      rest.pos++
+      return decoder.readKey()
+    case 118: {
+      rest.pos++
+      /** @type {Object<string,any>} */
+      const obj = {}
+      for (let n = decoding.readVarUint(rest); n > 0; n--) {
+        const key = decoder.readKey()
+        obj[key] = readValue(decoder)
+      }
+      return obj
+    }
+    case 117: {
+      rest.pos++
+      const arr = []
+      for (let n = decoding.readVarUint(rest); n > 0; n--) arr.push(readValue(decoder))
+      return arr
+    }
+    default:
+      return decoding.readAny(rest)
+  }
+}
+// YP24 end
 
 export class IdSetDecoder {
   /**
@@ -18,6 +62,15 @@ export class IdSetDecoder {
     this.dsCurrVal = 0
   }
 
+  /**
+   * YP26: the client of a delete set's ranges.
+   *
+   * @return {number}
+   */
+  readDsClient () {
+    return decoding.readVarUint(this.restDecoder)
+  }
+
   /**
    * @return {number}
    */
@@ -49,38 +102,60 @@ export class UpdateDecoder extends IdSetDecoder {
      * @type {Array<string>}
      */
     this.keys = []
-    decoding.readVarUint(decoder) // read feature flag - currently unused
-    this.keyClockDecoder = new decoding.IntDiffOptRleDecoder(decoding.readVarUint8Array(decoder))
+    // YP24: the feature flag names the encoding; another one (upstream's `0`) is refused
+    if (decoding.readVarUint(decoder) !== UPDATE_ENCODING) throw error.create('an update of another encoding')
+    this.keyClockDecoder = new decoding.UintOptRleDecoder(decoding.readVarUint8Array(decoder)) // YP24
     this.clientDecoder = new decoding.UintOptRleDecoder(decoding.readVarUint8Array(decoder))
     this.leftClockDecoder = new decoding.IntDiffOptRleDecoder(decoding.readVarUint8Array(decoder))
     this.rightClockDecoder = new decoding.IntDiffOptRleDecoder(decoding.readVarUint8Array(decoder))
     this.infoDecoder = new decoding.RleDecoder(decoding.readVarUint8Array(decoder), decoding.readUint8)
     this.stringDecoder = new decoding.StringDecoder(decoding.readVarUint8Array(decoder))
-    this.parentInfoDecoder = new decoding.RleDecoder(decoding.readVarUint8Array(decoder), decoding.readUint8)
     this.typeRefDecoder = new decoding.UintOptRleDecoder(decoding.readVarUint8Array(decoder))
     this.lenDecoder = new decoding.UintOptRleDecoder(decoding.readVarUint8Array(decoder))
+    // YP26 begin: the update's client table, read as its indices are
+    /**
+     * @type {Array<number>}
+     */
+    this.clients = []
+    // YP26 end
   }
 
   /**
    * @return {ID}
    */
   readLeftID () {
-    return new ID(this.clientDecoder.read(), this.leftClockDecoder.read())
+    return new ID(this.readClient(), this.leftClockDecoder.read())
   }
 
   /**
    * @return {ID}
    */
   readRightID () {
-    return new ID(this.clientDecoder.read(), this.rightClockDecoder.read())
+    return new ID(this.readClient(), this.rightClockDecoder.read())
   }
 
   /**
    * Read the next client id.
    * Use this in favor of readID whenever possible to reduce the number of objects created.
+   * YP26: an index in the update's client table (a new one's id follows it).
+   *
+   * @return {number}
    */
   readClient () {
-    return this.clientDecoder.read()
+    const index = this.clientDecoder.read()
+    const clients = this.clients
+    if (index === clients.length) clients.push(this.clientDecoder.read())
+    else if (index > clients.length) throw error.create('an unknown client')
+    return clients[index]
+  }
+
+  /**
+   * YP26: a delete set's client, from the client table.
+   *
+   * @return {number}
+   */
+  readDsClient () {
+    return this.readClient()
   }
 
   /**
@@ -97,13 +172,6 @@ export class UpdateDecoder extends IdSetDecoder {
     return this.stringDecoder.read()
   }
 
-  /**
-   * @return {boolean}
-   */
-  readParentInfo () {
-    return this.parentInfoDecoder.read() === 1
-  }
-
   /**
    * @return {number} An unsigned 8-bit integer
    */
@@ -124,7 +192,7 @@ export class UpdateDecoder extends IdSetDecoder {
    * @return {any}
    */
   readAny () {
-    return decoding.readAny(this.restDecoder)
+    return readValue(this) // YP24
   }
 
   /**
@@ -138,20 +206,22 @@ export class UpdateDecoder extends IdSetDecoder {
    * @return {any}
    */
   readJSON () {
-    return decoding.readAny(this.restDecoder)
+    return readValue(this) // YP24
   }
 
   /**
    * @return {string}
    */
   readKey () {
+    // YP24: `0` a new string, else the index of a known one plus one
     const keyClock = this.keyClockDecoder.read()
-    if (keyClock < this.keys.length) {
-      return this.keys[keyClock]
-    } else {
+    if (keyClock === 0) {
       const key = this.stringDecoder.read()
       this.keys.push(key)
       return key
     }
+    if (keyClock > this.keys.length) throw error.create('an unknown key')
+    return this.keys[keyClock - 1]
   }
+
 }

package/dist/crdt/vendor/yjs/src/utils/UpdateEncoder.js

@@ -1,6 +1,63 @@
 import * as error from 'lib0-v14/error'
 import * as encoding from 'lib0-v14/encoding'
 
+// YP24 begin (edytor fork: one string table per update — see UPSTREAM.md YP24)
+/**
+ * The update encoding this fork writes and reads, in upstream's reserved
+ * feature-flag varuint (upstream writes `0`): `1`, a string table per update.
+ */
+export const UPDATE_ENCODING = 1
+
+/**
+ * YP28: whether `x` is an integer past 31 bits a varint holds exactly.
+ *
+ * @param {any} x
+ * @return {boolean}
+ */
+const large = x => Number.isInteger(x) && x > 0x7fffffff && x <= Number.MAX_SAFE_INTEGER
+
+/**
+ * Write a content value in lib0's `writeAny` layout, its strings and object
+ * keys through the update's string table (`writeKey`).
+ *
+ * @param {UpdateEncoder} encoder
+ * @param {any} data
+ */
+const writeValue = (encoder, data) => {
+  const rest = encoder.restEncoder
+  if (typeof data === 'string') {
+    encoding.write(rest, 119)
+    encoder.writeKey(data)
+  } else if (large(data)) {
+    // YP28: an integer past lib0's 31 bits (a float64 there) as a varint
+    encoding.write(rest, 115)
+    encoding.writeVarUint(rest, data)
+  } else if (data !== null && typeof data === 'object' && !(data instanceof Uint8Array)) {
+    if (Array.isArray(data) && data.length === 2 && large(data[0]) && Number.isInteger(data[1]) && data[1] >= 0) {
+      // YP28: a pair of a large integer and a clock (an item id, a block
+      // slot's split key) names its first through the client table
+      encoding.write(rest, 114)
+      encoder.clientIndex(data[0])
+      encoding.writeVarUint(rest, data[1])
+    } else if (Array.isArray(data)) {
+      encoding.write(rest, 117)
+      encoding.writeVarUint(rest, data.length)
+      for (let i = 0; i < data.length; i++) writeValue(encoder, data[i])
+    } else {
+      const keys = Object.keys(data)
+      encoding.write(rest, 118)
+      encoding.writeVarUint(rest, keys.length)
+      for (let i = 0; i < keys.length; i++) {
+        encoder.writeKey(keys[i])
+        writeValue(encoder, data[keys[i]])
+      }
+    }
+  } else {
+    encoding.writeAny(rest, data)
+  }
+}
+// YP24 end
+
 export class IdSetEncoder {
   constructor () {
     this.restEncoder = encoding.createEncoder() // encodes all the rest / non-optimized
@@ -15,6 +72,15 @@ export class IdSetEncoder {
     this.dsCurrVal = 0
   }
 
+  /**
+   * YP26: the client of a delete set's ranges.
+   *
+   * @param {number} client
+   */
+  writeDsClient (client) {
+    encoding.writeVarUint(this.restEncoder, client)
+  }
+
   /**
    * @param {number} clock
    */
@@ -50,27 +116,52 @@ export class UpdateEncoder extends IdSetEncoder {
      * @type {number}
      */
     this.keyClock = 0
-    this.keyClockEncoder = new encoding.IntDiffOptRleEncoder()
+    this.keyClockEncoder = new encoding.UintOptRleEncoder() // YP24: 0 a new string, else its index + 1
     this.clientEncoder = new encoding.UintOptRleEncoder()
     this.leftClockEncoder = new encoding.IntDiffOptRleEncoder()
     this.rightClockEncoder = new encoding.IntDiffOptRleEncoder()
     this.infoEncoder = new encoding.RleEncoder(encoding.writeUint8)
     this.stringEncoder = new encoding.StringEncoder()
-    this.parentInfoEncoder = new encoding.RleEncoder(encoding.writeUint8)
     this.typeRefEncoder = new encoding.UintOptRleEncoder()
     this.lenEncoder = new encoding.UintOptRleEncoder()
+    // YP26 begin: one client table per update
+    /**
+     * Each client's index, in first-use order.
+     *
+     * @type {Map<number,number>}
+     */
+    this.clientTable = new Map()
+    // YP26 end
+  }
+
+  /**
+   * YP26: write `client` to the client column as its index in the update's
+   * client table, in first-use order: a new client's index (the table's
+   * size) is followed by its id, once.
+   *
+   * @param {number} client
+   */
+  clientIndex (client) {
+    const index = this.clientTable.get(client)
+    if (index === undefined) {
+      const next = this.clientTable.size
+      this.clientTable.set(client, next)
+      this.clientEncoder.write(next)
+      this.clientEncoder.write(client)
+    } else {
+      this.clientEncoder.write(index)
+    }
   }
 
   toUint8Array () {
     const encoder = encoding.createEncoder()
-    encoding.writeVarUint(encoder, 0) // this is a feature flag that we might use in the future
+    encoding.writeVarUint(encoder, UPDATE_ENCODING) // YP24: the feature flag names the encoding
     encoding.writeVarUint8Array(encoder, this.keyClockEncoder.toUint8Array())
     encoding.writeVarUint8Array(encoder, this.clientEncoder.toUint8Array())
     encoding.writeVarUint8Array(encoder, this.leftClockEncoder.toUint8Array())
     encoding.writeVarUint8Array(encoder, this.rightClockEncoder.toUint8Array())
     encoding.writeVarUint8Array(encoder, encoding.toUint8Array(this.infoEncoder))
     encoding.writeVarUint8Array(encoder, this.stringEncoder.toUint8Array())
-    encoding.writeVarUint8Array(encoder, encoding.toUint8Array(this.parentInfoEncoder))
     encoding.writeVarUint8Array(encoder, this.typeRefEncoder.toUint8Array())
     encoding.writeVarUint8Array(encoder, this.lenEncoder.toUint8Array())
     // @note The rest encoder is appended! (note the missing var)
@@ -82,7 +173,7 @@ export class UpdateEncoder extends IdSetEncoder {
    * @param {ID} id
    */
   writeLeftID (id) {
-    this.clientEncoder.write(id.client)
+    this.clientIndex(id.client) // YP26
     this.leftClockEncoder.write(id.clock)
   }
 
@@ -90,7 +181,7 @@ export class UpdateEncoder extends IdSetEncoder {
    * @param {ID} id
    */
   writeRightID (id) {
-    this.clientEncoder.write(id.client)
+    this.clientIndex(id.client) // YP26
     this.rightClockEncoder.write(id.clock)
   }
 
@@ -98,7 +189,16 @@ export class UpdateEncoder extends IdSetEncoder {
    * @param {number} client
    */
   writeClient (client) {
-    this.clientEncoder.write(client)
+    this.clientIndex(client) // YP26
+  }
+
+  /**
+   * YP26: a delete set's client goes through the client table too.
+   *
+   * @param {number} client
+   */
+  writeDsClient (client) {
+    this.writeClient(client)
   }
 
   /**
@@ -115,13 +215,6 @@ export class UpdateEncoder extends IdSetEncoder {
     this.stringEncoder.write(s)
   }
 
-  /**
-   * @param {boolean} isYKey
-   */
-  writeParentInfo (isYKey) {
-    this.parentInfoEncoder.write(isYKey ? 1 : 0)
-  }
-
   /**
    * @param {number} info An unsigned 8-bit integer
    */
@@ -142,7 +235,7 @@ export class UpdateEncoder extends IdSetEncoder {
    * @param {any} any
    */
   writeAny (any) {
-    encoding.writeAny(this.restEncoder, any)
+    writeValue(this, any) // YP24
   }
 
   /**
@@ -156,7 +249,7 @@ export class UpdateEncoder extends IdSetEncoder {
    * @param {any} embed
    */
   writeJSON (embed) {
-    encoding.writeAny(this.restEncoder, embed)
+    writeValue(this, embed) // YP24
   }
 
   /**
@@ -165,29 +258,23 @@ export class UpdateEncoder extends IdSetEncoder {
    *
    * We cache these keys in a Map and refer to them via a unique number.
    *
+   * YP24: the cache is on (upstream left it off for decoders older than its
+   * own), and every map key, root name and string of a content value goes
+   * through it: an update writes each distinct string once. The key column
+   * says `0` for a new string (the next in the string column) and the index
+   * of a known one plus one, so a key repeated block after block is the same
+   * small number every time.
+   *
    * @param {string} key
    */
   writeKey (key) {
     const clock = this.keyMap.get(key)
     if (clock === undefined) {
-      /**
-       * @todo uncomment to introduce this feature finally
-       *
-       * Background. The ContentFormat object was always encoded using writeKey, but the decoder used to use readString.
-       * Furthermore, I forgot to set the keyclock. So everything was working fine.
-       *
-       * However, this feature here is basically useless as it is not being used (it actually only consumes extra memory).
-       *
-       * I don't know yet how to reintroduce this feature..
-       *
-       * Older clients won't be able to read updates when we reintroduce this feature. So this should probably be done using a flag.
-       *
-       */
-      // this.keyMap.set(key, this.keyClock)
-      this.keyClockEncoder.write(this.keyClock++)
+      this.keyMap.set(key, this.keyClock++)
+      this.keyClockEncoder.write(0)
       this.stringEncoder.write(key)
     } else {
-      this.keyClockEncoder.write(clock)
+      this.keyClockEncoder.write(clock + 1)
     }
   }
 }

package/dist/crdt/vendor/yjs/src/utils/encoding.js

@@ -29,7 +29,7 @@ import { UpdateEncoder } from './UpdateEncoder.js'
 import { LazyStructReader, LazyStructWriter, writeStructToLazyStructWriter, finishLazyStructWriting } from './updates.js'
 import { readBlockSet, writeBlockSet } from './BlockSet.js'
 import { Skip } from '../structs/Skip.js'
-import { Item } from '../structs/Item.js'
+import { Item, applyPending, ContentMove } from '../structs/Item.js' // YP20, YP22: applyPending, ContentMove
 import { GC } from '../structs/GC.js'
 import { Doc } from './Doc.js'
 import { transact } from './Transaction.js'
@@ -287,6 +287,7 @@ export const readUpdate = (decoder, ydoc, transactionOrigin, structDecoder = new
     // start = performance.now()
     // console.log('time to merge: ', performance.now() - start) // @todo remove
     // start = performance.now()
+    const arrived = Array.from(ss.clients.keys()) // YP20, YP22: a hold or a move of this update may wait for another of its clients
     const restStructs = integrateStructs(transaction, store, ss)
     const pending = store.pendingStructs
     if (pending) {
@@ -312,6 +313,7 @@ export const readUpdate = (decoder, ydoc, transactionOrigin, structDecoder = new
     }
     // console.log('time to integrate: ', performance.now() - start) // @todo remove
     // start = performance.now()
+    if (store.pendingHolds !== null) applyPending(transaction, arrived) // YP20: the holds that waited for what just arrived
     const dsRest = readAndApplyDeleteSet(structDecoder, transaction, store)
     if (store.pendingDs) {
       // @todo we could make a lower-bound state-vector check as we do above
@@ -529,6 +531,16 @@ const getMissing = (struct, transaction, store) => {
   if (parent && parent.constructor === ID && (parent.clock >= store.getClock(parent.client) || store.skips.hasId(parent))) {
     return parent.client
   }
+  if (struct.content.constructor === ContentMove) { // YP22: a move record waits for the units it names and stands at
+    // (a skip stands for none of them: its sort reads the units' order, `sourceOrder`)
+    const { ids, at } = /** @type {ContentMove} */ (struct.content)
+    if (at !== null) {
+      for (const id of at) if (id.clock >= store.getClock(id.client) || store.skips.hasId(id)) return id.client
+    }
+    for (let i = 0; i < ids.length; i += 3) {
+      if (ids[i + 1] + ids[i + 2] > store.getClock(ids[i]) || store.skips.intersects(ids[i], ids[i + 1], ids[i + 2])) return ids[i]
+    }
+  }
   // We have all missing ids, now find the items
   if (origin) {
     struct.left = getItemCleanEnd(transaction, store, origin)