lib0 0.2.115-1 → 0.2.115-3

package/delta/d2.js

@@ -1,5 +1,11 @@
 /**
  * @beta this API is about to change
+ *
+ * ## Mutability
+ *
+ * Deltas are mutable by default. But references are often shared, by marking a Delta as "done". You
+ * may only modify deltas by applying other deltas to them. Casting a Delta to a DeltaBuilder
+ * manually, will likely modify "shared" state.
  */
 
 import * as list from '../list.js'
@@ -10,6 +16,10 @@ import * as fun from '../function.js'
 import * as s from '../schema.js'
 import * as error from '../error.js'
 import * as math from '../math.js'
+import * as rabin from '../hash/rabin.js'
+import * as encoding from '../encoding.js'
+import * as buffer from '../buffer.js'
+import * as patience from '../diff/patience.js'
 
 /**
  * @typedef {{
@@ -44,8 +54,9 @@ export const $attribution = s.$object({
 
 /**
  * @typedef {{
- *   name?: string
- *   attrs?: { [Key in string|number|symbol]: DeltaAttrOpJSON },
+ *   type: 'delta',
+ *   name?: string,
+ *   attrs?: { [Key in string|number]: DeltaAttrOpJSON },
  *   children?: Array<DeltaListOpJSON>
  * }} DeltaJSON
  */
