lib0 1.0.0-rc.20 → 1.0.0-rc.21

package/dist/delta/delta.d.ts

@@ -55,7 +55,7 @@ export const $attribution: s.Schema<Attribution>;
  * @typedef {{ type: 'insert', insert: string|Array<any>, format?: { [key: string]: any }, attribution?: Attribution } | { delete: number } | { type: 'retain', retain: number, format?: { [key:string]: any }|null, attribution?: Attribution|null } | { type: 'modify', value: object, format?: { [key:string]: any }|null, attribution?: Attribution|null }} DeltaListOpJSON
  */
 /**
- * @typedef {{ type: 'insert', value: any, prevValue?: any, attribution?: Attribution } | { type: 'delete', prevValue?: any, attribution?: Attribution } | { type: 'modify', value: DeltaJSON, attribution?: Attribution|null }} DeltaAttrOpJSON
+ * @typedef {{ type: 'insert', value: any, attribution?: Attribution } | { type: 'delete', attribution?: Attribution } | { type: 'modify', value: DeltaJSON, attribution?: Attribution|null }} DeltaAttrOpJSON
  */
 /**
  * @typedef {TextOp|InsertOp<any>|DeleteOp|RetainOp|ModifyOp<any>} ChildrenOpAny
@@ -224,11 +224,9 @@ export class InsertOp<ArrayContent extends unknown> extends list.ListNode {
 export class DeleteOp<Conf extends DeltaConf = {}> extends list.ListNode {
     /**
      * @param {number} len
-     * @param {DeltaBuilder<any>?} prevValue
      */
-    constructor(len: number, prevValue: DeltaBuilder<any> | null);
+    constructor(len: number);
     delete: number;
-    prevValue: Delta<Conf> | null;
     /**
      * @type {string|null}
      */
@@ -242,10 +240,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}
      */
@@ -254,7 +252,7 @@ export class DeleteOp<Conf extends DeltaConf = {}> extends list.ListNode {
      * @param {number} [start]
      * @param {number} [end]
      * @param {boolean} [_markAsDone] accepted for a uniform children-op `clone` signature; ignored (a
-     * cloned delete carries no prevValue).
+     * delete holds no nested content).
      * @return {DeleteOp}
      */
     clone(start?: number, end?: number, _markAsDone?: boolean): DeleteOp;
@@ -400,10 +398,9 @@ export class SetAttrOp<V extends unknown = any, K extends string | number = any>
     /**
      * @param {K} key
      * @param {V} value
-     * @param {V|undefined} prevValue
      * @param {Attribution?} attribution
      */
-    constructor(key: K, value: V, prevValue: V | undefined, attribution: Attribution | null);
+    constructor(key: K, value: V, attribution: Attribution | null);
     /**
      * @readonly
      * @type {K}
@@ -414,11 +411,6 @@ export class SetAttrOp<V extends unknown = any, K extends string | number = any>
      * @type {V}
      */
     readonly value: V;
-    /**
-     * @readonly
-     * @type {V|undefined}
-     */
-    readonly prevValue: V | undefined;
     /**
      * @readonly
      * @type {Attribution?}
@@ -466,18 +458,13 @@ export class SetAttrOp<V extends unknown = any, K extends string | number = any>
 export class DeleteAttrOp<V = any, K extends string | number = string | number> {
     /**
      * @param {K} key
-     * @param {V|undefined} prevValue
      * @param {Attribution?} attribution
      */
-    constructor(key: K, prevValue: V | undefined, attribution: Attribution | null);
+    constructor(key: K, attribution: Attribution | null);
     /**
      * @type {K}
      */
     key: K;
-    /**
-     * @type {V|undefined}
-     */
-    prevValue: V | undefined;
     attribution: Attribution | null;
     /**
      * @type {string|null}
@@ -654,20 +641,72 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
     /**
      * @type {Formats?}
      */
-    usedFormats: Formats | null;
+    _usedFormats: Formats | null;
     /**
      * @type {Attribution?}
      */
-    usedAttribution: Attribution | null;
+    _usedAttribution: Attribution | null;
+    /**
+     * Resolved data-companion cache for the `used*` contexts ({@link resolveUsedData}): what data
+     * ops inherit instead of the raw context. `undefined` = stale, recomputed on the next data-op
+     * consumption ({@link DeltaBuilder#_getUsedFormatsData}) — {@link DeltaBuilder#useFormats} & co
+     * clear it whenever they swap the context (which is why the public slots are read-only).
+     *
+     * @type {Formats|null|undefined}
+     */
+    _usedFormatsData: Formats | null | undefined;
+    /**
+     * @type {Attribution|null|undefined}
+     */
+    _usedAttributionData: Attribution | null | undefined;
+    /**
+     * The ambient formats context inherited by subsequent ops. Read-only: set it via
+     * {@link DeltaBuilder#useFormats} / {@link DeltaBuilder#updateUsedFormats}, which also invalidate
+     * the cached data companion — a direct overwrite would leave it stale.
+     *
+     * @return {Formats?}
+     */
+    get usedFormats(): Formats | null;
     /**
+     * The ambient attribution context inherited by subsequent ops. Read-only — see
+     * {@link DeltaBuilder#usedFormats}; set it via {@link DeltaBuilder#useAttribution} /
+     * {@link DeltaBuilder#updateUsedAttribution}.
+     *
+     * @return {Attribution?}
+     */
+    get usedAttribution(): Attribution | null;
+    /**
+     * Set the ambient attribution context inherited by subsequent ops (`undefined`/empty dim args).
+     * The object is interned — instruction ops store it, and data ops store its resolved companion
+     * ({@link resolveUsedData}), BY REFERENCE. Never mutate it after setting; pass a fresh object
+     * instead (same invariant as the objects stored on ops).
+     *
      * @param {Attribution?} attribution
      */
     useAttribution(attribution: Attribution | null): this;
     /**
+     * Set the ambient formats context inherited by subsequent ops (`undefined`/empty dim args). The
+     * object is interned — see {@link DeltaBuilder#useAttribution}: never mutate it after setting.
+     *
      * @param {Formats?} attributes
      * @return {this}
      */
     useFormats(attributes: Formats | null): this;
+    /**
+     * The `usedFormats` context resolved for data-op consumption ({@link resolveUsedData}): the slot
+     * object itself when it carries no `{k:null}` removals, one shared stripped copy otherwise.
+     * Cached until the context is swapped — no per-op traversal.
+     *
+     * @return {Formats?}
+     */
+    _getUsedFormatsData(): Formats | null;
+    /**
+     * See {@link DeltaBuilder#_getUsedFormatsData} — the `usedAttribution` analogue (its `format` key
+     * resolves one level deeper).
+     *
+     * @return {Attribution?}
+     */
+    _getUsedAttributionData(): Attribution | null;
     /**
      * @param {string} name
      * @param {any} value
@@ -736,19 +775,17 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
     retain(len: number, format?: Formats | null, attribution?: Attribution | null): this;
     /**
      * @param {number} len
-     * @param {DeltaBuilder<any>|null} prevValue
      */
