lib0 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/delta/position.d.ts

@@ -0,0 +1,65 @@
+/**
+ * A single step of a {@link Pos} path: a `string` attribute key, or a `number` content index.
+ *
+ * @typedef {string|number} PosStep
+ */
+/**
+ * A location in a delta tree. `path` descends from the node the position is relative to and ends in
+ * the terminal (a trailing-number cursor gap, or a trailing-string attribute leaf). `assoc` is the
+ * gravity at a boundary: `-1` binds to the preceding content, `1` to the following content. `attrs` is
+ * optional immutable user data carried with the position (e.g. an RDT's clientID/user metadata); it is
+ * stored on the {@link import('./delta.js').createMark mark} when the position is written with
+ * {@link import('./delta.js').DeltaBuilder#addMark} and read back by {@link marksToPositions}.
+ *
+ * @typedef {{ path: Array<PosStep>, assoc: -1|1, attrs?: object|null }} Pos
+ */
+/**
+ * A {@link Pos} tagged with the unique id of a stored {@link import('./delta.js').createMark mark} —
+ * what {@link marksToPositions} returns (its `attrs` is the mark's stored metadata). Add marks with
+ * {@link import('./delta.js').DeltaBuilder#addMark}.
+ *
+ * @typedef {{ id: string } & Pos} MarkPos
+ */
+/**
+ * Schema for a {@link Pos}.
+ *
+ * @type {s.Schema<Pos>}
+ */
+export const $pos: s.Schema<Pos>;
+export function create(path: Array<PosStep>, assoc?: -1 | 1, attrs?: object | null): Pos;
+export function equals(a: Pos | MarkPos, b: Pos | MarkPos): boolean;
+/**
+ * Schema for a {@link MarkPos}.
+ *
+ * @type {s.Schema<MarkPos>}
+ */
+export const $markPos: s.Schema<MarkPos>;
+export function marksToPositions(d: delta.DeltaAny): Array<MarkPos>;
+/**
+ * A single step of a {@link Pos} path: a `string` attribute key, or a `number` content index.
+ */
+export type PosStep = string | number;
+/**
+ * A location in a delta tree. `path` descends from the node the position is relative to and ends in
+ * the terminal (a trailing-number cursor gap, or a trailing-string attribute leaf). `assoc` is the
+ * gravity at a boundary: `-1` binds to the preceding content, `1` to the following content. `attrs` is
+ * optional immutable user data carried with the position (e.g. an RDT's clientID/user metadata); it is
+ * stored on the {@link import ('./delta.js').createMark mark} when the position is written with
+ * {@link import ('./delta.js').DeltaBuilder#addMark} and read back by {@link marksToPositions}.
+ */
+export type Pos = {
+    path: Array<PosStep>;
+    assoc: -1 | 1;
+    attrs?: object | null;
+};
+/**
+ * A {@link Pos} tagged with the unique id of a stored {@link import ('./delta.js').createMark mark} —
+ * what {@link marksToPositions} returns (its `attrs` is the mark's stored metadata). Add marks with
+ * {@link import ('./delta.js').DeltaBuilder#addMark}.
+ */
+export type MarkPos = {
+    id: string;
+} & Pos;
+import * as s from '../schema.js';
+import * as delta from './delta.js';
+//# sourceMappingURL=position.d.ts.map

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