@@ -58,6 +69,18 @@ export const $attribution = s.$object({
  * @typedef {{ type: 'insert', value: any, prevValue?: any, attribution?: Attribution } | { type: 'delete', prevValue?: any, attribution?: Attribution } | { type: 'modify', value: DeltaJSON }} DeltaAttrOpJSON
  */
 
+/**
+ * @typedef {TextOp|InsertOp<any>|DeleteOp|RetainOp|ModifyOp<any>} ChildrenOpAny
+ */
+
+/**
+ * @typedef {AttrInsertOp<any>|AttrDeleteOp<any>|AttrModifyOp} AttrOpAny
+ */
+
+/**
+ * @typedef {ChildrenOpAny|AttrOpAny} _OpAny
+ */
+
 /**
  * @type {s.Schema<DeltaAttrOpJSON>}
  */
@@ -78,7 +101,11 @@ const _cloneAttrs = attrs => attrs == null ? attrs : { ...attrs }
  * @param {MaybeDelta} maybeDelta
  * @return {MaybeDelta}
  */
-const _cloneMaybeDelta = maybeDelta => $deltaAny.check(maybeDelta) ? maybeDelta.clone() : maybeDelta
+const _markMaybeDeltaAsDone = maybeDelta => $deltaAny.check(maybeDelta) ? /** @type {MaybeDelta} */ (maybeDelta.done()) : maybeDelta
+
+/**
+ * @typedef {unknown & DeltaAny} Q
+ */
 
 export class TextOp extends list.ListNode {
   /**
@@ -88,9 +115,31 @@ export class TextOp extends list.ListNode {
    */
   constructor (insert, format, attribution) {
     super()
+    // Whenever this is modified, make sure to clear _fingerprint
+    /**
+     * @readonly
+     * @type {string}
+     */
     this.insert = insert
+    /**
+     * @readonly
+     * @type {FormattingAttributes|null}
+     */
     this.format = format
     this.attribution = attribution
+    /**
+     * @type {string?}
+     */
+    this._fingerprint = null
+  }
+
+  /**
+   * @param {string} newVal
+   */
+  _updateInsert (newVal) {
+    // @ts-ignore
+    this.insert = newVal
+    this._fingerprint = null
   }
 
   /**
@@ -104,6 +153,14 @@ export class TextOp extends list.ListNode {
     return this.insert.length
   }
 
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 0) // textOp type: 0
+      encoding.writeVarString(encoder, this.insert)
+      encoding.writeAny(encoder, this.format)
+    })))
+  }
+
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -111,7 +168,10 @@ export class TextOp extends list.ListNode {
    * @param {number} len
    */
   _splice (offset, len) {
+    this._fingerprint = null
+    // @ts-ignore
     this.insert = this.insert.slice(0, offset) + this.insert.slice(offset + len)
+    return this
   }
 
   /**
@@ -132,13 +192,13 @@ export class TextOp extends list.ListNode {
   /**
    * @return {TextOp}
    */
-  clone () {
-    return new TextOp(this.insert, _cloneAttrs(this.format), _cloneAttrs(this.attribution))
+  clone (start = 0, end = this.length) {
+    return new TextOp(this.insert.slice(start, end), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
   }
 }
 
 /**
- * @template ArrayContent
+ * @template {encoding.AnyEncodable|DeltaAny} ArrayContent
  */
 export class InsertOp extends list.ListNode {
   /**
@@ -148,9 +208,34 @@ export class InsertOp extends list.ListNode {
    */
   constructor (insert, format, attribution) {
     super()
+    /**
+     * @readonly
+     * @type {Array<ArrayContent>}
+     */
     this.insert = insert
+    /**
+     * @readonly
+     * @type {FormattingAttributes?}
+     */
     this.format = format
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
     this.attribution = attribution
+    /**
+     * @type {string?}
+     */
+    this._fingerprint = null
+  }
+
+  /**
+   * @param {ArrayContent} newVal
+   */
+  _updateInsert (newVal) {
+    // @ts-ignore
+    this.insert = newVal
+    this._fingerprint = null
   }
 
   /**
@@ -164,6 +249,42 @@ export class InsertOp extends list.ListNode {
     return this.insert.length
   }
 
+  /**
+   * @param {number} i
+   * @return {Extract<ArrayContent,DeltaAny>}
+   */
+  _modValue (i) {
+    /**
+     * @type {any}
+     */
+    let d = this.insert[i]
+    this._fingerprint = null
+    $deltaAny.expect(d)
+    if (d.isDone) {
+      // @ts-ignore
+      this.insert[i] = (d = clone(d))
+      return d
+    }
+    return d
+  }
+
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 1) // insertOp type: 1
+      encoding.writeVarUint(encoder, this.insert.length)
+      this.insert.forEach(ins => {
+        if ($deltaAny.check(ins)) {
+          encoding.writeUint8(encoder, 0)
+          encoding.writeVarString(encoder, ins.fingerprint)
+        } else {
+          encoding.writeUint8(encoder, 1)
+          encoding.writeAny(encoder, ins)
+        }
+      })
+      encoding.writeAny(encoder, this.format)
+    })))
+  }
+
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -171,7 +292,9 @@ export class InsertOp extends list.ListNode {
    * @param {number} len
    */
   _splice (offset, len) {
+    this._fingerprint = null
     this.insert.splice(offset, len)
+    return this
   }
 
   /**
@@ -192,11 +315,15 @@ export class InsertOp extends list.ListNode {
   /**
    * @return {InsertOp<ArrayContent>}
    */
-  clone () {
-    return new InsertOp(this.insert.slice(), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
+  clone (start = 0, end = this.length) {
+    return new InsertOp(this.insert.slice(start, end).map(_markMaybeDeltaAsDone), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
   }
 }
 
+/**
+ * @template {encoding.AnyEncodable|DeltaAny} [Children=never]
+ * @template {string} [Text=never]
+ */
 export class DeleteOp extends list.ListNode {
   /**
    * @param {number} len
@@ -204,6 +331,14 @@ export class DeleteOp extends list.ListNode {
   constructor (len) {
     super()
     this.delete = len
+    /**
+     * @type {(Children|Text) extends never ? null : (Delta<any,{},Children,Text>?)}
+     */
+    this.prevValue = null
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null
   }
 
   /**
@@ -217,6 +352,13 @@ export class DeleteOp extends list.ListNode {
     return 0
   }
 
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 2) // deleteOp type: 2
+      encoding.writeVarUint(encoder, this.delete)
+    })))
+  }
+
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -224,7 +366,10 @@ export class DeleteOp extends list.ListNode {
    * @param {number} len
    */
   _splice (_offset, len) {
+    this.prevValue = /** @type {any} */ (this.prevValue?.slice(_offset, len) || null)
+    this._fingerprint = null
     this.delete -= len
+    return this
   }
 
   /**
@@ -241,8 +386,8 @@ export class DeleteOp extends list.ListNode {
     return this.delete === other.delete
   }
 
-  clone () {
-    return new DeleteOp(this.delete)
+  clone (start = 0, end = this.delete) {
+    return new DeleteOp(end - start)
   }
 }
 
@@ -254,9 +399,25 @@ export class RetainOp extends list.ListNode {
    */
   constructor (retain, format, attribution) {
     super()
+    /**
+     * @readonly
+     * @type {number}
+     */
     this.retain = retain
+    /**
+     * @readonly
+     * @type {FormattingAttributes?}
+     */
     this.format = format
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
     this.attribution = attribution
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null
   }
 
   /**
@@ -270,6 +431,14 @@ export class RetainOp extends list.ListNode {
     return this.retain
   }
 
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 3) // retainOp type: 3
+      encoding.writeVarUint(encoder, this.retain)
+      encoding.writeAny(encoder, this.format)
+    })))
+  }
+
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -277,7 +446,10 @@ export class RetainOp extends list.ListNode {
    * @param {number} len
    */
   _splice (_offset, len) {
+    // @ts-ignore
     this.retain -= len
+    this._fingerprint = null
+    return this
   }
 
   /**
@@ -295,15 +467,15 @@ export class RetainOp extends list.ListNode {
     return this.retain === other.retain && fun.equalityDeep(this.format, other.format) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
-  clone () {
-    return new RetainOp(this.retain, _cloneAttrs(this.format), _cloneAttrs(this.attribution))
+  clone (start = 0, end = this.retain) {
+    return new RetainOp(end - start, _cloneAttrs(this.format), _cloneAttrs(this.attribution))
   }
 }
 
 /**
  * Delta that can be applied on a YType Embed
  *
- * @template {Delta<any,any,any,any,any>} DTypes
+ * @template {DeltaAny} [DTypes=DeltaAny]
  */
 export class ModifyOp extends list.ListNode {
   /**
@@ -313,9 +485,25 @@ export class ModifyOp extends list.ListNode {
    */
   constructor (delta, format, attribution) {
     super()
+    /**
+     * @readonly
+     * @type {DTypes}
+     */
     this.value = delta
+    /**
+     * @readonly
+     * @type {FormattingAttributes?}
+     */
     this.format = format
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
     this.attribution = attribution
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null
   }
 
   /**
@@ -329,6 +517,31 @@ export class ModifyOp extends list.ListNode {
     return 1
   }
 
+  /**
+   * @type {DeltaBuilderAny}
+   */
+  get _modValue () {
+    /**
+     * @type {any}
+     */
+    const d = this.value
+    this._fingerprint = null
+    if (d.isDone) {
+      // @ts-ignore
+      return (this.value = clone(d))
+    }
+    return d
+  }
+
+  get fingerprint () {
+    // don't cache fingerprint because we don't know when delta changes
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 4) // modifyOp type: 4
+      encoding.writeVarString(encoder, this.value.fingerprint)
+      encoding.writeAny(encoder, this.format)
+    })))
+  }
+
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -336,6 +549,7 @@ export class ModifyOp extends list.ListNode {
    * @param {number} _len
    */
   _splice (_offset, _len) {
+    return this
   }
 
   /**
@@ -357,15 +571,15 @@ export class ModifyOp extends list.ListNode {
    * @return {ModifyOp<DTypes>}
    */
   clone () {
-    return new ModifyOp(this.value.clone(), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
+    return new ModifyOp(/** @type {DTypes} */ (this.value.done()), _cloneAttrs(this.format), _cloneAttrs(this.attribution))
   }
 }
 
 /**
- * @template V
- * @template {string|number|symbol} [K=any]
+ * @template {encoding.AnyEncodable|DeltaAny} V
+ * @template {string|number} [K=any]
  */
-export class MapInsertOp {
+export class AttrInsertOp {
   /**
    * @param {K} key
    * @param {V} value
@@ -374,18 +588,29 @@ export class MapInsertOp {
    */
   constructor (key, value, prevValue, attribution) {
     /**
+     * @readonly
      * @type {K}
      */
     this.key = key
     /**
+     * @readonly
      * @type {V}
      */
     this.value = value
     /**
+     * @readonly
      * @type {V|undefined}
      */
     this.prevValue = prevValue
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
     this.attribution = attribution
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null
   }
 
   /**
@@ -393,6 +618,36 @@ export class MapInsertOp {
    */
   get type () { return 'insert' }
 
+  /**
+   * @type {DeltaBuilderAny}
+   */
+  get _modValue () {
+    /**
+     * @type {any}
+     */
+    const v = this.value
+    this._fingerprint = null
+    if ($deltaAny.check(v) && v.isDone) {
+      // @ts-ignore
+      return (this.value = clone(v))
+    }
+    return v
+  }
+
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 5) // map insert type: 5
+      encoding.writeAny(encoder, this.key)
+      if ($deltaAny.check(this.value)) {
+        encoding.writeUint8(encoder, 0)
+        encoding.writeVarString(encoder, this.value.fingerprint)
+      } else {
+        encoding.writeUint8(encoder, 1)
+        encoding.writeAny(encoder, this.value)
+      }
+    })))
+  }
+
   toJSON () {
     const v = this.value
     const prevValue = this.prevValue
@@ -404,25 +659,25 @@ export class MapInsertOp {
   }
 
   /**
-   * @param {MapInsertOp<V>} other
+   * @param {AttrInsertOp<V>} other
    */
   [traits.EqualityTraitSymbol] (other) {
     return this.key === other.key && fun.equalityDeep(this.value, other.value) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
   /**
-   * @return {MapInsertOp<V,K>}
+   * @return {AttrInsertOp<V,K>}
    */
   clone () {
-    return new MapInsertOp(this.key, _cloneMaybeDelta(this.value), _cloneMaybeDelta(this.prevValue), _cloneAttrs(this.attribution))
+    return new AttrInsertOp(this.key, _markMaybeDeltaAsDone(this.value), _markMaybeDeltaAsDone(this.prevValue), _cloneAttrs(this.attribution))
   }
 }
 
 /**
  * @template V
- * @template [K=string]
+ * @template {string|number} [K=string]
  */
-export class MapDeleteOp {
+export class AttrDeleteOp {
   /**
    * @param {K} key
    * @param {V|undefined} prevValue
@@ -438,6 +693,10 @@ export class MapDeleteOp {
      */
     this.prevValue = prevValue
     this.attribution = attribution
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null
   }
 
   get value () { return undefined }
@@ -447,6 +706,13 @@ export class MapDeleteOp {
    */
   get type () { return 'delete' }
 
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 6) // map delete type: 6
+      encoding.writeAny(encoder, this.key)
+    })))
+  }
+
   /**
    * @return {DeltaAttrOpJSON}
    */
@@ -458,35 +724,41 @@ export class MapDeleteOp {
   }
 
   /**
-   * @param {MapDeleteOp<V>} other
+   * @param {AttrDeleteOp<V>} other
    */
   [traits.EqualityTraitSymbol] (other) {
     return this.key === other.key && fun.equalityDeep(this.attribution, other.attribution)
   }
 
   clone () {
-    return new MapDeleteOp(this.key, _cloneMaybeDelta(this.prevValue), _cloneAttrs(this.attribution))
+    return new AttrDeleteOp(this.key, _markMaybeDeltaAsDone(this.prevValue), _cloneAttrs(this.attribution))
   }
 }
 
 /**
- * @template {DeltaAny} Modifier
- * @template [K=string]
+ * @template {DeltaAny} [Modifier=DeltaAny]
+ * @template {string|number} [K=string]
  */
