@opendaw/lib-box 0.0.6

package/README.md

@@ -0,0 +1 @@
+This package is part of the openDAW SDK

package/dist/address.d.ts

@@ -0,0 +1,47 @@
+import { Comparable, Comparator, DataInput, DataOutput, Func, int, Nullable, SortedSet, UUID } from "@opendaw/lib-std";
+import { FieldKey, FieldKeys } from "./field";
+export type AddressLayout = [UUID.Format, FieldKeys];
+export type AddressJSON = {
+    uuid: Array<int>;
+    fields: Array<int>;
+};
+export declare class Address implements Comparable<Address> {
+    #private;
+    static newSet<T>(keyExtractor: Func<T, Address>): SortedSet<Address, T>;
+    static readonly compose: (uuid: UUID.Format, ...fieldKeys: FieldKey[]) => Address;
+    static decode(str: string): Address;
+    static reconstruct(layout: AddressLayout): Address;
+    static boxRange<T>(set: SortedSet<Address, T>, id: UUID.Format, map: Func<T, UUID.Format>): Nullable<[int, int]>;
+    static readonly Comparator: Comparator<Address>;
+    static readonly MinimalComparator: Comparator<Address>;
+    static readonly LengthComparator: Comparator<Address>;
+    constructor(uuid: UUID.Format, fieldKeys: FieldKeys);
+    get uuid(): UUID.Format;
+    get fieldKeys(): FieldKeys;
+    isBox(): boolean;
+    isContent(): boolean;
+    equals(other: Address): boolean;
+    compareTo(other: Address): int;
+    append(key: FieldKey): Address;
+    startsWith(other: Address): boolean;
+    write(output: DataOutput): void;
+    decompose(): AddressLayout;
+    toJSON(): {
+        uuid: number[];
+        fields: number[];
+    };
+    toArrayBuffer(): ArrayBufferLike;
+    toString(): string;
+    static read(input: DataInput): Address;
+}
+export interface Addressable {
+    get address(): Address;
+}
+export declare namespace Addressable {
+    const AddressReader: (addressable: Addressable) => Address;
+    const Comparator: Comparator<Addressable>;
+    const equals: <A extends Addressable>(address: Address, sorted: ReadonlyArray<A>) => Array<A>;
+    const startsWith: <A extends Addressable>(address: Address, sorted: ReadonlyArray<A>) => Array<A>;
+    const endsWith: <A extends Addressable>(address: Address, sorted: ReadonlyArray<A>) => Array<A>;
+}
+//# sourceMappingURL=address.d.ts.map

package/dist/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../src/address.ts"],"names":[],"mappings":"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"}

package/dist/address.js

