lib0 0.2.116 → 1.0.0-0

package/{delta → src/delta}/delta.js

@@ -37,18 +37,14 @@ import * as prng from '../prng.js'
 /**
  * @type {s.Schema<Attribution>}
  */
-export const $attribution = s.$object({
+export const $attribution = /* @__PURE__ */(() => s.$object({
   insert: s.$array(s.$string).optional,
   insertAt: s.$number.optional,
   delete: s.$array(s.$string).optional,
   deleteAt: s.$number.optional,
   format: s.$record(s.$string, s.$array(s.$string)).optional,
   formatAt: s.$number.optional
-})
-
-/**
- * @typedef {s.Unwrap<$anyOp>} DeltaOps
- */
+}))()
 
 /**
  * @typedef {{ [key: string]: any }} FormattingAttributes
@@ -76,7 +72,7 @@ export const $attribution = s.$object({
  */
 
 /**
- * @typedef {AttrInsertOp<any>|AttrDeleteOp<any>|AttrModifyOp} AttrOpAny
+ * @typedef {SetAttrOp<any>|DeleteAttrOp<any>|ModifyAttrOp} AttrOpAny
  */
 
 /**
@@ -86,11 +82,11 @@ export const $attribution = s.$object({
 /**
  * @type {s.Schema<DeltaAttrOpJSON>}
  */
-export const $deltaMapChangeJson = s.$union(
+export const $deltaMapChangeJson = /* @__PURE__ */(() => s.$union(
   s.$object({ type: s.$literal('insert'), value: s.$any, prevValue: s.$any.optional, attribution: $attribution.optional }),
   s.$object({ type: s.$literal('modify'), value: s.$any }),
   s.$object({ type: s.$literal('delete'), prevValue: s.$any.optional, attribution: $attribution.optional })
-)
+))()
 
 /**
  * @template {{[key:string]: any} | null} Attrs
@@ -131,6 +127,10 @@ export class TextOp extends list.ListNode {
     this._fingerprint = null
   }
 
+  get $type () {
+    return $textOp
+  }
+
   /**
    * @param {string} newVal
    */
@@ -196,7 +196,7 @@ export class TextOp extends list.ListNode {
 }
 
 /**
- * @template {fingerprintTrait.Fingerprintable} ArrayContent
+ * @template {any} ArrayContent
  */
 export class InsertOp extends list.ListNode {
   /**
@@ -227,6 +227,10 @@ export class InsertOp extends list.ListNode {
     this._fingerprint = null
   }
 
+  get $type () {
+    return $insertOp
+  }
+
   /**
    * @param {ArrayContent} newVal
    */
@@ -271,7 +275,7 @@ export class InsertOp extends list.ListNode {
       encoding.writeVarUint(encoder, 1) // insertOp type: 1
       encoding.writeVarUint(encoder, this.insert.length)
       this.insert.forEach(ins => {
-        encoding.writeVarString(encoder, fingerprintTrait.fingerprint(ins))
+        encoding.writeVarString(encoder, fingerprintTrait.fingerprint(/** @type {any} */ (ins)))
       })
       encoding.writeAny(encoder, this.format)
     })))