-export class MapModifyOp {
+export class AttrModifyOp {
   /**
    * @param {K} key
    * @param {Modifier} delta
    */
   constructor (key, delta) {
     /**
+     * @readonly
      * @type {K}
      */
     this.key = key
     /**
+     * @readonly
      * @type {Modifier}
      */
     this.value = delta
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null
   }
 
   /**
@@ -494,6 +766,27 @@ export class MapModifyOp {
    */
   get type () { return 'modify' }
 
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeVarUint(encoder, 7) // map modify type: 7
+      encoding.writeAny(encoder, this.key)
+      encoding.writeVarString(encoder, this.value.fingerprint)
+    })))
+  }
+
+  /**
+   * @return {DeltaBuilder}
+   */
+  get _modValue () {
+    this._fingerprint = null
+    if (this.value.isDone) {
+      // @ts-ignore
+      this.value = /** @type {any} */ (clone(this.value))
+    }
+    // @ts-ignore
+    return this.value
+  }
+
   /**
    * @return {DeltaAttrOpJSON}
    */
@@ -505,38 +798,38 @@ export class MapModifyOp {
   }
 
   /**
-   * @param {MapModifyOp<Modifier>} other
+   * @param {AttrModifyOp<Modifier>} other
    */
   [traits.EqualityTraitSymbol] (other) {
     return this.key === other.key && this.value[traits.EqualityTraitSymbol](other.value)
   }
 
   /**
-   * @return {MapModifyOp<Modifier,K>}
+   * @return {AttrModifyOp<Modifier,K>}
    */
   clone () {
-    return new MapModifyOp(this.key, this.value.clone())
+    return new AttrModifyOp(this.key, /** @type {Modifier} */ (this.value.done()))
   }
 }
 
 /**
- * @type {s.Schema<MapDeleteOp<any> | DeleteOp>}
+ * @type {s.Schema<AttrDeleteOp<any> | DeleteOp>}
  */
-export const $deleteOp = s.$custom(o => o != null && (o.constructor === DeleteOp || o.constructor === MapDeleteOp))
+export const $deleteOp = s.$custom(o => o != null && (o.constructor === DeleteOp || o.constructor === AttrDeleteOp))
 
 /**
- * @type {s.Schema<MapInsertOp<any> | InsertOp<any>>}
+ * @type {s.Schema<AttrInsertOp<any> | InsertOp<any>>}
  */
-export const $insertOp = s.$custom(o => o != null && (o.constructor === MapInsertOp || o.constructor === InsertOp))
+export const $insertOp = s.$custom(o => o != null && (o.constructor === AttrInsertOp || o.constructor === InsertOp))
 
 /**
- * @template Content
+ * @template {encoding.AnyEncodable|DeltaAny} Content
  * @param {s.Schema<Content>} $content
- * @return {s.Schema<MapInsertOp<Content> | InsertOp<Content>>}
+ * @return {s.Schema<AttrInsertOp<Content> | InsertOp<Content>>}
  */
 export const $insertOpWith = $content => s.$custom(o =>
   o != null && (
-    (o.constructor === MapInsertOp && $content.check(/** @type {MapInsertOp<Content>} */ (o).value)) ||
+    (o.constructor === AttrInsertOp && $content.check(/** @type {AttrInsertOp<Content>} */ (o).value)) ||
       (o.constructor === InsertOp && /** @type {InsertOp<Content>} */ (o).insert.every(ins => $content.check(ins)))
   )
 )
@@ -552,18 +845,18 @@ export const $textOp = s.$constructedBy(TextOp)
 export const $retainOp = s.$constructedBy(RetainOp)
 
 /**
- * @type {s.Schema<MapModifyOp<any> | ModifyOp<any>>}
+ * @type {s.Schema<AttrModifyOp | ModifyOp>}
  */
-export const $modifyOp = s.$custom(o => o != null && (o.constructor === MapModifyOp || o.constructor === ModifyOp))
+export const $modifyOp = s.$custom(o => o != null && (o.constructor === AttrModifyOp || o.constructor === ModifyOp))
 
 /**
  * @template {DeltaAny} Modify
  * @param {s.Schema<Modify>} $content
- * @return {s.Schema<MapModifyOp<Modify> | ModifyOp<Modify>>}
+ * @return {s.Schema<AttrModifyOp<Modify> | ModifyOp<Modify>>}
  */
 export const $modifyOpWith = $content => s.$custom(o =>
   o != null && (
-    (o.constructor === MapModifyOp && $content.check(/** @type {MapModifyOp<Modify>} */ (o).value)) ||
+    (o.constructor === AttrModifyOp && $content.check(/** @type {AttrModifyOp<Modify>} */ (o).value)) ||
       (o.constructor === ModifyOp && $content.check(/** @type {ModifyOp<Modify>} */ (o).value))
   )
 )
@@ -579,8 +872,8 @@ export const $anyOp = s.$union($insertOp, $deleteOp, $textOp, $modifyOp)
  */
 
 /**
- * @template {{[Key in string|number|symbol]: any}} Attrs
- * @template {string|number|symbol} Key
+ * @template {{[Key in string|number]: any}} Attrs
+ * @template {string|number} Key
  * @template {any} Val
  * @typedef {{ [K in (Key | keyof Attrs)]: (unknown extends Attrs[K] ? never : Attrs[K]) | (Key extends K ? Val : never) }} AddToAttrs
  */
@@ -598,29 +891,20 @@ export const $anyOp = s.$union($insertOp, $deleteOp, $textOp, $modifyOp)
 
 /**
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} Schema
- * @typedef {_AnyToNull<Schema> extends null ? Delta<any,{[key:string|number|symbol]:any},any,string> : (Schema extends s.Schema<infer D> ? D : never)} AllowedDeltaFromSchema
+ * @typedef {_AnyToNull<Schema> extends null ? Delta<any,{[key:string|number]:any},any,string> : (Schema extends s.Schema<infer D> ? D : never)} AllowedDeltaFromSchema
  */
 
 /**
- * @typedef {Delta<any,{ [k:string]: any },any,any,any>} DeltaAny
+ * @typedef {Delta<any,{ [k:string|number]: any },any,any,any>} DeltaAny
  */
-
-// note: simply copy the values from Delta.attrs as the parameter of the function
 /**
- * @template {{[key:string|number|symbol]:any}} [Attrs={}]
- * @param {Delta<any,Attrs,any,any,any>} d
- * @param {(v:{ [K in keyof Attrs]: MapInsertOp<Attrs[K],K>|MapDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? MapModifyOp<Extract<Attrs[K],Delta>,K> : never) }[keyof Attrs])=>any} handler
+ * @typedef {DeltaBuilder<any,{ [k:string|number]: any },any,any,any>} DeltaBuilderAny
  */
-export const forEachAttr = (d, handler) => {
-  for (const k in d.attrs) {
-    handler(/** @type {any} */ (d.attrs[k]))
-  }
-}
 
 /**
  * @template {string} [NodeName=any]
- * @template {{[key:string|number|symbol]:any}} [Attrs={}]
- * @template {any} [Children=never]
+ * @template {{[k:string|number]:any}} [Attrs={}]
+ * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
  * @template {string|never} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  */
