edytor 3.0.0 → 4.0.0

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

@@ -481,11 +481,11 @@ export const createDeleteSetFromStructStore = ss => {
     const dsitems = []
     for (let i = 0; i < structs.length; i++) {
       const struct = structs[i]
-      if (struct.deleted) {
+      if (struct.removed) { // YP20: a held item is not deleted
         const clock = struct.id.clock
         let len = struct.length
         if (i + 1 < structs.length) {
-          for (let next = structs[i + 1]; i + 1 < structs.length && next.deleted; next = structs[++i + 1]) {
+          for (let next = structs[i + 1]; i + 1 < structs.length && next.removed; next = structs[++i + 1]) {
             len += next.length
           }
         }
@@ -514,7 +514,7 @@ export const writeIdSet = (encoder, idSet) => {
     .forEach(([client, _idRanges]) => {
       const idRanges = _idRanges.getIds()
       encoder.resetIdSetCurVal()
-      encoding.writeVarUint(encoder.restEncoder, client)
+      encoder.writeDsClient(client) // YP26
       const len = idRanges.length
       encoding.writeVarUint(encoder.restEncoder, len)
       for (let i = 0; i < len; i++) {
@@ -537,7 +537,7 @@ export const readIdSet = decoder => {
   const numClients = decoding.readVarUint(decoder.restDecoder)
   for (let i = 0; i < numClients; i++) {
     decoder.resetDsCurVal()
-    const client = decoding.readVarUint(decoder.restDecoder)
+    const client = decoder.readDsClient() // YP26
     const numberOfDeletes = decoding.readVarUint(decoder.restDecoder)
     if (numberOfDeletes > 0) {
       /**
@@ -571,7 +571,7 @@ export const readAndApplyDeleteSet = (decoder, transaction, store) => {
   const numClients = decoding.readVarUint(decoder.restDecoder)
   for (let i = 0; i < numClients; i++) {
     decoder.resetDsCurVal()
-    const client = decoding.readVarUint(decoder.restDecoder)
+    const client = decoder.readDsClient() // YP26
     const numberOfDeletes = decoding.readVarUint(decoder.restDecoder)
     const structs = store.clients.get(client) || []
     const state = store.getClock(client)
@@ -589,7 +589,7 @@ export const readAndApplyDeleteSet = (decoder, transaction, store) => {
          */
         let struct = structs[index]
         // split the first item if necessary
-        if (!struct.deleted && struct.id.clock < clock && struct.isItem) {
+        if (!struct.removed && struct.id.clock < clock && struct.isItem) { // YP20: removed, not held
           // increment index, we now want to use the next struct
           structs.splice(++index, 0, /** @type {Item} */ (struct).split(transaction, clock - struct.id.clock))
         }
@@ -597,7 +597,7 @@ export const readAndApplyDeleteSet = (decoder, transaction, store) => {
           // @ts-ignore
           struct = structs[index++]
           if (struct.id.clock < clockEnd) {
-            if (!struct.deleted) {
+            if (!struct.removed) { // YP20
               if (struct.isItem) {
                 if (clockEnd < struct.id.clock + struct.length) {
                   structs.splice(index, 0, /** @type {Item} */ (struct).split(transaction, clockEnd - struct.id.clock))

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

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import('./Transaction.js').Transaction} Transaction
+ */
+
 /**
  * Paired marks — an edytor fork addition (UPSTREAM.md YP13), not upstream source.
  *
@@ -117,33 +121,214 @@ export const formatValue = value => value instanceof MarkState ? value.value : v
 /**
  * The integration class of an item among the items of one origin: a
  * left-side mark item `0`, content and plain formats `1`, a right-side
- * mark item `2`. Deleted or collected items keep the class their content
- * gave them while it is there; a collected format item (its content gone)
- * would read `1`, which is why the fork never collects a paired mark item's
- * content (`ContentFormat#gc` keeps it).
+ * mark item `2`, a claim item `3` (YP21: a sequence unit `{ m }`, after
+ * everything else, so content and boundaries a concurrent writer puts at
+ * its origin land before it), a move record `4` or `5` by its side (YP22:
+ * after every slot of its origin — a split's pieces first — and a record
+ * standing after what precedes it before one standing before what follows
+ * it: the order every serial run of the gestures gives). Deleted or collected items keep the class
+ * their content gave them while it is there; a collected item (its content
+ * gone) would read `1`, which is why the fork never collects the content of
+ * an item of another class (`Item#gc` keeps it).
  *
  * @param {any} item
  * @return {number}
  */
 export const markClass = item => {
   const content = item.content
-  if (content === undefined || typeof content.key !== 'string') return 1
+  if (content === undefined) return 1
+  if (content.cls !== undefined) return content.cls // YP29: a collected mark or claim (`ContentDeleted`)
+  if (typeof content.key !== 'string') {
+    // YP22: a move record (its side: 0 after, 1 before)
+    if (content.priority !== undefined && content.ids !== undefined) return 4 + content.side
+    // YP21: a claim item
+    return item.parentSub === null && typeof content.arr?.[0]?.m === 'string' ? 3 : 1
+  }
   const role = pairedRole(content)
   if (role < 0) return 1
   const side = role === 0 ? content.value[4] : content.value[2]
   return side === SIDE_LEFT ? 0 : 2
 }
 
+/**
+ * YP22: the unit id `client:clock` names, as its item and clock, `null` where
+ * a GC struct replaced it.
+ *
+ * @param {import('./StructStore.js').StructStore} store
+ * @param {number} client
+ * @param {number} clock
+ * @return {{ item: any, clock: number } | null}
+ */
+const unitAt = (store, client, clock) => {
+  const item = store.getItem({ client, clock })
+  return item.isItem ? { item, clock } : null
+}
+
+/**
+ * YP22: the order of two units (`unitAt`): by clock in one item, else by
+ * `sequenceOrder` (`NaN`: not in one sequence); `0` for one unit.
+ *
+ * @param {{ item: any, clock: number }} p
+ * @param {{ item: any, clock: number }} q
+ * @return {number}
+ */
+const unitOrder = (p, q) => (p.item === q.item ? p.clock - q.clock : sequenceOrder(p.item, q.item))
+
+/**
+ * YP22: a block slot's split key (`{ b, s: [client, clock] }`: the id of the
+ * boundary item of the split that made the block, kept when the slot is
+ * collected, `Item#gc`) as a unit (`unitAt`: `null` where a GC struct
+ * replaced the boundary), `undefined` for any other item (a slot no split
+ * made, a boundary, whose own `s` names a block).
+ *
+ * @param {any} item
+ * @param {import('./StructStore.js').StructStore} store
+ * @return {{ item: any, clock: number } | null | undefined}
+ */
+const splitKey = (item, store) => {
+  const s = item.content.arr?.[0]?.s
+  return Array.isArray(s) ? unitAt(store, s[0], s[1]) : undefined
+}
+
+/**
+ * YP22: whether `item` is a list item outside a text (a block's or an
+ * array's slot: its parent is no `content` node) written by the writer of
+ * its origin: it extends that writer's run there, and sorts before every
+ * other writer's slot of the same origin (`order.insert.run`: the lines one
+ * writer types after its own line stay together around a peer's line
+ * inserted there meanwhile). Read from the item's ids and parent, which
+ * collection never changes, so every replica integrates alike.
+ *
+ * @param {any} item
+ * @return {boolean}
+ */
+const extendsRun = (/** @type {Item} */ item) =>
+  item.parentSub === null && /** @type {YNode} */ (item.parent).name !== 'content' && item.origin !== null && item.origin.client === item.id.client
+
+/**
+ * YP22: the order of two items of one sequence (one parent, one key):
+ * negative when `x` stands before `y`, positive after, `0` for one item,
+ * `NaN` when they are not in one sequence. The walk goes left from both at
+ * once, so it costs the distance between them.
+ *
+ * @param {any} x
+ * @param {any} y
+ * @return {number}
+ */
+export const sequenceOrder = (x, y) => {
+  if (x === y) return 0
+  if (x.parent !== y.parent || x.parentSub !== y.parentSub) return NaN
+  for (let l = x, r = y; ;) {
+    l = l.left
+    r = r.left
+    if (l === y || r === null) return 1
+    if (r === x || l === null) return -1
+  }
+}
+
+/**
+ * YP22: the chain record `r` stands at, outermost first — the units its
+ * writer named (`at`: the home slots from the root sequence down to the unit
+ * it stands at), else the first unit it moves — each as its item and clock,
+ * `null` where a GC struct replaced it.
+ *
+ * @param {any} r
+ * @param {import('./StructStore.js').StructStore} store
+ * @return {Array<{ item: any, clock: number } | null>}
+ */
+const chainOf = (r, store) => {
+  const c = r.content
+  return c.at !== null
+    ? c.at.map((/** @type {ID} */ id) => unitAt(store, id.client, id.clock))
+    : c.ids.length > 0 ? [unitAt(store, c.ids[0], c.ids[1])] : []
+}
+
+/**
+ * YP22: the order of two move records at one origin: by the chains they
+ * stand at (`chainOf`), level by level from the root — two units of one
+ * sequence by `sequenceOrder` (one item: by clock), a unit before the units
+ * inside its block (the shorter chain first); chains that meet no common
+ * sequence order nothing — then by their `part` (the writer's order among
+ * the records standing at one unit), then the stronger record first (the
+ * greater priority, then client: a unit both move shows at the first of the
+ * two). Two writers that move blocks out of one list into one gap at once (an
+ * outdent, a lift, a divider after an item) keep the list's order there and
+ * every serial order's placement of what stands at one item, whatever their
+ * client ids (the delete contract's CW-01 and DR-crdt-6 rules). It reads only
+ * the records and the units they name, all present when a record integrates
+ * (`getMissing`), so every replica sorts alike in any delivery order.
+ *
+ * @param {any} o
+ * @param {any} item
+ * @param {Transaction} tr
+ * @return {number}
+ */
+const sourceOrder = (o, item, tr) => {
+  const store = tr.doc.store
+  const x = chainOf(o, store)
+  const y = chainOf(item, store)
+  let d = 0
+  for (let i = 0; ; i++) {
+    const p = x[i]
+    const q = y[i]
+    if (p === undefined || q === undefined) {
+      d = (p === undefined ? 0 : 1) - (q === undefined ? 0 : 1)
+      break
+    }
+    if (p === null || q === null) break
+    d = unitOrder(p, q)
+    if (d === 0) continue
+    if (Number.isNaN(d)) d = 0
+    break
+  }
+  if (d === 0) d = o.content.part - item.content.part
+  if (d === 0) d = item.content.priority - o.content.priority || item.id.client - o.id.client
+  return d
+}
+
 /**
  * Whether `o` sorts before `item` among the items of one origin (the
- * integration's conflict rule): by class, then by client id as upstream.
+ * integration's conflict rule): by class, then (YP22) block slots by their
+ * split key and the origin writer's own first, records by `sourceOrder`,
+ * then by client id as upstream.
  *
  * @param {any} o
  * @param {any} item
+ * @param {Transaction} tr
  * @return {boolean}
  */
-export const sortsBefore = (o, item) => {
+export const sortsBefore = (o, item, tr) => {
   const a = markClass(o)
   const b = markClass(item)
-  return a !== b ? a < b : o.id.client < item.id.client
+  if (a !== b) return a < b
+  if (a === 1) {
+    // YP22: block slots a split made sort by their boundaries' order in the
+    // text (two writers' splits of one block keep its text's order), before
+    // the slots no split made; then the origin writer's own slots first.
+    const store = tr.doc.store
+    const x = splitKey(o, store)
+    const y = splitKey(item, store)
+    if (x !== undefined || y !== undefined) {
+      if (x === undefined || y === undefined) return y === undefined
+      if (x !== null && y !== null) {
+        // One total order over the keyed slots of an origin: the boundaries' text
+        // first (by the text node's item id, a root text first), then their place in
+        // it (two boundaries one item holds: their clocks).
+        const px = /** @type {YNode} */ (x.item.parent)._item
+        const py = /** @type {YNode} */ (y.item.parent)._item
+        if (x.item.parent !== y.item.parent) {
+          if (px === null || py === null) return px === null
+          return (px.id.client - py.id.client || px.id.clock - py.id.clock) < 0
+        }
+        const d = unitOrder(x, y)
+        if (d !== 0) return d < 0
+      }
+    }
+    const run = extendsRun(o)
+    if (run !== extendsRun(item)) return run
+  } else if (a >= 4) {
+    const d = sourceOrder(o, item, tr)
+    if (d !== 0) return d < 0
+  }
+  return o.id.client < item.id.client
 }

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

@@ -38,7 +38,7 @@ export const redoItem = (transaction, item, redoitems, itemsToDelete, deletedByH
    */
   let right
   // make sure that parent is redone
-  if (parentItem !== null && parentItem.deleted === true) {
+  if (parentItem !== null && parentItem.removed) { // YP20: a held parent is alive
     // try to undo parent if it will be undone anyway
     if (parentItem.redone === null && (!redoitems.has(parentItem) || redoItem(transaction, parentItem, redoitems, itemsToDelete, deletedByHistory) === null)) {
       return null

package/dist/crdt/vendor/yjs/src/utils/transaction-helpers.js

@@ -245,7 +245,7 @@ export const tryGcDeleteSet = (tr, ds, gcFilter) => {
         if (deleteItem.clock + deleteItem.len <= struct.id.clock) {
           break
         }
-        if (struct.isItem && struct.deleted && !(struct).keep && !isKeptReplaced(/** @type {Item} */ (struct)) && gcFilter(/** @type {Item} */ (struct))) { // YP14
+        if (struct.isItem && struct.removed && !(struct).keep && !isKeptReplaced(/** @type {Item} */ (struct)) && gcFilter(/** @type {Item} */ (struct))) { // YP14, YP20: removed
           /** @type {Item} */ (struct).gc(tr, false)
         }
       }

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

@@ -42,9 +42,9 @@ function * lazyStructReaderGenerator (decoder) {
           null, // right
           (info & binary.BIT7) === binary.BIT7 ? decoder.readRightID() : null, // right origin
           // @ts-ignore Force writing a string here.
-          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)
         )
         yield struct
         clock += struct.length

package/dist/crdt/vendor/yjs/src/ynode.js

@@ -10,6 +10,9 @@ import {
   ContentFormat,
   ContentString,
   ContentType,
+  ContentHold, // YP20
+  ContentMove, // YP22
+  readFormatValue, // YP25
   YXmlFragmentRefID,
   YXmlElementRefID,
   YXmlHookRefID
@@ -248,7 +251,7 @@ const insertMarkItem = (transaction, parent, index, side, content) => {
 const markHelper = (transaction, parent, index, length, mark, value, startSide, endSide) => {
   const doc = transaction.doc
   const client = doc.clientID
-  const l = /** @type {any} */ (doc)._markClock + 1
+  const l = /** @type {any} */ (doc)._clock + 1 // YP22: one clock with the move records
   const k = doc.store.getClock(client)
   insertMarkItem(transaction, parent, index, startSide, new ContentFormat(MARK_START + mark, [value, l, client, k, startSide]))
   insertMarkItem(transaction, parent, index + length, endSide, new ContentFormat(MARK_END + mark, [client, k, endSide]))
@@ -292,28 +295,74 @@ export const insertAtGapEndHelper = (transaction, parent, index, content) => {
 }
 // YP7 end
 
+// YP20 begin (edytor fork: hold records — see UPSTREAM.md YP20)
 /**
+ * The first clock in `(clock, end)` where membership in `set` changes, else `end`.
+ *
+ * @param {import('./utils/ids.js').IdSet} set
+ * @param {number} client
+ * @param {number} clock
+ * @param {number} end
+ * @return {number}
+ */
+const runEnd = (set, client, clock, end) => {
+  for (const r of set.clients.get(client)?.getIds() ?? []) {
+    if (r.clock > clock) return math.min(r.clock, end)
+    if (r.clock + r.len > clock) return math.min(r.clock + r.len, end)
+  }
+  return end
+}
+
+/**
+ * Append a hold record of `ids` to `list` (the document's records list).
+ *
+ * @param {Transaction} transaction
+ * @param {YNode} list
+ * @param {Array<number>} ids
+ */
+const holdHelper = (transaction, list, ids) => {
+  insertInGapHelper(transaction, list, list._length, new ContentHold(ids))
+}
+// YP20 end
+
+/**
+ * With `held`, the live units are not deleted: their ids go to `held`
+ * (`client, clock, len`), except those `fresh` names (YP20).
+ *
  * @param {Transaction} transaction
  * @param {ItemTextListPosition} currPos
  * @param {number} length
+ * @param {Array<number>|null} [held]
+ * @param {import('./utils/ids.js').IdSet|null} [fresh]
  * @return {ItemTextListPosition}
  *
  * @private
  * @function
  */
-export const deleteText = (transaction, currPos, length) => {
+export const deleteText = (transaction, currPos, length, held = null, fresh = null) => {
   const startLength = length
+  let kept = 0 // YP20
   while (length > 0 && currPos.right !== null) {
     const item = currPos.right
     if (!item.deleted && item.countable) {
-      if (length < item.length) {
-        getItemCleanStart(transaction, createID(item.id.client, item.id.clock + length))
+      const { client, clock } = item.id
+      // YP20: a held run ends where the open step's inserts start or end
+      const n = fresh === null ? math.min(length, item.length) : runEnd(fresh, client, clock, clock + math.min(length, item.length)) - clock
+      if (n < item.length) {
+        getItemCleanStart(transaction, createID(client, clock + n))
       }
       length -= item.length
-      item.delete(transaction)
+      if (held === null || (fresh !== null && fresh.has(client, clock))) {
+        item.delete(transaction)
+      } else {
+        held.push(client, clock, item.length)
+        kept += item.length
+      }
     }
     currPos.forward()
   }
+  // YP20: the held units hide when their record integrates
+  currPos.index -= kept
   const parent = /** @type {YNode} */ (/** @type {Item} */ (currPos.left || currPos.right).parent)
   if (parent._searchMarker) {
     updateMarkerChanges(parent._searchMarker, currPos.index, -startLength + length)
@@ -939,11 +988,17 @@ export class YNode {
 
   /**
    * Deletes elements starting from an index. A deleted node is left as it is.
+   * YP20: with `into` (the document's records list), the live units are not
+   * removed but held by one record appended to `into` (their writer's delete,
+   * which an undo of the record takes back), except those `fresh` names (the
+   * open undo step's inserts: removed, so that step's undo changes nothing).
    *
    * @param {number} index Index at which to start deleting elements
    * @param {number} length The number of elements to remove. Defaults to 1.
+   * @param {YNode|null} [into]
+   * @param {import('./utils/ids.js').IdSet|null} [fresh]
    */
-  delete (index, length = 1) {
+  delete (index, length = 1, into = null, fresh = null) {
     if (!(length > 0)) return
     if (this.doc == null) {
       const runs = prelimOf(this).runs
@@ -959,11 +1014,59 @@ export class YNode {
     if (this._item !== null && this._item.deleted) return
     transact(this.doc, transaction => {
       const currPos = cursorAt(transaction, this, index)
-      deleteText(transaction, currPos, length)
+      const held = into === null ? null : [] // YP20
+      deleteText(transaction, currPos, length, held, fresh)
+      if (held !== null && held.length > 0) {
+        // YP20: `deleteText` moved the markers as for a delete; the hold keeps them
+        const ms = this._searchMarker === null ? null : this._searchMarker.slice()
+        holdHelper(transaction, /** @type {YNode} */ (into), held)
+        if (ms !== null && this._searchMarker !== null) this._searchMarker.splice(0, this._searchMarker.length, ...ms)
+      }
       plantMarker(this, currPos)
     })
   }
 
+  /**
+   * YP20: append to this node (the document's records list) one hold record of
+   * the items `ids` names (`client, clock, len` triples): they read as deleted
+   * while the record is live.
+   *
+   * @param {Array<number>} ids
+   */
+  hold (ids) {
+    if (this.doc == null) throw new Error('hold: node is not integrated')
+    if (ids.length > 0) transact(this.doc, transaction => holdHelper(transaction, this, ids))
+  }
+
+  // YP22 begin (edytor fork: move records — see UPSTREAM.md YP22)
+  /**
+   * YP22: move the units `ids` (`client, clock, len` ranges, in the order
+   * they will show) to live index `index` of this sequence: one move record
+   * there (`ContentMove`); `side` is its class among the items of its origin
+   * (`0` after, `1` before), `at` the chain it stands at for the sort of two
+   * records at one origin — the units from the root sequence down to the
+   * unit it stands at, outermost first (`null`: the first unit it names) —
+   * and `part` the writer's order among the records standing at that unit.
+   *
+   * @param {number} index
+   * @param {Array<number>} ids
+   * @param {number} [side]
+   * @param {number} [part]
+   * @param {Array<ID>|null} [at]
+   */
+    move (index, ids, side = 0, part = 0, at = null) {
+    if (this.doc == null) throw new Error('move: node is not integrated')
+    if (ids.length === 0) return
+    transact(this.doc, transaction => {
+      // Above every record seen from a peer (`_clock`, raised by remote records
+      // only): this writer's records keep one priority until it sees another's,
+      // so its gestures win or lose together against a concurrent peer's.
+      const priority = /** @type {any} */ (transaction.doc)._clock + 1
+      insertInGapHelper(transaction, this, index, new ContentMove(priority, side, ids, part, at))
+    })
+  }
+  // YP22 end
+
   /**
    * Executes a provided function on once on every key-value pair.
    *
@@ -1081,9 +1184,13 @@ export const readContentString = decoder => new ContentString(decoder.readString
 
 /**
  * @param {UpdateDecoder} decoder
+ * @param {import('./utils/ID.js').ID} id YP25: the item's id (a paired mark's operation id is usually it)
  * @return {ContentFormat}
  */
-export const readContentFormat = decoder => new ContentFormat(decoder.readKey(), decoder.readJSON())
+export const readContentFormat = (decoder, id) => {
+  const key = decoder.readKey()
+  return new ContentFormat(key, readFormatValue(decoder, key, id)) // YP25
+}
 
 /**
  * @param {UpdateDecoder} decoder
@@ -1112,14 +1219,68 @@ export const readContentBinary = decoder => new ContentBinary(decoder.readBuf())
  */
 export const readContentDeleted = decoder => new ContentDeleted(decoder.readLen())
 
+/**
+ * YP20, YP22: a record's id ranges, a count then one `client, clock, len` each.
+ *
+ * @param {UpdateDecoder} decoder
+ * @return {Array<number>}
+ */
+const readIds = decoder => {
+  const ids = []
+  for (let n = decoder.readLen(); n > 0; n--) {
+    const id = decoder.readLeftID()
+    ids.push(id.client, id.clock, decoder.readLen())
+  }
+  return ids
+}
+
+/**
+ * YP20: a hold record, one `client, clock, len` per unit.
+ *
+ * @param {UpdateDecoder} decoder
+ * @return {ContentHold}
+ */
+export const readContentHold = decoder => new ContentHold(readIds(decoder))
+
+/**
+ * YP22: a move record: its priority, side, part and whether an anchor chain
+ * follows in one word, the chain (a count, then its units), then one
+ * `client, clock, len` per range.
+ *
+ * @param {UpdateDecoder} decoder
+ * @return {ContentMove}
+ */
+export const readContentMove = decoder => {
+  const word = decoder.readLen()
+  /** @type {Array<ID>|null} */
+  let at = null
+  if (word & 16) {
+    at = []
+    for (let n = decoder.readLen(); n > 0; n--) at.push(decoder.readLeftID())
+  }
+  return new ContentMove(word >> 5, word & 1, readIds(decoder), (word >> 1) & 7, at)
+}
+
+/**
+ * YP29: a collected mark or claim, its length and class.
+ *
+ * @param {UpdateDecoder} decoder
+ * @return {ContentDeleted}
+ */
+export const readContentClass = decoder => {
+  const word = decoder.readLen()
+  return new ContentDeleted(Math.floor(word / 4), word % 4)
+}
+
 const refused = () => { error.unexpectedCase() }
 
 /**
  * A lookup map for reading Item content. YP19: JSON (2), embed (5) and
  * subdocument (9) contents are refused like GC (0) and Skip (10): edytor
- * writes none, so an update holding one is malformed.
+ * writes none, so an update holding one is malformed. YP20: 11 is a hold
+ * record. YP22: 12 is a move record.
  *
- * @type {Array<function(UpdateDecoder):AbstractContent>}
+ * @type {Array<function(UpdateDecoder, import('./utils/ID.js').ID):AbstractContent>}
  */
 export const contentRefs = [
   refused, // 0 - GC is not ItemContent
@@ -1132,14 +1293,18 @@ export const contentRefs = [
   readContentType, // 7
   readContentAny, // 8
   refused, // 9 - subdocument
-  refused // 10 - Skip is not ItemContent
+  refused, // 10 - Skip is not ItemContent
+  readContentHold, // 11 - a hold record (YP20)
+  readContentMove, // 12 - a move record (YP22)
+  readContentClass // 13 - a collected mark or claim, its class (YP29)
 ]
 
 /**
  * @param {UpdateDecoder} decoder
  * @param {number} info
+ * @param {import('./utils/ID.js').ID} id YP25: the item's id (a format item reads it)
  */
-export const readItemContent = (decoder, info) => contentRefs[info & binary.BITS5](decoder)
+export const readItemContent = (decoder, info, id) => contentRefs[info & binary.BITS4](decoder, id) // YP27: four bits
 
 /**
  * @param {UpdateDecoder} decoder

package/dist/edytor.svelte.js

@@ -8,6 +8,7 @@ import { onInput } from './events/onInput.js';
 import { onPaste } from './events/onPaste.js';
 import { onTextDragEnd, onTextDragStart, preventUnsupportedDrop } from './events/onDrop.js';
 import { attachFocus, selectionIsInside, takeKeys } from './events/onFocus.js';
+import { attachPageHide } from './events/onPageHide.js';
 import { insertLineBreak, runIntent } from './events/beforeInputCommands.js';
 import { textPointAt } from './selection/selection.utils.js';
 import { Attempts } from './session/attempt.js';
@@ -794,7 +795,9 @@ export class Edytor {
                 keydown(event);
         }), 
         // Pointer and focus ownership, and the focus-time caret restore.
-        ...attachFocus(this, node), on(node, 'mousedown', this.selection.pointer.preventTripleClick), on(node, 'click', this.selection.pointer.tripleClick), 
+        ...attachFocus(this, node), 
+        // The page leaving for good ends the session's history.
+        attachPageHide(this), on(node, 'mousedown', this.selection.pointer.preventTripleClick), on(node, 'click', this.selection.pointer.tripleClick), 
         // Settle queued mutation repairs before the native menu opens —
         // spellcheck suggestions are computed against the DOM at this
         // moment (PM flushes its DOM observer on contextmenu for the

package/dist/events/beforeInputCommands.js

@@ -209,14 +209,14 @@ const splitKeepingChildren = (edytor, [id, offset, born, tail], child) => {
         return REFUSED;
     if (!child)
         return facade.compose({ ...split, writes: [step] });
-    // The rank of a first child, and the document's answer on placing the kind there.
+    // The document's answer on placing the kind as a first child.
     const slot = facade.prepare.insertBlocks({ parent: id, index: 0 }, [
         { id: born, type: tail?.type ?? facade.defaultChild(id) }
     ]);
     const first = 'writes' in slot ? slot.writes[0] : undefined;
     if (first?.op !== 'insertBlocks')
         return REFUSED;
-    const placed = { ...step, parent: id, rank: first.ranks[0] };
+    const placed = { ...step, parent: id, index: 0 };
     return facade.compose({ ...split, writes: [placed] });
 };
 /**

package/dist/events/onPageHide.d.ts

@@ -0,0 +1,3 @@
+import type { Edytor } from '../edytor.svelte.js';
+/** End the view's session when its page leaves for good; answers the teardown. */
+export declare const attachPageHide: (edytor: Edytor) => (() => void);

package/dist/events/onPageHide.js

@@ -0,0 +1,16 @@
+/**
+ * The page leaves for good (installed by `Edytor.attach`): a `pagehide` the
+ * back/forward cache keeps nothing of. The view tells its document the
+ * session's history ended (`document.endHistory()`, `hist.release.end`): the
+ * history's rule releases what the session deleted. A page the cache keeps
+ * may come back with its history, and a lost connection fires nothing here:
+ * both keep it.
+ *
+ * The page's lifecycle is the sync layer's (`onPageLeave`, which the
+ * providers leave by too): the view subscribes to its `write` phase, run
+ * before the providers' teardown whatever order they subscribed in, so the
+ * release goes out on a socket or store that is still open.
+ */
+import { onPageLeave } from '../crdt/providers/room.js';
+/** End the view's session when its page leaves for good; answers the teardown. */
+export const attachPageHide = (edytor) => onPageLeave(() => edytor.document.endHistory(), 'write');