@@ -0,0 +1,133 @@
+import { Arrays, assert, BinarySearch, SortedSet, UUID } from "@opendaw/lib-std";
+export class Address {
+    static newSet(keyExtractor) {
+        return new SortedSet(keyExtractor, Address.Comparator);
+    }
+    static compose = (uuid, ...fieldKeys) => {
+        const keys = fieldKeys.length === 0 ? this.#EMPTY_FIELD_KEYS : new Int16Array(fieldKeys);
+        assert(keys.every((value, index) => value === fieldKeys[index]), `fieldKeys (${keys.join(",")}) only allows i16`);
+        return new Address(uuid, keys);
+    };
+    static decode(str) {
+        const parts = str.split("/");
+        assert(parts.length > 0, "Unable to parse Address");
+        return Address.compose(UUID.parse(parts[0]), ...parts.slice(1).map(x => parseInt(x)));
+    }
+    static reconstruct(layout) { return this.compose(layout[0], ...layout[1]); }
+    static boxRange(set, id, map) {
+        const sorted = set.values();
+        const startIndex = BinarySearch.leftMostMapped(sorted, id, UUID.Comparator, map);
+        const length = sorted.length;
+        if (startIndex < 0 || startIndex >= length) {
+            return null;
+        }
+        for (let endIndex = startIndex; endIndex < length; endIndex++) {
+            if (UUID.Comparator(map(sorted[endIndex]), id) !== 0) {
+                if (startIndex < endIndex) {
+                    return [startIndex, endIndex];
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+        return [startIndex, length];
+    }
+    static Comparator = (a, b) => {
+        const compareId = UUID.Comparator(a.#uuid, b.#uuid);
+        if (compareId !== 0) {
+            return compareId;
+        }
+        const n = Math.min(a.#fieldKeys.length, b.#fieldKeys.length);
+        for (let i = 0; i < n; i++) {
+            const comparison = (a.#fieldKeys)[i] - (b.#fieldKeys)[i];
+            if (comparison !== 0) {
+                return comparison;
+            }
+        }
+        return a.#fieldKeys.length - b.#fieldKeys.length;
+    };
+    static MinimalComparator = (a, b) => {
+        const compareId = UUID.Comparator(a.#uuid, b.#uuid);
+        if (compareId !== 0) {
+            return compareId;
+        }
+        const n = Math.min(a.#fieldKeys.length, b.#fieldKeys.length);
+        for (let i = 0; i < n; i++) {
+            const comparison = (a.#fieldKeys)[i] - (b.#fieldKeys)[i];
+            if (comparison !== 0) {
+                return comparison;
+            }
+        }
+        return 0;
+    };
+    static LengthComparator = (a, b) => {
+        const compareId = UUID.Comparator(a.#uuid, b.#uuid);
+        if (compareId !== 0) {
+            return compareId;
+        }
+        return b.#fieldKeys.length - a.#fieldKeys.length;
+    };
+    static #EMPTY_FIELD_KEYS = new Int16Array(0);
+    #uuid;
+    #fieldKeys;
+    constructor(uuid, fieldKeys) {
+        this.#uuid = uuid;
+        this.#fieldKeys = fieldKeys;
+    }
+    get uuid() { return this.#uuid; }
+    get fieldKeys() { return this.#fieldKeys; }
+    isBox() { return this.#fieldKeys.length === 0; }
+    isContent() { return !this.isBox(); }
+    equals(other) { return Address.Comparator(this, other) === 0; }
+    compareTo(other) { return Address.Comparator(this, other); }
+    append(key) {
+        return new Address(this.#uuid, new Int16Array([...this.#fieldKeys, key]));
+    }
+    startsWith(other) {
+        return UUID.Comparator(other.#uuid, this.#uuid) === 0
+            && other.#fieldKeys.length <= this.#fieldKeys.length
+            && other.#fieldKeys.every((value, index) => this.#fieldKeys[index] === value);
+    }
+    write(output) {
+        output.writeBytes(new Int8Array(this.#uuid.buffer));
+        output.writeByte(this.#fieldKeys.length);
+        this.#fieldKeys.forEach(key => output.writeShort(key));
+    }
+    decompose() { return [this.#uuid, this.#fieldKeys]; }
+    toJSON() { return { uuid: Array.from(this.#uuid.values()), fields: Array.from(this.#fieldKeys.values()) }; }
+    toArrayBuffer() {
+        const array = new Uint8Array(UUID.length + this.#fieldKeys.length);
+        array.set(this.#uuid, 0);
+        array.set(this.#fieldKeys, UUID.length);
+        return array.buffer;
+    }
+    toString() { return [UUID.toString(this.#uuid), ...this.#fieldKeys].join("/"); }
+    static read(input) {
+        const uuidBytes = UUID.fromDataInput(input);
+        const numFields = input.readByte();
+        return Address.compose(uuidBytes, ...Arrays.create(() => input.readShort(), numFields));
+    }
+}
+export var Addressable;
+(function (Addressable) {
+    Addressable.AddressReader = (addressable) => addressable.address;
+    Addressable.Comparator = ({ address: a }, { address: b }) => Address.Comparator(a, b);
+    Addressable.equals = (address, sorted) => {
+        const [l, r] = BinarySearch.rangeMapped(sorted, address, Address.Comparator, Addressable.AddressReader);
+        return sorted.slice(l, r + 1);
+    };
+    Addressable.startsWith = (address, sorted) => {
+        const [l, r] = BinarySearch.rangeMapped(sorted, address, Address.MinimalComparator, Addressable.AddressReader);
+        return sorted
+            .slice(l, r + 1)
+            .filter((addressable) => addressable.address.startsWith(address));
+    };
+    Addressable.endsWith = (address, sorted) => {
+        const l = BinarySearch.leftMostMapped(sorted, address, Address.LengthComparator, Addressable.AddressReader);
+        const r = BinarySearch.rightMostMapped(sorted, address, Address.MinimalComparator, Addressable.AddressReader);
+        return sorted
+            .slice(l, r + 1)
+            .filter((addressable) => address.startsWith(addressable.address));
+    };
+})(Addressable || (Addressable = {}));

package/dist/array.d.ts

@@ -0,0 +1,19 @@
+import { Field, FieldConstruct } from "./field";
+import { UnreferenceableType } from "./pointer";
+import { DataInput, DataOutput, int, Nullish, Option } from "@opendaw/lib-std";
+import { VertexVisitor } from "./vertex";
+export type ArrayFieldFactory<FIELD extends Field> = (construct: FieldConstruct<UnreferenceableType>) => FIELD;
+export declare class ArrayField<FIELD extends Field = Field> extends Field<UnreferenceableType, Record<int, FIELD>> {
+    #private;
+    static create<FIELD extends Field>(construct: FieldConstruct<UnreferenceableType>, factory: ArrayFieldFactory<FIELD>, length: int): ArrayField<FIELD>;
+    private constructor();
+    accept<RETURN>(visitor: VertexVisitor<RETURN>): Nullish<RETURN>;
+    fields(): Iterable<FIELD>;
+    getField(key: keyof Record<int, FIELD>): Record<int, FIELD>[keyof Record<int, FIELD>];
+    optField(key: keyof Record<int, FIELD>): Option<Record<int, FIELD>[keyof Record<int, FIELD>]>;
+    read(input: DataInput): void;
+    write(output: DataOutput): void;
+    size(): int;
+    toJSON(): readonly FIELD[];
+}
+//# sourceMappingURL=array.d.ts.map

package/dist/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAE,cAAc,EAAC,MAAM,SAAS,CAAA;AAC7C,OAAO,EAAC,mBAAmB,EAAC,MAAM,WAAW,CAAA;AAC7C,OAAO,EAAoB,SAAS,EAAE,UAAU,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAc,MAAM,kBAAkB,CAAA;AAC5G,OAAO,EAAa,aAAa,EAAC,MAAM,UAAU,CAAA;AAElD,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,KAAK,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,mBAAmB,CAAC,KAAK,KAAK,CAAA;AAE9G,qBAAa,UAAU,CAAC,KAAK,SAAS,KAAK,GAAG,KAAK,CAC/C,SAAQ,KAAK,CAAC,mBAAmB,EAAE,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;;IACtD,MAAM,CAAC,MAAM,CAAC,KAAK,SAAS,KAAK,EAC7B,SAAS,EAAE,cAAc,CAAC,mBAAmB,CAAC,EAC9C,OAAO,EAAE,iBAAiB,CAAC,KAAK,CAAC,EACjC,MAAM,EAAE,GAAG,GAAG,UAAU,CAAC,KAAK,CAAC;IAKnC,OAAO;IAWP,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAI/D,MAAM,IAAI,QAAQ,CAAC,KAAK,CAAC;IAEzB,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,MAAM,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAIrF,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,MAAM,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAI7F,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAC5B,KAAK,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAE/B,IAAI,IAAI,GAAG;IAEX,MAAM;CACT"}

package/dist/array.js

@@ -0,0 +1,32 @@
+import { Field } from "./field";
+import { Arrays, asDefined, Option, safeExecute } from "@opendaw/lib-std";
+import { NoPointers } from "./vertex";
+export class ArrayField extends Field {
+    static create(construct, factory, length) {
+        return new ArrayField(construct, factory, length);
+    }
+    #fields;
+    constructor(construct, factory, length) {
+        super(construct);
+        this.#fields = Arrays.create((index) => factory({
+            parent: this,
+            fieldKey: index,
+            fieldName: String(index),
+            pointerRules: NoPointers
+        }), length);
+    }
+    accept(visitor) {
+        return safeExecute(visitor.visitArrayField, this);
+    }
+    fields() { return this.#fields; }
+    getField(key) {
+        return asDefined(this.#fields[key]);
+    }
+    optField(key) {
+        return Option.wrap(this.#fields[key]);
+    }
+    read(input) { this.#fields.forEach(field => field.read(input)); }
+    write(output) { this.#fields.forEach(field => field.write(output)); }
+    size() { return this.#fields.length; }
+    toJSON() { return this.#fields; }
+}

package/dist/box.d.ts

@@ -0,0 +1,51 @@
+import { Address } from "./address";
+import { DataInput, DataOutput, Func, int, Nullish, Option, Procedure, Subscription, UUID } from "@opendaw/lib-std";
+import { PointerRules, Vertex, VertexVisitor } from "./vertex";
+import { Field, FieldKey, FieldKeys, Fields } from "./field";
+import { PointerField, PointerTypes } from "./pointer";
+import { PointerHub } from "./pointer-hub";
+import { BoxGraph } from "./graph";
+import { Update } from "./updates";
+import { Propagation } from "./dispatchers";
+export type BoxConstruct<T extends PointerTypes> = {
+    uuid: UUID.Format;
+    graph: BoxGraph;
+    name: string;
+    pointerRules: PointerRules<T>;
+};
+export declare abstract class Box<P extends PointerTypes = PointerTypes, F extends Fields = any> implements Vertex<P, F> {
+    #private;
+    static readonly DEBUG_DELETION = false;
+    static Index: int;
+    protected constructor({ uuid, graph, name, pointerRules }: BoxConstruct<P>);
+    protected abstract initializeFields(): F;
+    abstract accept<VISITOR extends VertexVisitor<any>>(visitor: VISITOR): VISITOR extends VertexVisitor<infer R> ? Nullish<R> : void;
+    fields(): Iterable<Field>;
+    getField<K extends keyof F>(key: K): F[K];
+    optField<K extends keyof F>(key: K): Option<F[K]>;
+    subscribe(propagation: Propagation, procedure: Procedure<Update>): Subscription;
+    get box(): Box;
+    get name(): string;
+    get graph(): BoxGraph;
+    get parent(): Vertex;
+    get address(): Address;
+    get pointerRules(): PointerRules<P>;
+    get creationIndex(): number;
+    get pointerHub(): PointerHub;
+    estimateMemory(): int;
+    isBox(): this is Box;
+    isField(): this is Field;
+    isAttached(): boolean;
+    read(input: DataInput): void;
+    write(output: DataOutput): void;
+    serialize(): ArrayBufferLike;
+    toArrayBuffer(): ArrayBufferLike;
+    incomingEdges(): ReadonlyArray<PointerField>;
+    outgoingEdges(): ReadonlyArray<[PointerField, Vertex]>;
+    mapFields<T>(map: Func<Field, T>, ...keys: FieldKey[]): ReadonlyArray<T>;
+    searchVertex(keys: FieldKeys): Option<Vertex>;
+    delete(): void;
+    unstage(): void;
+    toString(): string;
+}
+//# sourceMappingURL=box.d.ts.map

package/dist/box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"box.d.ts","sourceRoot":"","sources":["../src/box.ts"],"names":[],"mappings":"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"}

package/dist/box.js

@@ -0,0 +1,122 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Address } from "./address";
+import { Arrays, asDefined, ByteArrayOutput, ByteCounter, Lazy, Option } from "@opendaw/lib-std";
+import { PointerHub } from "./pointer-hub";
+import { Serializer } from "./serializer";
+export class Box {
+    static DEBUG_DELETION = false;
+    static Index = 0 | 0;
+    #address;
+    #graph;
+    #name;
+    #pointerRules;
+    #fields;
+    #creationIndex = Box.Index++;
+    constructor({ uuid, graph, name, pointerRules }) {
+        this.#address = Address.compose(uuid);
+        this.#graph = graph;
+        this.#name = name;
+        this.#pointerRules = pointerRules;
+        this.#fields = this.initializeFields();
+        if (pointerRules.mandatory) {
+            this.graph.edges().watchVertex(this);
+        }
+    }
+    fields() { return Object.values(this.#fields); }
+    getField(key) { return asDefined(this.#fields[key]); }
+    optField(key) { return Option.wrap(this.#fields[key]); }
+    subscribe(propagation, procedure) {
+        return this.graph.subscribeVertexUpdates(propagation, this.address, procedure);
+    }
+    get box() { return this; }
+    get name() { return this.#name; }
+    get graph() { return this.#graph; }
+    get parent() { return this; }
+    get address() { return this.#address; }
+    get pointerRules() { return this.#pointerRules; }
+    get creationIndex() { return this.#creationIndex; }
+    get pointerHub() { return new PointerHub(this); }
+    estimateMemory() {
+        const byteCounter = new ByteCounter();
+        this.write(byteCounter);
+        return byteCounter.count;
+    }
+    isBox() { return true; }
+    isField() { return false; }
+    isAttached() { return this.#graph.findBox(this.address.uuid).nonEmpty(); }
+    read(input) { Serializer.readFields(input, this.#fields); }
+    write(output) { Serializer.writeFields(output, this.#fields); }
+    serialize() {
+        const output = ByteArrayOutput.create();
+        output.writeInt(this.#creationIndex); // allows to re-load the boxes in same order as created
+        output.writeString(this.name);
+        output.writeBytes(new Int8Array(this.address.uuid.buffer));
+        this.write(output);
+        return output.toArrayBuffer();
+    }
+    toArrayBuffer() {
+        const output = ByteArrayOutput.create();
+        this.write(output);
+        return output.toArrayBuffer();
+    }
+    incomingEdges() { return this.graph.edges().incomingEdgesOf(this); }
+    outgoingEdges() { return this.graph.edges().outgoingEdgesOf(this); }
+    mapFields(map, ...keys) {
+        if (keys.length === 0) {
+            return Arrays.empty();
+        }
+        let parent = this.getField(keys[0]);
+        const result = [map(parent)];
+        for (let index = 1; index < keys.length; index++) {
+            parent = parent.getField(keys[index]);
+            result.push(map(parent));
+        }
+        return result;
+    }
+    searchVertex(keys) {
+        if (keys.length === 0) {
+            return Option.wrap(this);
+        }
+        let parent = this.optField(keys[0]);
+        if (parent.isEmpty()) {
+            return Option.None;
+        }
+        for (let index = 1; index < keys.length; index++) {
+            parent = parent.unwrap().optField(keys[index]);
+            if (parent.isEmpty()) {
+                return Option.None;
+            }
+        }
+        return parent;
+    }
+    delete() {
+        const { boxes, pointers } = this.graph.dependenciesOf(this);
+        if (Box.DEBUG_DELETION) {
+            console.debug(`Delete ${this.toString()}`);
+            console.debug("\tunplugs", [...pointers].map(x => x.toString()).join("\n"));
+            console.debug("\tunstages", [...boxes].map(x => x.toString()).join("\n"), this);
+        }
+        for (const pointer of pointers) {
+            pointer.defer();
+        }
+        for (const box of boxes) {
+            box.unstage();
+        }
+        this.unstage();
+    }
+    unstage() { this.graph.unstageBox(this); }
+    toString() { return `${this.constructor.name} ${this.address.toString()}`; }
+}
+__decorate([
+    Lazy,
+    __metadata("design:type", PointerHub),
+    __metadata("design:paramtypes", [])
+], Box.prototype, "pointerHub", null);

package/dist/dispatchers.d.ts

@@ -0,0 +1,16 @@
+import { int, Procedure, Subscription } from "@opendaw/lib-std";
+import { Address, Addressable } from "./address";
+export declare enum Propagation {
+    This = 0,
+    Parent = 1,
+    Children = 2
+}
+export interface Dispatchers<TARGET extends Addressable> {
+    subscribe(propagation: Propagation, address: Address, procedure: Procedure<TARGET>): Subscription;
+    dispatch(target: TARGET): void;
+    countStations(): int;
+}
+export declare namespace Dispatchers {
+    const create: <TARGET extends Addressable>() => Dispatchers<TARGET>;
+}
+//# sourceMappingURL=dispatchers.d.ts.map

package/dist/dispatchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchers.d.ts","sourceRoot":"","sources":["../src/dispatchers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,SAAS,EAAE,YAAY,EAAwB,MAAM,kBAAkB,CAAA;AACpF,OAAO,EAAC,OAAO,EAAE,WAAW,EAAC,MAAM,WAAW,CAAA;AAE9C,oBAAY,WAAW;IAAE,IAAI,IAAA;IAAE,MAAM,IAAA;IAAE,QAAQ,IAAA;CAAC;AAEhD,MAAM,WAAW,WAAW,CAAC,MAAM,SAAS,WAAW;IACnD,SAAS,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,YAAY,CAAA;IACjG,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,aAAa,IAAI,GAAG,CAAA;CACvB;AAED,yBAAiB,WAAW,CAAC;IAClB,MAAM,MAAM,GAAI,MAAM,SAAS,WAAW,OAAK,WAAW,CAAC,MAAM,CAAkC,CAAA;CAC7G"}

package/dist/dispatchers.js

@@ -0,0 +1,127 @@
+import { Terminator, Unhandled } from "@opendaw/lib-std";
+import { Addressable } from "./address";
+export var Propagation;
+(function (Propagation) {
+    Propagation[Propagation["This"] = 0] = "This";
+    Propagation[Propagation["Parent"] = 1] = "Parent";
+    Propagation[Propagation["Children"] = 2] = "Children";
+})(Propagation || (Propagation = {}));
+export var Dispatchers;
+(function (Dispatchers) {
+    Dispatchers.create = () => new DispatchersImpl();
+})(Dispatchers || (Dispatchers = {}));
+class DispatchersImpl {
+    #thisDispatcher = new Dispatcher(Addressable.equals);
+    #parentDispatcher = new Dispatcher(Addressable.startsWith);
+    #childrenDispatcher = new Dispatcher(Addressable.endsWith);
+    #deferredStations = [];
+    #order = 0 | 0;
+    #dispatching = false;
+    subscribe(propagation, address, procedure) {
+        const monitor = new Monitor(address, propagation, this.#order++, procedure);
+        if (this.#dispatching) {
+            const deferred = new DeferredMonitor(monitor, propagation);
+            this.#deferredStations.push(deferred);
+            return deferred;
+        }
+        else {
+            return this.subscribeMonitor(monitor, propagation);
+        }
+    }
+    dispatch(target) {
+        this.#dispatching = true;
+        const invoked = [
+            ...this.#thisDispatcher.filter(target),
+            ...this.#parentDispatcher.filter(target),
+            ...this.#childrenDispatcher.filter(target)
+        ];
+        invoked
+            .sort(({ order: a }, { order: b }) => a - b)
+            .forEach((station) => station.procedure(target));
+        this.#dispatching = false;
+        this.#deferredStations.forEach((station) => station.subscribe(this));
+        this.#deferredStations.length = 0;
+    }
+    subscribeMonitor(monitor, propagation) {
+        switch (propagation) {
+            case Propagation.This:
+                return this.#thisDispatcher.subscribe(monitor);
+            case Propagation.Parent:
+                return this.#parentDispatcher.subscribe(monitor);
+            case Propagation.Children:
+                return this.#childrenDispatcher.subscribe(monitor);
+            default:
+                return Unhandled(propagation);
+        }
+    }
+    countStations() {
+        return this.#thisDispatcher.count() + this.#parentDispatcher.count() + this.#childrenDispatcher.count();
+    }
+}
+class Monitor {
+    address;
+    propagation;
+    order;
+    procedure;
+    constructor(address, propagation, order, procedure) {
+        this.address = address;
+        this.propagation = propagation;
+        this.order = order;
+        this.procedure = procedure;
+    }
+    toString() {
+        return `{ Monitor address: ${this.address}, propagation: ${Propagation[this.propagation]}, order: ${this.order} }`;
+    }
+}
+class Dispatcher {
+    filterStrategy;
+    #monitors = [];
+    #sorted = true;
+    constructor(filterStrategy) {
+        this.filterStrategy = filterStrategy;
+    }
+    subscribe(monitor) {
+        this.#monitors.push(monitor);
+        this.#sorted = this.#monitors.length < 2;
+        return {
+            terminate: () => {
+                let index = this.#monitors.length;
+                while (--index >= 0) {
+                    if (this.#monitors[index] === monitor) {
+                        this.#monitors.splice(index, 1);
+                    }
+                }
+            }
+        };
+    }
+    stations() {
+        if (!this.#sorted) {
+            this.#monitors.sort(Addressable.Comparator);
+            this.#sorted = true;
+        }
+        return this.#monitors;
+    }
+    filter(target) { return this.filterStrategy(target.address, this.stations()); }
+    count() { return this.#monitors.length; }
+}
+class DeferredMonitor {
+    monitor;
+    propagation;
+    #terminator = new Terminator();
+    #terminated = false;
+    constructor(monitor, propagation) {
+        this.monitor = monitor;
+        this.propagation = propagation;
+    }
+    subscribe(dispatchers) {
+        if (this.#terminated) {
+            return;
+        }
+        this.#terminator.terminate();
+        this.#terminator.own(dispatchers.subscribeMonitor(this.monitor, this.propagation));
+    }
+    terminate() {
+        this.#terminated = true;
+        this.#terminator.terminate();
+    }
+}

package/dist/editing.d.ts

@@ -0,0 +1,21 @@
+import { BoxGraph } from "./graph";
+import { Nullish, Option, Provider } from "@opendaw/lib-std";
+export interface ModificationProcess {
+    approve(): void;
+    revert(): void;
+}
+export declare class Editing {
+    #private;
+    constructor(graph: BoxGraph);
+    get graph(): BoxGraph;
+    isEmpty(): boolean;
+    clear(): void;
+    undo(): boolean;
+    redo(): boolean;
+    canModify(): boolean;
+    modify<R>(modifier: Provider<Nullish<R>>, mark?: boolean): Option<R>;
+    beginModification(): ModificationProcess;
+    mark(): void;
+    clearPending(): void;
+}
+//# sourceMappingURL=editing.d.ts.map

package/dist/editing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editing.d.ts","sourceRoot":"","sources":["../src/editing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,SAAS,CAAA;AAChC,OAAO,EAAsB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAiB/E,MAAM,WAAW,mBAAmB;IAChC,OAAO,IAAI,IAAI,CAAA;IACf,MAAM,IAAI,IAAI,CAAA;CACjB;AAED,qBAAa,OAAO;;gBASJ,KAAK,EAAE,QAAQ;IAI3B,IAAI,KAAK,IAAI,QAAQ,CAAqB;IAE1C,OAAO,IAAI,OAAO;IAElB,KAAK,IAAI,IAAI;IAOb,IAAI,IAAI,OAAO;IAWf,IAAI,IAAI,OAAO;IAef,SAAS,IAAI,OAAO;IAEpB,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,GAAE,OAAc,GAAG,MAAM,CAAC,CAAC,CAAC;IAW1E,iBAAiB,IAAI,mBAAmB;IAoCxC,IAAI,IAAI,IAAI;IAOZ,YAAY,IAAI,IAAI;CAKvB"}