@@ -0,0 +1,57 @@
+export function deltaRDT<Conf extends delta.DeltaConf>($delta: Schema<delta.Delta<Conf>>): DeltaRDT<Conf>;
+export type Schema<T> = import("../../schema.js").Schema<T>;
+export type RDT<Conf extends delta.DeltaConf> = import("../rdt.js").RDT<Conf>;
+import * as delta from '../delta.js';
+/**
+ * @template T
+ * @typedef {import('../../schema.js').Schema<T>} Schema
+ */
+/**
+ * @template {delta.DeltaConf} Conf
+ * @typedef {import('../rdt.js').RDT<Conf>} RDT
+ */
+/**
+ * An in-memory RDT whose state is the accumulated delta. Calling `applyDelta` merges the incoming delta
+ * into `state` (via {@link delta.DeltaBuilder#apply}) and re-emits it as a `'delta'`.
+ *
+ * @template {delta.DeltaConf} Conf
+ * @implements {RDT<Conf>}
+ * @extends {ObservableV2<{ delta: (delta: delta.Delta<Conf>, origin: any) => void, destroy: (rdt: DeltaRDT<Conf>) => void }>}
+ */
+declare class DeltaRDT<Conf extends delta.DeltaConf> extends ObservableV2<{
+    delta: (delta: delta.Delta<Conf>, origin: any) => void;
+    destroy: (rdt: DeltaRDT<Conf>) => void;
+}> implements RDT<Conf> {
+    /**
+     * @param {Schema<delta.Delta<Conf>>} $delta schema of the deltas this RDT produces
+     */
+    constructor($delta: Schema<delta.Delta<Conf>>);
+    $delta: import("../../schema.js").Schema<delta.Delta<Conf>>;
+    /**
+     * @type {delta.DeltaBuilderAny?}
+     */
+    state: delta.DeltaBuilderAny | null;
+    _mux: mux.mutex;
+    /**
+     * Merge an incoming delta into the current state and notify observers. Always returns `null`: this
+     * RDT accepts every valid delta unchanged, so it never produces a fix.
+     *
+     * @param {delta.Delta<Conf>} d
+     * @param {any} [origin] who produced the change; forwarded verbatim on the emitted `'delta'` event so
+     * listeners can recognise (and skip) changes they made themselves — see {@link RDT} “Origins”. Defaults
+     * to `null` (an anonymous/local change).
+     * @return {null}
+     */
+    applyDelta(d: delta.Delta<Conf>, origin?: any): null;
+    /**
+     * The current state as a delta: the accumulated `state`, or an empty delta when nothing has been
+     * applied yet.
+     *
+     * @return {delta.Delta<Conf>}
+     */
+    get delta(): delta.Delta<Conf>;
+}
+import { ObservableV2 } from '../../observable.js';
+import * as mux from '../../mutex.js';
+export {};
+//# sourceMappingURL=delta.d.ts.map

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