@@ -313,8 +317,7 @@ export class InsertOp extends list.ListNode {
 }
 
 /**
- * @template {fingerprintTrait.Fingerprintable} [Children=never]
- * @template {string} [Text=never]
+ * @template {DeltaConf} [DConf={}]
  */
 export class DeleteOp extends list.ListNode {
   /**
@@ -324,7 +327,7 @@ export class DeleteOp extends list.ListNode {
     super()
     this.delete = len
     /**
-     * @type {(Children|Text) extends never ? null : (Delta<any,{},Children,Text>?)}
+     * @type {Delta<DConf>?}
      */
     this.prevValue = null
     /**
@@ -333,6 +336,10 @@ export class DeleteOp extends list.ListNode {
     this._fingerprint = null
   }
 
+  get $type () {
+    return $deleteOp
+  }
+
   /**
    * @return {'delete'}
    */
@@ -358,7 +365,7 @@ export class DeleteOp extends list.ListNode {
    * @param {number} len
    */
   _splice (_offset, len) {
-    this.prevValue = /** @type {any} */ (this.prevValue?.slice(_offset, len) || null)
+    this.prevValue = /** @type {any} */ (this.prevValue ? slice(this.prevValue, _offset, len) : null)
     this._fingerprint = null
     this.delete -= len
     return this
@@ -378,6 +385,11 @@ export class DeleteOp extends list.ListNode {
     return this.delete === other.delete
   }
 
+  /**
+   * @param {number} start
+   * @param {number} end
+   * @return {DeleteOp}
+   */
   clone (start = 0, end = this.delete) {
     return new DeleteOp(end - start)
   }
@@ -412,6 +424,10 @@ export class RetainOp extends list.ListNode {
     this._fingerprint = null
   }
 
+  get $type () {
+    return $retainOp
+  }
+
   /**
    * @return {'retain'}
    */
@@ -467,7 +483,7 @@ export class RetainOp extends list.ListNode {
 /**
  * Delta that can be applied on a YType Embed
  *
- * @template {DeltaAny} [DTypes=DeltaAny]
+ * @template {Delta} [DTypes=DeltaAny]
  */
 export class ModifyOp extends list.ListNode {
   /**
@@ -498,6 +514,10 @@ export class ModifyOp extends list.ListNode {
     this._fingerprint = null
   }
 
+  get $type () {
+    return $modifyOp
+  }
+
   /**
    * @return {'modify'}
    */
@@ -568,10 +588,10 @@ export class ModifyOp extends list.ListNode {
 }
 
 /**
- * @template {fingerprintTrait.Fingerprintable} V
+ * @template {any} [V=any]
  * @template {string|number} [K=any]
  */
-export class AttrInsertOp {
+export class SetAttrOp {
   /**
    * @param {K} key
    * @param {V} value
@@ -605,6 +625,10 @@ export class AttrInsertOp {
     this._fingerprint = null
   }
 
+  get $type () {
+    return $setAttrOp
+  }
+
   /**
    * @return {'insert'}
    */
@@ -635,7 +659,7 @@ export class AttrInsertOp {
         encoding.writeVarString(encoder, this.value.fingerprint)
       } else {
         encoding.writeUint8(encoder, 1)
-        encoding.writeAny(encoder, this.value)
+        encoding.writeAny(encoder, /** @type {any} */ (this.value))
       }
     })))
   }
@@ -651,25 +675,25 @@ export class AttrInsertOp {
   }
 
   /**
-   * @param {AttrInsertOp<V>} other
+   * @param {SetAttrOp<V>} other
    */
   [equalityTrait.EqualityTraitSymbol] (other) {
     return this.key === other.key && fun.equalityDeep(this.value, other.value) && fun.equalityDeep(this.attribution, other.attribution)
   }
 
   /**
-   * @return {AttrInsertOp<V,K>}
+   * @return {SetAttrOp<V,K>}
    */
   clone () {
-    return new AttrInsertOp(this.key, _markMaybeDeltaAsDone(this.value), _markMaybeDeltaAsDone(this.prevValue), _cloneAttrs(this.attribution))
+    return new SetAttrOp(this.key, _markMaybeDeltaAsDone(this.value), _markMaybeDeltaAsDone(this.prevValue), _cloneAttrs(this.attribution))
   }
 }
 
 /**
- * @template V
- * @template {string|number} [K=string]
+ * @template [V=any]
+ * @template {string|number} [K=string|number]
  */
-export class AttrDeleteOp {
+export class DeleteAttrOp {
   /**
    * @param {K} key
    * @param {V|undefined} prevValue
@@ -691,13 +715,17 @@ export class AttrDeleteOp {
     this._fingerprint = null
   }
 
-  get value () { return undefined }
+  get $type () {
+    return $deleteAttrOp
+  }
 
   /**
    * @type {'delete'}
    */
   get type () { return 'delete' }
 
+  get value () { return undefined }
+
   get fingerprint () {
     return this._fingerprint || (this._fingerprint = buffer.toBase64(encoding.encode(encoder => {
       encoding.writeVarUint(encoder, 6) // map delete type: 6
@@ -716,14 +744,14 @@ export class AttrDeleteOp {
   }
 
   /**
-   * @param {AttrDeleteOp<V>} other
+   * @param {DeleteAttrOp<V>} other
    */
   [equalityTrait.EqualityTraitSymbol] (other) {
     return this.key === other.key && fun.equalityDeep(this.attribution, other.attribution)
   }
 
   clone () {
-    return new AttrDeleteOp(this.key, _markMaybeDeltaAsDone(this.prevValue), _cloneAttrs(this.attribution))
+    return new DeleteAttrOp(this.key, _markMaybeDeltaAsDone(this.prevValue), _cloneAttrs(this.attribution))
   }
 }
 
@@ -731,7 +759,7 @@ export class AttrDeleteOp {
  * @template {DeltaAny} [Modifier=DeltaAny]
  * @template {string|number} [K=string]
  */
-export class AttrModifyOp {
+export class ModifyAttrOp {
   /**
    * @param {K} key
    * @param {Modifier} delta
@@ -753,6 +781,10 @@ export class AttrModifyOp {
     this._fingerprint = null
   }
 
+  get $type () {
+    return $modifyAttrOp
+  }
+
   /**
    * @type {'modify'}
    */
@@ -790,78 +822,59 @@ export class AttrModifyOp {
   }
 
   /**
-   * @param {AttrModifyOp<Modifier>} other
+   * @param {ModifyAttrOp<Modifier>} other
    */
   [equalityTrait.EqualityTraitSymbol] (other) {
     return this.key === other.key && this.value[equalityTrait.EqualityTraitSymbol](other.value)
   }
 
   /**
-   * @return {AttrModifyOp<Modifier,K>}
+   * @return {ModifyAttrOp<Modifier,K>}
    */
   clone () {
-    return new AttrModifyOp(this.key, /** @type {Modifier} */ (this.value.done()))
+    return new ModifyAttrOp(this.key, /** @type {Modifier} */ (this.value.done()))
   }
 }
 
-/**
- * @type {s.Schema<AttrDeleteOp<any> | DeleteOp>}
- */
-export const $deleteOp = s.$custom(o => o != null && (o.constructor === DeleteOp || o.constructor === AttrDeleteOp))
+export const $insertOp = /** @type {s.Schema<InsertOp<any>>} */ (s.$type('insertOp'))
+export const $modifyOp = /** @type {s.Schema<ModifyOp>} */ (s.$type('modifyOp'))
+export const $textOp = /** @type {s.Schema<TextOp>} */ (s.$type('textOp'))
+export const $deleteOp = /** @type {s.Schema<DeleteOp<any>>} */ (s.$type('deleteOp'))
+export const $retainOp = /** @type {s.Schema<RetainOp>} */ (s.$type('retainOp'))
+export const $anyOp = s.$union($insertOp, $deleteOp, $textOp, $modifyOp)
 
-/**
- * @type {s.Schema<AttrInsertOp<any> | InsertOp<any>>}
- */
-export const $insertOp = s.$custom(o => o != null && (o.constructor === AttrInsertOp || o.constructor === InsertOp))
+export const $setAttrOp = /** @type {s.Schema<SetAttrOp<any>>} */ (s.$type('setAttrOp'))
+export const $modifyAttrOp = /** @type {s.Schema<ModifyAttrOp<any,string|number>>} */ (s.$type('modifyAttrOp'))
+export const $deleteAttrOp = /** @type {s.Schema<DeleteAttrOp<any,string|number>>} */ (s.$type('deleteAttrOp'))
+export const $anyAttrOp = s.$union($setAttrOp, $deleteAttrOp, $modifyAttrOp)
 
 /**
  * @template {fingerprintTrait.Fingerprintable} Content
  * @param {s.Schema<Content>} $content
- * @return {s.Schema<AttrInsertOp<Content> | InsertOp<Content>>}
- */
-export const $insertOpWith = $content => s.$custom(o =>
-  o != null && (
-    (o.constructor === AttrInsertOp && $content.check(/** @type {AttrInsertOp<Content>} */ (o).value)) ||
-      (o.constructor === InsertOp && /** @type {InsertOp<Content>} */ (o).insert.every(ins => $content.check(ins)))
-  )
-)
-
-/**
- * @type {s.Schema<TextOp>}
+ * @return {s.Schema<SetAttrOp<Content>>}
  */
-export const $textOp = s.$constructedBy(TextOp)
+export const $setAttrOpWith = $content => s.$custom(o => $setAttrOp.check(o) && $content.check(o.value))
 
 /**
- * @type {s.Schema<RetainOp>}
- */
-export const $retainOp = s.$constructedBy(RetainOp)
-
-/**
- * @type {s.Schema<AttrModifyOp | ModifyOp>}
+ * @template {fingerprintTrait.Fingerprintable} Content
+ * @param {s.Schema<Content>} $content
+ * @return {s.Schema<InsertOp<Content>>}
  */
-export const $modifyOp = s.$custom(o => o != null && (o.constructor === AttrModifyOp || o.constructor === ModifyOp))
+export const $insertOpWith = $content => s.$custom(o => $insertOp.check(o) && $content.check(o.insert.every(ins => $content.check(ins))))
 
 /**
  * @template {DeltaAny} Modify
  * @param {s.Schema<Modify>} $content
- * @return {s.Schema<AttrModifyOp<Modify> | ModifyOp<Modify>>}
+ * @return {s.Schema<ModifyOp<Modify>>}
  */
-export const $modifyOpWith = $content => s.$custom(o =>
-  o != null && (
-    (o.constructor === AttrModifyOp && $content.check(/** @type {AttrModifyOp<Modify>} */ (o).value)) ||
-      (o.constructor === ModifyOp && $content.check(/** @type {ModifyOp<Modify>} */ (o).value))
-  )
-)
-
-export const $anyOp = s.$union($insertOp, $deleteOp, $textOp, $modifyOp)
+export const $modifyOpWith = $content => s.$custom(o => $modifyOp.check(o) && $content.check(o.value))
 
 /**
- * @template {Array<any>|string} C1
- * @template {Array<any>|string} C2
- * @typedef {Extract<C1 | C2, Array<any>> extends never
- *   ? never
- *   : (Array<(Extract<C1 | C2,Array<any>> extends Array<infer AC1> ? (unknown extends AC1 ? never : AC1) : never)>)} MergeListArrays
+ * @template {DeltaAny} Modify
+ * @param {s.Schema<Modify>} $content
+ * @return {s.Schema<ModifyAttrOp<Modify>>}
  */
+export const $modifyAttrOpWith = $content => s.$custom(o => $modifyAttrOp.check(o) && $content.check(/** @type {ModifyAttrOp<Modify>} */ (o).value))
 
 /**
  * @template {{[Key in string|number]: any}} Attrs
@@ -877,40 +890,104 @@ export const $anyOp = s.$union($insertOp, $deleteOp, $textOp, $modifyOp)
  */
 
 /**
- * @template X
- * @typedef {0 extends (1 & X) ? null : X} _AnyToNull
+ * @typedef {Delta<any>} DeltaAny
  */
 
 /**
- * @template {s.Schema<Delta<any,any,any,any,any>>|null} Schema
- * @typedef {_AnyToNull<Schema> extends null ? Delta<any,{[key:string|number]:any},any,string> : (Schema extends s.Schema<infer D> ? D : never)} AllowedDeltaFromSchema
+ * @typedef {DeltaBuilder<any>} DeltaBuilderAny
  */
 
 /**
- * @typedef {Delta<any,{ [k:string|number]: any },any,any,any>} DeltaAny
+ * @typedef {object} DeltaConf
+ * @property {string} [DeltaConf.name]
+ * @property {fingerprintTrait.Fingerprintable} [DeltaConf.children=never]
+ * @property {boolean} [DeltaConf.text=never]
+ * @property {{[K:string|number]:fingerprintTrait.Fingerprintable}} [DeltaConf.attrs={}]
+ * @property {boolean} [DeltaConf.fixed=never]
+ * @property {boolean} [DeltaConf.recursiveChildren=false]
+ * @property {boolean} [DeltaConf.recursiveAttrs=false]
  */
+
+/**
+ * @template {DeltaConf} DConf
+ * @typedef {DConf extends {name:infer Name} ? (unknown extends Name ? any : (Exclude<Name,undefined>)) : any} DeltaConfGetName
+ */
+
+/**
+ * @template {DeltaConf} DConf
+ * @typedef {(DConf extends {children:infer Children} ? (unknown extends Children ? any : Children) : never) | (DConf extends {recursiveChildren:true} ? Delta<DConf> : never)} DeltaConfGetChildren
+ */
+
 /**
- * @typedef {DeltaBuilder<any,{ [k:string|number]: any },any,any,any>} DeltaBuilderAny
+ * @template {DeltaConf} DConf
+ * @typedef {DConf extends {fixed:true} ? DeltaConfGetChildren<DConf> : any } DeltaConfGetAllowedChildren
  */
 
 /**
- * @template {string} [NodeName=any]
- * @template {{[k:string|number]:any}} [Attrs={}]
- * @template {fingerprintTrait.Fingerprintable} [Children=never]
- * @template {string} [Text=never]
- * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
+ * @template {DeltaConf} DConf
+ * @typedef {0 extends (1 & DConf) ? string : (DConf extends {text:true} ? string : never)} DeltaConfGetText
  */
-export class Delta {
+
+/**
+ * @template {DeltaConf} DConf
+ * @typedef {import('../ts.js').TypeIsAny<DConf, {[K:string|number]:any}, (DConf extends {attrs:infer Attrs} ? (Attrs extends undefined ? {} : Attrs) : {})>} DeltaConfGetAttrs
+ */
+
+/**
+ * @template {DeltaConf} DConf
+ * @typedef {DConf extends {fixed:true} ? DeltaConfGetAttrs<DConf> : {[K:string|number]:any}} DeltaConfGetAllowedAttrs
+ */
+
+/**
+ * @template {DeltaConf} DConf
+ * @typedef {0 extends (1 & DConf) ? true : (DConf extends { fixed: true } ? true : false)} DeltaConfGetFixed
+ */
+
+/**
+ * @template {DeltaConf} DConf
+ * @typedef {DConf extends {recursiveChildren:true} ? true : false} DeltaConfGetRecursiveChildren
+ */
+
+/**
+ * @template {DeltaConf} DConf
+ * @typedef {DConf extends {recursiveAttrs:true} ? true : false} DeltaConfigGetRecursiveAttrs
+ */
+
+/**
+ * Transform Delta(Builder) to a normal delta.
+ *
+ * @template V
+ * @typedef {V extends never ? never : (import('../ts.js').TypeIsAny<V,any,V extends Delta<infer DConf> ? Delta<DConf> : V>)} _SanifyDelta
+ */
+
+/**
+ * @template {DeltaConf} DConf
+ * @typedef {import('../ts.js').Prettify<{[K in keyof DConf]: K extends 'attrs' ? import('../ts.js').Prettify<{ [KA in keyof DConf[K]]: _SanifyDelta<DConf[K][KA]> },1> : (K extends 'children' ? _SanifyDelta<DConf[K]> : DConf[K]) }, 1>} PrettifyDeltaConf
+ */
+
+/**
+ * @template {DeltaConf} D1
+ * @template {DeltaConf} D2
+ * @typedef {import('../ts.js').TypeIsAny<D1, any, PrettifyDeltaConf<{[K in (keyof D1|keyof D2)]: K extends keyof D2 ? D2[K] : (K extends keyof D1 ? D1[K] : never)}>>} DeltaConfOverwrite
+ */
+
+/**
+ * @template {string} Name
+ * @template {{[K in string|number]:any}} Attrs
+ * @template Children
+ * @template {boolean} Text
+ */
+class DeltaData {
   /**
-   * @param {NodeName} [name]
-   * @param {Schema} [$schema]
+   * @param {string?} name
+   * @param {s.Schema<Delta<any>>?} $schema
    */
   constructor (name, $schema) {
-    this.name = name || null
-    this.$schema = $schema || null
+    this.name = /** @type {Name} */ (name)
+    this.$schema = $schema
     /**
-     * @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]> }
+     * @type {{ [K in keyof Attrs]?: K extends string|number ? (SetAttrOp<Attrs[K],K>|DeleteAttrOp<Attrs[K],K>|(Attrs[K] extends never ? never : (Attrs[K] extends Delta ? ModifyAttrOp<Extract<Attrs[K],Delta>,K> : never))) : never }
+     *       & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string|number ? (SetAttrOp<Attrs[K],K>|DeleteAttrOp<Attrs[K],K>|(Attrs[K] extends never ? never : (Delta extends Attrs[K] ? ModifyAttrOp<Extract<Attrs[K],Delta>,K> : never))) : never }[keyof Attrs]> }
      * }
      */
     this.attrs = /** @type {any} */ ({
@@ -923,11 +1000,8 @@ export class Delta {
 
     /**
      * @type {list.List<
-     *   RetainOp
-     *   | DeleteOp
-     *   | (Text extends never ? never : TextOp)
-     *   | (Children extends never ? never : InsertOp<Children>)
-     *   | (Delta extends Children ? ModifyOp<Extract<Children,Delta<any,any,any,any,any>>> : never)
+     *   | (Text extends true ? (RetainOp|TextOp|DeleteOp<any>) : never)
+     *   | (RetainOp|InsertOp<Children>|DeleteOp<any>|(Delta extends Children ? ModifyOp<Extract<Children,Delta>> : never))
      * >}
      */
     this.children = /** @type {any} */ (list.create())
@@ -942,7 +1016,19 @@ export class Delta {
     this._fingerprint = null
     this.isDone = false
   }
+}
 
+/**
+ * @template {DeltaConf} [DConf={}]
+ * @extends {DeltaData<
+ *   DeltaConfGetName<DConf>,
+ *   DeltaConfGetAttrs<DConf>,
+ *   DeltaConfGetChildren<DConf>,
+ *   DConf extends {text:true} ? true : false
+ * >}
+ */
+export class Delta extends DeltaData {
+  get $type () { return $deltaAny }
   /**
    * @type {string}
    */
@@ -1014,7 +1100,7 @@ export class Delta {
   }
 
   /**
-   * @param {Delta<any,any,any,any,any>} other
+   * @param {Delta<any>} other
    * @return {boolean}
    */
   equals (other) {
@@ -1031,66 +1117,27 @@ export class Delta {
     return this.name === other.name && fun.equalityDeep(this.attrs, other.attrs) && fun.equalityDeep(this.children, other.children) && this.childCnt === other.childCnt
   }
 
-  /**
-   * @return {DeltaBuilder<NodeName,Attrs,Children,Text,Schema>}
-   */
-  clone () {
-    return this.slice(0, this.childCnt)
-  }
-
-  /**
-   * @param {number} start
-   * @param {number} end
-   * @return {DeltaBuilder<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 {ChildrenOpAny?}
-     */
-    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
-      }
-    }
-    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
-  }
-
+  // toString () {
+  //   /**
+  //    * @type {Array<[string|number,string]>}
+  //    */
+  //   const attrs = []
+  //   for (const attr of this.attrs) {
+  //     attrs.push([attr.key, $deleteAttrOp.check(attr) ? 'delete' : attr.type + ' ' + (attr.value?.toString() ?? attr.value)])
+  //   }
+  //   attrs.sort((a, b) => a[0].toString() < b[0].toString() ? -1 : 1)
+  //   const attrsString = attrs.map(attr => `${attr[0]} = ${attr[1]}`).join(', ')
+  //   if (this.childCnt === 0) return `<${this.name ?? ''} ${attrsString}/>`
+  //   this.children.toArray() drnt
+  //   return '<>'
+  // }
+  //
   /**
    * 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>}
+   * @return {Delta<DConf>}
    */
   done (markAsDone = true) {
     if (!this.isDone) {
@@ -1105,17 +1152,66 @@ export class Delta {
   }
 }
 
+/**
+ * @template {DeltaConf} DConf
+ * @param {Delta<DConf>} d
+ * @param {number} start
+ * @param {number} end
+ * @param {ChildrenOpAny?} currNode - start slicing at this node (instead of d.children.start)
+ * @return {DeltaBuilder<DConf>}
+ */
+export const slice = (d, start = 0, end = d.childCnt, currNode = d.children.start) => {
+  const cpy = /** @type {DeltaAny} */ (new DeltaBuilder(d.name, d.$schema))
+  cpy.origin = d.origin
+  // copy attrs
+  for (const op of d.attrs) {
+    // @ts-ignore
+    cpy.attrs[op.key] = /** @type {any} */ (op.clone())
+  }
+  // copy children
+  const slicedLen = end - start
+  let remainingLen = slicedLen
+  let currNodeOffset = 0
+  while (start > 0 && currNode != null) {
+    if (currNode.length <= start) {
+      start -= currNode.length
+      currNode = currNode.next
+    } else {
+      currNodeOffset = start
+      start = 0
+    }
+  }
+  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())
+    remainingLen -= currNode.length
+    currNode = currNode.next
+  }
+  if (currNode != null && remainingLen > 0) {
+    list.pushEnd(cpy.children, currNode.clone(0, remainingLen))
+    remainingLen -= math.min(currNode.length, remainingLen)
+  }
+  cpy.childCnt = slicedLen - remainingLen
+  // @ts-ignore
+  return cpy
+}
+
 /**
  * @template {DeltaAny} D
  * @param {D} d
- * @return {D extends DeltaBuilder<infer NodeName,infer Attrs,infer Children,infer Text,infer Schema> ? DeltaBuilder<NodeName,Attrs,Children,Text,Schema> : never}
+ * @return {D extends Delta<infer DConf> ? DeltaBuilder<DConf> : never}
  */
-export const clone = d => /** @type {any} */ (d.slice(0, d.childCnt))
+export const clone = d => /** @type {any} */ (slice(d, 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
+ * @param {InsertOp<any>|RetainOp|DeleteOp<any>|TextOp|ModifyOp<any>} op
  */
 const tryMergeWithPrev = (parent, op) => {
   const prevOp = op.prev
@@ -1135,7 +1231,7 @@ const tryMergeWithPrev = (parent, op) => {
     // @ts-ignore
     /** @type {RetainOp} */ (prevOp).retain += op.retain
   } else if ($deleteOp.check(op)) {
-    /** @type {DeleteOp} */ (prevOp).delete += op.delete
+    /** @type {DeleteOp<any>} */ (prevOp).delete += op.delete
   } else if ($textOp.check(op)) {
     /** @type {TextOp} */ (prevOp)._updateInsert(/** @type {TextOp} */ (prevOp).insert + op.insert)
   } else {
@@ -1160,17 +1256,13 @@ const modDeltaCheck = d => {
 }
 
 /**
- * @template {string} [NodeName=any]
- * @template {{[key:string|number]:any}} [Attrs={}]
- * @template {fingerprintTrait.Fingerprintable} [Children=never]
- * @template {string} [Text=never]
- * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
- * @extends {Delta<NodeName,Attrs,Children,Text,Schema>}
+ * @template {DeltaConf} [DConf={}]
+ * @extends {Delta<DConf>}
  */
 export class DeltaBuilder extends Delta {
   /**
-   * @param {NodeName} [name]
-   * @param {Schema} [$schema]
+   * @param {string?} name
+   * @param {s.Schema<Delta<DConf>>?} $schema
    */
   constructor (name, $schema) {
     super(name, $schema)
@@ -1243,17 +1335,14 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,any,infer Children,infer Text,infer Schema> ? ((Children extends never ? never : Array<Children>) | Text) : never} NewContent
+   * @template {(DConf extends {fixed:true} ? never : (Array<any>|string)) | (DeltaConfGetChildren<DConf> extends infer Children ? (Children extends never ? never : Array<Children>) : never) | DeltaConfGetText<DConf>} NewContent
    * @param {NewContent} insert
    * @param {FormattingAttributes?} [formatting]
    * @param {Attribution?} [attribution]
-   * @return {DeltaBuilder<
-   *   NodeName,
-   *   Attrs,
-   *   Exclude<NewContent,string>[number]|Children,
-   *   (Extract<NewContent,string>|Text) extends never ? never : string,
-   *   Schema
-   * >}
+   * @return {DeltaBuilder<DConf extends {fixed: true} ? DConf : DeltaConfOverwrite<DConf,
+   * (Exclude<NewContent,string> extends never ? {} : {
+   *   children: Exclude<NewContent,string>[number]|DeltaConfGetChildren<DConf>
+   * }) & (Extract<NewContent,string> extends never ? {} : { text: true })>>}
    */
   insert (insert, formatting = null, attribution = null) {
     modDeltaCheck(this)
@@ -1277,7 +1366,7 @@ export class DeltaBuilder extends Delta {
         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))
+        list.pushEnd(this.children, new InsertOp(insert.slice() /* ensures that we don't reuse an existing array */, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution))
       }
       this.childCnt += insert.length
     }
@@ -1285,17 +1374,11 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,any,infer Children,any,any> ? Extract<Children,Delta<any,any,any,any,any>> : never} NewContent
+   * @template {Extract<DeltaConfGetAllowedChildren<DConf>,Delta>} NewContent
    * @param {NewContent} modify
    * @param {FormattingAttributes?} formatting
    * @param {Attribution?} attribution
-   * @return {DeltaBuilder<
-   *   NodeName,
-   *   Attrs,
-   *   Exclude<NewContent,string>[number]|Children,
-   *   (Extract<NewContent,string>|Text) extends string ? string : never,
-   *   Schema
-   * >}
+   * @return {DeltaBuilder<DeltaConfOverwrite<DConf, {children: DeltaConfGetChildren<DConf>|NewContent}>>}
    */
   modify (modify, formatting = null, attribution = null) {
     modDeltaCheck(this)
@@ -1316,7 +1399,7 @@ export class DeltaBuilder extends Delta {
     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)) {
+    if ($retainOp.check(lastOp) && fun.equalityDeep(mergedFormats, lastOp.format) && fun.equalityDeep(mergedAttribution, lastOp.attribution)) {
       // @ts-ignore
       lastOp.retain += len
     } else if (len > 0) {
@@ -1331,8 +1414,8 @@ export class DeltaBuilder extends Delta {
    */
   delete (len) {
     modDeltaCheck(this)
-    const lastOp = /** @type {DeleteOp|InsertOp<any>} */ (this.children.end)
-    if (lastOp instanceof DeleteOp) {
+    const lastOp = /** @type {DeleteOp<any>|InsertOp<any>} */ (this.children.end)
+    if ($deleteOp.check(lastOp)) {
       lastOp.delete += len
     } else if (len > 0) {
       list.pushEnd(this.children, new DeleteOp(len))
@@ -1342,94 +1425,81 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
-   * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer Attrs,any,any,any> ? (keyof Attrs) : never} Key
-   * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer Attrs,any,any,any> ? (Attrs[Key]) : never} Val
+   * @template {keyof DeltaConfGetAllowedAttrs<DConf>} Key
+   * @template {DeltaConfGetAllowedAttrs<DConf>[Key]} Val
    * @param {Key} key
    * @param {Val} val
    * @param {Attribution?} attribution
    * @param {Val|undefined} [prevValue]
-   * @return {DeltaBuilder<
-   *   NodeName,
-   *   { [K in keyof AddToAttrs<Attrs,Key,Val>]: AddToAttrs<Attrs,Key,Val>[K]  },
-   *   Children,
-   *   Text,
-   *   Schema
-   * >}
-   */
-  set (key, val, attribution = null, prevValue) {
+   * @return {DeltaBuilder<DeltaConfOverwrite<DConf,{attrs:AddToAttrs<DeltaConfGetAttrs<DConf>,Key,Val>}>>}
+   */
+  setAttr (key, val, attribution = null, prevValue) {
     modDeltaCheck(this)
-    this.attrs[key] = /** @type {any} */ (new AttrInsertOp(key, val, prevValue, mergeAttrs(this.usedAttribution, attribution)))
+    // @ts-ignore
+    this.attrs[key] /** @type {any} */ =
+      (new SetAttrOp(/** @type {any} */ (key), val, prevValue, mergeAttrs(this.usedAttribution, attribution)))
     return /** @type {any} */ (this)
   }
 
   /**
-   * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer Attrs,any,any,any> ? Attrs : never} NewAttrs
+   * @template {DeltaConfGetAllowedAttrs<DConf>} NewAttrs
    * @param {NewAttrs} attrs
    * @param {Attribution?} attribution
-   * @return {DeltaBuilder<
-   *   NodeName,
-   *   { [K in keyof MergeAttrs<Attrs,NewAttrs>]: MergeAttrs<Attrs,NewAttrs>[K] },
-   *   Children,
-   *   Text,
-   *   Schema
-   * >}
-   */
-  setMany (attrs, attribution = null) {
+   * @return {DeltaBuilder<DeltaConfOverwrite<
+   *   DConf,
+   *   { attrs: MergeAttrs<DeltaConfGetAttrs<DConf>,NewAttrs> }
+   *   >>
+   * }
+   */
+  setAttrs (attrs, attribution = null) {
     modDeltaCheck(this)
     for (const k in attrs) {
-      this.set(/** @type {any} */ (k), attrs[k], attribution)
+      this.setAttr(/** @type {any} */ (k), /** @type {any} */ (attrs)[/** @type {any} */ (k)], attribution)
     }
     return /** @type {any} */ (this)
   }
 
   /**
-   * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer As,any,any,any> ? keyof As : never} Key
+   * @template {keyof DeltaConfGetAllowedAttrs<DConf>} Key
    * @param {Key} key
    * @param {Attribution?} attribution
    * @param {any} [prevValue]
-   * @return {DeltaBuilder<
-   *   NodeName,
-   *   { [K in keyof AddToAttrs<Attrs,Key,never>]: AddToAttrs<Attrs,Key,never>[K] },
-   *   Children,
-   *   Text,
-   *   Schema
-   * >}
-   */
-  unset (key, attribution = null, prevValue) {
+   * @return {DeltaBuilder<DeltaConfOverwrite<DConf, {
+   *   attrs: AddToAttrs<DeltaConfGetAttrs<DConf>,Key,never>
+   * }>>}
+   */
+  deleteAttr (key, attribution = null, prevValue) {
     modDeltaCheck(this)
-    this.attrs[key] = /** @type {any} */ (new AttrDeleteOp(key, prevValue, mergeAttrs(this.usedAttribution, attribution)))
+    // @ts-ignore
+    this.attrs[key] /** @type {any} */ =
+      (new DeleteAttrOp(/** @type {any} */ (key), prevValue, mergeAttrs(this.usedAttribution, attribution)))
     return /** @type {any} */ (this)
   }
 
   /**
-   * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer As,any,any,any> ? { [K in keyof As]: Extract<As[K],Delta<any,any,any,any,any>> extends never ? never : K }[keyof As] : never} Key
-   * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer As,any,any,any> ? Extract<As[Key],Delta<any,any,any,any,any>> : never} D
+   * @template {DeltaConfGetAllowedAttrs<DConf> extends infer As ? { [K in keyof As]: Extract<As[K],DeltaAny> extends never ? never : K }[keyof As] : never} Key
+   * @template {Extract<DeltaConfGetAllowedAttrs<DConf>[Key],DeltaAny>} D
    * @param {Key} key
    * @param {D} modify
-   * @return {DeltaBuilder<
-   *   NodeName,
-   *   { [K in keyof AddToAttrs<Attrs,Key,D>]: AddToAttrs<Attrs,Key,D>[K]  },
-   *   Children,
-   *   Text,
-   *   Schema
-   * >}
-   */
-  update (key, modify) {
+   * @return {DeltaBuilder<DeltaConfOverwrite<DConf,{attrs:AddToAttrs<DeltaConfGetAttrs<DConf>,Key,D>}>>}
+   */
+  modifyAttr (key, modify) {
     modDeltaCheck(this)
-    this.attrs[key] = /** @type {any} */ (new AttrModifyOp(key, modify))
+    this.attrs[key] = /** @type {any} */ (new ModifyAttrOp(key, modify))
     return /** @type {any} */ (this)
   }
 
   /**
-   * @param {Delta<NodeName,Attrs,Children,Text,any>} other
+   * @param {Delta<DConf>} other
    */
   apply (other) {
     modDeltaCheck(this)
     this.$schema?.expect(other)
     // apply attrs
     for (const op of other.attrs) {
-      const c = /** @type {AttrInsertOp<any,any>|AttrDeleteOp<any>|AttrModifyOp<any,any>} */ (this.attrs[op.key])
-      if ($modifyOp.check(op)) {
+      // @ts-ignore
+      const c = /** @type {SetAttrOp<any,any>|DeleteAttrOp<any>|ModifyAttrOp<any,any>} */ (this.attrs[op.key])
+      if ($modifyAttrOp.check(op)) {
         if ($deltaAny.check(c?.value)) {
           c._modValue.apply(op.value)
         } else {
@@ -1437,13 +1507,14 @@ export class DeltaBuilder extends Delta {
           // @ts-ignore
           this.attrs[op.key] = op.clone()
         }
-      } else if ($insertOp.check(op)) {
+      } else if ($setAttrOp.check(op)) {
         // @ts-ignore
         op.prevValue = c?.value
         // @ts-ignore
         this.attrs[op.key] = op.clone()
-      } else if ($deleteOp.check(op)) {
+      } else if ($deleteAttrOp.check(op)) {
         op.prevValue = c?.value
+        // @ts-ignore
         delete this.attrs[op.key]
       }
     }
@@ -1459,7 +1530,7 @@ export class DeltaBuilder extends Delta {
      * 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>>}
+     * @type {Array<InsertOp<any>|RetainOp|DeleteOp<any>|TextOp|ModifyOp<any>>}
      */
     const maybeMergeable = []
     /**
@@ -1528,7 +1599,7 @@ export class DeltaBuilder extends Delta {
             list.pushEnd(this.children, scheduleForMerge(new DeleteOp(remainingLen)))
             this.childCnt += remainingLen
             break
-          } else if (opsI instanceof DeleteOp) {
+          } else if ($deleteOp.check(opsI)) {
             const delLen = opsI.length - offset
             // the same content can't be deleted twice, remove duplicated deletes
             if (delLen >= remainingLen) {
@@ -1573,8 +1644,8 @@ export class DeltaBuilder extends Delta {
           this.childCnt += 1
           return
         }
-        if ($modifyOp.check(opsI)) {
-          opsI._modValue.apply(op.value)
+        if ($modifyAttrOp.check(opsI)) {
+          opsI._modValue.apply(/** @type {any} */ (op.value))
         } else if ($insertOp.check(opsI)) {
           opsI._modValue(offset).apply(op.value)
         } else if ($retainOp.check(opsI)) {
@@ -1627,24 +1698,30 @@ export class DeltaBuilder extends Delta {
      * - modify vs modify ⇒ rebase using priority
      */
     for (const op of this.attrs) {
-      if ($insertOp.check(op)) {
-        if ($insertOp.check(other.attrs[op.key]) && !priority) {
+      if ($setAttrOp.check(op)) {
+        if ($setAttrOp.check(other.attrs[op.key]) && !priority) {
+          // @ts-ignore
           delete this.attrs[op.key]
         }
-      } else if ($deleteOp.check(op)) {
+      } else if ($deleteAttrOp.check(op)) {
+        // @ts-ignore
         const otherOp = other.attrs[/** @type {any} */ (op.key)]
-        if ($insertOp.check(otherOp)) {
+        if ($setAttrOp.check(otherOp)) {
+          // @ts-ignore
           delete this.attrs[otherOp.key]
         }
-      } else if ($modifyOp.check(op)) {
+      } else if ($modifyAttrOp.check(op)) {
         const otherOp = other.attrs[/** @type {any} */ (op.key)]
         if (otherOp == null) {
           // nop
-        } else if ($modifyOp.check(otherOp)) {
+        } else if ($modifyAttrOp.check(otherOp)) {
           op._modValue.rebase(otherOp.value, priority)
         } else {
+          // @ts-ignore
           delete this.attrs[otherOp.key]
         }
+      } else {
+        error.unexpectedCase()
       }
     }
     /**
@@ -1771,9 +1848,15 @@ export class DeltaBuilder extends Delta {
    *
    *     delta.create().insert('a').append(delta.create().insert('b')) // => insert "ab"
    *
-   * @template {DeltaAny} OtherDelta
-   * @param {OtherDelta} other
-   * @return {CastToDelta<OtherDelta> extends Delta<any,any,infer OtherChildren,infer OtherText,any> ? DeltaBuilder<NodeName,Attrs,Children|OtherChildren,Text|OtherText,Schema> : never}
+   * @todo on fixed deltas this should not extend
+   *
+   * @template {DeltaConf} OtherDeltaConf
+   * @param {Delta<OtherDeltaConf>} other
+   * @return {DeltaBuilder<DeltaConfOverwrite<
+   *   DConf,
+   *   (DeltaConfGetChildren<OtherDeltaConf> extends never ? {} : { children: DeltaConfGetChildren<DConf> | DeltaConfGetChildren<OtherDeltaConf> })
+   *   & (DeltaConfGetText<OtherDeltaConf> extends string ? { text: true } : never)
+   * >>}
    */
   append (other) {
     const children = this.children
@@ -1811,70 +1894,52 @@ const updateOpFormat = (op, formatUpdate) => {
 }
 
 /**
- * @template {DeltaAny} D
- * @typedef {D extends DeltaBuilder<infer N,infer Attrs,infer Children,infer Text,infer Schema> ? Delta<N,Attrs,Children,Text,Schema> : D} CastToDelta
- */
-
-/**
- * @template {string} NodeName
- * @template {{ [key: string|number]: any }} [Attrs={}]
- * @template {fingerprintTrait.Fingerprintable|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} Name
- * @template {{[k:string|number]:any}} Attrs
- * @template {fingerprintTrait.Fingerprintable} Children
- * @template {boolean} HasText
- * @template {{ [k:string]:any }} Formats
- * @template {boolean} Recursive
- * @extends {s.Schema<Delta<
- *   Name,
- *   Attrs,
- *   Children|(Recursive extends true ? RecursiveDelta<Name,Attrs,Children,HasText extends true ? string : never> : never),
- *   HasText extends true ? string : never,
- *   any>>}
+ * @template {DeltaConf} DConf
+ * @extends {s.Schema<Delta<DConf>>}
  */
 export class $Delta extends s.Schema {
   /**
-   * @param {s.Schema<Name>} $name
-   * @param {s.Schema<Attrs>} $attrs
-   * @param {s.Schema<Children>} $children
-   * @param {HasText} hasText
-   * @param {s.Schema<Formats>} $formats
-   * @param {Recursive} recursive
+   * @param {s.Schema<any>} $name
+   * @param {s.Schema<any>} $attrs
+   * @param {s.Schema<any>} $children
+   * @param {any} hasText
+   * @param {any} recursiveChildren
+   * @param {s.Schema<{[K:string]:any}>} $formats
    */
-  constructor ($name, $attrs, $children, hasText, $formats, recursive) {
+  constructor ($name, $attrs, $children, hasText, recursiveChildren, $formats) {
     super()
     const $attrsPartial = s.$$object.check($attrs) ? $attrs.partial : $attrs
-    if (recursive) {
+    if (recursiveChildren) {
       // @ts-ignore
       $children = s.$union($children, this)
     }
-    this.shape = { $name, $attrs: $attrsPartial, $children, hasText, $formats }
+    /**
+     * @type {{
+     *   $name: s.Schema<DeltaConfGetName<DConf>>,
+     *   $attrs: s.Schema<DeltaConfGetAttrs<DConf>>,
+     *   $children: s.Schema<DeltaConfGetChildren<DConf>>,
+     *   hasText: DeltaConfGetText<DConf>
+     *   recursiveChildren: DeltaConfGetRecursiveChildren<DConf>,
+     *   $formats: s.Schema<{[K:string]:any}>
+     * }}
+     */
+    this.shape = { $name, $attrs: $attrsPartial, $children, hasText, $formats, recursiveChildren }
   }
 
   /**
    * @param {any} o
    * @param {s.ValidationError} [err]
-   * @return {o is Delta<
-   *   Name,
-   *   Attrs,
-   *   Children|(Recursive extends true ? RecursiveDelta<Name,Attrs,Children,HasText extends true ? string : never> : never),
-   *   HasText extends true ? string : never,
-   *   any>}
+   * @return {o is Delta<DConf>}
    */
   check (o, err = undefined) {
     const { $name, $attrs, $children, hasText, $formats } = this.shape
-    if (!(o instanceof Delta)) {
+    if (!$deltaAny.check(o, err)) {
       err?.extend(null, 'Delta', o?.constructor.name, 'Constructor match failed')
     } else if (o.name != null && !$name.check(o.name, err)) {
       err?.extend('Delta.name', $name.toString(), o.name, 'Unexpected node name')
     } else if (list.toArray(o.children).some(c => (!hasText && $textOp.check(c)) || (hasText && $textOp.check(c) && c.format != null && !$formats.check(c.format)) || ($insertOp.check(c) && !c.insert.every(ins => $children.check(ins))))) {
       err?.extend('Delta.children', '', '', 'Children don\'t match the schema')
-    } else if (object.some(o.attrs, (op, k) => $insertOp.check(op) && !$attrs.check({ [k]: op.value }, err))) {
+    } else if (object.some(o.attrs, (op, k) => $setAttrOp.check(op) && !$attrs.check({ [k]: op.value }, err))) {
       err?.extend('Delta.attrs', '', '', 'Attrs don\'t match the schema')
     } else {
       return true
@@ -1888,7 +1953,7 @@ export class $Delta extends s.Schema {
  * @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]
+ * @template {boolean} [RecursiveChildren=false]
  * @template {{ [k:string]:any }} [Formats={[k:string]:any}]
  * @param {object} opts
  * @param {NodeNameSchema?} [opts.name]
@@ -1896,24 +1961,25 @@ export class $Delta extends s.Schema {
  * @param {ChildrenSchema?} [opts.children] The type of content in `insertOp`
  * @param {HasText} [opts.text] Whether this delta contains text using `textOp`
  * @param {Formats} [opts.formats]
- * @param {Recursive} [opts.recursive]
- * @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, text, formats, recursive }) => /** @type {any} */ (new $Delta(
-  name == null ? s.$any : s.$(name),
+ * @param {RecursiveChildren} [opts.recursiveChildren]
+ * @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<{
+ *   name: NodeName,
+ *   attrs: Attrs,
+ *   children: Children,
+ *   text: HasText,
+ *   recursiveChildren: RecursiveChildren
+ * }>> : never}
+ */
+export const $delta = ({ name, attrs, children, text, formats, recursiveChildren: recursive }) => /** @type {any} */ (new $Delta(
+  /** @type {any} */ (name == null ? s.$any : s.$(name)),
   /** @type {any} */ (attrs == null ? s.$object({}) : s.$(attrs)),
   /** @type {any} */ (children == null ? s.$never : s.$(children)),
   text ?? false,
-  formats == null ? s.$any : s.$(formats),
-  recursive ?? false
+  recursive ?? false,
+  formats == null ? s.$any : s.$(formats)
 ))
 
-export const $$delta = s.$constructedBy($Delta)
+export const $$delta = /* @__PURE__ */s.$constructedBy($Delta)
 
 /**
  * @todo remove this
@@ -1943,11 +2009,12 @@ export const _$delta = ({ name, attrs, children, text, recursive }) => {
   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 => {
+  const $d = s.$custom(d => {
     if (
+      !$deltaAny.check(d) ||
       !$name.check(d.name) ||
       object.some(d.attrs,
-        (op, k) => $insertOp.check(op) && !$attrsPartial.check({ [k]: op.value })
+        (op, k) => $setAttrOp.check(op) && !$attrsPartial.check({ [k]: op.value })
       )
     ) return false
     for (const op of d.children) {
@@ -1963,15 +2030,8 @@ export const _$delta = ({ name, attrs, children, text, recursive }) => {
   return /** @type {any} */ ($d)
 }
 
-/**
- * @type {s.Schema<DeltaAny>}
- */
-export const $deltaAny = /** @type {any} */ (s.$instanceOf(Delta))
-
-/**
- * @type {s.Schema<DeltaBuilderAny>}
- */
-export const $deltaBuilderAny = /** @type {any} */ (s.$instanceOf(DeltaBuilder))
+export const $deltaAny = /** @type {s.Schema<DeltaAny>} */ (/* @__PURE__ */s.$type('delta'))
+export const $deltaBuilderAny = /** @type {s.Schema<DeltaBuilderAny>} */ (/* @__PURE__ */s.$custom(o => $deltaAny.check(o) && !o.isDone))
 
 /**
  * Helper function to merge attribution and attributes. The latter input "wins".
@@ -2000,16 +2060,16 @@ export const mergeDeltas = (a, b) => {
 }
 
 /**
- * @template {DeltaAny} D
+ * @template {DeltaConf} DConf
  * @param {prng.PRNG} gen
- * @param {s.Schema<D>} $d
- * @return {D extends Delta<infer NodeName,infer Attrs,infer Children,infer Text,infer Schema> ? DeltaBuilder<NodeName,Attrs,Children,Text,Schema> : never}
+ * @param {s.Schema<Delta<DConf>>} $d
+ * @return {DeltaBuilder<DConf>}
  */
 export const random = (gen, $d) => {
-  const { $name, $attrs, $children, hasText, $formats: $formats_ } = /** @type {$Delta<any,any,any,boolean,any,any>} */ (/** @type {any} */ ($d)).shape
+  const { $name, $attrs, $children, hasText, $formats: $formats_ } = /** @type {$Delta<any>} */ (/** @type {any} */ ($d)).shape
   const d = s.$$any.check($name) ? create($deltaAny) : create(s.random(gen, $name), $deltaAny)
   const $formats = s.$$any.check($formats_) ? s.$null : $formats_
-  prng.bool(gen) && d.setMany(s.random(gen, $attrs))
+  prng.bool(gen) && d.setAttrs(s.random(gen, $attrs))
   for (let i = prng.uint32(gen, 0, 5); i > 0; i--) {
     if (hasText && prng.bool(gen)) {
       d.insert(prng.word(gen), s.random(gen, $formats))
@@ -2030,13 +2090,13 @@ export const random = (gen, $d) => {
 
 /**
  * @overload
- * @return {DeltaBuilder<any,{},never,never,null>}
+ * @return {DeltaBuilder<{}>}
  */
 /**
- * @template {string} NodeName
+ * @template {string|null} NodeName
  * @overload
  * @param {NodeName} nodeName
- * @return {DeltaBuilder<NodeName,{},never,never,null>}
+ * @return {DeltaBuilder<NodeName extends string ? { name: NodeName } : {}>}
  */
 /**
  * @template {string} NodeName
@@ -2044,13 +2104,13 @@ export const random = (gen, $d) => {
  * @overload
  * @param {NodeName} nodeName
  * @param {Schema} schema
- * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? DeltaBuilder<NodeName,Attrs,Children,Text,Schema> : never}
+ * @return {Schema extends s.Schema<Delta<infer DConf>> ? DeltaBuilder<DeltaConfOverwrite<DConf, {fixed:true}>> : never}
  */
 /**
  * @template {s.Schema<DeltaAny>} Schema
  * @overload
  * @param {Schema} schema
- * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? DeltaBuilder<N,Attrs,Children,Text,Schema> : never}
+ * @return {Schema extends s.Schema<Delta<infer DConf>> ? DeltaBuilder<DeltaConfOverwrite<DConf, {fixed:true}>> : never}
  */
 /**
  * @template {string|null} NodeName
@@ -2060,111 +2120,100 @@ export const random = (gen, $d) => {
  * @param {NodeName} nodeName
  * @param {Attrs} attrs
  * @param {Children} [children]
- * @return {DeltaBuilder<
- *   NodeName extends null ? any : NodeName,
- *   Attrs extends null ? {} : Attrs,
- *   Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
- *   Extract<Children,string>,
- *   null
- * >}
+ * @return {DeltaBuilder<{
+ *   name: NodeName,
+ *   attrs: Attrs extends null ? {} : Attrs,
+ *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
+ *   text: Extract<Children,string> extends never ? false : true
+ * }>}
  */
 /**
- * @param {string|s.Schema<DeltaAny>} [nodeNameOrSchema]
+ * @param {string|s.Schema<DeltaAny>|null} [nodeNameOrSchema]
  * @param {{[K:string|number]:any}|s.Schema<DeltaAny>} [attrsOrSchema]
  * @param {(Array<any>|string)} [children]
- * @return {DeltaBuilder<any,any,any,any,any>}
+ * @return {DeltaBuilder<{}>}
  */
 export const create = (nodeNameOrSchema, attrsOrSchema, children) => {
   const nodeName = /** @type {any} */ (s.$string.check(nodeNameOrSchema) ? nodeNameOrSchema : null)
   const schema = /** @type {any} */ (s.$$schema.check(nodeNameOrSchema) ? nodeNameOrSchema : (s.$$schema.check(attrsOrSchema) ? attrsOrSchema : null))
-  const d = /** @type {DeltaBuilder<any,any,any,string,null>} */ (new DeltaBuilder(nodeName, schema))
+  const d = /** @type {DeltaBuilder<any>} */ (new DeltaBuilder(nodeName, schema))
   if (s.$objectAny.check(attrsOrSchema)) {
-    d.setMany(attrsOrSchema)
+    d.setAttrs(attrsOrSchema)
   }
   children && d.insert(children)
   return d
 }
 
-// DELTA TEXT
-
-/**
- * @template {fingerprintTrait.Fingerprintable} [Embeds=never]
- * @typedef {Delta<any,{},Embeds,string>} TextDelta
- */
-
 /**
- * @template {fingerprintTrait.Fingerprintable} [Embeds=never]
- * @typedef {DeltaBuilder<any,{},Embeds,string>} TextDeltaBuilder
- */
-
-/**
- * @template {Array<s.Schema<any>>} [$Embeds=any]
- * @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), text: true }))
-export const $textOnly = $text()
-
-/**
- * @template {s.Schema<Delta<any,{},any,any,null>>} [Schema=s.Schema<Delta<any,{},never,string,null>>]
- * @param {Schema} [$schema]
- * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? DeltaBuilder<N,Attrs,Children,Text,Schema> : never}
- */
-export const text = $schema => /** @type {any} */ (create($schema || $textOnly))
-
-/**
- * @template {fingerprintTrait.Fingerprintable} Children
- * @typedef {Delta<any,{},Children,never>} ArrayDelta
- */
-
-/**
- * @template {fingerprintTrait.Fingerprintable} Children
- * @typedef {DeltaBuilder<any,{},Children,never>} ArrayDeltaBuilder
- */
-
-/**
- * @template {any|s.Schema<any>} $Children
- * @param {$Children} [$children]
- * @return {s.Schema<ArrayDelta<s.Unwrap<s.ReadSchema<$Children>>>>}
- */
-export const $array = $children => /** @type {any} */ ($delta({ children: $children }))
-
-/**
- * @template {s.Schema<ArrayDelta<any>>} [$Schema=never]
- * @param {$Schema} $schema
- * @return {$Schema extends never ? ArrayDeltaBuilder<never> : DeltaBuilder<any,{},never,never,$Schema>}
+ * @template {string|null} NodeName
+ * @template {Array<any>|string} [Children=never]
+ * @overload
+ * @param {NodeName} nodeName
+ * @param {...Array<Children>} [children]
+ * @return {DeltaBuilder<{
+ *   name: NodeName,
+ *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
+ *   text: Extract<Children,string> extends never ? false : true
+ * }>}
  */
-export const array = $schema => /** @type {any} */ ($schema ? create($schema) : create())
-
 /**
- * @template {{ [K: string|number]: any }} Attrs
- * @typedef {Delta<any,Attrs,never,never>} MapDelta
+ * @template {Array<any>|string} [Children=never]
+ * @overload
+ * @param {...Array<Children>} [children]
+ * @return {DeltaBuilder<{
+ *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
+ *   text: Extract<Children,string> extends never ? false : true
+ * }>}
  */
-
 /**
- * @template {{ [K: string|number]: any }} Attrs
- * @typedef {DeltaBuilder<any,Attrs,never,never>} MapDeltaBuilder
+ * @template {{[k:string|number]:any}|null} Attrs
+ * @template {Array<any>|string} [Children=never]
+ * @overload
+ * @param {Attrs} attrs
+ * @param {...Array<Children>} [children]
+ * @return {DeltaBuilder<{
+ *   attrs: Attrs extends null ? {} : Attrs,
+ *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
+ *   text: Extract<Children,string> extends never ? false : true
+ * }>}
  */
-
 /**
- * @template {{ [K: string|number]: any }} $Attrs
- * @param {s.Schema<$Attrs>} $attrs
- * @return {s.Schema<MapDelta<$Attrs>>}
+ * @template {string|null} NodeName
+ * @template {{[k:string|number]:any}|null} Attrs
+ * @template {Array<any>|string} [Children=never]
+ * @overload
+ * @param {NodeName} nodeName
+ * @param {Attrs} attrs
+ * @param {...Array<Children>} [children]
+ * @return {DeltaBuilder<{
+ *   name: NodeName,
+ *   attrs: Attrs extends null ? {} : Attrs,
+ *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
+ *   text: Extract<Children,string> extends never ? false : true
+ * }>}
  */
-export const $map = $attrs => /** @type {any} */ ($delta({ attrs: $attrs }))
-
 /**
- * @template {s.Schema<MapDelta<any>>|undefined} [$Schema=undefined]
- * @param {$Schema} [$schema]
- * @return {$Schema extends s.Schema<MapDelta<infer Attrs>> ? DeltaBuilder<any,Attrs,never,never,$Schema> : MapDeltaBuilder<{}>}
+ * @param {Array<string|null|{[K:string|number]:any}|Array<any>>} args
+ * @return {DeltaBuilder<{}>}
  */
-export const map = $schema => /** @type {any} */ (create(/** @type {any} */ ($schema)))
+export const from = (...args) => {
+  const hasName = s.$string.check(args[0])
+  let i = hasName ? 1 : 0
+  const d = create(hasName ? /** @type {string} */ (args[0]) : null)
+  if (s.$objectAny.check(args[i])) {
+    d.setAttrs(/** @type {any} */ (args[i++]))
+  }
+  for (; i < args.length; i++) {
+    d.insert(/** @type {any} */ (args[i]))
+  }
+  return d
+}
 
 /**
- * @template {DeltaAny} D
- * @param {D} d1
- * @param {NoInfer<D>} d2
- * @return {D extends Delta<infer N,infer Attrs,infer Children,infer Text,any> ? DeltaBuilder<N,Attrs,Children,Text,null> : never}
+ * @template {DeltaConf} DConf
+ * @param {Delta<DConf>} d1
+ * @param {NoInfer<Delta<DConf>>} d2
+ * @return {DeltaBuilder<DConf>}
  */
 export const diff = (d1, d2) => {
   /**
@@ -2172,9 +2221,21 @@ export const diff = (d1, d2) => {
    */
   const d = create()
   if (d1.fingerprint !== d2.fingerprint) {
+    /**
+     * @type {ChildrenOpAny?}
+     */
     let left1 = d1.children.start
+    /**
+     * @type {ChildrenOpAny?}
+     */
     let left2 = d2.children.start
+    /**
+     * @type {ChildrenOpAny?}
+     */
     let right1 = d1.children.end
+    /**
+     * @type {ChildrenOpAny?}
+     */
     let right2 = d2.children.end
     let commonPrefixOffset = 0
     // perform a patience sort
@@ -2222,7 +2283,7 @@ export const diff = (d1, d2) => {
        * @param {ChildrenOpAny[]} opsShould
        */
       const diffAndApply = (opsIs, opsShould) => {
-        const d = create()
+        const d = create($deltaAny)
         // @todo unoptimized implementation. Convert content to array and diff that based on
         // generated fingerprints. We probably could do better and cache more information.
         // - benchmark
@@ -2247,11 +2308,12 @@ export const diff = (d1, d2) => {
           const cd = cdiff[i]
           cd.remove = isContent.slice(cd.index, cd.index + cd.remove.length)
           cd.insert = shouldContent.slice(cd.index + adj, cd.index + adj + cd.insert.length)
-          adj += cd.remove.length - cd.insert.length
+          adj += cd.insert.length - cd.remove.length
         }
         for (let i = 0, lastIndex = 0; i < cdiff.length; i++) {
           const cd = cdiff[i]
           d.retain(cd.index - lastIndex)
+          lastIndex = cd.index
           let cdii = 0
           let cdri = 0
           // try to match as much content as possible, preferring to skip over non-deltas
@@ -2280,7 +2342,7 @@ export const diff = (d1, d2) => {
         if (hasFormatting) {
           const formattingDiff = create()
           // update opsIs with content diff. then we can figure out the formatting diff.
-          const isUpdated = create()
+          const isUpdated = create($deltaAny)
           // copy opsIs to fresh delta
           opsIs.forEach(op => {
             isUpdated.childCnt += op.length
@@ -2338,11 +2400,12 @@ export const diff = (d1, d2) => {
       currIndexOffset2 += change.insert.length - change.remove.length
     }
     for (const attr2 of d2.attrs) {
+      // @ts-ignore
       const attr1 = d1.attrs[attr2.key]
       if (attr1 == null || (attr1.fingerprint !== attr2.fingerprint)) {
         /* c8 ignore else */
-        if ($insertOp.check(attr2)) {
-          d.set(attr2.key, attr2.value)
+        if ($setAttrOp.check(attr2)) {
+          d.setAttr(attr2.key, attr2.value)
         } else {
           /* c8 ignore next 2 */
           error.unexpectedCase()
@@ -2350,8 +2413,9 @@ export const diff = (d1, d2) => {
       }
     }
     for (const attr1 of d1.attrs) {
+      // @ts-ignore
       if (d2.attrs[attr1.key] == null) {
-        d.unset(attr1.key)
+        d.deleteAttr(attr1.key)
       }
     }
   }