lib0 1.0.0-rc.16 → 1.0.0-rc.18

package/dist/delta/delta.d.ts

@@ -1,4 +1,17 @@
 /**
+ * Provenance metadata on a content/attr op: *who/what* inserted, deleted, or formatted it. The canonical
+ * shape below is a convention — apply/diff/equality treat attribution as an **opaque** object (never branching
+ * on these field names), so custom keys flow through — with ONE exception: the nested `format` key merges per
+ * inner key (one level), so applying `{format:{italic:[…]}}` *adds* italic while keeping a pre-existing
+ * `{format:{bold:[…]}}`, and `{format:{bold:null}}` removes just that inner key (an emptied `format` is
+ * dropped). Every other key is flat/wholesale. The `format`/`formatAt` part exists only on
+ * children (content ops), never on node attribute ops. As an *update value* on `retain`/`modify`/`*Attr`,
+ * attribution uses the same unified tri-state as {@link Formats} (`undefined` skip / `null`
+ * clear / `{k:v}` set / `{k:null}` remove) — see the delta `readme.md` "Formats & Attributions". The blanket
+ * `null`-clear channel caveat on {@link Formats} applies here too; note `rebase` does not
+ * reconcile attribution at all (concurrent attribution edits don't converge), so prefer deterministic
+ * attribution assignment outside of concurrent editing.
+ *
  * @typedef {{
  *   insert?: string[]
  *   insertAt?: number
@@ -13,7 +26,17 @@
  */
 export const $attribution: s.Schema<Attribution>;
 /**
- * @typedef {{ [key: string]: any }} FormattingAttributes
+ * Rich-text formatting attributes (`{ bold: true, … }`). As an *update value* on `retain`/`modify` it is a
+ * unified tri-state (identical to {@link Attribution}): `undefined`/omitted = skip, `null` = clear all,
+ * `{k:v}` = set, `{k:null}` = remove key — see the delta `readme.md` "Formats & Attributions".
+ *
+ * ⚠️ **Blanket `null` clear is a local-only utility — never send it over a channel.** A `null` clear carries
+ * no key information, so it cannot be reconciled key-by-key under `rebase`: a clear *always wins* a concurrent
+ * edit (priority-independent — that is what makes it converge), which silently DROPS the other side's set. For
+ * collaborative / transmitted data, clear keys individually with `{k:null}` removals instead — those reconcile
+ * by priority and converge without data loss (this is what {@link diff} emits and what the rebase fuzz uses).
+ *
+ * @typedef {{ [key: string]: any }} Formats
  */
 /**
  * @typedef {{ id: string, key: number|string, assoc: 1|-1, attrs?: object }} MarkJSON
@@ -29,10 +52,10 @@ export const $attribution: s.Schema<Attribution>;
  * }} DeltaJSON
  */
 /**
- * @typedef {{ type: 'insert', insert: string|Array<any>, format?: { [key: string]: any }, attribution?: Attribution } | { delete: number } | { type: 'retain', retain: number, format?: { [key:string]: any }, attribution?: Attribution } | { type: 'modify', value: object }} DeltaListOpJSON
+ * @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 }} DeltaAttrOpJSON
+ * @typedef {{ type: 'insert', value: any, prevValue?: any, attribution?: Attribution } | { type: 'delete', prevValue?: any, attribution?: Attribution } | { type: 'modify', value: DeltaJSON, attribution?: Attribution|null }} DeltaAttrOpJSON
  */
 /**
  * @typedef {TextOp|InsertOp<any>|DeleteOp|RetainOp|ModifyOp<any>} ChildrenOpAny
@@ -68,10 +91,10 @@ export const $deltaMapChangeJson: s.Schema<DeltaAttrOpJSON>;
 export class TextOp extends list.ListNode {
     /**
      * @param {string} insert
-     * @param {FormattingAttributes|null} format
+     * @param {Formats|null} format
      * @param {Attribution?} attribution
      */