@@ -0,0 +1,102 @@
+/**
+ * Schema describing the deltas produced/consumed by a {@link DomRDT}: a recursive node with a string
+ * name, string→string attributes, and text content.
+ */
+export const $domDelta: s.Schema<delta.Delta<{
+    name: string;
+    attrs: {
+        [x: string]: string;
+    };
+    text: true;
+    recursiveChildren: true;
+}>>;
+export function domRDT(dom: Element): DomRDT;
+export type Schema<T> = import("../../schema.js").Schema<T>;
+export type RDT<Conf extends delta.DeltaConf> = import("../rdt.js").RDT<Conf>;
+/**
+ * The {@link delta.DeltaConf} of the deltas a {@link DomRDT} produces/consumes (see {@link $domDelta}).
+ */
+export type DomConf = {
+    name: string;
+    attrs: {
+        [key: string]: string;
+    };
+    text: true;
+    recursiveChildren: true;
+};
+export type DomDelta = delta.Delta<DomConf>;
+import * as delta from '../delta.js';
+import * as s from '../../schema.js';
+/**
+ * The {@link delta.DeltaConf} of the deltas a {@link DomRDT} produces/consumes (see {@link $domDelta}).
+ *
+ * @typedef {{ name: string, attrs: { [key:string]: string }, text: true, recursiveChildren: true }} DomConf
+ */
+/**
+ * @typedef {delta.Delta<DomConf>} DomDelta
+ */
+/**
+ * An RDT backed by a live DOM subtree. DOM mutations observed via `MutationObserver` are diffed
+ * against the last-known state and emitted as deltas; incoming deltas are applied back onto the DOM.
+ *
+ * @implements {RDT<DomConf>}
+ * @extends {ObservableV2<{ delta: (delta: delta.Delta<DomConf>, origin: any) => void, destroy: (rdt: DomRDT) => void }>}
+ */
+declare class DomRDT extends ObservableV2<{
+    delta: (delta: delta.Delta<DomConf>, origin: any) => void;
+    destroy: (rdt: DomRDT) => void;
+}> implements RDT<DomConf> {
+    /**
+     * @param {Element} observedNode
+     */
+    constructor(observedNode: Element);
+    /**
+     * @type {Schema<DomDelta>}
+     */
+    $delta: Schema<DomDelta>;
+    observedNode: Element;
+    /**
+     * Last-known DOM state. The observe path diffs the live DOM against this to compute the change to
+     * emit, then advances it; `applyDelta` re-syncs it after mutating the DOM.
+     *
+     * @type {DomDelta}
+     */
+    _state: DomDelta;
+    observer: MutationObserver;
+    /**
+     * Pull the local DOM changes accumulated since the last sync as a delta (by diffing the live DOM
+     * against `_state`), advancing `_state` to the current DOM.
+     *
+     * @return {DomDelta}
+     */
+    _pull(): DomDelta;
+    /**
+     * @param {MutationRecord[]} mutations
+     */
+    _mutationHandler: (mutations: MutationRecord[]) => void;
+    /**
+     * Apply a foreign delta onto the DOM.
+     *
+     * The DOM may have been edited locally (`b`) since the last sync, concurrently with the incoming
+     * change (`d`). We pull `b` first and rebase the two against each other (OT) so neither is lost:
+     * `d` rebased onto `b` is applied to the DOM, and `b` rebased onto `d` is returned as the fix so the
+     * binding pipes it back through the transformer to the other side.
+     *
+     * @param {delta.Delta<DomConf>} d
+     * @param {any} [origin] who produced `d`; forwarded verbatim on the emitted `'delta'` event so
+     * listeners can recognise (and skip) their own changes — see {@link RDT} “Origins”. Defaults to `null`
+     * (an anonymous/local change).
+     * @return {delta.DeltaBuilder<DomConf> | null} the rebased local change (`b`), or `null` when there
+     * were no concurrent edits
+     */
+    applyDelta(d: delta.Delta<DomConf>, origin?: any): delta.DeltaBuilder<DomConf> | null;
+    /**
+     * The current state as a delta: an "insert everything" delta describing the observed subtree.
+     *
+     * @return {delta.Delta<DomConf>}
+     */
+    get delta(): delta.Delta<DomConf>;
+}
+import { ObservableV2 } from '../../observable.js';
+export {};
+//# sourceMappingURL=dom.d.ts.map

package/dist/delta/rdt.d.ts