-    delete(len: number, prevValue?: DeltaBuilder<any> | null): this;
+    delete(len: number): this;
     /**
      * @template {Extract<keyof DeltaConfGetAllowedAttrs<Conf, FixedConf>,string|number>} Key
      * @template {DeltaConfGetAllowedAttrs<Conf, FixedConf>[Key]} Val
      * @param {Key} key
      * @param {Val} val
      * @param {Attribution?} [attribution] provenance for this attr (data: object or `null`/none)
-     * @param {Val|undefined} [prevValue]
      * @return {DeltaBuilder<DeltaConfOverwrite<Conf,{attrs:AddToAttrs<DeltaConfGetAttrs<Conf>,Key,Val>}>, FixedConf>}
      */
-    setAttr<Key extends Extract<keyof DeltaConfGetAllowedAttrs<Conf, FixedConf>, string | number>, Val extends DeltaConfGetAllowedAttrs<Conf, FixedConf>[Key]>(key: Key, val: Val, attribution?: Attribution | null, prevValue?: Val | undefined): DeltaBuilder<DeltaConfOverwrite<Conf, {
+    setAttr<Key extends Extract<keyof DeltaConfGetAllowedAttrs<Conf, FixedConf>, string | number>, Val extends DeltaConfGetAllowedAttrs<Conf, FixedConf>[Key]>(key: Key, val: Val, attribution?: Attribution | null): DeltaBuilder<DeltaConfOverwrite<Conf, {
         attrs: AddToAttrs<DeltaConfGetAttrs<Conf>, Key, Val>;
     }>, FixedConf>;
     /**
@@ -768,12 +805,11 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
      * @template {Extract<keyof DeltaConfGetAllowedAttrs<Conf, FixedConf>,string|number>} Key
      * @param {Key} key
      * @param {Attribution?} [attribution] provenance for the deletion (data: object or `null`/none)
-     * @param {any} [prevValue]
      * @return {DeltaBuilder<DeltaConfOverwrite<Conf, {
      *   attrs: AddToAttrs<DeltaConfGetAttrs<Conf>,Key,never>
      * }>, FixedConf>}
      */
-    deleteAttr<Key extends Extract<keyof DeltaConfGetAllowedAttrs<Conf, FixedConf>, string | number>>(key: Key, attribution?: Attribution | null, prevValue?: any): DeltaBuilder<DeltaConfOverwrite<Conf, {
+    deleteAttr<Key extends Extract<keyof DeltaConfGetAllowedAttrs<Conf, FixedConf>, string | number>>(key: Key, attribution?: Attribution | null): DeltaBuilder<DeltaConfOverwrite<Conf, {
         attrs: AddToAttrs<DeltaConfGetAttrs<Conf>, Key, never>;
     }>, FixedConf>;
     /**
@@ -1050,6 +1086,7 @@ export function from<NodeName extends string | null, Attrs extends {
     text: Extract<Children, string> extends never ? false : true;
 }>;
 export function diff<Conf_1 extends DeltaConf>(d1: Delta<Conf_1>, d2: NoInfer<Delta<Conf_1>>, options?: DiffOptions): Delta<Conf_1>;
+export function inverse<Conf_1 extends DeltaConf>(d: DeltaAny, base: Delta<Conf_1>): Delta<Conf_1>;
 export function diffChangesetWithSeparator(changeset: Array<{
     index: number;
     remove: Array<any>;
@@ -1132,11 +1169,9 @@ export type DeltaListOpJSON = {
 export type DeltaAttrOpJSON = {
     type: "insert";
     value: any;
-    prevValue?: any;
     attribution?: Attribution;
 } | {
     type: "delete";
-    prevValue?: any;
     attribution?: Attribution;
 } | {
     type: "modify";

package/dist/delta/rdt.d.ts

@@ -62,6 +62,12 @@ export { deltaRDT } from "./rdt/delta.js";
  * @type {Schema<RDT<any>>}
  */
 export const $rdt: Schema<RDT<any>>;
+/**
+ * @typedef {object} BindOptions
+ * @property {delta.DiffOptions['compare']} [diffCompare] **Experimental** (may be changed or removed
+ * in a future release). Forwarded as `compare` to {@link delta.diff} when the initial-state sync diffs
+ * `a`'s projection against `b`'s current state, controlling how nodes are paired into `modify` ops.
+ */
 /**
  * Connects two RDTs so that changes on either side are transformed and reflected on the other.
  *
@@ -81,8 +87,9 @@ export class Binding<A extends delta.DeltaConf, B extends delta.DeltaConf> {
      * @param {RDT<B>} b
      * @param {dt.TemplateFactory<A,B>} [template] a `$d => Template` factory; defaults to the
      * {@link dt.id identity} transformer. `bind` injects `a`'s schema, then materializes via `.init()`.
+     * @param {BindOptions} [options]
      */
-    constructor(a: RDT<A>, b: RDT<B>, template?: dt.TemplateFactory<A, B>);
+    constructor(a: RDT<A>, b: RDT<B>, template?: dt.TemplateFactory<A, B>, options?: BindOptions);
     /**
      * @type {dt.Transformer<A,B>}
      */
@@ -105,7 +112,7 @@ export class Binding<A extends delta.DeltaConf, B extends delta.DeltaConf> {
      */
     destroy: () => void;
 }
-export function bind<A extends delta.DeltaConf, B extends delta.DeltaConf>(a: RDT<A>, b: RDT<B>, template?: dt.TemplateFactory<A, B>): Binding<A, B>;
+export function bind<A extends delta.DeltaConf, B extends delta.DeltaConf>(a: RDT<A>, b: RDT<B>, template?: dt.TemplateFactory<A, B>, options?: BindOptions): Binding<A, B>;
 export type Schema<T> = import("../schema.js").Schema<T>;
 /**
  * Abstract interface for a delta-based Replicated Data Type.
@@ -158,6 +165,14 @@ export type RDT<Conf extends import("./delta.js").DeltaConf> = import("../observ
     applyDelta: (delta: delta.Delta<Conf>, origin?: any) => delta.DeltaBuilder<Conf> | null;
     destroy: () => void;
 };
+export type BindOptions = {
+    /**
+     * **Experimental** (may be changed or removed
+     * in a future release). Forwarded as `compare` to {@link delta.diff} when the initial-state sync diffs
+     * `a`'s projection against `b`'s current state, controlling how nodes are paired into `modify` ops.
+     */
+    diffCompare?: delta.DiffOptions["compare"];
+};
 import * as delta from './delta.js';
 import * as dt from './transformer.js';
 import * as mux from '../mutex.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "1.0.0-rc.20",
+  "version": "1.0.0-rc.21",
   "description": "",
   "sideEffects": false,
   "type": "module",

package/src/delta/delta.js

@@ -6,7 +6,7 @@
  * This module exports a large surface, but a consumer only needs a handful of it:
  * - **build / apply / inspect:** {@link create} (the constructor) and the {@link DeltaBuilder} methods
  *   it returns (`insert`/`delete`/`retain`/`modify`/`setAttr`/`addMark`/…, `apply`, `rebase`, `done`);
- *   {@link clone}, {@link slice}, {@link diff}, and `toJSON`/`equals`/`isEmpty` on the result.
+ *   {@link clone}, {@link slice}, {@link diff}, {@link inverse}, and `toJSON`/`equals`/`isEmpty` on the result.
  * - **schemas:** {@link $delta} (define a typed delta schema) and {@link $deltaAny} (the catch-all).
  * - **types:** `Delta`, `DeltaBuilder`, `DeltaAny`, `DeltaConf` for annotations.
  *
@@ -109,7 +109,7 @@ export const $attribution = /* @__PURE__ */(() => s.$object({
  */
 
 /**
- * @typedef {{ type: 'insert', value: any, prevValue?: any, attribution?: Attribution } | { type: 'delete', prevValue?: any, attribution?: Attribution } | { type: 'modify', value: DeltaJSON, attribution?: Attribution|null }} DeltaAttrOpJSON
+ * @typedef {{ type: 'insert', value: any, attribution?: Attribution } | { type: 'delete', attribution?: Attribution } | { type: 'modify', value: DeltaJSON, attribution?: Attribution|null }} DeltaAttrOpJSON
  */
 
 /**
@@ -128,9 +128,9 @@ export const $attribution = /* @__PURE__ */(() => s.$object({
  * @type {s.Schema<DeltaAttrOpJSON>}
  */
 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('insert'), value: s.$any, attribution: $attribution.optional }),
   s.$object({ type: s.$literal('modify'), value: s.$any, attribution: $attribution.optional }),
-  s.$object({ type: s.$literal('delete'), prevValue: s.$any.optional, attribution: $attribution.optional })
+  s.$object({ type: s.$literal('delete'), attribution: $attribution.optional })
 ))()
 
 /**
@@ -144,8 +144,10 @@ const _cloneAttrs = attrs => attrs == null ? attrs : { ...attrs }
  * as the inner step of {@link mergeAttr}). Per key: `undefined` skips, `null` removes, anything else sets.
  * `resolve` true (data semantics) applies a `null` removal by deleting the key; false (instruction semantics)
  * keeps the `null` verbatim so it still removes when the instruction is later applied. When `resolve` is true
- * the `base` is canonicalised too — a `{k:null}` already present in `base` (e.g. from a `useAttribution`
- * context) has nothing to clear on settled data, so it is dropped rather than copied through.
+ * the `base` is canonicalised too — a `{k:null}` already present in `base` has nothing to clear on settled
+ * data, so it is dropped rather than copied through. (The used-context call sites pass pre-resolved
+ * companions — see {@link resolveUsedData} — so for them this is a no-op safety net; it matters for the
+ * apply/diff paths that merge instructions onto stored values.)
  *
  * @param {{[k:string]:any}|null|undefined} base
  * @param {{[k:string]:any}} update
@@ -225,46 +227,83 @@ const resolveBeyond = (arg, deep) => {
   return object.isEmpty(m) ? undefined : m
 }
 /**
- * Combine a builder's `used*` context (set via {@link DeltaBuilder#useFormats}/`useAttribution`) with
- * a per-call format/attribution argument under the unified tri-state: `undefined` inherits the context
- * (or stays `undefined` — "skip" — when there is none); `null` clears (ignoring the context); an object
- * merges over the context. `resolve` true (data op) applies any `{k:null}` removal against the context so the
- * stored value is canonical (no `null` leaves); false (instruction op) keeps removals verbatim for later.
+ * Resolve a `used*` context (set via {@link DeltaBuilder#useFormats}/`useAttribution`) for **data**
+ * consumption: settled data stores canonical values only
+ * (no `null` leaves — see {@link combineData}), while the slot itself keeps removal instructions
+ * verbatim for the instruction ops it governs. Returns the SAME object when it is already canonical
+ * (the common case — provenance contexts carry no removals), so every data op under one context shares
+ * one interned object; otherwise strips the removals ONCE into a shared copy (`{}` collapses to `null`).
+ * Never called per op — {@link DeltaBuilder#_getUsedFormatsData} caches the result per context object.
  *
  * @param {{[k:string]:any}|null} used
- * @param {{[k:string]:any}|null|undefined} arg
- * @param {boolean} deep `true` for the `attribution` dimension (its `format` key merges per inner key via
- *   {@link mergeAttr}); `false` for `format` (shallow, {@link mergeShallow}).
- * @param {boolean} resolve see above ({@link mergeShallow})
- * @return {{[k:string]:any}|null|undefined}
+ * @param {boolean} deep `true` for the `attribution` dimension (its `format` key resolves one level
+ *   deeper via {@link mergeAttr}); `false` for `format` (shallow, {@link mergeShallow})
+ * @return {{[k:string]:any}|null}
  */
-const combineUsed = (used, arg, deep, resolve) =>
-  arg === undefined
-    ? (used === null ? undefined : used)
-    : arg === null
-      ? null
-      : (deep ? mergeAttr(used, arg, resolve) : mergeShallow(used, arg, resolve))
+const resolveUsedData = (used, deep) => {
+  if (used === null) return null
+  let empty = true
+  let canonical = true
+  for (const k in used) {
+    empty = false
+    const v = used[k]
+    if (v === null) { canonical = false; break } // a top-level removal (incl. `format: null`)
+    if (deep && k === 'format' && s.$objectAny.check(v)) {
+      // mirror mergeAttr's resolve-mode base handling: an emptied `format` is dropped on data, and an
+      // inner `{k:null}` removal is stripped — either makes the context non-canonical for data ops
+      let formatCanonical = false // empty `format: {}` ⇒ non-canonical
+      for (const ik in v) {
+        if (v[ik] === null) { formatCanonical = false; break }
+        formatCanonical = true
+      }
+      if (!formatCanonical) { canonical = false; break }
+    }
+  }
+  if (empty) return null
+  if (canonical) return used
+  const m = deep ? mergeAttr(used, {}, true) : mergeShallow(used, {}, true)
+  return object.isEmpty(m) ? null : m
+}
 /**
- * Combine + normalize for an **instruction** op (`retain`/`modify`/`modifyAttr`): keep the tri-state —
- * `undefined` (skip), `null` (clear), or a non-empty object; an empty merge result `{}` is a no-op → `undefined`.
+ * Combine a builder's `used*` context with a per-call format/attribution argument for an
+ * **instruction** op (`retain`/`modify`/`modifyAttr`) under the unified tri-state: `undefined` — or an
+ * empty object, an empty update — inherits the context BY IDENTITY (no traversal, no copy; contexts
+ * are interned); `null` clears (ignoring the context); a non-empty object merges over the context,
+ * keeping `{k:null}` removals verbatim so they still remove when the instruction is later applied.
+ * An empty result is a no-op → `undefined` (skip).
  *
- * @param {{[k:string]:any}|null} used
+ * @param {{[k:string]:any}|null} used the raw context slot (removal instructions intact)
  * @param {{[k:string]:any}|null|undefined} arg
- * @param {boolean} deep see {@link combineUsed}
+ * @param {boolean} deep `true` for the `attribution` dimension (its `format` key merges per inner key via
+ *   {@link mergeAttr}); `false` for `format` (shallow, {@link mergeShallow}).
  * @return {{[k:string]:any}|null|undefined}
  */
-const combineInstr = (used, arg, deep) => { const r = combineUsed(used, arg, deep, false); return r !== null && object.isEmpty(r) ? undefined : r }
+const combineInstr = (used, arg, deep) => {
+  if (arg === null) return null // explicit clear — must precede the isEmpty check (object.isEmpty(null) is true)
+  if (arg === undefined || object.isEmpty(arg)) return used === null || object.isEmpty(used) ? undefined : used
+  const r = deep ? mergeAttr(used, arg, false) : mergeShallow(used, arg, false)
+  return object.isEmpty(r) ? undefined : r
+}
 /**
- * Combine + normalize for a **data** op (`insert`/`text`/`setAttr`/`deleteAttr`): the stored value is a
- * canonical object or `null` ("none") — `{k:null}` removals are resolved against the context, and
- * `undefined`/`null`/`{}` all collapse to `null`.
+ * Combine for a **data** op (`insert`/`text`/`setAttr`/`deleteAttr`): the stored value is a canonical
+ * object or `null` ("none") — never a `{k:null}` removal, there is nothing to remove on settled data.
+ * `usedData` is the builder's RESOLVED context companion ({@link resolveUsedData}, cached by
+ * {@link DeltaBuilder#_getUsedFormatsData}) and thus already canonical (`null` or a non-empty
+ * no-`null` object), so `undefined` — or an empty object, an empty update — inherits it BY IDENTITY
+ * (no traversal, no copy); `null` clears; a non-empty object merges over it, resolving the argument's
+ * own `{k:null}` removals. `{}` results collapse to `null`.
  *
- * @param {{[k:string]:any}|null} used
+ * @param {{[k:string]:any}|null} usedData
  * @param {{[k:string]:any}|null|undefined} arg
- * @param {boolean} deep see {@link combineUsed}
+ * @param {boolean} deep see {@link combineInstr}
  * @return {{[k:string]:any}|null}
  */
-const combineData = (used, arg, deep) => { const r = combineUsed(used, arg, deep, true); return object.isEmpty(r) ? null : /** @type {{[k:string]:any}} */ (r) }
+const combineData = (usedData, arg, deep) => {
+  if (arg === null) return null // explicit clear — must precede the isEmpty check (object.isEmpty(null) is true)
+  if (arg === undefined || object.isEmpty(arg)) return usedData
+  const r = deep ? mergeAttr(usedData, arg, true) : mergeShallow(usedData, arg, true)
+  return object.isEmpty(r) ? null : /** @type {{[k:string]:any}} */ (r)
+}
 /**
  * @template {any} MaybeDelta
  * @param {MaybeDelta} maybeDelta
@@ -531,12 +570,10 @@ export class InsertOp extends list.ListNode {
 export class DeleteOp extends list.ListNode {
   /**
    * @param {number} len
-   * @param {DeltaBuilder<any>?} prevValue
    */
-  constructor (len, prevValue) {
+  constructor (len) {
     super()
     this.delete = len
-    this.prevValue = /** @type {Delta<Conf>?} */ (prevValue)
     /**
      * @type {string|null}
      */
@@ -564,13 +601,10 @@ 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) {
-    if (this.prevValue) {
-      /** @type {DeltaBuilder<any>} */ (this.prevValue).apply(create().retain(offset).delete(len))
-    }
+  _splice (_offset, len) {
     this._fingerprint = null
     this.delete -= len
     return this
@@ -594,11 +628,11 @@ export class DeleteOp extends list.ListNode {
    * @param {number} [start]
    * @param {number} [end]
    * @param {boolean} [_markAsDone] accepted for a uniform children-op `clone` signature; ignored (a
-   * cloned delete carries no prevValue).
+   * delete holds no nested content).
    * @return {DeleteOp}
    */
   clone (start = 0, end = this.delete, _markAsDone = true) {
-    return new DeleteOp(end - start, null)
+    return new DeleteOp(end - start)
   }
 }
 
@@ -822,10 +856,9 @@ export class SetAttrOp {
   /**
    * @param {K} key
    * @param {V} value
-   * @param {V|undefined} prevValue
    * @param {Attribution?} attribution
    */
-  constructor (key, value, prevValue, attribution) {
+  constructor (key, value, attribution) {
     /**
      * @readonly
      * @type {K}
@@ -836,11 +869,6 @@ export class SetAttrOp {
      * @type {V}
      */
     this.value = value
-    /**
-     * @readonly
-     * @type {V|undefined}
-     */
-    this.prevValue = prevValue
     /**
      * @readonly
      * @type {Attribution?}
@@ -905,7 +933,7 @@ export class SetAttrOp {
    * @return {SetAttrOp<V,K>}
    */
   clone () {
-    return new SetAttrOp(this.key, _markMaybeDeltaAsDone(this.value), _markMaybeDeltaAsDone(this.prevValue), _cloneAttrs(this.attribution))
+    return new SetAttrOp(this.key, _markMaybeDeltaAsDone(this.value), _cloneAttrs(this.attribution))
   }
 }
 
@@ -917,18 +945,13 @@ export class SetAttrOp {
 export class DeleteAttrOp {
   /**
    * @param {K} key
-   * @param {V|undefined} prevValue
    * @param {Attribution?} attribution
    */
-  constructor (key, prevValue, attribution) {
+  constructor (key, attribution) {
     /**
      * @type {K}
      */
     this.key = key
-    /**
-     * @type {V|undefined}
-     */
-    this.prevValue = prevValue
     this.attribution = attribution
     /**
      * @type {string|null}
@@ -977,7 +1000,7 @@ export class DeleteAttrOp {
    * @return {DeleteAttrOp<V,K>}
    */
   clone () {
-    return new DeleteAttrOp(this.key, _markMaybeDeltaAsDone(this.prevValue), _cloneAttrs(this.attribution))
+    return new DeleteAttrOp(this.key, _cloneAttrs(this.attribution))
   }
 }
 
@@ -1609,7 +1632,7 @@ const _cloneMaybeDeltaDeep = v => $deltaAny.check(v) ? cloneDeep(v) : v
  * Deep-clone one content (child) op for {@link cloneDeep}: a fresh op whose nested deltas (an insert's
  * delta content, a modify's value) are themselves deep-cloned. `format`/`attribution` objects are
  * retained (shared) — they are always copied before being mutated (see {@link cloneDeep}). Ops without a
- * nested delta a clone keeps (`text`/`retain`/`delete` — `delete` drops its prevValue) use `op.clone()`.
+ * nested delta (`text`/`retain`/`delete`) use `op.clone()`.
  *
  * @param {ChildrenOpAny} op
  * @return {ChildrenOpAny}
@@ -1623,7 +1646,7 @@ const _cloneChildOpDeep = op =>
 
 /**
  * Deep-clone one attribute op for {@link cloneDeep} — the attribute-dimension mirror of
- * {@link _cloneChildOpDeep}: a `setAttr`'s value/prevValue and a `modifyAttr`'s value may be nested
+ * {@link _cloneChildOpDeep}: a `setAttr`'s value and a `modifyAttr`'s value may be nested
  * deltas and are deep-cloned.
  *
  * @param {AttrOpAny} op
@@ -1631,11 +1654,11 @@ const _cloneChildOpDeep = op =>
  */
 const _cloneAttrOpDeep = op =>
   $setAttrOp.check(op)
-    ? new SetAttrOp(op.key, _cloneMaybeDeltaDeep(op.value), _cloneMaybeDeltaDeep(op.prevValue), op.attribution)
+    ? new SetAttrOp(op.key, _cloneMaybeDeltaDeep(op.value), op.attribution)
     : ($modifyAttrOp.check(op)
         ? new ModifyAttrOp(op.key, cloneDeep(op.value), op.attribution)
-        // the only remaining attr op is a deleteAttr (its prevValue may be a nested delta)
-        : new DeleteAttrOp(op.key, _cloneMaybeDeltaDeep(op.prevValue), op.attribution))
+        // the only remaining attr op is a deleteAttr
+        : new DeleteAttrOp(op.key, op.attribution))
 
 /**
  * A **deep** clone of `d`: like {@link clone}, but every nested delta — an insert's delta content, a
@@ -1919,32 +1942,100 @@ export class DeltaBuilder extends Delta {
     /**
      * @type {Formats?}
      */
-    this.usedFormats = null
+    this._usedFormats = null
     /**
      * @type {Attribution?}
      */
-    this.usedAttribution = null
+    this._usedAttribution = null
+    /**
+     * Resolved data-companion cache for the `used*` contexts ({@link resolveUsedData}): what data
+     * ops inherit instead of the raw context. `undefined` = stale, recomputed on the next data-op
+     * consumption ({@link DeltaBuilder#_getUsedFormatsData}) — {@link DeltaBuilder#useFormats} & co
+     * clear it whenever they swap the context (which is why the public slots are read-only).
+     *
+     * @type {Formats|null|undefined}
+     */
+    this._usedFormatsData = undefined
+    /**
+     * @type {Attribution|null|undefined}
+     */
+    this._usedAttributionData = undefined
   }
 
   /**
+   * The ambient formats context inherited by subsequent ops. Read-only: set it via
+   * {@link DeltaBuilder#useFormats} / {@link DeltaBuilder#updateUsedFormats}, which also invalidate
+   * the cached data companion — a direct overwrite would leave it stale.
+   *
+   * @return {Formats?}
+   */
+  get usedFormats () { return this._usedFormats }
+
+  /**
+   * The ambient attribution context inherited by subsequent ops. Read-only — see
+   * {@link DeltaBuilder#usedFormats}; set it via {@link DeltaBuilder#useAttribution} /
+   * {@link DeltaBuilder#updateUsedAttribution}.
+   *
+   * @return {Attribution?}
+   */
+  get usedAttribution () { return this._usedAttribution }
+
+  /**
+   * Set the ambient attribution context inherited by subsequent ops (`undefined`/empty dim args).
+   * The object is interned — instruction ops store it, and data ops store its resolved companion
+   * ({@link resolveUsedData}), BY REFERENCE. Never mutate it after setting; pass a fresh object
+   * instead (same invariant as the objects stored on ops).
+   *
    * @param {Attribution?} attribution
    */
   useAttribution (attribution) {
     modDeltaCheck(this)
-    this.usedAttribution = attribution
+    if (this._usedAttribution !== attribution) {
+      this._usedAttribution = attribution
+      this._usedAttributionData = undefined // clear the data companion — recomputed on next consumption
+    }
     return this
   }
 
   /**
+   * Set the ambient formats context inherited by subsequent ops (`undefined`/empty dim args). The
+   * object is interned — see {@link DeltaBuilder#useAttribution}: never mutate it after setting.
+   *
    * @param {Formats?} attributes
    * @return {this}
    */
   useFormats (attributes) {
     modDeltaCheck(this)
-    this.usedFormats = attributes
+    if (this._usedFormats !== attributes) {
+      this._usedFormats = attributes
+      this._usedFormatsData = undefined // clear the data companion — recomputed on next consumption
+    }
     return this
   }
 
+  /**
+   * The `usedFormats` context resolved for data-op consumption ({@link resolveUsedData}): the slot
+   * object itself when it carries no `{k:null}` removals, one shared stripped copy otherwise.
+   * Cached until the context is swapped — no per-op traversal.
+   *
+   * @return {Formats?}
+   */
+  _getUsedFormatsData () {
+    const d = this._usedFormatsData
+    return d !== undefined ? d : (this._usedFormatsData = /** @type {Formats?} */ (resolveUsedData(this._usedFormats, false)))
+  }
+
+  /**
+   * See {@link DeltaBuilder#_getUsedFormatsData} — the `usedAttribution` analogue (its `format` key
+   * resolves one level deeper).
+   *
+   * @return {Attribution?}
+   */
+  _getUsedAttributionData () {
+    const d = this._usedAttributionData
+    return d !== undefined ? d : (this._usedAttributionData = /** @type {Attribution?} */ (resolveUsedData(this._usedAttribution, true)))
+  }
+
   /**
    * @param {string} name
    * @param {any} value
@@ -1952,14 +2043,16 @@ export class DeltaBuilder extends Delta {
   updateUsedFormats (name, value) {
     modDeltaCheck(this)
     if (value == null) {
-      this.usedFormats = object.assign({}, this.usedFormats)
-      delete this.usedFormats?.[name]
-      if (object.isEmpty(this.usedFormats)) {
-        this.usedFormats = null
+      this._usedFormats = object.assign({}, this._usedFormats)
+      delete this._usedFormats?.[name]
+      if (object.isEmpty(this._usedFormats)) {
+        this._usedFormats = null
       }
-    } else if (!fun.equalityDeep(this.usedFormats?.[name], value)) {
-      this.usedFormats = object.assign({}, this.usedFormats)
-      this.usedFormats[name] = value
+      this._usedFormatsData = undefined // clear the data companion — recomputed on next consumption
+    } else if (!fun.equalityDeep(this._usedFormats?.[name], value)) {
+      this._usedFormats = object.assign({}, this._usedFormats)
+      this._usedFormats[name] = value
+      this._usedFormatsData = undefined // clear the data companion — recomputed on next consumption
     }
     return this
   }
@@ -1972,14 +2065,16 @@ export class DeltaBuilder extends Delta {
   updateUsedAttribution (name, value) {
     modDeltaCheck(this)
     if (value == null) {
-      this.usedAttribution = object.assign({}, this.usedAttribution)
-      delete this.usedAttribution?.[name]
-      if (object.isEmpty(this.usedAttribution)) {
-        this.usedAttribution = null
+      this._usedAttribution = object.assign({}, this._usedAttribution)
+      delete this._usedAttribution?.[name]
+      if (object.isEmpty(this._usedAttribution)) {
+        this._usedAttribution = null
       }
-    } else if (!fun.equalityDeep(this.usedAttribution?.[name], value)) {
-      this.usedAttribution = object.assign({}, this.usedAttribution)
-      this.usedAttribution[name] = value
+      this._usedAttributionData = undefined // clear the data companion — recomputed on next consumption
+    } else if (!fun.equalityDeep(this._usedAttribution?.[name], value)) {
+      this._usedAttribution = object.assign({}, this._usedAttribution)
+      this._usedAttribution[name] = value
+      this._usedAttributionData = undefined // clear the data companion — recomputed on next consumption
     }
     return this
   }
@@ -1996,8 +2091,8 @@ export class DeltaBuilder extends Delta {
    */
   insert (insert, formatting, attribution) {
     modDeltaCheck(this)
-    const mergedFormats = combineData(this.usedFormats, formatting, false)
-    const mergedAttribution = combineData(this.usedAttribution, attribution, true)
+    const mergedFormats = combineData(this._getUsedFormatsData(), formatting, false)
+    const mergedAttribution = combineData(this._getUsedAttributionData(), attribution, true)
     /**
      * @param {TextOp | InsertOp<any>} lastOp
      */
@@ -2102,19 +2197,15 @@ export class DeltaBuilder extends Delta {
 
   /**
    * @param {number} len
-   * @param {DeltaBuilder<any>|null} prevValue
    */
-  delete (len, prevValue = null) {
+  delete (len) {
     modDeltaCheck(this)
     const lastOp = /** @type {DeleteOp<any>|InsertOp<any>} */ (this.children.end)
-    if ($deleteOp.check(lastOp) && typeof lastOp.prevValue === typeof prevValue) {
+    if ($deleteOp.check(lastOp)) {
       lastOp.delete += len
       lastOp._fingerprint = null
-      if (prevValue != null) {
-        /** @type {DeltaBuilder<any>} */ (lastOp.prevValue).append(prevValue)
-      }
     } else if (len > 0) {
-      list.pushEnd(this.children, new DeleteOp(len, prevValue))
+      list.pushEnd(this.children, new DeleteOp(len))
     }
     this.childCnt += len
     return this
@@ -2126,14 +2217,13 @@ export class DeltaBuilder extends Delta {
    * @param {Key} key
    * @param {Val} val
    * @param {Attribution?} [attribution] provenance for this attr (data: object or `null`/none)
-   * @param {Val|undefined} [prevValue]
    * @return {DeltaBuilder<DeltaConfOverwrite<Conf,{attrs:AddToAttrs<DeltaConfGetAttrs<Conf>,Key,Val>}>, FixedConf>}
    */
-  setAttr (key, val, attribution, prevValue) {
+  setAttr (key, val, attribution) {
     modDeltaCheck(this)
     // @ts-ignore
     this.attrs[key] /** @type {any} */ =
-      (new SetAttrOp(/** @type {any} */ (key), val, prevValue, combineData(this.usedAttribution, attribution, true)))
+      (new SetAttrOp(/** @type {any} */ (key), val, combineData(this._getUsedAttributionData(), attribution, true)))
     // a delta-valued attribute carries marks in its subtree - flag conservatively (never decremented)
     if ($deltaAny.check(val)) this.maybeHasMarks ||= val.maybeHasMarks
     return /** @type {any} */ (this)
@@ -2161,18 +2251,17 @@ export class DeltaBuilder extends Delta {
    * @template {Extract<keyof DeltaConfGetAllowedAttrs<Conf, FixedConf>,string|number>} Key
    * @param {Key} key
    * @param {Attribution?} [attribution] provenance for the deletion (data: object or `null`/none)
-   * @param {any} [prevValue]
    * @return {DeltaBuilder<DeltaConfOverwrite<Conf, {
    *   attrs: AddToAttrs<DeltaConfGetAttrs<Conf>,Key,never>
    * }>, FixedConf>}
    */
-  deleteAttr (key, attribution, prevValue) {
+  deleteAttr (key, attribution) {
     modDeltaCheck(this)
     // dropping a delta-valued attribute drops its subtree's marks; the conservative `maybeHasMarks` flag
     // is left as-is (never decremented - marksToPositions self-corrects it)
     // @ts-ignore
     this.attrs[key] /** @type {any} */ =
-      (new DeleteAttrOp(/** @type {any} */ (key), prevValue, combineData(this.usedAttribution, attribution, true)))
+      (new DeleteAttrOp(/** @type {any} */ (key), combineData(this._getUsedAttributionData(), attribution, true)))
     return /** @type {any} */ (this)
   }
 
@@ -2240,16 +2329,11 @@ export class DeltaBuilder extends Delta {
           this.maybeHasMarks ||= op.value.maybeHasMarks // flag any marks the new modify value carries
         }
       } else if ($setAttrOp.check(op)) {
-        const prev = c?.value
-        // @ts-ignore
-        op.prevValue = prev
         // a delta-valued attribute carries marks in its subtree - flag conservatively (never decremented)
         if ($deltaAny.check(op.value)) this.maybeHasMarks ||= op.value.maybeHasMarks
         // @ts-ignore
         this.attrs[op.key] = move ? op : op.clone()
       } else if ($deleteAttrOp.check(op)) {
-        const prev = c?.value
-        op.prevValue = prev
         // removing a delta-valued attribute drops its subtree's marks; the conservative `maybeHasMarks`
         // flag is left as-is (never decremented - marksToPositions self-corrects it)
         if (final) {
@@ -2374,7 +2458,7 @@ export class DeltaBuilder extends Delta {
         let remainingLen = op.delete
         while (remainingLen > 0) {
           if (opsI == null) {
-            _insertChild(this, null, scheduleForMerge(new DeleteOp(remainingLen, null)))
+            _insertChild(this, null, scheduleForMerge(new DeleteOp(remainingLen)))
             break
           } else if ($retainOp.check(opsI)) { // retain ⇒ splice retain, insert delete
             const delLen = math.min(opsI.length - offset, remainingLen)
@@ -2388,7 +2472,7 @@ export class DeltaBuilder extends Delta {
               opsI = opNextUndeleted(opsI)
               offset = 0
             }
-            insertClonedOp(new DeleteOp(delLen, null))
+            insertClonedOp(new DeleteOp(delLen))
             remainingLen -= delLen
           } else if ($modifyOp.check(opsI)) { // modify ⇒ delete the source position it stands for
             // a modify op addresses an underlying source position (retain + change), so deleting it
@@ -2398,7 +2482,7 @@ export class DeltaBuilder extends Delta {
             _removeChild(this, opsI)
             opsI = opNextUndeleted(opsI)
             offset = 0
-            insertClonedOp(new DeleteOp(1, null))
+            insertClonedOp(new DeleteOp(1))
             remainingLen -= 1
           } else if (!$deleteOp.check(opsI)) { // insert / embed ⇒ replace
             // case1: delete o fully
@@ -2686,10 +2770,8 @@ export class DeltaBuilder extends Delta {
           otherOffset += maxCommonLen
         } else { // insert/text.check(otherChild)
           if (currOffset > 0) {
-            // clone the LEFT (prefix) and shrink currChild from the front, so the original op survives as
-            // the [currOffset..] suffix — keeping a DeleteOp's prevValue in sync (DeleteOp.clone drops it).
-            _insertChild(this, currChild, currChild.clone(0, currOffset))
-            _shrinkChild(this, currChild, 0, currOffset)
+            // split currChild so the cursor sits on the boundary; continue on the [currOffset..] suffix
+            currChild = _splitChildAt(this, currChild, currOffset)
             currOffset = 0
           }
           _insertChild(this, currChild, new RetainOp(otherChild.length, undefined, undefined))
@@ -4002,6 +4084,118 @@ export const diff = (d1, d2, options = {}) => {
   return d.done(false)
 }
 
+/**
+ * The tri-state update that undoes a `format`/`attribution` instruction `update` against the stored
+ * value `stored` (object or `null`/none) it was applied to: applying the result after `update` restores
+ * `stored`. Merge the instruction onto `stored` the way an apply resolves it ({@link applyDim}), then
+ * diff the merged result back to `stored` ({@link diffDim}). `undefined` (skip) inverts to `undefined`.
+ *
+ * @param {{[k:string]:any}|null|undefined} stored
+ * @param {{[k:string]:any}|null|undefined} update
+ * @param {boolean} deep `true` for the `attribution` dimension (its `format` key merges per inner key —
+ *   see {@link mergeAttr}); `false` for `format` (shallow)
+ * @return {{[k:string]:any}|null|undefined}
+ */
+const inverseDim = (stored, update, deep) => {
+  if (update === undefined) return undefined
+  const merged = update === null ? null : (deep ? mergeAttr(stored, update, true) : mergeShallow(stored, update, true))
+  return diffDim(object.isEmpty(merged) ? null : merged, stored ?? null, deep)
+}
+
+/**
+ * Compute a delta that undoes `d` — a change that was applied to the settled document state `base`
+ * (inserts and set attributes only, e.g. an RDT's final state): `base.apply(d).apply(inverse(d, base))`
+ * equals `base`. Inspired by Quill's `Delta#invert`, `base` supplies what the change alone doesn't
+ * carry: deleted content is re-inserted from `base` (with its stored format/attribution), an
+ * overwritten or deleted attribute is restored to its `base` value, and an inverted `retain`/`modify`
+ * instruction is diffed against the `base` op's stored format/attribution.
+ *
+ * Content only: marks are local/ephemeral cursor state and are not inverted (mirroring {@link diff}).
+ * Like {@link diff}, the result *shares* re-inserted children and restored attribute values with `base`.
+ *
+ * The round-trip holds for changes whose content-consuming ops (`retain`/`delete`/`modify`) stay within
+ * `base`'s bounds. Beyond-base ops degrade gracefully: following ops stay positioned, but there is no
+ * stored content to restore — and what a final apply *materializes* beyond content (e.g. a format set
+ * kept as a trailing formatted retain, or an appended modify) cannot be removed by any change, so such
+ * a change is not fully undone.
+ *
+ * @template {DeltaConf} Conf
+ * @param {DeltaAny} d
+ * @param {Delta<Conf>} base
+ * @return {Delta<Conf>}
+ */
+export const inverse = (d, base) => {
+  const inv = create(d.name === base.name ? d.name : null, $deltaAny)
+  for (const op of d.attrs) {
+    const baseOp = /** @type {AttrOpAny|undefined} */ ((/** @type {any} */ (base.attrs))[op.key])
+    if ($modifyAttrOp.check(op) && $setAttrOp.check(baseOp) && $deltaAny.check(baseOp.value)) {
+      // the modify edited base's nested delta in place: undo it there, and undo the attribution
+      // instruction it merged onto the attr op
+      inv.modifyAttr(op.key, inverse(op.value, baseOp.value), /** @type {Attribution?} */ (inverseDim(baseOp.attribution, op.attribution, true)))
+    } else if ($setAttrOp.check(baseOp)) {
+      // a set/delete (or a modify that replaced a non-delta value) overwrote a settled attr:
+      // restore value + attribution from base
+      inv.setAttr(op.key, baseOp.value, baseOp.attribution)
+    } else if (!$deleteAttrOp.check(op)) {
+      // a set/modify introduced an attr base didn't have: undo by deleting it
+      inv.deleteAttr(op.key)
+    } // else: deleted an attr base didn't have — nothing to restore
+  }
+  // walk base's children alongside d's ops: an insert consumes no base positions; retain/delete/modify
+  // consume their length in base coordinates
+  let baseOp = /** @type {ChildrenOpAny?} */ (base.children.start)
+  let baseOffset = 0
+  /**
+   * Advance the base cursor by `len`, reporting each traversed chunk `(op, start, end)` (stored
+   * format/attribution are uniform per op, so per-op chunks are exact); returns the length that
+   * extends beyond base's content.
+   *
+   * @param {number} len
+   * @param {(op: TextOp|InsertOp<any>, start: number, end: number) => void} f
+   */
+  const forBase = (len, f) => {
+    while (len > 0 && baseOp != null) {
+      const chunk = math.min(len, baseOp.length - baseOffset)
+      f(/** @type {TextOp|InsertOp<any>} */ (baseOp), baseOffset, baseOffset + chunk)
+      len -= chunk
+      baseOffset += chunk
+      if (baseOffset === baseOp.length) {
+        baseOp = baseOp.next
+        baseOffset = 0
+      }
+    }
+    return len
+  }
+  for (const op of d.children) {
+    if ($textOp.check(op) || $insertOp.check(op)) {
+      inv.delete(op.length)
+    } else if ($retainOp.check(op)) {
+      const rest = forBase(op.retain, (bop, start, end) => {
+        inv.retain(end - start, inverseDim(bop.format, op.format, false), /** @type {Attribution?} */ (inverseDim(bop.attribution, op.attribution, true)))
+      })
+      // beyond base there is no stored content to restore — keep following ops positioned (see the
+      // beyond-base note in the fn docs)
+      rest > 0 && inv.retain(rest)
+    } else if ($modifyOp.check(op)) {
+      if (baseOp == null) {
+        // a modify beyond base edited no stored content — keep the position (mirrors retain-beyond)
+        inv.retain(1)
+      } else {
+        const bop = /** @type {InsertOp<any>} */ (baseOp)
+        const node = /** @type {DeltaAny} */ (bop.insert[baseOffset])
+        inv.modify(inverse(/** @type {DeltaAny} */ (op.value), node), inverseDim(bop.format, op.format, false), /** @type {Attribution?} */ (inverseDim(bop.attribution, op.attribution, true)))
+        forBase(1, () => {})
+      }
+    } else if ($deleteOp.check(op)) {
+      // re-insert the deleted base content with its stored format/attribution
+      forBase(op.delete, (bop, start, end) => {
+        inv.insert(bop.insert.slice(start, end), bop.format, bop.attribution)
+      })
+    }
+  }
+  return inv.done(false)
+}
+
 /**
  * Default pairing predicate for {@link diff}: two delta nodes are paired (and recursed into via
  * `modify`) when their names match.

package/src/delta/rdt.js

@@ -155,6 +155,13 @@ const propagate = (binding, ta, tb) => {
   }
 }
 
+/**
+ * @typedef {object} BindOptions
+ * @property {delta.DiffOptions['compare']} [diffCompare] **Experimental** (may be changed or removed
+ * in a future release). Forwarded as `compare` to {@link delta.diff} when the initial-state sync diffs
+ * `a`'s projection against `b`'s current state, controlling how nodes are paired into `modify` ops.
+ */
+
 /**
  * Connects two RDTs so that changes on either side are transformed and reflected on the other.
  *
@@ -174,8 +181,9 @@ export class Binding {
    * @param {RDT<B>} b
    * @param {dt.TemplateFactory<A,B>} [template] a `$d => Template` factory; defaults to the
    * {@link dt.id identity} transformer. `bind` injects `a`'s schema, then materializes via `.init()`.
+   * @param {BindOptions} [options]
    */
-  constructor (a, b, template = /** @type {dt.TemplateFactory<A,B>} */ (dt.id)) {
+  constructor (a, b, template = /** @type {dt.TemplateFactory<A,B>} */ (dt.id), options = {}) {
     /**
      * @type {dt.Transformer<A,B>}
      */
@@ -210,7 +218,7 @@ export class Binding {
       // `diff` shares nested children with `tres.b` by default, and `tres.b` is a (possibly stateful)
       // transformer's output that may still alias its internal state — so `clone` keeps the diff
       // independent, since it is then applied into `b` (which freezes it) and propagated onward.
-      const diffB = tres.b ? delta.diff(this.b.delta, tres.b, { clone: true }) : null
+      const diffB = tres.b ? delta.diff(this.b.delta, tres.b, { clone: true, compare: options.diffCompare }) : null
       const fb = diffB ? this.b.applyDelta(diffB, this) : null
       propagate(this, fa, fb)
     })
@@ -241,6 +249,7 @@ export class Binding {
  * @param {RDT<B>} b
  * @param {dt.TemplateFactory<A,B>} [template] a `$d => Template` factory (e.g. `dt.id` or
  * `$d => dt.renameAttrs($d, {a:'b'})`)
+ * @param {BindOptions} [options] `diffCompare` is **experimental** — see {@link BindOptions}.
  * @return {Binding<A,B>}
  */
-export const bind = (a, b, template) => new Binding(a, b, template)
+export const bind = (a, b, template, options = {}) => new Binding(a, b, template, options)

package/src/delta/transformer/attribution-to-format.js

@@ -173,9 +173,9 @@ const stripAttrAttributions = (out) => {
     if (delta.$modifyAttrOp.check(op)) {
       if (op.attribution !== undefined) out.modifyAttr(op.key, op.value)
     } else if (delta.$setAttrOp.check(op)) {
-      if (op.attribution != null) out.setAttr(op.key, op.value, undefined, op.prevValue)
+      if (op.attribution != null) out.setAttr(op.key, op.value)
     } else if (op.attribution != null) { // DeleteAttrOp
-      out.deleteAttr(op.key, undefined, op.prevValue)
+      out.deleteAttr(op.key)
     }
   }
 }

package/src/delta/transformer/conform.js

@@ -246,7 +246,7 @@ export class ConformTransformer extends Transformer {
         if (t != null) { out.modifyAttr(key, t.applyA(op.value).b); keptAttrKeys.add(key) }
       } else { // deleteAttr (the only remaining attr-op kind)
         const dop = /** @type {delta.DeleteAttrOp<any>} */ (op)
-        out.deleteAttr(key, dop.attribution, dop.prevValue)
+        out.deleteAttr(key, dop.attribution)
         this.transformAttrs.delete(key)
         keptAttrKeys.add(key)
       }
@@ -276,7 +276,7 @@ export class ConformTransformer extends Transformer {
     /** @param {number} n */
     const addRetain = n => addUniform(delta.$retainOp, n, () => new delta.RetainOp(n, null, null)) // n pass-through positions
     /** @param {number} n */
-    const addDrop = n => addUniform(delta.$deleteOp, n, () => new delta.DeleteOp(n, null)) // n dropped positions
+    const addDrop = n => addUniform(delta.$deleteOp, n, () => new delta.DeleteOp(n)) // n dropped positions
     /** @param {ConformTransformer} t */
     const addTransformed = t => { // one child routed through nested conform `t`
       if (src != null && delta.$insertOp.check(src)) { delta._spliceInsert(cmap, src, off, [t]); off += 1 } else { splitCursor(); delta._mergeChildWithPrev(cmap, delta._insertChild(cmap, src, new delta.InsertOp([t], null, null))) }

package/src/delta/transformer/full-attributions.js

@@ -181,9 +181,9 @@ const buildFull = (d, overlay) => {
       const childOverlay = (oa != null && delta.$modifyAttrOp.check(oa) && delta.$deltaAny.check(oa.value)) ? oa.value : null
       full.modifyAttr(aop.key, delta.$deltaAny.check(aop.value) ? buildFull(aop.value, childOverlay) : aop.value, applyFull(oa == null ? undefined : oa.attribution, aop.attribution))
     } else if (delta.$setAttrOp.check(aop)) {
-      full.setAttr(aop.key, aop.value, aop.attribution, aop.prevValue)
+      full.setAttr(aop.key, aop.value, aop.attribution)
     } else if (delta.$deleteAttrOp.check(aop)) {
-      full.deleteAttr(aop.key, aop.attribution, aop.prevValue)
+      full.deleteAttr(aop.key, aop.attribution)
     }
   }
   full.done(false)