-    constructor(insert: string, format: FormattingAttributes | null, attribution: Attribution | null);
+    constructor(insert: string, format: Formats | null, attribution: Attribution | null);
     /**
      * @readonly
      * @type {string}
@@ -79,9 +102,9 @@ export class TextOp extends list.ListNode {
     readonly insert: string;
     /**
      * @readonly
-     * @type {FormattingAttributes|null}
+     * @type {Formats|null}
      */
-    readonly format: FormattingAttributes | null;
+    readonly format: Formats | null;
     attribution: Attribution | null;
     /**
      * @type {string?}
@@ -129,10 +152,10 @@ export class TextOp extends list.ListNode {
 export class InsertOp<ArrayContent extends unknown> extends list.ListNode {
     /**
      * @param {Array<ArrayContent>} insert
-     * @param {FormattingAttributes|null} format
+     * @param {Formats|null} format
      * @param {Attribution?} attribution
      */
-    constructor(insert: Array<ArrayContent>, format: FormattingAttributes | null, attribution: Attribution | null);
+    constructor(insert: Array<ArrayContent>, format: Formats | null, attribution: Attribution | null);
     /**
      * @readonly
      * @type {Array<ArrayContent>}
@@ -140,9 +163,9 @@ export class InsertOp<ArrayContent extends unknown> extends list.ListNode {
     readonly insert: Array<ArrayContent>;
     /**
      * @readonly
-     * @type {FormattingAttributes?}
+     * @type {Formats?}
      */
-    readonly format: FormattingAttributes | null;
+    readonly format: Formats | null;
     /**
      * @readonly
      * @type {Attribution?}
@@ -247,10 +270,10 @@ export class DeleteOp<Conf extends DeltaConf = {}> extends list.ListNode {
 export class RetainOp extends list.ListNode {
     /**
      * @param {number} retain
-     * @param {FormattingAttributes|null} format
-     * @param {Attribution?} attribution
+     * @param {Formats|null|undefined} format tri-state: `undefined` skip / `null` clear / object merge
+     * @param {Attribution|null|undefined} attribution tri-state: `undefined` skip / `null` clear / object merge
      */
-    constructor(retain: number, format: FormattingAttributes | null, attribution: Attribution | null);
+    constructor(retain: number, format: Formats | null | undefined, attribution: Attribution | null | undefined);
     /**
      * @readonly
      * @type {number}
@@ -258,14 +281,14 @@ export class RetainOp extends list.ListNode {
     readonly retain: number;
     /**
      * @readonly
-     * @type {FormattingAttributes?}
+     * @type {Formats|null|undefined}
      */
-    readonly format: FormattingAttributes | null;
+    readonly format: Formats | null | undefined;
     /**
      * @readonly
-     * @type {Attribution?}
+     * @type {Attribution|null|undefined}
      */
-    readonly attribution: Attribution | null;
+    readonly attribution: Attribution | null | undefined;
     /**
      * @type {string|null}
      */
