lib0 1.0.0-rc.14 → 1.0.0-rc.15

package/dist/delta/binding.d.ts

@@ -3,104 +3,67 @@
  * @typedef {import('../schema.js').Schema<T>} Schema
  */
 /**
- * @template {delta.AbstractDelta} DeltaA
- * @template {delta.AbstractDelta} DeltaB
+ * 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 `$schema` (so a {@link Binding} can initialize a
+ * transformer for it), and accepts foreign deltas via `applyDelta`.
+ *
+ * @template {delta.DeltaAny} D
+ * @typedef {ObservableV2<{ delta: (delta: D) => void, destroy: (rdt: RDT<D>) => void }> & {
+ *   $schema: Schema<D>,
+ *   applyDelta: (delta: D) => void,
+ *   destroy: () => void
+ * }} RDT
  */
-export class Binding<DeltaA extends delta.AbstractDelta, DeltaB extends delta.AbstractDelta> {
+/**
+ * Connects two RDTs so that changes on either side are transformed and reflected on the other.
+ *
+ * @template {delta.DeltaAny} DeltaA
+ */
+export class Binding<DeltaA extends delta.DeltaAny> {
     /**
      * @param {RDT<DeltaA>} a
-     * @param {RDT<DeltaB>} b
-     * @param {dt.Template<any,DeltaA,DeltaB>} template
+     * @param {RDT<delta.DeltaAny>} b
+     * @param {dt.Template} [template] defaults to the {@link dt.id identity} transformer
+     */
+    constructor(a: RDT<DeltaA>, b: RDT<delta.DeltaAny>, template?: dt.Template);
+    /**
+     * @type {dt.Transformer<any,any>}
      */
-    constructor(a: RDT<DeltaA>, b: RDT<DeltaB>, template: dt.Template<any, DeltaA, DeltaB>);
+    t: dt.Transformer<any, any>;
     /**
-     * @type {dt.Transformer<any,DeltaA,DeltaB>}
+     * @type {RDT<any>}
      */
-    t: dt.Transformer<any, DeltaA, DeltaB>;
-    a: RDT<DeltaA>;
-    b: RDT<DeltaB>;
+    a: RDT<any>;
+    /**
+     * @type {RDT<any>}
+     */
+    b: RDT<any>;
     _mux: mux.mutex;
-    _achanged: (delta: DeltaA) => void;
-    _bchanged: (delta: DeltaB) => void;
+    _achanged: (delta: any) => void;
+    _bchanged: (delta: any) => void;
     destroy: () => void;
 }
-export function bind<DeltaA extends delta.AbstractDelta, Transformer extends dt.Template<any, DeltaA, any>>(a: RDT<DeltaA>, b: RDT<Transformer extends dt.Template<any, DeltaA, infer DeltaB> ? DeltaB : never>, template: dt.Template<any, DeltaA, any>): Binding<DeltaA, Transformer extends dt.Template<any, DeltaA, infer DeltaB> ? DeltaB : never>;
-export function deltaRDT<Delta extends delta.AbstractDelta>($delta: Schema<Delta>): DeltaRDT<Delta>;
-export const $domDelta: any;
-export function domRDT(dom: Element): DomRDT<delta.RecursiveNode<string, {
-    [key: string]: string;
-}, never, true>>;
+export function bind<DeltaA extends delta.DeltaAny>(a: RDT<DeltaA>, b: RDT<delta.DeltaAny>, template?: dt.Template): Binding<DeltaA>;
 export type Schema<T> = import("../schema.js").Schema<T>;
 /**
- * Abstract Interface for a delta-based Replicated Data Type.
+ * 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 `$schema` (so a {@link Binding} can initialize a
+ * transformer for it), and accepts foreign deltas via `applyDelta`.
  */
-export type RDT<Delta extends delta.AbstractDelta> = ObservableV2<{
-    "change": (delta: Delta) => void;
-    "destroy": (rdt: RDT<Delta>) => void;
+export type RDT<D extends delta.DeltaAny> = ObservableV2<{
+    delta: (delta: D) => void;
+    destroy: (rdt: RDT<D>) => void;
 }> & {
-    update: (delta: Delta) => any;
+    $schema: Schema<D>;
+    applyDelta: (delta: D) => void;
     destroy: () => void;
 };
-export type DomDelta = delta.RecursiveNode<string, {
-    [key: string]: string;
-}, never, true>;
 import * as delta from './delta.js';
+import * as dt from './transformer.js';
 import * as mux from '../mutex.js';
-/**
- * @template {delta.AbstractDelta} Delta
- * @implements RDT<Delta>
- * @extends {ObservableV2<{ change: (delta: Delta) => void, 'destroy': (rdt:DeltaRDT<Delta>)=>void }>}
- */
-declare class DeltaRDT<Delta extends delta.AbstractDelta> extends ObservableV2<{
-    change: (delta: Delta) => void;
-    destroy: (rdt: DeltaRDT<Delta>) => void;
-}> implements RDT<Delta> {
-    /**
-     * @param {Schema<Delta>} $delta
-     */
-    constructor($delta: Schema<Delta>);
-    $delta: s.Schema<Delta>;
-    /**
-     * @type {Delta?}
-     */
-    state: Delta | null;
-    _mux: mux.mutex;
-    /**
-     * @param {Delta} delta
-     */
-    update: (delta: Delta) => any;
-}
-/**
- * @typedef {delta.RecursiveNode<string, { [key:string]: string }, never, true>} DomDelta
- */
-/**
- * @template {DomDelta} [D=DomDelta]
- * @implements RDT<D>
- * @extends {ObservableV2<{ change: (delta: D)=>void, destroy: (rdt:DomRDT<D>)=>void }>}>}
- */
-declare class DomRDT<D extends DomDelta = delta.RecursiveNode<string, {
-    [key: string]: string;
-}, never, true>> extends ObservableV2<{
-    change: (delta: D) => void;
-    destroy: (rdt: DomRDT<D>) => void;
-}> implements RDT<D> {
-    /**
-     * @param {Element} observedNode
-     */
-    constructor(observedNode: Element);
-    observedNode: Element;
-    _mux: mux.mutex;
-    observer: MutationObserver;
-    /**
-     * @param {MutationRecord[]} mutations
-     */
-    _mutationHandler: (mutations: MutationRecord[]) => any;
-    /**
-     * @param {D} delta
-     */
-    update: (delta: D) => void;
-}
 import { ObservableV2 } from '../observable.js';
-import * as s from '../schema.js';
-export {};
 //# sourceMappingURL=binding.d.ts.map

package/dist/delta/delta.d.ts

@@ -818,8 +818,7 @@ export function create<Schema extends s.Schema<DeltaAny>>(schema: Schema): Schem
  * @param {NodeName} nodeName
  * @param {Attrs} attrs
  * @param {Children} [children]
- * @return {DeltaBuilder<{
- *   name: NodeName,
+ * @return {DeltaBuilder<(NodeName extends string ? { name: NodeName } : {}) & {
  *   attrs: Attrs extends null ? {} : Attrs,
  *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
  *   text: Extract<Children,string> extends never ? false : true
@@ -827,8 +826,9 @@ export function create<Schema extends s.Schema<DeltaAny>>(schema: Schema): Schem
  */
 export function create<NodeName extends string | null, Attrs extends {
     [k: string | number]: any;
-} | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, children?: Children | undefined): DeltaBuilder<{
+} | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, children?: Children | undefined): DeltaBuilder<(NodeName extends string ? {
     name: NodeName;
+} : {}) & {
     attrs: Attrs extends null ? {} : Attrs;
     children: Extract<Children, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never;
     text: Extract<Children, string> extends never ? false : true;
@@ -839,14 +839,14 @@ export function create<NodeName extends string | null, Attrs extends {
  * @overload
  * @param {NodeName} nodeName
  * @param {...Array<Children>} children
- * @return {DeltaBuilder<{
- *   name: NodeName,
+ * @return {DeltaBuilder<(NodeName extends string ? { name: NodeName } : {}) & {
  *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
  *   text: Extract<Children,string> extends never ? false : true
  * }>}
  */
-export function from<NodeName extends string | null, Children extends Array<any> | string = never>(nodeName: NodeName, ...children: Array<Children>[]): DeltaBuilder<{
+export function from<NodeName extends string | null, Children extends Array<any> | string = never>(nodeName: NodeName, ...children: Array<Children>[]): DeltaBuilder<(NodeName extends string ? {
     name: NodeName;
+} : {}) & {
     children: Extract<Children, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never;
     text: Extract<Children, string> extends never ? false : true;
 }>;
@@ -890,8 +890,7 @@ export function from<Attrs extends {
  * @param {NodeName} nodeName
  * @param {Attrs} attrs
  * @param {...Array<Children>} children
- * @return {DeltaBuilder<{
- *   name: NodeName,
+ * @return {DeltaBuilder<(NodeName extends string ? { name: NodeName } : {}) & {
  *   attrs: Attrs extends null ? {} : Attrs,
  *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
  *   text: Extract<Children,string> extends never ? false : true
@@ -899,13 +898,14 @@ export function from<Attrs extends {
  */
 export function from<NodeName extends string | null, Attrs extends {
     [k: string | number]: any;
-} | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, ...children: Array<Children>[]): DeltaBuilder<{
+} | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, ...children: Array<Children>[]): DeltaBuilder<(NodeName extends string ? {
     name: NodeName;
+} : {}) & {
     attrs: Attrs extends null ? {} : Attrs;
     children: Extract<Children, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never;
     text: Extract<Children, string> extends never ? false : true;
 }>;
-export function diff<Conf_1 extends DeltaConf>(d1: Delta<Conf_1>, d2: NoInfer<Delta<Conf_1>>): Delta<Conf_1>;
+export function diff<Conf_1 extends DeltaConf>(d1: Delta<Conf_1>, d2: NoInfer<Delta<Conf_1>>, options?: DiffOptions): Delta<Conf_1>;
 export function diffChangesetWithSeparator(changeset: Array<{
     index: number;
     remove: Array<any>;
@@ -979,6 +979,13 @@ export type DeltaConf = {
     recursiveChildren?: boolean | undefined;
     recursiveAttrs?: boolean | undefined;
 };
+/**
+ * Coerce a computed conf to provably satisfy the `DeltaConf` constraint. Declaration emit re-checks
+ * type arguments eagerly, so a deeply-computed conf (mapped/recursive) passed to `Delta<…>` /
+ * `Transformer<…>` must be wrapped here: the conditional exposes `DeltaConf` as its upper bound,
+ * letting the constraint resolve without forcing TS to expand the (self-referential) body.
+ */
+export type AsDeltaConf<T> = T extends infer DC extends DeltaConf ? DC : never;
 export type DeltaConfGetName<Conf_1 extends DeltaConf> = Conf_1 extends {
     name: infer Name;
 } ? (unknown extends Name ? any : (Exclude<Name, undefined>)) : any;
@@ -1034,7 +1041,7 @@ export type ReadDeltaConf<DConfSpec extends ReadableDeltaConf> = [DConfSpec exte
     attrs: infer A;
 } ? s.ReadSchemaUnwrapped<A> : {}, DConfSpec extends {
     children: infer C;
-} ? s.ReadSchemaUnwrapped<C> : never] extends [infer NodeName_1, infer Attrs_1, infer Children_1] ? PrettifyDeltaConf<(import("../ts.js").TypeIsAny<NodeName_1, {}, {
+} ? s.ReadSchemaUnwrapped<C> : never] extends [infer NodeName_1, infer Attrs_1, infer Children_1] ? AsDeltaConf<PrettifyDeltaConf<(import("../ts.js").TypeIsAny<NodeName_1, {}, {
     name: NodeName_1;
 }> & ([keyof Attrs_1] extends [never] ? {} : {
     attrs: Attrs_1;
@@ -1048,7 +1055,15 @@ export type ReadDeltaConf<DConfSpec extends ReadableDeltaConf> = [DConfSpec exte
     recursiveChildren: true;
 } ? {
     recursiveChildren: true;
-} : {})) extends infer DC extends DeltaConf ? DC : never> : never;
+} : {}))>> : never;
+export type DiffOptions = {
+    /**
+     * Predicate deciding when two nodes
+     * are paired into a `modify` (vs. replaced wholesale). Defaults to comparing names
+     * (`(d1, d2) => d1.name === d2.name`). Called as `compare(fromNode, toNode)`.
+     */
+    compare?: ((d1: DeltaAny, d2: DeltaAny) => boolean) | undefined;
+};
 import * as s from '../schema.js';
 import * as list from '../list.js';
 import * as equalityTrait from '../trait/equality.js';
@@ -1079,6 +1094,15 @@ import * as fingerprintTrait from '../trait/fingerprint.js';
  * @property {boolean} [DeltaConf.recursiveChildren=false]
  * @property {boolean} [DeltaConf.recursiveAttrs=false]
  */
+/**
+ * Coerce a computed conf to provably satisfy the `DeltaConf` constraint. Declaration emit re-checks
+ * type arguments eagerly, so a deeply-computed conf (mapped/recursive) passed to `Delta<…>` /
+ * `Transformer<…>` must be wrapped here: the conditional exposes `DeltaConf` as its upper bound,
+ * letting the constraint resolve without forcing TS to expand the (self-referential) body.
+ *
+ * @template T
+ * @typedef {T extends infer DC extends DeltaConf ? DC : never} AsDeltaConf
+ */
 /**
  * @template {DeltaConf} Conf
  * @typedef {Conf extends {name:infer Name} ? (unknown extends Name ? any : (Exclude<Name,undefined>)) : any} DeltaConfGetName

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

@@ -0,0 +1,45 @@
+export function deltaRDT<D extends delta.DeltaAny>($schema: Schema<D>): DeltaRDT<D>;
+export type Schema<T> = import("../../schema.js").Schema<T>;
+export type RDT<D extends delta.DeltaAny> = import("../binding.js").RDT<D>;
+import * as delta from '../delta.js';
+/**
+ * @template T
+ * @typedef {import('../../schema.js').Schema<T>} Schema
+ */
+/**
+ * @template {delta.DeltaAny} D
+ * @typedef {import('../binding.js').RDT<D>} 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.DeltaAny} D
+ * @implements {RDT<D>}
+ * @extends {ObservableV2<{ delta: (delta: D) => void, destroy: (rdt: DeltaRDT<D>) => void }>}
+ */
+declare class DeltaRDT<D extends delta.DeltaAny> extends ObservableV2<{
+    delta: (delta: D) => void;
+    destroy: (rdt: DeltaRDT<D>) => void;
+}> implements RDT<D> {
+    /**
+     * @param {Schema<D>} $schema schema of the deltas this RDT produces
+     */
+    constructor($schema: Schema<D>);
+    $schema: import("../../schema.js").Schema<D>;
+    /**
+     * @type {delta.DeltaBuilderAny?}
+     */
+    state: delta.DeltaBuilderAny | null;
+    _mux: mux.mutex;
+    /**
+     * Merge an incoming delta into the current state and notify observers.
+     *
+     * @param {D} d
+     */
+    applyDelta(d: D): void;
+}
+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,61 @@
+/**
+ * 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<DomDelta>;
+export type Schema<T> = import("../../schema.js").Schema<T>;
+export type RDT<D extends delta.DeltaAny> = import("../binding.js").RDT<D>;
+export type DomDelta = delta.Delta<{
+    name: string;
+    attrs: {
+        [key: string]: string;
+    };
+    text: true;
+    recursiveChildren: true;
+}>;
+import * as delta from '../delta.js';
+import * as s from '../../schema.js';
+/**
+ * An RDT backed by a live DOM subtree. DOM mutations observed via `MutationObserver` are emitted as
+ * deltas; incoming deltas are applied back onto the DOM.
+ *
+ * @template {DomDelta} [D=DomDelta]
+ * @implements {RDT<D>}
+ * @extends {ObservableV2<{ delta: (delta: D) => void, destroy: (rdt: DomRDT<D>) => void }>}
+ */
+declare class DomRDT<D extends DomDelta = DomDelta> extends ObservableV2<{
+    delta: (delta: D) => void;
+    destroy: (rdt: DomRDT<D>) => void;
+}> implements RDT<D> {
+    /**
+     * @param {Element} observedNode
+     */
+    constructor(observedNode: Element);
+    /**
+     * @type {Schema<D>}
+     */
+    $schema: Schema<D>;
+    observedNode: Element;
+    _mux: mux.mutex;
+    observer: MutationObserver;
+    /**
+     * @param {MutationRecord[]} mutations
+     */
+    _mutationHandler: (mutations: MutationRecord[]) => any;
+    /**
+     * @param {D} d
+     */
+    applyDelta(d: D): void;
+}
+import { ObservableV2 } from '../../observable.js';
+import * as mux from '../../mutex.js';
+export {};
+//# sourceMappingURL=dom.d.ts.map

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

@@ -0,0 +1,64 @@
+/**
+ * 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 {(d: delta.DeltaAny) => Template | null} handler picks the template for a child node, or
+     * `null` to leave that child untransformed. Evaluated once, when the child is inserted.
+     */
+    constructor(handler: (d: delta.DeltaAny) => Template | null);
+    handler: (d: 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;
+    /**
+     * @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}.
+ *
+ * @implements Template
+ */
+export class Children implements Template {
+    /**
+     * @param {(d: delta.DeltaAny) => Template | null} handler
+     */
+    constructor(handler: (d: delta.DeltaAny) => Template | null);
+    handler: (d: delta.DeltaAny) => Template | null;
+    get stateless(): boolean;
+    /**
+     * @template {delta.DeltaConf} IN
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} _$d
+     * @return {Transformer<IN, any>}
+     */
+    init<IN extends delta.DeltaConf>(_$d: import("../../schema.js").Schema<delta.Delta<IN>>): Transformer<IN, any>;
+}
+export function children(handler: (d: delta.DeltaAny) => Template | null): Children;
+export type Template = import("./core.js").Template;
+import { Transformer } from './core.js';
+import * as delta from '../delta.js';
+//# sourceMappingURL=children.d.ts.map

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

@@ -0,0 +1,69 @@
+export function $tresult<A extends delta.DeltaConf, B extends delta.DeltaConf>($a: s.Schema<delta.Delta<A>>, $b: s.Schema<delta.Delta<B>>): s.Schema<TransformResult<A, B>>;
+export function createTransformResult<DeltaA extends delta.DeltaBuilderAny = delta.DeltaBuilderAny, DeltaB extends delta.DeltaBuilderAny = delta.DeltaBuilderAny>(a: DeltaA | null, b: DeltaB | null): TransformResult<any, any>;
+/**
+ * @template {delta.DeltaConf} A
+ * @template {delta.DeltaConf} B
+ */
+export class Transformer<A extends delta.DeltaConf, B extends delta.DeltaConf> {
+    /**
+     * @param {TransformResult<A, B>} tin
+     * @return {TransformResult<A,B>}
+     */
+    apply(tin: TransformResult<A, B>): TransformResult<A, B>;
+    /**
+     * @param {delta.DeltaBuilder<A>} t
+     * @return {TransformResult<A,B>}
+     */
+    applyA(t: delta.DeltaBuilder<A>): TransformResult<A, B>;
+    /**
+     * @param {delta.DeltaBuilder<B>} t
+     * @return {TransformResult<A,B>}
+     */
+    applyB(t: delta.DeltaBuilder<B>): TransformResult<A, B>;
+}
+export function transformerWith<A extends delta.DeltaConf, B extends delta.DeltaConf>(_a: s.Schema<delta.Delta<A>> | A, _b: s.Schema<delta.Delta<B>> | A): s.Schema<Transformer<A, B>>;
+export const $transformer: s.Schema<Transformer<delta.DeltaConf, delta.DeltaConf>>;
+export type TransformResultAny = TransformResult<any, any>;
+/**
+ * A composable transformer factory. `init` instantiates a stateful {@link Transformer} for a given
+ * input schema; `stateless` reports whether the produced transformer carries no per-instance state
+ * (so it can be shared / cached).
+ */
+export type Template = {
+    stateless: boolean;
+    init: ($d: s.Schema<delta.DeltaAny>) => Transformer<any, any>;
+};
+import * as delta from '../delta.js';
+import * as s from '../../schema.js';
+/**
+ * @template {delta.DeltaConf} [A={}]
+ * @template {delta.DeltaConf} [B={}]
+ */
+declare class TransformResult<A extends delta.DeltaConf = {}, B extends delta.DeltaConf = {}> {
+    /**
+     * @param {delta.DeltaBuilder<A>?} a
+     * @param {delta.DeltaBuilder<B>?} b
+     */
+    constructor(a: delta.DeltaBuilder<A> | null, b: delta.DeltaBuilder<B> | null);
+    /**
+     * @type {delta.DeltaBuilder<A>?}
+     */
+    a: delta.DeltaBuilder<A> | null;
+    /**
+     * @type {delta.DeltaBuilder<B>?}
+     */
+    b: delta.DeltaBuilder<B> | null;
+    isEmpty(): boolean;
+    clear(): void;
+    /**
+     * @param {delta.DeltaBuilder<A>?} a
+     */
+    applyA(a: delta.DeltaBuilder<A> | null): this;
+    /**
+     * @param {delta.DeltaBuilder<B>?} b
+     */
+    applyB(b: delta.DeltaBuilder<B> | null): this;
+    reverse(): TransformResult<B, A>;
+}
+export {};
+//# sourceMappingURL=core.d.ts.map

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

@@ -0,0 +1,103 @@
+/**
+ * @typedef {import('./core.js').Template} Template
+ */
+/**
+ * @template {delta.DeltaConf} DConf
+ * @template {delta.DeltaConf} IN
+ * @typedef {delta.AsDeltaConf<{ [K in keyof DConf & keyof IN]: K extends 'attrs' ? import('../../ts.js').PropsPickShared<DConf[K], IN[K]> : (DConf[K] & IN[K])}>} ApplyExpectType
+ */
+/**
+ * Drops everything that does not match the configured schema (only attrs are filtered for now).
+ *
+ * @template {delta.DeltaConf} DConf
+ * @implements Template
+ */
+export class Filter<DConf extends delta.DeltaConf> implements Template {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<DConf>>} $d
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<DConf>>);
+    $d: delta.$Delta<delta.DeltaConf>;
+    $dshape: {
+        $name: s.Schema<any>;
+        $attrs: s.Schema<{}>;
+        $children: s.Schema<never>;
+        hasText: never;
+        recursiveChildren: false;
+        $formats: s.Schema<{
+            [K: string]: any;
+        }>;
+    };
+    get stateless(): boolean;
+    /**
+     * @template {delta.DeltaConf} IN
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} _$d
+     * @return {Transformer<IN,ApplyExpectType<DConf, IN>>}
+     */
+    init<IN extends delta.DeltaConf>(_$d: import("../../schema.js").Schema<delta.Delta<IN>>): Transformer<IN, ApplyExpectType<DConf, IN>>;
+}
+/**
+ * @template {delta.DeltaConf} IN
+ * @template {delta.DeltaConf} OUT
+ * @template {delta.DeltaConf} DConf
+ * @extends Transformer<IN,OUT>
+ */
+export class FilterTransformer<IN extends delta.DeltaConf, OUT extends delta.DeltaConf, DConf extends delta.DeltaConf> extends Transformer<IN, OUT> {
+    /**
+     * @param {delta.$Delta<DConf>} $d
+     */
+    constructor($d: delta.$Delta<DConf>);
+    $dshape: {
+        $name: s.Schema<delta.DeltaConfGetName<DConf>>;
+        $attrs: s.Schema<import("../../ts.js").TypeIsAny<DConf, {
+            [K: string]: any;
+            [K: number]: any;
+        }, DConf extends {
+            attrs: infer Attrs;
+        } ? Attrs extends undefined ? {} : Attrs : {}>>;
+        $children: s.Schema<delta.DeltaConfGetChildren<DConf>>;
+        hasText: delta.DeltaConfGetText<DConf>;
+        recursiveChildren: delta.DeltaConfGetRecursiveChildren<DConf>;
+        $formats: s.Schema<{
+            [K: string]: any;
+        }>;
+    };
+    filter: delta.DeltaBuilder<{
+        children: any;
+    }, true>;
+    /**
+     * @type {delta.DeltaAny}
+     */
+    dreversed: delta.DeltaAny;
+    /**
+     * @param {delta.DeltaBuilderAny} deltaA
+     */
+    applyA(deltaA: delta.DeltaBuilderAny): {
+        a: delta.DeltaBuilder<any, false> | null;
+        b: delta.DeltaBuilder<any, false> | null;
+        isEmpty(): boolean;
+        clear(): void;
+        applyA(a: delta.DeltaBuilder<any, false> | null): /*elided*/ any;
+        applyB(b: delta.DeltaBuilder<any, false> | null): /*elided*/ any;
+        reverse(): /*elided*/ any;
+    };
+    /**
+     * @param {delta.DeltaBuilderAny} deltaB
+     */
+    applyB(deltaB: delta.DeltaBuilderAny): {
+        a: delta.DeltaBuilder<any, false> | null;
+        b: delta.DeltaBuilder<any, false> | null;
+        isEmpty(): boolean;
+        clear(): void;
+        applyA(a: delta.DeltaBuilder<any, false> | null): /*elided*/ any;
+        applyB(b: delta.DeltaBuilder<any, false> | null): /*elided*/ any;
+        reverse(): /*elided*/ any;
+    };
+}
+export function filter<DConf extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<DConf>>): Filter<DConf>;
+export type Template = import("./core.js").Template;
+export type ApplyExpectType<DConf extends delta.DeltaConf, IN extends delta.DeltaConf> = delta.AsDeltaConf<{ [K in keyof DConf & keyof IN]: K extends "attrs" ? import("../../ts.js").PropsPickShared<DConf[K], IN[K]> : (DConf[K] & IN[K]); }>;
+import * as delta from '../delta.js';
+import * as s from '../../schema.js';
+import { Transformer } from './core.js';
+//# sourceMappingURL=filter.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * The identity {@link import('./core.js').Template Template}: it maps every change verbatim in both
+ * directions, so both sides stay bit-for-bit equal. A stateless singleton (an attr-rename with no
+ * renames).
+ *
+ * @type {import('./core.js').Template}
+ */
+export const id: import("./core.js").Template;
+//# sourceMappingURL=id.d.ts.map