lib0 1.0.0-rc.13 → 1.0.0-rc.14

package/dist/delta/delta.d.ts

@@ -42,6 +42,22 @@ export const $attribution: s.Schema<Attribution>;
  * @type {s.Schema<DeltaAttrOpJSON>}
  */
 export const $deltaMapChangeJson: s.Schema<DeltaAttrOpJSON>;
+/**
+ * Invariants shared by all op classes below (TextOp, InsertOp, DeleteOp,
+ * RetainOp, ModifyOp, SetAttrOp, DeleteAttrOp, ModifyAttrOp):
+ *
+ * - **Only code inside `delta.js` may mutate op fields.** External consumers
+ *   treat ops as immutable; structural fields are JSDoc-annotated `@readonly`
+ *   to reinforce this. Mutation is permitted only while the owning Delta is
+ *   not `done` — every builder entry point routes through `modDeltaCheck`
+ *   to enforce this at runtime.
+ * - **Any mutation of a fingerprinted field MUST null `_fingerprint`.** The
+ *   fingerprint is a lazy cache; if it has already been computed and the
+ *   underlying data changes without invalidating it, every subsequent
+ *   fingerprint read (and any `diff` / equality check that relies on it) is
+ *   wrong. Fields covered: insert, delete, retain, format, attribution,
+ *   value, key.
+ */
 export class TextOp extends list.ListNode {
     /**
      * @param {string} insert
@@ -125,9 +141,9 @@ export class InsertOp<ArrayContent extends unknown> extends list.ListNode {
      */
     _fingerprint: string | null;
     /**
-     * @param {ArrayContent} newVal
+     * @param {ArrayContent} _newVal
      */
-    _updateInsert(newVal: ArrayContent): void;
+    _updateInsert(_newVal: ArrayContent): void;
     /**
      * @return {'insert'}
      */
@@ -184,10 +200,10 @@ export class DeleteOp<Conf extends DeltaConf = {}> extends list.ListNode {
     /**
      * Remove a part of the operation (similar to Array.splice)
      *
-     * @param {number} _offset
+     * @param {number} offset
      * @param {number} len
      */
-    _splice(_offset: number, len: number): this;
+    _splice(offset: number, len: number): this;
     /**
      * @return {DeltaListOpJSON}
      */
@@ -666,10 +682,12 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
      *
      * a.apply(b).apply(c)
      *
-     * @todo fuzz test the above property
+     * If `final = true`, we consider this delta the final state and drop deleteAttrOps from
+     * attributes. (E.g. if `otherOp` deletes an attribute, this op will simply not have the
+     * attribute). Any kind of `delete` op might be considered a bug. A final delta is not idempotent.
      *
      * @param {Delta<Conf>?} other
-     * @param {{ final?: boolean }} opts -- experimental
+     * @param {{ final?: boolean }} opts -- (experimental)
      * @return {DeltaBuilder<Conf>}
      */
     apply(other: Delta<Conf> | null, { final }?: {

package/dist/delta/transformer.d.ts

@@ -215,10 +215,10 @@ export class ProjectionTransformer<A extends delta.DeltaConf, B extends delta.De
 /**
  * @template {delta.DeltaConf} A
  * @template {delta.DeltaConf} B
- * @template {Pipe<Template[]>} PipeTemplate
+ * @template {Pipe<any>} PipeTemplate
  * @extends {Transformer<A,B>}
  */
-export class PipeTransformer<A extends delta.DeltaConf, B extends delta.DeltaConf, PipeTemplate extends Pipe<Template[]>> extends Transformer<A, B> {
+export class PipeTransformer<A extends delta.DeltaConf, B extends delta.DeltaConf, PipeTemplate extends Pipe<any>> extends Transformer<A, B> {
     /**
      * @param {PipeTemplate} tpipe
      */
@@ -244,7 +244,102 @@ export type ApplyAttrRename<Renames extends {
     attrs: import("../ts.js").PropsRename<delta.DeltaConfGetAttrs<IN>, Renames>;
 }>;
 export type ApplyExpectType<DConf extends delta.DeltaConf, IN extends delta.DeltaConf> = { [K in keyof DConf & keyof IN]: K extends "attrs" ? import("../ts.js").PropsPickShared<DConf[K], IN[K]> : (DConf[K] & IN[K]); } & {};
-export type ApplyPipe<TS extends Array<Template>, IN extends delta.DeltaConf> = TS extends [infer FirstT extends Template, ...infer RestT extends Template[]] ? ApplyPipe<RestT, ApplyTemplate<FirstT, IN>> : IN;
+/**
+ * Marker for absent props in a NormalizedDeltaConf.
+ */
+export type NotSet = {
+    "lib0:notset": true;
+};
+/**
+ * DeltaConf in normalized form: all props defined, absent props are set to NotSet.
+ *
+ * ApplyPipe iterates over this form (see ApplyPipeNorm).
+ */
+export type NormalizedDeltaConf<Name, Attrs, Children, Text, RecursiveChildren, RecursiveAttrs> = {
+    name: Name;
+    attrs: Attrs;
+    children: Children;
+    text: Text;
+    recursiveChildren: RecursiveChildren;
+    recursiveAttrs: RecursiveAttrs;
+};
+export type NormalizeDeltaConf<C extends delta.DeltaConf> = NormalizedDeltaConf<C extends {
+    name: infer Name extends string;
+} ? Name : NotSet, C extends {
+    attrs: infer Attrs extends {
+        [K: string | number]: any;
+    };
+} ? Attrs : NotSet, C extends {
+    children: infer Children;
+} ? Children : NotSet, C extends {
+    text: infer Text extends boolean;
+} ? Text : NotSet, C extends {
+    recursiveChildren: infer RecursiveChildren extends boolean;
+} ? RecursiveChildren : NotSet, C extends {
+    recursiveAttrs: infer RecursiveAttrs extends boolean;
+} ? RecursiveAttrs : NotSet>;
+/**
+ * Strip NotSet props from a NormalizedDeltaConf, producing a regular DeltaConf again.
+ */
+export type DenormalizeDeltaConf<NC> = { [K in keyof NC as NC[K] extends NotSet ? never : K]: NC[K]; } & {};
+/**
+ * Intersect a prop of a Filter conf with the corresponding pipe conf prop. The prop is only kept
+ * if it is defined on both sides (mirrors ApplyExpectType).
+ */
+export type FilterConfProp<FilterProp, PipeProp> = FilterProp extends NotSet ? NotSet : PipeProp extends NotSet ? NotSet : FilterProp & PipeProp;
+/**
+ * Apply each Template to a NormalizedDeltaConf - must mirror the semantics of ApplyAttrRename /
+ * ApplyExpectType.
+ *
+ * This shape is tuned to stay below typescript's instantiation-depth limit (TS2589) for long
+ * pipes (~85 templates via pipe().init(), measured). What we learned:
+ *
+ * - The per-step destructure of NC is the load-bearing part: typescript resolves types lazily,
+ *   and member inference out of the literal that was passed as a type argument in the previous
+ *   step is what forces resolution of the accumulated conf. Without it (e.g. carrying the conf
+ *   props as individual type params), the attrs accumulate as a deferred PropsRename chain and
+ *   the limit hits at ~45 templates. Local annotations do NOT force resolution: `X & {}`,
+ *   `X extends infer N ? ...`, and an inline `{ attrs: X } extends { attrs: infer A } ? ...`
+ *   roundtrip were all measured to have no effect.
+ * - The recursion must carry a plain object literal. Wrapping the accumulator in a helper alias
+ *   (even a trivial one like NormalizedDeltaConf) defers per step and rebuilds the chain.
+ * - The outer check must be on TS alone. Coupling NC into the check type (e.g.
+ *   `[TS, NC] extends [[...], {...}]`) makes the conditional generic-deferred whenever the conf
+ *   is generic, which sends constraint comparisons (e.g. Pipe<TS> vs Pipe<any>) into infinite
+ *   recursion.
+ */
+export type ApplyPipeNorm<TS extends Array<Template>, NC> = TS extends [infer FirstT extends Template, ...infer RestT extends Template[]] ? (NC extends {
+    name: infer Name;
+    attrs: infer Attrs extends {
+        [K: string | number]: any;
+    };
+    children: infer Children;
+    text: infer Text;
+    recursiveChildren: infer RecursiveChildren;
+    recursiveAttrs: infer RecursiveAttrs;
+} ? ApplyPipeNorm<RestT, FirstT extends AttrRename<infer Renames> ? {
+    name: Name;
+    attrs: import("../ts.js").PropsRename<Attrs extends NotSet ? {} : Attrs, Renames>;
+    children: Children;
+    text: Text;
+    recursiveChildren: RecursiveChildren;
+    recursiveAttrs: RecursiveAttrs;
+} : FirstT extends Filter<infer DConf extends delta.DeltaConf> ? (NormalizeDeltaConf<DConf> extends {
+    name: infer FilterName;
+    attrs: infer FilterAttrs;
+    children: infer FilterChildren;
+    text: infer FilterText;
+    recursiveChildren: infer FilterRecursiveChildren;
+    recursiveAttrs: infer FilterRecursiveAttrs;
+} ? {
+    name: FilterConfProp<FilterName, Name>;
+    attrs: FilterAttrs extends NotSet ? NotSet : Attrs extends NotSet ? NotSet : import("../ts.js").PropsPickShared<FilterAttrs, Attrs>;
+    children: FilterConfProp<FilterChildren, Children>;
+    text: FilterConfProp<FilterText, Text>;
+    recursiveChildren: FilterConfProp<FilterRecursiveChildren, RecursiveChildren>;
+    recursiveAttrs: FilterConfProp<FilterRecursiveAttrs, RecursiveAttrs>;
+} : never) : NC> : NC) : NC;
+export type ApplyPipe<TS extends Array<Template>, IN extends delta.DeltaConf> = DenormalizeDeltaConf<ApplyPipeNorm<TS, NormalizeDeltaConf<IN>>>;
 export type ApplyQueryAttr<AttrName extends string, IN extends delta.DeltaConf> = {
     name: "lib0:value";
     attrs: {
@@ -253,14 +348,13 @@ export type ApplyQueryAttr<AttrName extends string, IN extends delta.DeltaConf>
         } ? V : never;
     };
 };
-export type EnsureDeltaConf<IN> = IN extends infer OUT extends delta.DeltaConf ? OUT : never;
-export type ApplyTemplate<T extends Template, IN extends delta.DeltaConf> = EnsureDeltaConf<T extends AttrRename<infer Renames> ? ApplyAttrRename<Renames, IN> : T extends Filter<infer DConf extends delta.DeltaConf> ? ApplyExpectType<DConf, IN> : IN>;
 /**
  * Flattens nested Pipe instances into a single flat Template array.
  * Since pipe() always produces flat Pipes, Inner is already flat and
  * only one level of unwrapping is needed per Pipe element.
+ * Tail-recursive with an accumulator so the instantiation depth stays constant.
  */
-export type FlattenTemplates<TS extends Array<Template>> = TS extends [infer F extends Template, ...infer R extends Template[]] ? F extends Pipe<infer Inner extends Template[]> ? [...Inner, ...FlattenTemplates<R>] : [F, ...FlattenTemplates<R>] : [];
+export type FlattenTemplates<TS extends Array<Template>, Acc extends Array<Template> = []> = TS extends [infer F extends Template, ...infer R extends Template[]] ? FlattenTemplates<R, F extends Pipe<infer Inner extends Template[]> ? [...Acc, ...Inner] : [...Acc, F]> : Acc;
 import * as delta from './delta.js';
 import * as s from '../schema.js';
 /**

package/dist/hash/fnv1a.d.ts

@@ -0,0 +1,11 @@
+/**
+ * FNV-1a offset basis (32bit).
+ */
+export const offsetBasis: 2166136261;
+/**
+ * FNV-1a prime (32bit).
+ */
+export const prime: 16777619;
+export function digest(data: Uint8Array, hash?: number): number;
+export function digestString(str: string, hash?: number): number;
+//# sourceMappingURL=fnv1a.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "1.0.0-rc.13",
+  "version": "1.0.0-rc.14",
   "description": "",
   "sideEffects": false,
   "type": "module",
@@ -69,6 +69,10 @@
       "types": "./dist/crypto/rsa-oaep.d.ts",
       "default": "./src/crypto/rsa-oaep.js"
     },
+    "./hash/fnv1a": {
+      "types": "./dist/hash/fnv1a.d.ts",
+      "default": "./src/hash/fnv1a.js"
+    },
     "./hash/rabin": {
       "types": "./dist/hash/rabin.d.ts",
       "default": "./src/hash/rabin.js"

package/src/bin/0serve.js

@@ -89,9 +89,17 @@ const server = http.createServer((req, res) => {
 server.listen(port, host, () => {
   logging.print(logging.BOLD, logging.ORANGE, `Server is running on http://${host}:${port}`)
   if (paramOpenFile) {
-    const start = debugBrowser || (process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open')
+    const url = `http://${host}:${port}/${paramOpenFile}`
     import('child_process').then(cp => {
-      cp.exec(`${start} http://${host}:${port}/${paramOpenFile}`)
+      if (debugBrowser) {
+        cp.execFile(debugBrowser, [url])
+      } else if (process.platform === 'darwin') {
+        cp.execFile('open', [url])
+      } else if (process.platform === 'win32') {
+        cp.execFile('cmd', ['/c', 'start', '', url])
+      } else {
+        cp.execFile('xdg-open', [url])
+      }
     })
   }
 })

package/src/delta/delta.js

@@ -101,6 +101,22 @@ const _cloneAttrs = attrs => attrs == null ? attrs : { ...attrs }
  */
 const _markMaybeDeltaAsDone = maybeDelta => $deltaAny.check(maybeDelta) ? /** @type {MaybeDelta} */ (maybeDelta.done()) : maybeDelta
 
+/**
+ * Invariants shared by all op classes below (TextOp, InsertOp, DeleteOp,
+ * RetainOp, ModifyOp, SetAttrOp, DeleteAttrOp, ModifyAttrOp):
+ *
+ * - **Only code inside `delta.js` may mutate op fields.** External consumers
+ *   treat ops as immutable; structural fields are JSDoc-annotated `@readonly`
+ *   to reinforce this. Mutation is permitted only while the owning Delta is
+ *   not `done` — every builder entry point routes through `modDeltaCheck`
+ *   to enforce this at runtime.
+ * - **Any mutation of a fingerprinted field MUST null `_fingerprint`.** The
+ *   fingerprint is a lazy cache; if it has already been computed and the
+ *   underlying data changes without invalidating it, every subsequent
+ *   fingerprint read (and any `diff` / equality check that relies on it) is
+ *   wrong. Fields covered: insert, delete, retain, format, attribution,
+ *   value, key.
+ */
 export class TextOp extends list.ListNode {
   /**
    * @param {string} insert
@@ -228,14 +244,17 @@ export class InsertOp extends list.ListNode {
     this._fingerprint = null
   }
 
+  /* c8 ignore start */
   /**
-   * @param {ArrayContent} newVal
+   * @param {ArrayContent} _newVal
    */
-  _updateInsert (newVal) {
-    // @ts-ignore
-    this.insert = newVal
-    this._fingerprint = null
+  _updateInsert (_newVal) {
+    // Mirror of TextOp._updateInsert; not currently called on InsertOp because
+    // adjacent inserts are merged in-place via `end.insert.push(...)`. Kept for
+    // parity with TextOp's API.
+    error.unexpectedCase() // throw if called
   }
+  /* c8 ignore stop */
 
   /**
    * @return {'insert'}
@@ -357,11 +376,13 @@ export class DeleteOp extends list.ListNode {
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
-   * @param {number} _offset
+   * @param {number} offset
    * @param {number} len
    */
-  _splice (_offset, len) {
-    this.prevValue = /** @type {any} */ (this.prevValue ? slice(this.prevValue, _offset, len) : null)
+  _splice (offset, len) {
+    if (this.prevValue) {
+      /** @type {DeltaBuilder<any>} */ (this.prevValue).apply(create().retain(offset).delete(len))
+    }
     this._fingerprint = null
     this.delete -= len
     return this
@@ -547,6 +568,9 @@ export class ModifyOp extends list.ListNode {
     })))
   }
 
+  /* c8 ignore start */
+  // ModifyOp has length 1, so callers never pass offset>0 or len>0 — splitHere
+  // is a no-op for length-1 ops. Kept for the structural _splice contract.
   /**
    * Remove a part of the operation (similar to Array.splice)
    *
@@ -556,6 +580,7 @@ export class ModifyOp extends list.ListNode {
   _splice (_offset, _len) {
     return this
   }
+  /* c8 ignore stop */
 
   /**
    * @return {DeltaListOpJSON}
@@ -851,7 +876,7 @@ export const $setAttrOpWith = $content => s.$custom(o => $setAttrOp.check(o) &&
  * @param {s.Schema<Content>} $content
  * @return {s.Schema<InsertOp<Content>>}
  */
-export const $insertOpWith = $content => s.$custom(o => $insertOp.check(o) && $content.check(o.insert.every(ins => $content.check(ins))))
+export const $insertOpWith = $content => s.$custom(o => $insertOp.check(o) && o.insert.every(ins => $content.check(ins)))
 
 /**
  * @template {DeltaAny} Modify
@@ -1231,9 +1256,13 @@ const tryMergeWithPrev = (parent, op) => {
     /** @type {DeleteOp<any>} */ (prevOp).delete += op.delete
   } else if ($textOp.check(op)) {
     /** @type {TextOp} */ (prevOp)._updateInsert(/** @type {TextOp} */ (prevOp).insert + op.insert)
+  /* c8 ignore start */
   } else {
+    // unreachable: the constructor check at the top of the function already
+    // limits `op` to one of the four kinds tested above
     error.unexpectedCase()
   }
+  /* c8 ignore stop */
   list.remove(parent, op)
 }
 
@@ -1501,10 +1530,12 @@ export class DeltaBuilder extends Delta {
    *
    * a.apply(b).apply(c)
    *
-   * @todo fuzz test the above property
+   * If `final = true`, we consider this delta the final state and drop deleteAttrOps from
+   * attributes. (E.g. if `otherOp` deletes an attribute, this op will simply not have the
+   * attribute). Any kind of `delete` op might be considered a bug. A final delta is not idempotent.
    *
    * @param {Delta<Conf>?} other
-   * @param {{ final?: boolean }} opts -- experimental
+   * @param {{ final?: boolean }} opts -- (experimental)
    * @return {DeltaBuilder<Conf>}
    */
   apply (other, { final = this.isFinal } = {}) {
@@ -1517,7 +1548,7 @@ export class DeltaBuilder extends Delta {
       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)
+          c._modValue.apply(op.value, { final })
         } else {
           // then this is a simple modify
           // @ts-ignore
@@ -1588,10 +1619,14 @@ export class DeltaBuilder extends Delta {
       this.childCnt += op.length
     }
     for (const op of other.children) {
+      // defensive: the per-branch logic below resets opsI/offset whenever it
+      // consumes an op exactly. This guard catches any path that forgets to.
+      /* c8 ignore start */
       if (opsI?.length === offset) {
         opsI = opNextUndeleted(opsI)
         offset = 0
       }
+      /* c8 ignore stop */
       if ($textOp.check(op) || $insertOp.check(op)) {
         insertClonedOp(op)
       } else if ($retainOp.check(op)) {
@@ -1611,7 +1646,11 @@ export class DeltaBuilder extends Delta {
         }
         if (opsI != null) {
           if (op.format != null && retainLen > 0) {
-            offset = retainLen
+            // accumulate onto the existing offset — the else-branch below uses
+            // `offset += retainLen`, and we must agree with it when prior
+            // iterations have advanced offset into opsI without splitting (e.g.
+            // a format-less retain followed by a same-format retain).
+            offset += retainLen
             splitHere()
             updateOpFormat(/** @type {ChildrenOpAny} */ (opsI.prev), op.format)
             scheduleForMerge(opsI.prev)
@@ -1670,9 +1709,12 @@ export class DeltaBuilder extends Delta {
               opsI._splice(offset, delLen)
             }
             remainingLen -= delLen
+          /* c8 ignore start */
           } else {
+            // unreachable: opsI was already typed as retain | non-delete-content | delete above
             error.unexpectedCase()
           }
+          /* c8 ignore stop */
         }
       } else if ($modifyOp.check(op)) {
         if (opsI != null && op.format != null && (!$deleteOp.check(opsI) && !$retainOp.check(opsI))) { // retain handles splitting seperately, without copying attrs
@@ -1709,14 +1751,20 @@ export class DeltaBuilder extends Delta {
             opsI._splice(0, 1)
             scheduleForMerge(opsI)
           }
-        } else if ($deleteOp.check(opsI)) {
-          // nop
+        /* c8 ignore start */
         } else {
+          // remaining branches: opsI is deleteOp or something unknown
+          // both branches are unreachable today: opNextUndeleted skips
+          // delete ops, so opsI is never a delete during iteration; and the four
+          // branches above exhaust the other op kinds. The deleteOp branch is
+          // kept as a defensive no-op (drops a modify that lands in a deleted
+          // region) rather than a throw.
           error.unexpectedCase()
         }
       } else {
         error.unexpectedCase()
       }
+      /* c8 ignore stop */
     }
     // iterate backwards, to ensure that we merge all content
     for (let i = maybeMergeable.length - 1; i >= 0; i--) {
@@ -1772,9 +1820,12 @@ export class DeltaBuilder extends Delta {
           // @ts-ignore
           delete this.attrs[otherOp.key]
         }
+      /* c8 ignore start */
       } else {
+        // unreachable: attr ops are exhaustively setAttr | deleteAttr | modifyAttr
         error.unexpectedCase()
       }
+      /* c8 ignore stop */
     }
     /**
      * Rebase children.
@@ -1831,7 +1882,10 @@ export class DeltaBuilder extends Delta {
           otherOffset = otherChild.length
         } else {
           if ($modifyOp.check(otherChild)) {
-            /** @type {any} */ (currChild.value).rebase(otherChild, priority)
+            // _modValue (not .value) — ModifyOp.clone() marks its inner delta
+            // as `done`, so a cloned ModifyOp can only be rebased after the
+            // _modValue getter lazy-clones it back to mutable.
+            currChild._modValue.rebase(otherChild.value, priority)
           } else if ($deleteOp.check(otherChild)) {
             list.remove(this.children, currChild)
             this.childCnt -= 1
@@ -1848,21 +1902,70 @@ export class DeltaBuilder extends Delta {
          * - insert: split curr op and insert retain
          */
         if ($retainOp.check(otherChild) || $modifyOp.check(otherChild)) {
+          // Format reconciliation. priority=true is a no-op (currChild's format
+          // wins). For !priority, currChild concedes any format key that
+          // otherChild also writes — but only over the [currOffset..currOffset+
+          // maxCommonLen] overlap. Split currChild around the overlap so the
+          // prefix/suffix keep their original format and only the middle piece
+          // carries the stripped format.
+          if (
+            !priority &&
+            $retainOp.check(currChild) &&
+            currChild.format != null &&
+            otherChild.format != null
+          ) {
+            /** @type {FormattingAttributes} */
+            const stripped = {}
+            let strippedAny = false
+            for (const k in currChild.format) {
+              if (k in otherChild.format) {
+                strippedAny = true
+              } else {
+                stripped[k] = currChild.format[k]
+              }
+            }
+            if (strippedAny) {
+              // split off the suffix [currOffset+maxCommonLen..length] if any
+              if (currOffset + maxCommonLen < currChild.length) {
+                const suffix = currChild.clone(currOffset + maxCommonLen, currChild.length)
+                list.insertBetween(this.children, currChild, currChild.next, suffix)
+                currChild._splice(currOffset + maxCommonLen, currChild.length - (currOffset + maxCommonLen))
+              }
+              // split off the prefix [0..currOffset] if any
+              if (currOffset > 0) {
+                const prefix = currChild.clone(0, currOffset)
+                list.insertBetween(this.children, currChild.prev, currChild, prefix)
+                currChild._splice(0, currOffset)
+                currOffset = 0
+              }
+              // currChild now spans exactly the overlap. Replace its format.
+              /** @type {any} */ (currChild).format = object.isEmpty(stripped) ? null : stripped
+              currChild._fingerprint = null
+            }
+          }
           currOffset += maxCommonLen
           otherOffset += maxCommonLen
         } else if ($deleteOp.check(otherChild)) {
           if ($retainOp.check(currChild)) {
             // @ts-ignore
             currChild.retain -= maxCommonLen
+            currChild._fingerprint = null
           } else if ($deleteOp.check(currChild)) {
             currChild.delete -= maxCommonLen
+            currChild._fingerprint = null
           }
           this.childCnt -= maxCommonLen
-        } else { // insert/text.check(currOp)
+          // advance other so subsequent currChild ops see what comes AFTER this
+          // delete; without this we'd loop against the same delete forever and
+          // never reach other's later inserts.
+          otherOffset += maxCommonLen
+        } else { // insert/text.check(otherChild)
           if (currOffset > 0) {
-            const leftPart = currChild.clone(currOffset)
+            const leftPart = currChild.clone(0, currOffset)
             list.insertBetween(this.children, currChild.prev, currChild, leftPart)
-            currChild._splice(currOffset, currChild.length - currOffset)
+            // leftPart is the prefix; currChild becomes the suffix. Remove the
+            // prefix portion from currChild so it represents [currOffset..length].
+            currChild._splice(0, currOffset)
             currOffset = 0
           }
           list.insertBetween(this.children, currChild.prev, currChild, new RetainOp(otherChild.length, null, null))
@@ -2000,8 +2103,10 @@ export class $Delta extends s.Schema {
   check (o, err = undefined) {
     const { $name, $attrs, $children, hasText, $formats } = this.shape
     if (!$deltaAny.check(o, err)) {
+      /* c8 ignore next */
       err?.extend(null, 'Delta', o?.constructor.name, 'Constructor match failed')
     } else if (o.name != null && !$name.check(o.name, err)) {
+      /* c8 ignore next */
       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')
@@ -2097,7 +2202,7 @@ export const mergeDeltas = (a, b) => {
     c.apply(b)
     return /** @type {any} */ (c)
   }
-  return a == null ? b : (a || null)
+  return /** @type {D} */ (a || b || null)
 }
 
 /**
@@ -2325,6 +2430,16 @@ class _DiffStringWrapper {
  */
 
 /**
+ * Compute a delta that, when applied to `d1`, produces `d2`. Only the children and attributes of
+ * `d1` and `d2` are compared; the top-level node names of `d1` and `d2` are *not*. Diffing
+ * `<div>a</div>` against `<span>a</span>` is valid and yields an empty diff — they have the same
+ * children and attributes, so as far as `diff` is concerned they are equal at the level it cares
+ * about. The top-level name is treated as a document-type marker, not as diffable content.
+ *
+ * Names *are* compared on children: a child node whose name changes between `d1` and `d2` is
+ * replaced wholesale (delete + insert), not converted into a `modify` op. Same-name child nodes
+ * at aligned positions are paired and recursed into via `modify`.
+ *
  * @template {DeltaConf} Conf
  * @param {Delta<Conf>} d1
  * @param {NoInfer<Delta<Conf>>} d2
@@ -2395,9 +2510,14 @@ export const diff = (d1, d2) => {
           cs2.push(left2.insert)
         } else if ($insertOp.check(left2)) {
           cs2.push(...left2.insert.map(ins => typeof ins === 'string' ? new _DiffStringWrapper(ins) : ins))
+        /* c8 ignore start */
         } else {
+          // unreachable for valid diff inputs (delete on the rhs would already
+          // have been rejected via the `[lib0/delta] diffing deletes unsupported`
+          // path above)
           error.unexpectedCase()
         }
+        /* c8 ignore stop */
         formattingNeedsDiff ||= left2.format != null
         left2 = left2.next
       }
@@ -2459,9 +2579,14 @@ export const diff = (d1, d2) => {
             a = a.next
             aOffset = 0
           }
+        /* c8 ignore start */
         } else {
+          // unreachable: by this point both a and b are insert/text (deletes
+          // were rejected upstream and `originalUpdated` is the result of an
+          // apply, which keeps inserts only).
           error.unexpectedCase()
         }
+        /* c8 ignore stop */
       }
       // @todo instead of applying, we want to first exec d, then formattingDiff - we need a merge
       // function!
@@ -2481,10 +2606,11 @@ export const diff = (d1, d2) => {
           } else {
             d.setAttr(key, nextVal)
           }
+        /* c8 ignore start */
         } else {
-          /* c8 ignore next 2 */
           error.unexpectedCase()
         }
+        /* c8 ignore stop */
       }
     }
     for (const { key } of d1.attrs) {

package/src/delta/transformer.js

@@ -164,43 +164,116 @@ export const $transformer = transformerWith(s.$any, s.$any)
  */
 
 /**
- * @template {Array<Template>} TS
- * @template {delta.DeltaConf} IN
- * @typedef {TS extends [infer FirstT extends Template, ...infer RestT extends Template[]] ? ApplyPipe<RestT,ApplyTemplate<FirstT,IN>> : IN } ApplyPipe
+ * Marker for absent props in a NormalizedDeltaConf.
+ *
+ * @typedef {{ 'lib0:notset': true }} NotSet
  */
 
 /**
- * @template {string} AttrName
- * @template {delta.DeltaConf} IN
- * @typedef {{ name: 'lib0:value', attrs: { value: IN extends { attrs: { [K in AttrName]: infer V } } ? V : never }}} ApplyQueryAttr
+ * DeltaConf in normalized form: all props defined, absent props are set to NotSet.
+ *
+ * ApplyPipe iterates over this form (see ApplyPipeNorm).
+ *
+ * @template Name
+ * @template Attrs
+ * @template Children
+ * @template Text
+ * @template RecursiveChildren
+ * @template RecursiveAttrs
+ * @typedef {{ name: Name, attrs: Attrs, children: Children, text: Text, recursiveChildren: RecursiveChildren, recursiveAttrs: RecursiveAttrs }} NormalizedDeltaConf
+ */
+
+/**
+ * @template {delta.DeltaConf} C
+ * @typedef {NormalizedDeltaConf<
+ *   C extends { name: infer Name extends string } ? Name : NotSet,
+ *   C extends { attrs: infer Attrs extends {[K:string|number]:any} } ? Attrs : NotSet,
+ *   C extends { children: infer Children } ? Children : NotSet,
+ *   C extends { text: infer Text extends boolean } ? Text : NotSet,
+ *   C extends { recursiveChildren: infer RecursiveChildren extends boolean } ? RecursiveChildren : NotSet,
+ *   C extends { recursiveAttrs: infer RecursiveAttrs extends boolean } ? RecursiveAttrs : NotSet
+ * >} NormalizeDeltaConf
+ */
+
+/**
+ * Strip NotSet props from a NormalizedDeltaConf, producing a regular DeltaConf again.
+ *
+ * @template NC
+ * @typedef {{ [K in keyof NC as NC[K] extends NotSet ? never : K]: NC[K] } & {}} DenormalizeDeltaConf
  */
 
 /**
- * @template IN
- * @typedef {IN extends infer OUT extends delta.DeltaConf ? OUT : never} EnsureDeltaConf
+ * Intersect a prop of a Filter conf with the corresponding pipe conf prop. The prop is only kept
+ * if it is defined on both sides (mirrors ApplyExpectType).
+ *
+ * @template FilterProp
+ * @template PipeProp
+ * @typedef {FilterProp extends NotSet ? NotSet : PipeProp extends NotSet ? NotSet : FilterProp & PipeProp} FilterConfProp
+ */
+
+/**
+ * Apply each Template to a NormalizedDeltaConf - must mirror the semantics of ApplyAttrRename /
+ * ApplyExpectType.
+ *
+ * This shape is tuned to stay below typescript's instantiation-depth limit (TS2589) for long
+ * pipes (~85 templates via pipe().init(), measured). What we learned:
+ *
+ * - The per-step destructure of NC is the load-bearing part: typescript resolves types lazily,
+ *   and member inference out of the literal that was passed as a type argument in the previous
+ *   step is what forces resolution of the accumulated conf. Without it (e.g. carrying the conf
+ *   props as individual type params), the attrs accumulate as a deferred PropsRename chain and
+ *   the limit hits at ~45 templates. Local annotations do NOT force resolution: `X & {}`,
+ *   `X extends infer N ? ...`, and an inline `{ attrs: X } extends { attrs: infer A } ? ...`
+ *   roundtrip were all measured to have no effect.
+ * - The recursion must carry a plain object literal. Wrapping the accumulator in a helper alias
+ *   (even a trivial one like NormalizedDeltaConf) defers per step and rebuilds the chain.
+ * - The outer check must be on TS alone. Coupling NC into the check type (e.g.
+ *   `[TS, NC] extends [[...], {...}]`) makes the conditional generic-deferred whenever the conf
+ *   is generic, which sends constraint comparisons (e.g. Pipe<TS> vs Pipe<any>) into infinite
+ *   recursion.
+ *
+ * @template {Array<Template>} TS
+ * @template NC
+ * @typedef {TS extends [infer FirstT extends Template, ...infer RestT extends Template[]]
+ *   ? (NC extends { name: infer Name, attrs: infer Attrs extends {[K:string|number]:any}, children: infer Children, text: infer Text, recursiveChildren: infer RecursiveChildren, recursiveAttrs: infer RecursiveAttrs }
+ *     ? ApplyPipeNorm<RestT,
+ *       FirstT extends AttrRename<infer Renames> ? { name: Name, attrs: import('../ts.js').PropsRename<Attrs extends NotSet ? {} : Attrs, Renames>, children: Children, text: Text, recursiveChildren: RecursiveChildren, recursiveAttrs: RecursiveAttrs } :
+ *       FirstT extends Filter<infer DConf extends delta.DeltaConf> ? (NormalizeDeltaConf<DConf> extends { name: infer FilterName, attrs: infer FilterAttrs, children: infer FilterChildren, text: infer FilterText, recursiveChildren: infer FilterRecursiveChildren, recursiveAttrs: infer FilterRecursiveAttrs } ? {
+ *         name: FilterConfProp<FilterName, Name>,
+ *         attrs: FilterAttrs extends NotSet ? NotSet : Attrs extends NotSet ? NotSet : import('../ts.js').PropsPickShared<FilterAttrs, Attrs>,
+ *         children: FilterConfProp<FilterChildren, Children>,
+ *         text: FilterConfProp<FilterText, Text>,
+ *         recursiveChildren: FilterConfProp<FilterRecursiveChildren, RecursiveChildren>,
+ *         recursiveAttrs: FilterConfProp<FilterRecursiveAttrs, RecursiveAttrs>
+ *       } : never) :
+ *       NC>
+ *     : NC)
+ *   : NC} ApplyPipeNorm
  */
 
 /**
- * @template {Template} T
+ * @template {Array<Template>} TS
  * @template {delta.DeltaConf} IN
- * @typedef {EnsureDeltaConf<
- *     T extends AttrRename<infer Renames> ? ApplyAttrRename<Renames,IN> :
- *     T extends Filter<infer DConf extends delta.DeltaConf> ? ApplyExpectType<DConf,IN> :
- *     IN
- * >} ApplyTemplate
+ * @typedef {DenormalizeDeltaConf<ApplyPipeNorm<TS, NormalizeDeltaConf<IN>>>} ApplyPipe
+ */
+
+/**
+ * @template {string} AttrName
+ * @template {delta.DeltaConf} IN
+ * @typedef {{ name: 'lib0:value', attrs: { value: IN extends { attrs: { [K in AttrName]: infer V } } ? V : never }}} ApplyQueryAttr
  */
 
 /**
  * Flattens nested Pipe instances into a single flat Template array.
  * Since pipe() always produces flat Pipes, Inner is already flat and
  * only one level of unwrapping is needed per Pipe element.
+ * Tail-recursive with an accumulator so the instantiation depth stays constant.
  *
  * @template {Array<Template>} TS
+ * @template {Array<Template>} [Acc=[]]
  * @typedef {TS extends [infer F extends Template, ...infer R extends Template[]]
- *   ? F extends Pipe<infer Inner extends Template[]>
- *     ? [...Inner, ...FlattenTemplates<R>]
- *     : [F, ...FlattenTemplates<R>]
- *   : []} FlattenTemplates
+ *   ? FlattenTemplates<R, F extends Pipe<infer Inner extends Template[]> ? [...Acc, ...Inner] : [...Acc, F]>
+ *   : Acc} FlattenTemplates
  */
 
 /**
@@ -563,7 +636,7 @@ export class ProjectionTransformer extends Transformer {
 /**
  * @template {delta.DeltaConf} A
  * @template {delta.DeltaConf} B
- * @template {Pipe<Template[]>} PipeTemplate
+ * @template {Pipe<any>} PipeTemplate
  * @extends {Transformer<A,B>}
  */
 export class PipeTransformer extends Transformer {
@@ -576,7 +649,7 @@ export class PipeTransformer extends Transformer {
     /**
      * @type {Transformer<any,any>[]}
      */
-    this.ts = tpipe.templates.map(t => t.init(delta.$deltaAny))
+    this.ts = tpipe.templates.map((/** @type {Template} */ t) => t.init(delta.$deltaAny))
   }
 
   /**

package/src/hash/fnv1a.js

@@ -0,0 +1,82 @@
+/**
+ * @module fnv1a
+ * FNV-1a (32bit) - a fast, non-cryptographic hash function.
+ * Spec: http://www.isthe.com/chongo/tech/comp/fnv/
+ */
+
+import * as math from '../math.js'
+
+/**
+ * FNV-1a offset basis (32bit).
+ */
+export const offsetBasis = 0x811c9dc5
+
+/**
+ * FNV-1a prime (32bit).
+ */
+export const prime = 0x01000193
+
+/**
+ * Compute the FNV-1a 32bit hash of a byte sequence.
+ *
+ * Pass the result of a previous call as `hash` to digest a message in chunks:
+ * `digest(concat(a, b)) === digest(b, digest(a))`.
+ *
+ * @param {Uint8Array} data
+ * @param {number} hash - continue hashing from a previous result (defaults to the offset basis)
+ * @return {number} unsigned 32bit hash
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export const digest = (data, hash = offsetBasis) => {
+  for (let i = 0; i < data.length; i++) {
+    hash = math.imul(hash ^ data[i], prime)
+  }
+  return hash >>> 0
+}
+
+/**
+ * Compute the FNV-1a 32bit hash of a string - without allocating the utf8 encoding.
+ *
+ * Equivalent to `digest(string.encodeUtf8(str))`: the string is hashed as utf8 bytes; lone
+ * surrogates are hashed as the replacement character (like TextEncoder encodes them).
+ *
+ * Prefer this over `digest(string.encodeUtf8(str))` when hashing strings - it skips the
+ * TextEncoder call and the Uint8Array allocation, making it ~5x faster for small strings
+ * (<=20 chars, e.g. object keys) and ~2x faster for larger ones.
+ *
+ * @param {string} str
+ * @param {number} hash - continue hashing from a previous result (defaults to the offset basis)
+ * @return {number} unsigned 32bit hash
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export const digestString = (str, hash = offsetBasis) => {
+  for (let i = 0; i < str.length; i++) {
+    let c = str.charCodeAt(i)
+    if (c < 0x80) {
+      hash = math.imul(hash ^ c, prime)
+    } else {
+      if (c >= 0xd800 && c < 0xe000) {
+        const lo = str.charCodeAt(i + 1) // NaN when out of bounds ⇒ NaN & x === 0
+        if (c < 0xdc00 && (lo & 0xfc00) === 0xdc00) {
+          c = 0x10000 + ((c & 0x3ff) << 10) + (lo & 0x3ff)
+          i++
+        } else {
+          c = 0xfffd // lone surrogate ⇒ replacement character
+        }
+      }
+      if (c < 0x800) {
+        hash = math.imul(hash ^ (0xc0 | (c >> 6)), prime)
+      } else {
+        if (c < 0x10000) {
+          hash = math.imul(hash ^ (0xe0 | (c >> 12)), prime)
+        } else {
+          hash = math.imul(hash ^ (0xf0 | (c >> 18)), prime)
+          hash = math.imul(hash ^ (0x80 | ((c >> 12) & 0x3f)), prime)
+        }
+        hash = math.imul(hash ^ (0x80 | ((c >> 6) & 0x3f)), prime)
+      }
+      hash = math.imul(hash ^ (0x80 | (c & 0x3f)), prime)
+    }
+  }
+  return hash >>> 0
+}