@@ -633,7 +917,9 @@ export class Delta {
     this.name = name || null
     this.$schema = $schema || null
     /**
-     * @type {{ [K in keyof Attrs]?: MapInsertOp<Attrs[K],K>|MapDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? MapModifyOp<Extract<Attrs[K],Delta>,K> : never) } & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: MapInsertOp<Attrs[K],K>|MapDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? MapModifyOp<Extract<Attrs[K],Delta>,K> : never) }[keyof Attrs]> }}
+     * @type {{ [K in keyof Attrs]?: K extends string|number ? (AttrInsertOp<Attrs[K],K>|AttrDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? AttrModifyOp<Extract<Attrs[K],DeltaAny>,K> : never)) : never }
+     *   & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string|number ? (AttrInsertOp<Attrs[K],K>|AttrDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? AttrModifyOp<Extract<Attrs[K],DeltaAny>,K> : never)) : never }[keyof Attrs]> }
+     * }
      */
     this.attrs = /** @type {any} */ ({
       * [Symbol.iterator] () {
@@ -653,10 +939,50 @@ export class Delta {
      * >}
      */
     this.children = /** @type {any} */ (list.create())
+    this.childCnt = 0
     /**
      * @type {any}
      */
     this.origin = null
+    /**
+     * @type {string|null}
+     */
+    this._fingerprint = null
+    this.isDone = false
+  }
+
+  /**
+   * @type {string}
+   */
+  get fingerprint () {
+    return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
+      encoding.writeAny(encoder, this.name)
+      /**
+       * @type {Array<number|string>}
+       */
+      const keys = []
+      for (const attr of this.attrs) {
+        keys.push(attr.key)
+      }
+      keys.sort((a, b) => {
+        const aIsString = s.$string.check(a)
+        const bIsString = s.$string.check(b)
+        // numbers first
+        // in ascending order
+        return (aIsString && bIsString)
+          ? a.localeCompare(b)
+          : (aIsString ? 1 : (bIsString ? -1 : (a - b)))
+      })
+      encoding.writeVarUint(encoder, keys.length)
+      for (const key of keys) {
+        encoding.writeVarString(encoder, /** @type {any} */ (this.attrs[/** @type {keyof Attrs} */ (key)]).fingerprint)
+      }
+      encoding.writeVarUint(encoder, this.children.len)
+      for (const child of this.children) {
+        encoding.writeVarString(encoder, child.fingerprint)
+      }
+      return buffer.toBase64(rabin.fingerprint(rabin.StandardIrreducible128, encoding.toUint8Array(encoder)))
+    })))
   }
 
   isEmpty () {
@@ -667,6 +993,7 @@ export class Delta {
    * @return {DeltaJSON}
    */
   toJSON () {
+    const name = this.name
     /**
      * @type {any}
      */
@@ -675,14 +1002,15 @@ export class Delta {
      * @type {any}
      */
     const children = []
-    forEachAttr(this, attr => {
+    for (const attr of this.attrs) {
       attrs[attr.key] = attr.toJSON()
-    })
+    }
     this.children.forEach(val => {
       children.push(val.toJSON())
     })
     return object.assign(
-      (this.name != null ? { name: this.name } : {}),
+      { type: /** @type {'delta'} */ ('delta') },
+      (name != null ? { name } : {}),
       (object.isEmpty(attrs) ? {} : { attrs }),
       (children.length > 0 ? { children } : {})
     )
@@ -697,36 +1025,139 @@ export class Delta {
   }
 
   /**
-   * @return {this}
+   * @param {any} other
+   * @return {boolean}
    */
-  clone () {
+  [traits.EqualityTraitSymbol] (other) {
+    // @todo it is only necessary to compare finrerprints OR do a deep equality check
+    return this.name === other.name && fun.equalityDeep(this.attrs, other.attrs) && fun.equalityDeep(this.children, other.children) && this.childCnt === other.childCnt && this.fingerprint === other.fingerprint
+  }
+
+  /**
+   * @param {number} start
+   * @param {number} end
+   * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
+   */
+  slice (start = 0, end = this.childCnt) {
+    const cpy = /** @type {DeltaAny} */ (new DeltaBuilder(/** @type {any} */ (this.name), this.$schema))
+    cpy.origin = this.origin
+    // copy attrs
+    for (const op of this.attrs) {
+      cpy.attrs[op.key] = /** @type {any} */ (op.clone())
+    }
+    // copy children
+    const slicedLen = end - start
+    let remainingLen = slicedLen
     /**
-     * @type {Delta<any,Attrs,any,any,any>}
+     * @type {ChildrenOpAny?}
      */
-    const d = new DeltaBuilder(/** @type {any} */ (this.name), this.$schema)
-    d.origin = this.origin
-    for (const op of this.attrs) {
-      d.attrs[op.key] = /** @type {any} */ (op)
+    let currNode = this.children.start
+    let currNodeOffset = 0
+    while (start > 0 && currNode != null) {
+      if (currNode.length <= start) {
+        start -= currNode.length
+        currNode = currNode.next
+      } else {
+        currNodeOffset = start
+        start = 0
+      }
     }
-    this.children.forEach(op => {
-      list.pushEnd(d.children, op.clone())
-    })
-    return /** @type {any} */ (d)
+    if (currNodeOffset > 0 && currNode) {
+      const ncpy = currNode.clone(currNodeOffset, currNodeOffset + math.min(remainingLen, currNode.length - currNodeOffset))
+      list.pushEnd(cpy.children, ncpy)
+      remainingLen -= ncpy.length
+      currNode = currNode.next
+    }
+    while (currNode != null && currNode.length <= remainingLen) {
+      list.pushEnd(cpy.children, currNode.clone())
+      currNode = currNode.next
+    }
+    if (currNode != null && remainingLen > 0) {
+      list.pushEnd(cpy.children, currNode.clone(0, remainingLen))
+    }
+    cpy.childCnt = slicedLen - remainingLen
+    // @ts-ignore
+    return cpy
   }
 
   /**
-   * @param {any} other
-   * @return {boolean}
+   * Mark this delta as done and perform some cleanup (e.g. remove appended retains without
+   * formats&attributions). In the future, there might be additional merge operations that can be
+   * performed to result in smaller deltas. Set `markAsDone=false` to only perform the cleanup.
+   *
+   * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
    */
-  [traits.EqualityTraitSymbol] (other) {
-    return this.name === other.name && fun.equalityDeep(this.attrs, other.attrs) && fun.equalityDeep(this.children, other.children)
+  done (markAsDone = true) {
+    if (!this.isDone) {
+      this.isDone = markAsDone
+      const cs = this.children
+      for (let end = cs.end; end !== null && $retainOp.check(end) && end.format == null && end.attribution == null; end = cs.end) {
+        this.childCnt -= end.length
+        list.popEnd(cs)
+      }
+    }
+    return this
   }
 }
 
+/**
+ * @template {DeltaAny} D
+ * @param {D} d
+ * @return {D extends Delta<infer NodeName,infer Attrs,infer Children,infer Text,infer Schema> ? DeltaBuilder<NodeName,Attrs,Children,Text,Schema> : never}
+ */
+export const clone = d => /** @type {any} */ (d.slice(0, d.childCnt))
+
+/**
+ * Try merging this op with the previous op
+ * @param {list.List<any>} parent
+ * @param {InsertOp<any>|RetainOp|DeleteOp|TextOp|ModifyOp<any>} op
+ */
+const tryMergeWithPrev = (parent, op) => {
+  const prevOp = op.prev
+  if (
+    prevOp?.constructor !== op.constructor ||
+    (
+      (!$deleteOp.check(op) && !$modifyOp.check(op)) && (!fun.equalityDeep(op.format, /** @type {InsertOp<any>} */ (prevOp).format) || !fun.equalityDeep(op.attribution, /** @type {InsertOp<any>} */ (prevOp).attribution))
+    )
+  ) {
+    // constructor mismatch or format/attribution mismatch
+    return
+  }
+  // can be merged
+  if ($insertOp.check(op)) {
+    /** @type {InsertOp<any>} */ (prevOp).insert.push(...op.insert)
+  } else if ($retainOp.check(op)) {
+    // @ts-ignore
+    /** @type {RetainOp} */ (prevOp).retain += op.retain
+  } else if ($deleteOp.check(op)) {
+    /** @type {DeleteOp} */ (prevOp).delete += op.delete
+  } else if ($textOp.check(op)) {
+    /** @type {TextOp} */ (prevOp)._updateInsert(/** @type {TextOp} */ (prevOp).insert + op.insert)
+  } else {
+    error.unexpectedCase()
+  }
+  list.remove(parent, op)
+}
+
+/**
+ * Ensures that the delta can be edited. clears _fingerprint cache.
+ *
+ * @param {any} d
+ */
+const modDeltaCheck = d => {
+  if (d.isDone) {
+    /**
+     * You tried to modify a delta after it has been marked as "done".
+     */
+    throw error.create("Readonly Delta can't be modified")
+  }
+  d._fingerprint = null
+}
+
 /**
  * @template {string} [NodeName=any]
- * @template {{[key:string|number|symbol]:any}} [Attrs={}]
- * @template {any} [Children=never]
+ * @template {{[key:string|number]:any}} [Attrs={}]
+ * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
  * @template {string|never} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  * @extends {Delta<NodeName,Attrs,Children,Text,Schema>}
@@ -752,6 +1183,7 @@ export class DeltaBuilder extends Delta {
    * @param {Attribution?} attribution
    */
   useAttribution (attribution) {
+    modDeltaCheck(this)
     this.usedAttribution = attribution
     return this
   }
@@ -761,6 +1193,7 @@ export class DeltaBuilder extends Delta {
    * @return {this}
    */
   useAttributes (attributes) {
+    modDeltaCheck(this)
     this.usedAttributes = attributes
     return this
   }
@@ -770,6 +1203,7 @@ export class DeltaBuilder extends Delta {
    * @param {any} value
    */
   updateUsedAttributes (name, value) {
+    modDeltaCheck(this)
     if (value == null) {
       this.usedAttributes = object.assign({}, this.usedAttributes)
       delete this.usedAttributes?.[name]
@@ -789,6 +1223,7 @@ export class DeltaBuilder extends Delta {
    * @param {Attribution[NAME]?} value
    */
   updateUsedAttribution (name, value) {
+    modDeltaCheck(this)
     if (value == null) {
       this.usedAttribution = object.assign({}, this.usedAttribution)
       delete this.usedAttribution?.[name]
@@ -811,11 +1246,12 @@ export class DeltaBuilder extends Delta {
    *   NodeName,
    *   Attrs,
    *   Exclude<NewContent,string>[number]|Children,
-   *   (Extract<NewContent,string>|Text) extends string ? string : never,
+   *   (Extract<NewContent,string>|Text) extends never ? never : string,
    *   Schema
    * >}
    */
   insert (insert, formatting = null, attribution = null) {
+    modDeltaCheck(this)
     const mergedAttributes = mergeAttrs(this.usedAttributes, formatting)
     const mergedAttribution = mergeAttrs(this.usedAttribution, attribution)
     /**
@@ -825,16 +1261,20 @@ export class DeltaBuilder extends Delta {
     const end = this.children.end
     if (s.$string.check(insert)) {
       if ($textOp.check(end) && checkMergedEquals(end)) {
-        end.insert += insert
+        end._updateInsert(end.insert + insert)
       } else if (insert.length > 0) {
         list.pushEnd(this.children, new TextOp(insert, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution))
       }
+      this.childCnt += insert.length
     } else if (arr.isArray(insert)) {
       if ($insertOp.check(end) && checkMergedEquals(end)) {
+        // @ts-ignore
         end.insert.push(...insert)
+        end._fingerprint = null
       } else if (insert.length > 0) {
         list.pushEnd(this.children, new InsertOp(insert, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution))
       }
+      this.childCnt += insert.length
     }
     return /** @type {any} */ (this)
   }
@@ -853,9 +1293,11 @@ export class DeltaBuilder extends Delta {
    * >}
    */
   modify (modify, formatting = null, attribution = null) {
+    modDeltaCheck(this)
     const mergedAttributes = mergeAttrs(this.usedAttributes, formatting)
     const mergedAttribution = mergeAttrs(this.usedAttribution, attribution)
     list.pushEnd(this.children, new ModifyOp(modify, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution))
+    this.childCnt += 1
     return /** @type {any} */ (this)
   }
 
@@ -865,14 +1307,17 @@ export class DeltaBuilder extends Delta {
    * @param {Attribution?} [attribution]
    */
   retain (len, format = null, attribution = null) {
+    modDeltaCheck(this)
     const mergedFormats = mergeAttrs(this.usedAttributes, format)
     const mergedAttribution = mergeAttrs(this.usedAttribution, attribution)
     const lastOp = /** @type {RetainOp|InsertOp<any>} */ (this.children.end)
     if (lastOp instanceof RetainOp && fun.equalityDeep(mergedFormats, lastOp.format) && fun.equalityDeep(mergedAttribution, lastOp.attribution)) {
+      // @ts-ignore
       lastOp.retain += len
     } else if (len > 0) {
       list.pushEnd(this.children, new RetainOp(len, mergedFormats, mergedAttribution))
     }
+    this.childCnt += len
     return this
   }
 
@@ -880,12 +1325,14 @@ export class DeltaBuilder extends Delta {
    * @param {number} len
    */
   delete (len) {
+    modDeltaCheck(this)
     const lastOp = /** @type {DeleteOp|InsertOp<any>} */ (this.children.end)
     if (lastOp instanceof DeleteOp) {
       lastOp.delete += len
     } else if (len > 0) {
       list.pushEnd(this.children, new DeleteOp(len))
     }
+    this.childCnt += len
     return this
   }
 
@@ -905,7 +1352,8 @@ export class DeltaBuilder extends Delta {
    * >}
    */
   set (key, val, attribution = null, prevValue) {
-    this.attrs[key] = /** @type {any} */ (new MapInsertOp(key, val, prevValue, mergeAttrs(this.usedAttribution, attribution)))
+    modDeltaCheck(this)
+    this.attrs[key] = /** @type {any} */ (new AttrInsertOp(key, val, prevValue, mergeAttrs(this.usedAttribution, attribution)))
     return /** @type {any} */ (this)
   }
 
@@ -922,6 +1370,7 @@ export class DeltaBuilder extends Delta {
    * >}
    */
   setMany (attrs, attribution = null) {
+    modDeltaCheck(this)
     for (const k in attrs) {
       this.set(/** @type {any} */ (k), attrs[k], attribution)
     }
@@ -942,7 +1391,8 @@ export class DeltaBuilder extends Delta {
    * >}
    */
   unset (key, attribution = null, prevValue) {
-    this.attrs[key] = /** @type {any} */ (new MapDeleteOp(key, prevValue, mergeAttrs(this.usedAttribution, attribution)))
+    modDeltaCheck(this)
+    this.attrs[key] = /** @type {any} */ (new AttrDeleteOp(key, prevValue, mergeAttrs(this.usedAttribution, attribution)))
     return /** @type {any} */ (this)
   }
 
@@ -960,7 +1410,8 @@ export class DeltaBuilder extends Delta {
    * >}
    */
   update (key, modify) {
-    this.attrs[key] = /** @type {any} */ (new MapModifyOp(key, modify))
+    modDeltaCheck(this)
+    this.attrs[key] = /** @type {any} */ (new AttrModifyOp(key, modify))
     return /** @type {any} */ (this)
   }
 
@@ -968,37 +1419,64 @@ export class DeltaBuilder extends Delta {
    * @param {Delta<NodeName,Attrs,Children,Text,any>} other
    */
   apply (other) {
+    modDeltaCheck(this)
     this.$schema?.expect(other)
-    forEachAttr(/** @type {Delta<NodeName,Attrs,Children,Text,any>} */ (/** @type {any} */ (other)), op => {
-      const c = this.attrs[op.key]
+    // apply attrs
+    for (let op of other.attrs) {
+      const c = /** @type {AttrInsertOp<any,any>|AttrDeleteOp<any>|AttrModifyOp<any,any>} */ (this.attrs[op.key])
       if ($modifyOp.check(op)) {
         if ($deltaAny.check(c?.value)) {
-          /** @type {DeltaBuilder} */ (c.value).apply(op.value)
+          c._modValue.apply(op.value)
         } else {
           // then this is a simple modify
-          this.attrs[op.key] = /** @type {any} */ (op)
+          // @ts-ignore
+          this.attrs[op.key] = op.clone()
         }
       } else {
-        /** @type {MapInsertOp<any>} */ (op).prevValue = c?.value
-        this.attrs[op.key] = /** @type {any} */ (op)
+        op = /** @type {any} */ (op.clone())
+        // @ts-ignore
+        op.prevValue = c?.value
+        // @ts-ignore
+        this.attrs[op.key] = op
       }
-    })
+    }
     // apply children
+    /**
+     * @type {ChildrenOpAny?}
+     */
     let opsI = this.children.start
     let offset = 0
+    /**
+     * At the end, we will try to merge this op, and op.next op with their respective previous op.
+     *
+     * Hence, anytime an op is cloned, deleted, or inserted (anytime list.* api is used) we must add
+     * an op to maybeMergeable.
+     *
+     * @type {Array<InsertOp<any>|RetainOp|DeleteOp|TextOp|ModifyOp<any>>}
+     */
+    const maybeMergeable = []
+    /**
+     * @template {InsertOp<any>|RetainOp|DeleteOp|TextOp|ModifyOp<any>|null} OP
+     * @param {OP} op
+     * @return {OP}
+     */
+    const scheduleForMerge = op => {
+      op && maybeMergeable.push(op)
+      return op
+    }
     other.children.forEach(op => {
       if ($textOp.check(op) || $insertOp.check(op)) {
         if (offset === 0) {
-          list.insertBetween(this.children, opsI == null ? this.children.end : opsI.prev, opsI, op.clone())
+          list.insertBetween(this.children, opsI == null ? this.children.end : opsI.prev, opsI, scheduleForMerge(op.clone()))
         } else {
           if (opsI == null) error.unexpectedCase()
-          const cpy = opsI.clone()
-          cpy._splice(0, offset)
+          const cpy = scheduleForMerge(opsI.clone(offset))
           opsI._splice(offset, opsI.length - offset)
           list.insertBetween(this.children, opsI, opsI.next || null, cpy)
-          list.insertBetween(this.children, opsI, cpy || null, op)
+          list.insertBetween(this.children, opsI, cpy || null, scheduleForMerge(op.clone()))
           offset = 0
         }
+        this.childCnt += op.insert.length
       } else if ($retainOp.check(op)) {
         let skipLen = op.length
         while (opsI != null && opsI.length - offset <= skipLen) {
@@ -1009,13 +1487,15 @@ export class DeltaBuilder extends Delta {
         if (opsI != null) {
           offset += skipLen
         } else {
-          list.pushEnd(this.children, new RetainOp(skipLen, op.format, op.attribution))
+          list.pushEnd(this.children, scheduleForMerge(new RetainOp(skipLen, op.format, op.attribution)))
+          this.childCnt += skipLen
         }
       } else if ($deleteOp.check(op)) {
         let remainingLen = op.delete
         while (remainingLen > 0) {
           if (opsI == null) {
-            list.pushEnd(this.children, new DeleteOp(remainingLen))
+            list.pushEnd(this.children, scheduleForMerge(new DeleteOp(remainingLen)))
+            this.childCnt += remainingLen
             break
           } else if (opsI instanceof DeleteOp) {
             const delLen = opsI.length - offset
@@ -1033,9 +1513,11 @@ export class DeltaBuilder extends Delta {
             // case3: delete some part of end
             // case4: delete some part of center
             const delLen = math.min(opsI.length - offset, remainingLen)
+            this.childCnt -= delLen
             if (opsI.length === delLen) {
               // case 1
               offset = 0
+              scheduleForMerge(opsI.next)
               list.remove(this.children, opsI)
             } else if (offset === 0) {
               // case 2
@@ -1056,32 +1538,26 @@ export class DeltaBuilder extends Delta {
       } else if ($modifyOp.check(op)) {
         if (opsI == null) {
           list.pushEnd(this.children, op.clone())
+          this.childCnt += 1
           return
         }
         if ($modifyOp.check(opsI)) {
-          /** @type {any} */ (opsI.value).apply(op.value)
-        } else if ($textOp.check(opsI) || $insertOp.check(opsI)) {
-          const d = opsI.insert[offset]
-          if (!$deltaAny.check(d)) {
-            // probably incompatible delta. can only modify deltas
-            error.unexpectedCase()
-          }
-          /** @type {any} */ (d).apply(op.value)
+          opsI._modValue.apply(op.value)
+        } else if ($insertOp.check(opsI)) {
+          opsI._modValue(offset).apply(op.value)
         } else if ($retainOp.check(opsI)) {
           if (offset > 0) {
-            const cpy = opsI.clone()
-            cpy._splice(offset, opsI.length - offset) // skipped len
+            const cpy = scheduleForMerge(opsI.clone(0, offset)) // skipped len
             opsI._splice(0, offset) // new remainder
             list.insertBetween(this.children, opsI.prev, opsI, cpy) // insert skipped len
             offset = 0
           }
-          // not deleting opsI, because current idea is that modify should not
-          // advance content
-          list.insertBetween(this.children, opsI.prev, opsI, op.clone()) // insert skipped len
+          list.insertBetween(this.children, opsI.prev, opsI, scheduleForMerge(op.clone())) // insert skipped len
           if (opsI.length === 1) {
             list.remove(this.children, opsI)
           } else {
             opsI._splice(0, 1)
+            scheduleForMerge(opsI)
           }
         } else if ($deleteOp.check(opsI)) {
           // nop
@@ -1092,15 +1568,22 @@ export class DeltaBuilder extends Delta {
         error.unexpectedCase()
       }
     })
+    maybeMergeable.forEach(op => {
+      // check if this is still integrated
+      if (op.prev?.next === op) {
+        tryMergeWithPrev(this.children, op)
+        op.next && tryMergeWithPrev(this.children, op.next)
+      }
+    })
     return this
   }
 
   /**
-   * @param {Delta<any,any,any,any,any>} other
+   * @param {DeltaAny} other
    * @param {boolean} priority
    */
   rebase (other, priority) {
-    // @todo rebase children
+    modDeltaCheck(this)
     /**
      * Rebase attributes
      *
@@ -1111,7 +1594,7 @@ export class DeltaBuilder extends Delta {
      * - delete vs delete ⇒ current delete op is removed because item has already been deleted
      * - modify vs modify ⇒ rebase using priority
      */
-    forEachAttr(this, op => {
+    for (const op of this.attrs) {
       if ($insertOp.check(op)) {
         if ($insertOp.check(other.attrs[op.key]) && !priority) {
           delete this.attrs[op.key]
@@ -1126,77 +1609,182 @@ export class DeltaBuilder extends Delta {
         if (otherOp == null) {
           // nop
         } else if ($modifyOp.check(otherOp)) {
-          op.value.rebase(otherOp.value, priority)
+          op._modValue.rebase(otherOp.value, priority)
         } else {
           delete this.attrs[otherOp.key]
         }
       }
-    })
+    }
+    /**
+     * Rebase children.
+     *
+     * Precedence: insert with higher priority comes first. Op with less priority is transformed to
+     * be inserted later.
+     *
+     * @todo always check if inser OR text
+     */
+    /**
+     * @type {ChildrenOpAny?}
+     */
+    let currChild = this.children.start
+    let currOffset = 0
+    /**
+     * @type {ChildrenOpAny?}
+     */
+    let otherChild = other.children.start
+    let otherOffset = 0
+    while (currChild != null && otherChild != null) {
+      if ($insertOp.check(currChild) || $textOp.check(currChild)) {
+        /**
+         * Transforming *insert*. If other is..
+         * - insert: transform based on priority
+         * - retain/delete/modify: transform next op against other
+         */
+        if ($insertOp.check(otherChild) || $modifyOp.check(otherChild) || $textOp.check(otherChild)) {
+          if (!priority) {
+            list.insertBetween(this.children, currChild.prev, currChild, new RetainOp(otherChild.length, null, null))
+            this.childCnt += otherChild.length
+            // curr is transformed against other, transform curr against next
+            otherOffset = otherChild.length
+          } else {
+            // curr stays as is, transform next op
+            currOffset = currChild.length
+          }
+        } else { // otherChild = delete | retain | modify - curr stays as is, transform next op
+          currOffset = currChild.length
+        }
+      } else if ($modifyOp.check(currChild)) {
+        /**
+         * Transforming *modify*. If other is..
+         * - insert: adjust position
+         * - modify: rebase curr modify on other modify
+         * - delete: remove modify
+         * - retain: adjust offset
+         */
+        if ($insertOp.check(otherChild) || $textOp.check(otherChild)) {
+          // @todo: with all list changes (retain insertions, removal), try to merge the surrounding
+          // ops later
+          list.insertBetween(this.children, currChild.prev, currChild, new RetainOp(otherChild.length, null, null))
+          this.childCnt += otherChild.length
+          // curr is transformed against other, transform curr against next
+          otherOffset = otherChild.length
+        } else {
+          if ($modifyOp.check(otherChild)) {
+            /** @type {any} */ (currChild.value).rebase(otherChild, priority)
+          } else if ($deleteOp.check(otherChild)) {
+            list.remove(this.children, currChild)
+            this.childCnt -= 1
+          }
+          currOffset += 1
+          otherOffset += 1
+        }
+      } else { // DeleteOp | RetainOp
+        const maxCommonLen = math.min(currChild.length - currOffset, otherChild.length - otherOffset)
+        /**
+         * Transforming *retain* OR *delete*. If other is..
+         * - retain / modify: adjust offsets
+         * - delete: shorten curr op
+         * - insert: split curr op and insert retain
+         */
+        if ($retainOp.check(otherChild) || $modifyOp.check(otherChild)) {
+          currOffset += maxCommonLen
+          otherOffset += maxCommonLen
+        } else if ($deleteOp.check(otherChild)) {
+          if ($retainOp.check(currChild)) {
+            // @ts-ignore
+            currChild.retain -= maxCommonLen
+          } else if ($deleteOp.check(currChild)) {
+            currChild.delete -= maxCommonLen
+          }
+          this.childCnt -= maxCommonLen
+        } else { // insert/text.check(currOp)
+          if (currOffset > 0) {
+            const leftPart = currChild.clone(currOffset)
+            list.insertBetween(this.children, currChild.prev, currChild, leftPart)
+            currChild._splice(currOffset, currChild.length - currOffset)
+            currOffset = 0
+          }
+          list.insertBetween(this.children, currChild.prev, currChild, new RetainOp(otherChild.length, null, null))
+          this.childCnt += otherChild.length
+          otherOffset = otherChild.length
+        }
+      }
+      if (currOffset >= currChild.length) {
+        currChild = currChild.next
+        currOffset = 0
+      }
+      if (otherOffset >= otherChild.length) {
+        otherChild = otherChild.next
+        otherOffset = 0
+      }
+    }
     return this
   }
 
   /**
-   * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
+   * Same as doing `delta.rebase(other.inverse())`, without creating a temporary delta.
+   *
+   * @param {DeltaAny} other
+   * @param {boolean} priority
    */
-  done () {
-    const cs = this.children
-    for (let end = cs.end; end !== null && $retainOp.check(end) && end.format == null; end = cs.end) {
-      list.popEnd(cs)
-    }
+  rebaseOnInverse (other, priority) {
+    modDeltaCheck(this)
+    // @todo
+    console.info('method rebaseOnInverse unimplemented')
     return this
   }
 }
 
 /**
  * @template {string} NodeName
- * @template {{ [key: string|number|symbol]: any }} [Attrs={}]
- * @template {any} [Children=never]
+ * @template {{ [key: string|number]: any }} [Attrs={}]
+ * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
  * @template {string|never} [Text=never]
  * @typedef {Delta<NodeName,Attrs,Children|Delta<NodeName,Attrs,Children,Text>|RecursiveDelta<NodeName,Attrs,Children,Text>,Text>} RecursiveDelta
  */
 
 /**
- * @template {string} [NodeName=any]
- * @template {{ [key: string|number|symbol]: any }} [Attrs={}]
- * @template {any} [Children=never]
+ * @template {s.Schema<string>|string|Array<string>} [NodeNameSchema=s.Schema<any>]
+ * @template {s.Schema<{ [key: string|number]: any }>|{ [key:string|number]:any }} [AttrsSchema=s.Schema<{}>]
+ * @template {any} [ChildrenSchema=s.Schema<never>]
  * @template {boolean} [HasText=false]
  * @template {boolean} [Recursive=false]
  * @param {object} opts
- * @param {s.Schema<NodeName>?} [opts.name]
- * @param {s.Schema<Attrs>?} [opts.attrs]
- * @param {s.Schema<Children>?} [opts.children]
- * @param {HasText} [opts.hasText]
+ * @param {NodeNameSchema?} [opts.name]
+ * @param {AttrsSchema?} [opts.attrs]
+ * @param {ChildrenSchema?} [opts.children]
+ * @param {HasText} [opts.text]
  * @param {Recursive} [opts.recursive]
- * @return {s.Schema<Delta<
+ * @return {[s.Unwrap<s.ReadSchema<NodeNameSchema>>,s.Unwrap<s.ReadSchema<AttrsSchema>>,s.Unwrap<s.ReadSchema<ChildrenSchema>>] extends [infer NodeName, infer Attrs, infer Children] ? s.Schema<Delta<
  *     NodeName,
  *     Attrs,
  *     Children|(Recursive extends true ? RecursiveDelta<NodeName,Attrs,Children,HasText extends true ? string : never> : never),
  *     HasText extends true ? string : never
- * >>}
+ * >> : never}
  */
-export const $delta = ({ name, attrs, children, hasText, recursive }) => {
-  name = name == null ? s.$any : name
+export const $delta = ({ name, attrs, children, text, recursive }) => {
   /**
    * @type {s.Schema<Array<any>>}
    */
-  let $arrContent = children == null ? s.$never : s.$array(children)
-  const $attrsPartial = attrs == null ? s.$object({}) : (s.$$object.check(attrs) ? attrs.partial : attrs)
+  let $arrContent = children == null ? s.$never : s.$array(s.$(children))
+  const $name = name == null ? s.$any : s.$(name)
+  const $attrsPartial = attrs == null ? s.$object({}) : (s.$$record.check(attrs) ? attrs : /** @type {any} */ (s.$(attrs)).partial)
   const $d = s.$instanceOf(Delta, /** @param {Delta<any,any,any,any,any>} d */ d => {
     if (
-      !name.check(d.name) ||
+      !$name.check(d.name) ||
       object.some(d.attrs,
         (op, k) => $insertOp.check(op) && !$attrsPartial.check({ [k]: op.value })
       )
     ) return false
     for (const op of d.children) {
-      if ((!hasText && $textOp.check(op)) || ($insertOp.check(op) && !$arrContent.check(op.insert))) {
+      if ((!text && $textOp.check(op)) || ($insertOp.check(op) && !$arrContent.check(op.insert))) {
         return false
       }
     }
     return true
   })
   if (recursive) {
-    $arrContent = children == null ? s.$array($d) : s.$array(children, $d)
+    $arrContent = children == null ? s.$array($d) : s.$array(s.$(children), $d)
   }
   return /** @type {any} */ ($d)
 }
@@ -1216,16 +1804,16 @@ export const $deltaAny = /** @type {any} */ (s.$instanceOf(Delta))
 export const mergeAttrs = (a, b) => object.isEmpty(a) ? b : (object.isEmpty(b) ? a : object.assign({}, a, b))
 
 /**
- * @template {DeltaBuilder?} D
+ * @template {DeltaAny|null} D
  * @param {D} a
  * @param {D} b
  * @return {D}
  */
 export const mergeDeltas = (a, b) => {
   if (a != null && b != null) {
-    const c = /** @type {Exclude<D,null>} */ (a.clone())
+    const c = clone(a)
     c.apply(b)
-    return c
+    return /** @type {any} */ (c)
   }
   return a == null ? b : (a || null)
 }
@@ -1256,8 +1844,8 @@ export const mergeDeltas = (a, b) => {
  */
 /**
  * @template {string|null} NodeName
- * @template {{[k:string|number|symbol]:any}|null} Attrs
- * @template {Array<any>|string} Children
+ * @template {{[k:string|number]:any}|null} Attrs
+ * @template {Array<any>|string} [Children=never]
  * @overload
  * @param {NodeName} nodeName
  * @param {Attrs} attrs
@@ -1272,7 +1860,7 @@ export const mergeDeltas = (a, b) => {
  */
 /**
  * @param {string|s.Schema<DeltaAny>} [nodeNameOrSchema]
- * @param {{[K:string|number|symbol]:any}|s.Schema<DeltaAny>} [attrsOrSchema]
+ * @param {{[K:string|number]:any}|s.Schema<DeltaAny>} [attrsOrSchema]
  * @param {(Array<any>|string)} [children]
  * @return {DeltaBuilder<any,any,any,any,any>}
  */
@@ -1290,12 +1878,12 @@ export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
 // DELTA TEXT
 
 /**
- * @template [Embeds=never]
+ * @template {encoding.AnyEncodable|DeltaAny} [Embeds=never]
  * @typedef {Delta<any,{},Embeds,string>} TextDelta
  */
 
 /**
- * @template [Embeds=never]
+ * @template {encoding.AnyEncodable|DeltaAny} [Embeds=never]
  * @typedef {DeltaBuilder<any,{},Embeds,string>} TextDeltaBuilder
  */
 
@@ -1304,7 +1892,7 @@ export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
  * @param {$Embeds} $embeds
  * @return {s.Schema<TextDelta<_AnyToNull<$Embeds> extends null ? never : ($Embeds extends Array<s.Schema<infer $C>> ? $C : never)>>}
  */
-export const $text = (...$embeds) => /** @type {any} */ ($delta({ children: s.$union(...$embeds), hasText: true }))
+export const $text = (...$embeds) => /** @type {any} */ ($delta({ children: s.$union(...$embeds), text: true }))
 export const $textOnly = $text()
 
 /**
@@ -1315,21 +1903,21 @@ export const $textOnly = $text()
 export const text = $schema => /** @type {any} */ (create($schema || $textOnly))
 
 /**
- * @template {any} Children
+ * @template {encoding.AnyEncodable|DeltaAny} Children
  * @typedef {Delta<any,{},Children,never>} ArrayDelta
  */
 
 /**
- * @template {any} Children
+ * @template {encoding.AnyEncodable|DeltaAny} Children
  * @typedef {DeltaBuilder<any,{},Children,never>} ArrayDeltaBuilder
  */
 
 /**
- * @template {s.Schema<any>} $Children
+ * @template {any|s.Schema<any>} $Children
  * @param {$Children} [$children]
- * @return {s.Schema<ArrayDelta<$Children>>}
+ * @return {s.Schema<ArrayDelta<s.Unwrap<s.ReadSchema<$Children>>>>}
  */
-export const $array = $children => $delta({ children: $children })
+export const $array = $children => /** @type {any} */ ($delta({ children: $children }))
 
 /**
  * @template {s.Schema<ArrayDelta<any>>} [$Schema=never]
@@ -1339,17 +1927,17 @@ export const $array = $children => $delta({ children: $children })
 export const array = $schema => /** @type {any} */ ($schema ? create($schema) : create())
 
 /**
- * @template {{ [K: string|number|symbol]: any }} Attrs
+ * @template {{ [K: string|number]: any }} Attrs
  * @typedef {Delta<any,Attrs,never,never>} MapDelta
  */
 
 /**
- * @template {{ [K: string|number|symbol]: any }} Attrs
+ * @template {{ [K: string|number]: any }} Attrs
  * @typedef {DeltaBuilder<any,Attrs,never,never>} MapDeltaBuilder
  */
 
 /**
- * @template {{ [K: string|number|symbol]: any }} $Attrs
+ * @template {{ [K: string|number]: any }} $Attrs
  * @param {s.Schema<$Attrs>} $attrs
  * @return {s.Schema<MapDelta<$Attrs>>}
  */
@@ -1361,3 +1949,97 @@ export const $map = $attrs => /** @type {any} */ ($delta({ attrs: $attrs }))
  * @return {$Schema extends s.Schema<MapDelta<infer Attrs>> ? DeltaBuilder<any,Attrs,never,never,$Schema> : MapDeltaBuilder<{}>}
  */
 export const map = $schema => /** @type {any} */ (create(/** @type {any} */ ($schema)))
+
+/**
+ * @template {DeltaAny} D
+ * @param {D} d1
+ * @param {NoInfer<D>} d2
+ * @return {D}
+ */
+export const diff = (d1, d2) => {
+  /**
+   * @type {DeltaBuilderAny}
+   */
+  const d = create()
+  if (d1.fingerprint !== d2.fingerprint) {
+    let left1 = d1.children.start
+    let left2 = d2.children.start
+    let right1 = d1.children.end
+    let right2 = d2.children.end
+    let commonPrefixOffset = 0
+    // perform a patience sort
+    // 1) remove common prefix and suffix
+    while (left1 != null && left1.fingerprint === left2?.fingerprint) {
+      if (!$deleteOp.check(left1)) {
+        commonPrefixOffset += left1.length
+      }
+      left1 = left1.next
+      left2 = left2.next
+    }
+    while (right1 !== null && right1 !== left1 && right1.fingerprint === right2?.fingerprint) {
+      right1 = right1.prev
+      right2 = right2.prev
+    }
+    /**
+     * @type {Array<ChildrenOpAny>}
+     */
+    const ops1 = []
+    /**
+     * @type {Array<ChildrenOpAny>}
+     */
+    const ops2 = []
+    while (left1 !== null && left1 !== right1?.next) {
+      ops1.push(left1)
+      left1 = left1.next
+    }
+    while (left2 !== null && left2 !== right2?.next) {
+      ops2.push(left2)
+      left2 = left2.next
+    }
+    const fprints1 = ops1.map(op => op.fingerprint)
+    const fprints2 = ops2.map(op => op.fingerprint)
+    const changeset = patience.diff(fprints1, fprints2)
+    d.retain(commonPrefixOffset)
+    for (let i = 0, lastIndex1 = 0, currIndexOffset2 = 0; i < changeset.length; i++) {
+      const change = changeset[i]
+      d.retain(change.index - lastIndex1)
+      // insert minimal diff at curred position in d
+      /**
+       * @param {DeltaBuilderAny} d
+       * @param {ChildrenOpAny[]} opsIs
+       * @param {ChildrenOpAny[]} opsShould
+       *
+       */
+      const diffAndApply = (d, opsIs, opsShould) => {
+        // naive implementation
+        d.delete(opsIs.reduce((currLen, op) => currLen + op.length, 0))
+        opsShould.forEach(newIns => {
+          if ($insertOp.check(newIns) || $textOp.check(newIns)) {
+            d.insert(newIns.insert)
+          } else {
+            error.unexpectedCase()
+          }
+        })
+      }
+      diffAndApply(d, ops1.slice(change.index, change.index + change.remove.length), ops2.slice(change.index + currIndexOffset2, change.insert.length))
+      lastIndex1 = change.index + change.remove.length
+      currIndexOffset2 += change.insert.length - change.remove.length
+    }
+    for (const attr2 of d2.attrs) {
+      const attr1 = d1.attrs[attr2.key]
+      if (attr1 == null || (attr1.fingerprint !== attr2.fingerprint)) {
+        if ($insertOp.check(attr2)) {
+          d.set(attr2.key, attr2.value)
+        } else {
+          error.unexpectedCase()
+        }
+      }
+    }
+    for (const attr1 of d1.attrs) {
+      if (d2.attrs[attr1.key] == null) {
+        d.unset(attr1.key)
+      }
+    }
+  }
+  return /** @type {D} */ (d.done())
+}