@@ -310,10 +333,10 @@ export class RetainOp extends list.ListNode {
 export class ModifyOp<DTypes extends Delta = DeltaAny> extends list.ListNode {
     /**
      * @param {DTypes} delta
-     * @param {FormattingAttributes|null} format
-     * @param {Attribution?} attribution
+     * @param {Formats|null|undefined} format tri-state: `undefined` skip / `null` clear / object merge
+     * @param {Attribution|null|undefined} attribution tri-state: `undefined` skip / `null` clear / object merge
      */
-    constructor(delta: DTypes, format: FormattingAttributes | null, attribution: Attribution | null);
+    constructor(delta: DTypes, format: Formats | null | undefined, attribution: Attribution | null | undefined);
     /**
      * @readonly
      * @type {DTypes}
@@ -321,14 +344,14 @@ export class ModifyOp<DTypes extends Delta = DeltaAny> extends list.ListNode {
     readonly value: DTypes;
     /**
      * @readonly
-     * @type {FormattingAttributes?}
+     * @type {Formats|null|undefined}
      */
-    readonly format: FormattingAttributes | null;
+    readonly format: Formats | null | undefined;
     /**
      * @readonly
-     * @type {Attribution?}
+     * @type {Attribution|null|undefined}
      */
-    readonly attribution: Attribution | null;
+    readonly attribution: Attribution | null | undefined;
     /**
      * @type {string|null}
      */
@@ -491,8 +514,9 @@ export class ModifyAttrOp<Modifier extends DeltaAny = DeltaAny, K extends string
     /**
      * @param {K} key
      * @param {Modifier} delta
+     * @param {Attribution|null|undefined} attribution tri-state: `undefined` skip / `null` clear / object merge
      */
-    constructor(key: K, delta: Modifier);
+    constructor(key: K, delta: Modifier, attribution: Attribution | null | undefined);
     /**
      * @readonly
      * @type {K}
@@ -503,6 +527,11 @@ export class ModifyAttrOp<Modifier extends DeltaAny = DeltaAny, K extends string
      * @type {Modifier}
      */
     readonly value: Modifier;
+    /**
+     * @readonly
+     * @type {Attribution|null|undefined}
+     */
+    readonly attribution: Attribution | null | undefined;
     /**
      * @type {string|null}
      */
@@ -622,9 +651,9 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
      */
     constructor(name: string | null, $schema: s.Schema<Delta<Conf>> | null);
     /**
-     * @type {FormattingAttributes?}
+     * @type {Formats?}
      */
-    usedAttributes: FormattingAttributes | null;
+    usedFormats: Formats | null;
     /**
      * @type {Attribution?}
      */
@@ -634,15 +663,15 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
      */
     useAttribution(attribution: Attribution | null): this;
     /**
-     * @param {FormattingAttributes?} attributes
+     * @param {Formats?} attributes
      * @return {this}
      */
-    useAttributes(attributes: FormattingAttributes | null): this;
+    useFormats(attributes: Formats | null): this;
     /**
      * @param {string} name
      * @param {any} value
      */
-    updateUsedAttributes(name: string, value: any): this;
+    updateUsedFormats(name: string, value: any): this;
     /**
      * @template {keyof Attribution} NAME
      * @param {NAME} name
@@ -652,14 +681,14 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
     /**
      * @template {(FixedConf extends true ? never : (Array<any>|string)) | (DeltaConfGetChildren<Conf> extends infer Children ? (Children extends never ? never : Array<Children>) : never) | DeltaConfGetText<Conf>} NewContent
      * @param {NewContent} insert
-     * @param {FormattingAttributes?} [formatting]
+     * @param {Formats?} [formatting]
      * @param {Attribution?} [attribution]
      * @return {DeltaBuilder<FixedConf extends true ? Conf : DeltaConfOverwrite<Conf,
      * (Exclude<NewContent,string> extends never ? {} : {
      *   children: Exclude<NewContent,string>[number]|DeltaConfGetChildren<Conf>
      * }) & (Extract<NewContent,string> extends never ? {} : { text: true })>, FixedConf>}
      */
-    insert<NewContent extends (FixedConf extends true ? never : (Array<any> | string)) | (DeltaConfGetChildren<Conf> extends infer Children_1 ? (Children_1 extends never ? never : Array<Children_1>) : never) | DeltaConfGetText<Conf>>(insert: NewContent, formatting?: FormattingAttributes | null, attribution?: Attribution | null): DeltaBuilder<FixedConf extends true ? Conf : DeltaConfOverwrite<Conf, (Exclude<NewContent, string> extends never ? {} : {
+    insert<NewContent extends (FixedConf extends true ? never : (Array<any> | string)) | (DeltaConfGetChildren<Conf> extends infer Children_1 ? (Children_1 extends never ? never : Array<Children_1>) : never) | DeltaConfGetText<Conf>>(insert: NewContent, formatting?: Formats | null, attribution?: Attribution | null): DeltaBuilder<FixedConf extends true ? Conf : DeltaConfOverwrite<Conf, (Exclude<NewContent, string> extends never ? {} : {
         children: Exclude<NewContent, string>[number] | DeltaConfGetChildren<Conf>;
     }) & (Extract<NewContent, string> extends never ? {} : {
         text: true;
@@ -667,11 +696,11 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
     /**
      * @template {Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>,Delta|DeltaData<any,any,any,any>|DeltaBuilder>} NewContent
      * @param {NewContent} modify
-     * @param {FormattingAttributes?} formatting
-     * @param {Attribution?} attribution
+     * @param {Formats?} [formatting] tri-state: omit/`undefined` skip, `null` clear, `{k:v}`/`{k:null}` set/remove
+     * @param {Attribution?} [attribution] tri-state: omit/`undefined` skip, `null` clear, `{k:v}`/`{k:null}` set/remove
      * @return {DeltaBuilder<DeltaConfOverwrite<Conf, {children: DeltaConfGetChildren<Conf>|NewContent}>, FixedConf>}
      */
-    modify<NewContent extends Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>, Delta | DeltaData<any, any, any, any> | DeltaBuilder>>(modify: NewContent, formatting?: FormattingAttributes | null, attribution?: Attribution | null): DeltaBuilder<DeltaConfOverwrite<Conf, {
+    modify<NewContent extends Extract<DeltaConfGetAllowedChildren<Conf, FixedConf>, Delta | DeltaData<any, any, any, any> | DeltaBuilder>>(modify: NewContent, formatting?: Formats | null, attribution?: Attribution | null): DeltaBuilder<DeltaConfOverwrite<Conf, {
         children: DeltaConfGetChildren<Conf> | NewContent;
     }>, FixedConf>;
     /**
@@ -700,10 +729,10 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
     removeMark(pos: import("./position.js").Pos, id: string): this;
     /**
      * @param {number} len
-     * @param {FormattingAttributes?} [format]
+     * @param {Formats?} [format]
      * @param {Attribution?} [attribution]
      */
-    retain(len: number, format?: FormattingAttributes | null, attribution?: Attribution | null): this;
+    retain(len: number, format?: Formats | null, attribution?: Attribution | null): this;
     /**
      * @param {number} len
      * @param {DeltaBuilder<any>|null} prevValue
@@ -714,7 +743,7 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
      * @template {DeltaConfGetAllowedAttrs<Conf, FixedConf>[Key]} Val
      * @param {Key} key
      * @param {Val} val
-     * @param {Attribution?} attribution
+     * @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>}
      */
@@ -724,7 +753,7 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
     /**
      * @template {DeltaConfGetAllowedAttrs<Conf, FixedConf>} NewAttrs
      * @param {NewAttrs} attrs
-     * @param {Attribution?} attribution
+     * @param {Attribution?} [attribution] provenance applied to each set attr (data: object or `null`/none)
      * @return {DeltaBuilder<DeltaConfOverwrite<
      *   Conf,
      *   { attrs: MergeAttrs<DeltaConfGetAttrs<Conf>,NewAttrs> }
@@ -737,7 +766,7 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
     /**
      * @template {Extract<keyof DeltaConfGetAllowedAttrs<Conf, FixedConf>,string|number>} Key
      * @param {Key} key
-     * @param {Attribution?} attribution
+     * @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>
@@ -751,9 +780,10 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
      * @template {Extract<DeltaConfGetAllowedAttrs<Conf, FixedConf>[Key],DeltaAny>} D
      * @param {Key} key
      * @param {D} modify
+     * @param {Attribution?} [attribution] tri-state instruction merged onto the target attr op: omit/`undefined` skip, `null` clear, `{k:v}`/`{k:null}` set/remove
      * @return {DeltaBuilder<DeltaConfOverwrite<Conf,{attrs:AddToAttrs<DeltaConfGetAttrs<Conf>,Key,D>}>, FixedConf>}
      */
-    modifyAttr<Key extends DeltaConfGetAllowedAttrs<Conf, FixedConf> extends infer As ? { [K in keyof As]: Extract<As[K], DeltaAny> extends never ? never : K; }[keyof As] : never, D extends Extract<DeltaConfGetAllowedAttrs<Conf, FixedConf>[Key], DeltaAny>>(key: Key, modify: D): DeltaBuilder<DeltaConfOverwrite<Conf, {
+    modifyAttr<Key extends DeltaConfGetAllowedAttrs<Conf, FixedConf> extends infer As ? { [K in keyof As]: Extract<As[K], DeltaAny> extends never ? never : K; }[keyof As] : never, D extends Extract<DeltaConfGetAllowedAttrs<Conf, FixedConf>[Key], DeltaAny>>(key: Key, modify: D, attribution?: Attribution | null): DeltaBuilder<DeltaConfOverwrite<Conf, {
         attrs: AddToAttrs<DeltaConfGetAttrs<Conf>, Key, D>;
     }>, FixedConf>;
     /**
@@ -891,6 +921,7 @@ export function random<Conf_1 extends DeltaConf>(gen: prng.PRNG, $d: s.Schema<De
     source?: DeltaAny | null | undefined;
     minChildOps?: number | undefined;
     maxChildOps?: number | undefined;
+    attribution?: boolean | undefined;
 }): DeltaBuilder<Conf_1>;
 /**
  * @overload
@@ -1023,6 +1054,20 @@ export function diffChangesetWithSeparator(changeset: Array<{
     remove: Array<any>;
     insert: Array<any>;
 }>, separator: RegExp): any[];
+/**
+ * Provenance metadata on a content/attr op: *who/what* inserted, deleted, or formatted it. The canonical
+ * shape below is a convention — apply/diff/equality treat attribution as an **opaque** object (never branching
+ * on these field names), so custom keys flow through — with ONE exception: the nested `format` key merges per
+ * inner key (one level), so applying `{format:{italic:[…]}}` *adds* italic while keeping a pre-existing
+ * `{format:{bold:[…]}}`, and `{format:{bold:null}}` removes just that inner key (an emptied `format` is
+ * dropped). Every other key is flat/wholesale. The `format`/`formatAt` part exists only on
+ * children (content ops), never on node attribute ops. As an *update value* on `retain`/`modify`/`*Attr`,
+ * attribution uses the same unified tri-state as {@link Formats} (`undefined` skip / `null`
+ * clear / `{k:v}` set / `{k:null}` remove) — see the delta `readme.md` "Formats & Attributions". The blanket
+ * `null`-clear channel caveat on {@link Formats} applies here too; note `rebase` does not
+ * reconcile attribution at all (concurrent attribution edits don't converge), so prefer deterministic
+ * attribution assignment outside of concurrent editing.
+ */
 export type Attribution = {
     insert?: string[];
     insertAt?: number;
@@ -1031,7 +1076,18 @@ export type Attribution = {
     format?: Record<string, string[]>;
     formatAt?: number;
 };
-export type FormattingAttributes = {
+/**
+ * Rich-text formatting attributes (`{ bold: true, … }`). As an *update value* on `retain`/`modify` it is a
+ * unified tri-state (identical to {@link Attribution}): `undefined`/omitted = skip, `null` = clear all,
+ * `{k:v}` = set, `{k:null}` = remove key — see the delta `readme.md` "Formats & Attributions".
+ *
+ * ⚠️ **Blanket `null` clear is a local-only utility — never send it over a channel.** A `null` clear carries
+ * no key information, so it cannot be reconciled key-by-key under `rebase`: a clear *always wins* a concurrent
+ * edit (priority-independent — that is what makes it converge), which silently DROPS the other side's set. For
+ * collaborative / transmitted data, clear keys individually with `{k:null}` removals instead — those reconcile
+ * by priority and converge without data loss (this is what {@link diff} emits and what the rebase fuzz uses).
+ */
+export type Formats = {
     [key: string]: any;
 };
 export type MarkJSON = {
@@ -1062,11 +1118,15 @@ export type DeltaListOpJSON = {
     retain: number;
     format?: {
         [key: string]: any;
-    };
-    attribution?: Attribution;
+    } | null;
+    attribution?: Attribution | null;
 } | {
     type: "modify";
     value: object;
+    format?: {
+        [key: string]: any;
+    } | null;
+    attribution?: Attribution | null;
 };
 export type DeltaAttrOpJSON = {
     type: "insert";
@@ -1080,6 +1140,7 @@ export type DeltaAttrOpJSON = {
 } | {
     type: "modify";
     value: DeltaJSON;
+    attribution?: Attribution | null;
 };
 export type ChildrenOpAny = TextOp | InsertOp<any> | DeleteOp | RetainOp | ModifyOp<any>;
 export type AttrOpAny = SetAttrOp<any> | DeleteAttrOp<any> | ModifyAttrOp;

package/dist/delta/rdt/delta.d.ts

@@ -46,7 +46,7 @@ declare class DeltaRDT<D extends delta.DeltaAny> extends ObservableV2<{
      *
      * @return {D}
      */
-    toDelta(): D;
+    get delta(): D;
 }
 import { ObservableV2 } from '../../observable.js';
 import * as mux from '../../mutex.js';

package/dist/delta/rdt/dom.d.ts

@@ -83,7 +83,7 @@ declare class DomRDT<D extends DomDelta = DomDelta> extends ObservableV2<{
      *
      * @return {D}
      */
-    toDelta(): D;
+    get delta(): D;
 }
 import { ObservableV2 } from '../../observable.js';
 export {};

package/dist/delta/rdt.d.ts

@@ -1,4 +1,39 @@
 export { deltaRDT } from "./rdt/delta.js";
+/**
+ * @template T
+ * @typedef {import('../schema.js').Schema<T>} Schema
+ */
+/**
+ * Abstract interface for a delta-based Replicated Data Type.
+ *
+ * An RDT is an observable that emits a `'delta'` (and, on teardown, a `'destroy'`) event, exposes the
+ * {@link Schema schema} of the deltas it produces via `$delta` (so a {@link Binding} can initialize a
+ * transformer for it), exposes its current state as a delta via the `delta` getter, and accepts foreign
+ * deltas via `applyDelta`.
+ *
+ * `applyDelta(d)` applies `d` and then, if the change would violate the RDT's own invariants, applies
+ * a **fix** of its own (e.g. reversing part of `d`, or inserting missing content) and returns that fix
+ * — `null` when none was needed. The fix is a regular change on this RDT, so a {@link Binding} maps it
+ * onto the other side just like any other change. `applyDelta` also emits the *effective* change
+ * (`d` together with the fix) on the `'delta'` channel.
+ *
+ * @template {import('./delta.js').DeltaAny} D
+ * @typedef {import('../observable.js').ObservableV2<{ delta: (delta: D) => void, destroy: (rdt: RDT<D>) => void }> & {
+ *   $delta: Schema<D>,
+ *   delta: D,
+ *   applyDelta: (delta: D) => D | null,
+ *   destroy: () => void
+ * }} RDT
+ */
+/**
+ * Schema guard for any {@link RDT}. RDTs are **duck-typed** — they have several independent
+ * implementations (`deltaRDT`, `domRDT`, …) and no common constructor — so this matches by shape
+ * rather than by `instanceof`: an object exposing a `$delta` {@link Schema}, an `applyDelta` method,
+ * and the observable `on`/`destroy` channel. The (possibly expensive) `delta` getter is not invoked.
+ *
+ * @type {Schema<RDT<any>>}
+ */
+export const $rdt: Schema<RDT<any>>;
 /**
  * Connects two RDTs so that changes on either side are transformed and reflected on the other.
  *
@@ -41,8 +76,8 @@ export type Schema<T> = import("../schema.js").Schema<T>;
  *
  * An RDT is an observable that emits a `'delta'` (and, on teardown, a `'destroy'`) event, exposes the
  * {@link Schema schema} of the deltas it produces via `$delta` (so a {@link Binding} can initialize a
- * transformer for it), exposes its current state as a delta via `toDelta`, and accepts foreign deltas
- * via `applyDelta`.
+ * transformer for it), exposes its current state as a delta via the `delta` getter, and accepts foreign
+ * deltas via `applyDelta`.
  *
  * `applyDelta(d)` applies `d` and then, if the change would violate the RDT's own invariants, applies
  * a **fix** of its own (e.g. reversing part of `d`, or inserting missing content) and returns that fix
@@ -55,7 +90,7 @@ export type RDT<D extends import("./delta.js").DeltaAny> = import("../observable
     destroy: (rdt: RDT<D>) => void;
 }> & {
     $delta: Schema<D>;
-    toDelta: () => D;
+    delta: D;
     applyDelta: (delta: D) => D | null;
     destroy: () => void;
 };

package/dist/delta/transformer/attribution-to-format.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Stateless transformer (holds only its `conf`); a single shared instance per template suffices.
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class AttributionToFormatTransformer extends Transformer<any, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     * @param {Conf} conf
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>, conf: Conf);
+    conf: Conf;
+}
+/**
+ * Template for {@link AttributionToFormatTransformer}.
+ *
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, any>}
+ */
+export class AttributionToFormat<IN extends delta.DeltaConf = any> extends Template<IN, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+     * @param {Conf} conf
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>, conf: Conf);
+    /**
+     * @type {Conf}
+     */
+    conf: Conf;
+}
+export function attributionToFormat<IN extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>, conf: Conf): AttributionToFormat<IN>;
+/**
+ * Maps an attribution object to the format value placed under its namespaced key (or `null` to clear
+ * that key, `{}`/`undefined` to leave it unchanged).
+ */
+export type Handler = (attribution: import("../delta.js").Attribution) => any;
+/**
+ * Per-dimension handlers. Each fires when the op's attribution has a key with that dimension's prefix
+ * (`insert`/`insertAt` → `insert`, etc.); the whole attribution object is passed in. A missing handler
+ * means "do not render that dimension".
+ */
+export type Conf = {
+    insert?: Handler;
+    delete?: Handler;
+    format?: Handler;
+    attrs?: Handler;
+};
+import { Transformer } from './core.js';
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+//# sourceMappingURL=attribution-to-format.d.ts.map

package/dist/delta/transformer/full-attributions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Stateful transformer holding the accumulated attribution overlay.
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class FullAttributionsTransformer extends Transformer<any, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>);
+    /**
+     * Content-free overlay: the full accumulated attribution at every document position (instruction
+     * form). Mutated in place each change by `rebase` + `apply`.
+     *
+     * @type {delta.DeltaBuilderAny}
+     */
+    overlay: delta.DeltaBuilderAny;
+}
+/**
+ * Template for {@link FullAttributionsTransformer}. The transform touches only the `attribution`
+ * dimension (metadata, not part of the delta schema), so the output schema equals the input schema.
+ *
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, IN>}
+ */
+export class FullAttributions<IN extends delta.DeltaConf = any> extends Template<IN, IN> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>);
+}
+export function fullAttributions<IN extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>): FullAttributions<IN>;
+import { Transformer } from './core.js';
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+//# sourceMappingURL=full-attributions.d.ts.map

package/dist/delta/transformer.d.ts

@@ -9,4 +9,6 @@ export * from "./transformer/children.js";
 export * from "./transformer/project.js";
 export * from "./transformer/value.js";
 export * from "./transformer/rename-attrs.js";
+export * from "./transformer/attribution-to-format.js";
+export * from "./transformer/full-attributions.js";
 //# sourceMappingURL=transformer.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "1.0.0-rc.16",
+  "version": "1.0.0-rc.18",
   "description": "",
   "sideEffects": false,
   "type": "module",
@@ -106,6 +106,14 @@
       "types": "./dist/delta/transformer/rename-attrs.d.ts",
       "default": "./src/delta/transformer/rename-attrs.js"
     },
+    "./delta/transformer/attribution-to-format": {
+      "types": "./dist/delta/transformer/attribution-to-format.d.ts",
+      "default": "./src/delta/transformer/attribution-to-format.js"
+    },
+    "./delta/transformer/full-attributions": {
+      "types": "./dist/delta/transformer/full-attributions.d.ts",
+      "default": "./src/delta/transformer/full-attributions.js"
+    },
     "./delta/rdt": {
       "types": "./dist/delta/rdt.d.ts",
       "default": "./src/delta/rdt.js"

package/src/bin/0serve.js

@@ -13,7 +13,7 @@ import * as env from '../environment.js'
 import * as number from '../number.js'
 import * as logging from 'lib0/logging'
 
-const host = env.getParam('--host', 'localhost')
+const host = env.getParam('--host', '127.0.0.1')
 const port = number.parseInt(env.getParam('--port', '8000'))
 const paramOpenFile = env.getParam('-o', '')
 const debugBrowser = env.getConf('DEBUG_BROWSER')