@@ -0,0 +1,180 @@
+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, origin)` 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.
+ *
+ * ## Origins
+ *
+ * Every `'delta'` event carries a second argument, `origin` — an opaque `any` value (modelled after
+ * {@link https://docs.yjs.dev/api/transactions Yjs transaction origins}) that identifies **where the
+ * change came from**. Whoever produces the change sets it, and it is usually the producing instance
+ * itself: a communication provider, an editor binding, or the {@link Binding} that mapped the change
+ * over from the other side. A change an RDT observes locally (e.g. a `MutationObserver` firing on a DOM
+ * edit) uses that RDT itself as the origin.
+ *
+ * Origins let a listener tell **its own** changes apart from foreign ones so it can skip the ones it
+ * already knows about — a change it produced is not looped back to where it came from. The canonical use
+ * is a network provider: it tags every remote update it applies with itself (`rdt.applyDelta(update,
+ * this)`) and then ignores `'delta'` events whose `origin === this`, so it never re-broadcasts an update
+ * it just received. The `origin` argument to `applyDelta` is optional and defaults to `null` (an
+ * anonymous/local change); the emitted event always carries whatever value was supplied.
+ *
+ * ## `Delta` vs `DeltaBuilder`
+ *
+ * The interface is parameterized by a {@link import('./delta.js').DeltaConf DeltaConf} (like a
+ * {@link import('./transformer.js').Transformer transformer}). Almost everything it exposes is the
+ * *read* form — {@link import('./delta.js').Delta Delta} — because those values are **shared** and must
+ * not be mutated in place: `$delta` is the delta schema, the `delta` getter returns a state snapshot,
+ * `applyDelta` reads a change into the RDT, and the `'delta'` event payload is broadcast to every
+ * listener. The one *owned, mutable* form — {@link import('./delta.js').DeltaBuilder DeltaBuilder} — is
+ * the fix `applyDelta` returns to the {@link Binding}. The binding never mutates a shared read delta: it
+ * {@link import('./delta.js').cloneDeep deep-clones} every change into a private builder before the
+ * transformer rebases it (transformers manipulate deltas in place — see {@link Binding}).
+ *
+ * @template {import('./delta.js').DeltaConf} Conf
+ * @typedef {import('../observable.js').ObservableV2<{ delta: (delta: delta.Delta<Conf>, origin: any) => void, destroy: (rdt: RDT<Conf>) => void }> & {
+ *   $delta: Schema<delta.Delta<Conf>>,
+ *   delta: delta.Delta<Conf>,
+ *   applyDelta: (delta: delta.Delta<Conf>, origin?: any) => delta.DeltaBuilder<Conf> | 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>>;
+/**
+ * @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.
+ *
+ * The {@link dt.Transformer transformer} it drives **manipulates deltas in place** (it splices op lists
+ * and rebases nodes directly, rather than only via `apply`/`rebase`) — a deliberate exception to the
+ * general rule that deltas are edited through `apply`/`rebase`. Consequently every change handed to it
+ * must be a privately-owned, fully-mutable delta, so the binding {@link delta.cloneDeep deep-clones}
+ * each incoming change (which is a shared read delta — an event payload or a snapshot) before the
+ * transformer touches it. See the initial-state sync below and {@link propagate}.
+ *
+ * @template {delta.DeltaConf} A
+ * @template {delta.DeltaConf} B
+ */
+export class Binding<A extends delta.DeltaConf, B extends delta.DeltaConf> {
+    /**
+     * @param {RDT<A>} a
+     * @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>, options?: BindOptions);
+    /**
+     * @type {dt.Transformer<A,B>}
+     */
+    t: dt.Transformer<A, B>;
+    /**
+     * @type {RDT<A>}
+     */
+    a: RDT<A>;
+    /**
+     * @type {RDT<B>}
+     */
+    b: RDT<B>;
+    _mux: mux.mutex;
+    _achanged: (delta: delta.Delta<A>, origin: any) => void;
+    _bchanged: (delta: delta.Delta<B>, origin: any) => void;
+    /**
+     * Tear the binding down: unsubscribe both sides' `'delta'` and `'destroy'` listeners so changes are no
+     * longer propagated. Call this when you no longer need the two RDTs kept in sync. It is also invoked
+     * automatically when either bound RDT emits `'destroy'`. The RDTs themselves are NOT destroyed.
+     */
+    destroy: () => void;
+}
+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.
+ *
+ * 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, origin)` 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.
+ *
+ * ## Origins
+ *
+ * Every `'delta'` event carries a second argument, `origin` — an opaque `any` value (modelled after
+ * {@link https://docs.yjs.dev/api/transactions Yjs transaction origins}) that identifies **where the
+ * change came from**. Whoever produces the change sets it, and it is usually the producing instance
+ * itself: a communication provider, an editor binding, or the {@link Binding} that mapped the change
+ * over from the other side. A change an RDT observes locally (e.g. a `MutationObserver` firing on a DOM
+ * edit) uses that RDT itself as the origin.
+ *
+ * Origins let a listener tell **its own** changes apart from foreign ones so it can skip the ones it
+ * already knows about — a change it produced is not looped back to where it came from. The canonical use
+ * is a network provider: it tags every remote update it applies with itself (`rdt.applyDelta(update,
+ * this)`) and then ignores `'delta'` events whose `origin === this`, so it never re-broadcasts an update
+ * it just received. The `origin` argument to `applyDelta` is optional and defaults to `null` (an
+ * anonymous/local change); the emitted event always carries whatever value was supplied.
+ *
+ * ## `Delta` vs `DeltaBuilder`
+ *
+ * The interface is parameterized by a {@link import ('./delta.js').DeltaConf DeltaConf} (like a
+ * {@link import ('./transformer.js').Transformer transformer}). Almost everything it exposes is the
+ * *read* form — {@link import ('./delta.js').Delta Delta} — because those values are **shared** and must
+ * not be mutated in place: `$delta` is the delta schema, the `delta` getter returns a state snapshot,
+ * `applyDelta` reads a change into the RDT, and the `'delta'` event payload is broadcast to every
+ * listener. The one *owned, mutable* form — {@link import ('./delta.js').DeltaBuilder DeltaBuilder} — is
+ * the fix `applyDelta` returns to the {@link Binding}. The binding never mutates a shared read delta: it
+ * {@link import ('./delta.js').cloneDeep deep-clones} every change into a private builder before the
+ * transformer rebases it (transformers manipulate deltas in place — see {@link Binding}).
+ */
+export type RDT<Conf extends import("./delta.js").DeltaConf> = import("../observable.js").ObservableV2<{
+    delta: (delta: delta.Delta<Conf>, origin: any) => void;
+    destroy: (rdt: RDT<Conf>) => void;
+}> & {
+    $delta: Schema<delta.Delta<Conf>>;
+    delta: delta.Delta<Conf>;
+    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';
+export { $domDelta, domRDT } from "./rdt/dom.js";
+//# sourceMappingURL=rdt.d.ts.map

package/dist/delta/transformer/attr.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Projects a single node attribute into a `lib0:value` node's `value` attribute (and back).
+ *
+ * @template {string} AttrName
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, ApplyAttr<AttrName, IN>>}
+ */
+export class Attr<AttrName extends string, IN extends delta.DeltaConf = any> extends Template<IN, {
+    name: "lib0:value";
+    attrs: {
+        value: delta._SanifyDelta<IN extends {
+            attrs: { [K in AttrName]: infer V; };
+        } ? V : never>;
+    };
+}> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+     * @param {AttrName} attrName
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>, attrName: AttrName);
+    attrName: AttrName;
+}
+/**
+ * @template {delta.DeltaConf} A
+ * @template {delta.DeltaConf} B
+ * @extends {Transformer<A,B>}
+ */
+export class AttrTransformer<A extends delta.DeltaConf, B extends delta.DeltaConf> extends Transformer<A, B> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     * @param {string} attrName
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>, attrName: string);
+    attrName: keyof import("../../ts.js").TypeIsAny<A, {
+        [K: string]: any;
+        [K: number]: any;
+    }, A extends {
+        attrs: infer Attrs;
+    } ? Attrs extends undefined ? {} : Attrs : {}> & (string | number);
+    /**
+     * @param {delta.DeltaBuilder<A>} d
+     * @return {import('./core.js').TransformResultAny}
+     */
+    applyA(d: delta.DeltaBuilder<A>): import("./core.js").TransformResultAny;
+    /**
+     * @param {delta.DeltaBuilder<B>} d
+     * @return {import('./core.js').TransformResultAny}
+     */
+    applyB(d: delta.DeltaBuilder<B>): import("./core.js").TransformResultAny;
+}
+export function attr<AttrName extends string, IN extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>, attrName: AttrName): Attr<AttrName, IN>;
+export type ApplyAttr<AttrName extends string, IN extends delta.DeltaConf> = import("./core.js").ResolveOut<{
+    name: "lib0:value";
+    attrs: {
+        value: IN extends {
+            attrs: { [K in AttrName]: infer V; };
+        } ? V : never;
+    };
+}>;
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+import { Transformer } from './core.js';
+//# sourceMappingURL=attr.d.ts.map

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/children.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Stateful transformer that descends one level into a node's child *nodes* and applies a per-child
+ * sub-transformer, chosen by `handler`. Attributes and text pass through untouched. Designed to be
+ * applied recursively (see {@link children}).
+ *
+ * The per-child sub-transformer instances are kept in {@link ChildrenTransformer#childTs}, positionally
+ * aligned to the parent's child list (children carry no stable id - identity is positional). `children`
+ * never changes the child count at its own level, so side A and side B stay aligned position-for-
+ * position and the same `childTs` indexes both directions.
+ *
+ * `childTs` is a sparse positional map kept as a delta: each transformed child is an `insert([t])` op
+ * holding its sub-transformer; every other position (text runs, opted-out nodes) is a coalesced
+ * `retain(n)` gap. A run of N text characters costs one retain op, not N array slots. It is walked with
+ * a forward cursor in step with the change (see {@link ChildrenTransformer#transform}). Transformer
+ * instances are carried by reference across rebuilds, so their per-instance state survives.
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class ChildrenTransformer extends Transformer<any, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     * @param {(child: delta.DeltaAny, $child: import('../../schema.js').Schema<delta.DeltaAny>) => Template | null} handler
+     * picks the (schema-bound) template for a child node, or `null` to leave it untransformed. Evaluated
+     * once, when the child is inserted, with the derived per-child schema.
+     * @param {import('../../schema.js').Schema<delta.DeltaAny>} childSchema per-child-node schema each
+     * sub-template is built against (derived from the parent's input schema; `$deltaAny` when not derivable).
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>, handler: (child: delta.DeltaAny, $child: import("../../schema.js").Schema<delta.DeltaAny>) => Template | null, childSchema: import("../../schema.js").Schema<delta.DeltaAny>);
+    handler: (child: delta.DeltaAny, $child: import("../../schema.js").Schema<delta.DeltaAny>) => Template | null;
+    /**
+     * Sparse positional map of sub-transformers: `insert([t])` at each transformed child, `retain(n)`
+     * over gaps (text and opted-out nodes).
+     *
+     * @type {delta.DeltaBuilderAny}
+     */
+    childTs: delta.DeltaBuilderAny;
+    childSchema: import("../../schema.js").Schema<delta.DeltaAny>;
+    /**
+     * @param {delta.DeltaBuilderAny} d the change to map
+     * @param {boolean} fwd `true` maps side A -> B (applying sub-transformers' `applyA`), `false` maps
+     * side B -> A. `children` is 1:1 over children, so the same `childTs` indexes both directions.
+     * @return {import('./core.js').TransformResultAny}
+     */
+    transform(d: delta.DeltaBuilderAny, fwd: boolean): import("./core.js").TransformResultAny;
+}
+/**
+ * Template for {@link ChildrenTransformer}.
+ *
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, any>}
+ */
+export class Children<IN extends delta.DeltaConf = any> extends Template<IN, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+     * @param {(child: delta.DeltaAny, $child: import('../../schema.js').Schema<delta.DeltaAny>) => Template | null} handler
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>, handler: (child: delta.DeltaAny, $child: import("../../schema.js").Schema<delta.DeltaAny>) => Template | null);
+    handler: (child: delta.DeltaAny, $child: import("../../schema.js").Schema<delta.DeltaAny>) => Template | null;
+    /**
+     * @type {import('../../schema.js').Schema<delta.DeltaAny>}
+     */
+    childSchema: import("../../schema.js").Schema<delta.DeltaAny>;
+}
+export function children<IN extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>, handler: (child: delta.DeltaAny, $child: import("../../schema.js").Schema<delta.DeltaAny>) => Template | null): Children<IN>;
+import { Transformer } from './core.js';
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+//# sourceMappingURL=children.d.ts.map