reactronic 0.22.308 → 0.22.311

package/build/dist/source/Rx.js

@@ -0,0 +1,47 @@
+import { Log } from './util/Dbg';
+import { Kind } from './Options';
+import { Meta, ObjectHandle } from './impl/Data';
+import { Changeset } from './impl/Changeset';
+import { Hooks } from './impl/Hooks';
+import { OperationController } from './impl/Operation';
+export class Rx {
+    static getRevisionOf(obj) { return obj[Meta.Revision]; }
+    static why(brief = false) { return brief ? OperationController.briefWhy() : OperationController.why(); }
+    static getController(method) { return OperationController.of(method); }
+    static pullLastResult(method, args) { return Rx.getController(method).pullLastResult(args); }
+    static configureCurrentOperation(options) { return OperationController.configureImpl(undefined, options); }
+    static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }
+    static dispose(obj) { Changeset.dispose(obj); }
+    static get reactionsAutoStartDisabled() { return Hooks.reactionsAutoStartDisabled; }
+    static set reactionsAutoStartDisabled(value) { Hooks.reactionsAutoStartDisabled = value; }
+    static get isLogging() { return Log.isOn; }
+    static get loggingOptions() { return Log.opt; }
+    static setLoggingMode(isOn, options) { Log.setMode(isOn, options); }
+    static setLoggingHint(obj, name) { Hooks.setHint(obj, name); }
+    static getLoggingHint(obj, full = false) { return ObjectHandle.getHint(obj, full); }
+    static setProfilingMode(isOn, options) { Hooks.setProfilingMode(isOn, options); }
+}
+export function nonreactive(func, ...args) {
+    return OperationController.runWithin(undefined, func, ...args);
+}
+export function sensitive(sensitivity, func, ...args) {
+    return Hooks.sensitive(sensitivity, func, ...args);
+}
+export function isnonreactive(proto, prop) {
+    return Hooks.decorateData(false, proto, prop);
+}
+export function transaction(proto, prop, pd) {
+    const opts = { kind: Kind.Transaction };
+    return Hooks.decorateOperation(true, transaction, opts, proto, prop, pd);
+}
+export function reaction(proto, prop, pd) {
+    const opts = { kind: Kind.Reaction, throttling: -1 };
+    return Hooks.decorateOperation(true, reaction, opts, proto, prop, pd);
+}
+export function cached(proto, prop, pd) {
+    const opts = { kind: Kind.Cache, noSideEffects: true };
+    return Hooks.decorateOperation(true, cached, opts, proto, prop, pd);
+}
+export function options(value) {
+    return Hooks.decorateOperationParametrized(options, value);
+}

package/build/dist/source/Worker.d.ts

@@ -0,0 +1,8 @@
+export interface Worker {
+    readonly id: number;
+    readonly hint: string;
+    readonly isCanceled: boolean;
+    readonly isFinished: boolean;
+    cancel(error: Error, restartAfter?: Worker | null): this;
+    whenFinished(): Promise<void>;
+}

package/build/dist/source/Worker.js

@@ -0,0 +1 @@
+export {};

package/build/dist/source/api.d.ts

@@ -0,0 +1,14 @@
+export { all, pause } from './util/Utils';
+export { SealedArray } from './util/SealedArray';
+export { SealedMap } from './util/SealedMap';
+export { SealedSet } from './util/SealedSet';
+export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, ProfilingOptions, LoggingLevel } from './Options';
+export { Worker } from './Worker';
+export { Controller } from './Controller';
+export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
+export { ReactiveObject, ReactiveArray, ReactiveMap } from './impl/Hooks';
+export { Changeset } from './impl/Changeset';
+export { Transaction } from './impl/Transaction';
+export { Monitor } from './impl/Monitor';
+export { Journal } from './impl/Journal';
+export { Rx, nonreactive, sensitive, isnonreactive, transaction, reaction, cached, options } from './Rx';

package/build/dist/source/api.js

@@ -0,0 +1,13 @@
+export { all, pause } from './util/Utils';
+export { SealedArray } from './util/SealedArray';
+export { SealedMap } from './util/SealedMap';
+export { SealedSet } from './util/SealedSet';
+export { Kind, Reentrance, LoggingLevel } from './Options';
+export { Controller } from './Controller';
+export { Ref, ToggleRef } from './Ref';
+export { ReactiveObject, ReactiveArray, ReactiveMap } from './impl/Hooks';
+export { Changeset } from './impl/Changeset';
+export { Transaction } from './impl/Transaction';
+export { Monitor } from './impl/Monitor';
+export { Journal } from './impl/Journal';
+export { Rx, nonreactive, sensitive, isnonreactive, transaction, reaction, cached, options } from './Rx';

package/build/dist/source/impl/Changeset.d.ts

@@ -0,0 +1,60 @@
+import { Kind, SnapshotOptions } from '../Options';
+import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, Subscription, Subscriber } from './Data';
+export declare const MAX_REVISION: number;
+export declare const UNDEFINED_REVISION: number;
+export declare class Changeset implements AbstractChangeset {
+    static idGen: number;
+    private static stampGen;
+    private static pending;
+    private static oldest;
+    static garbageCollectionSummaryInterval: number;
+    static lastGarbageCollectionSummaryTimestamp: number;
+    static totalObjectHandleCount: number;
+    static totalObjectSnapshotCount: number;
+    readonly id: number;
+    readonly options: SnapshotOptions;
+    get hint(): string;
+    get timestamp(): number;
+    private revision;
+    private bumper;
+    items: Map<ObjectHandle, ObjectSnapshot>;
+    reactions: Subscriber[];
+    sealed: boolean;
+    constructor(options: SnapshotOptions | null);
+    static current: () => Changeset;
+    static edit: () => Changeset;
+    static markUsed: (subscription: Subscription, os: ObjectSnapshot, m: MemberName, h: ObjectHandle, kind: Kind, weak: boolean) => void;
+    static markEdited: (oldValue: any, newValue: any, edited: boolean, os: ObjectSnapshot, m: MemberName, h: ObjectHandle) => void;
+    static isConflicting: (oldValue: any, newValue: any) => boolean;
+    static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
+    static revokeAllSubscriptions: (changeset: Changeset) => void;
+    static enqueueReactionsToRun: (reactions: Array<Subscriber>) => void;
+    seekSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
+    getRelevantSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
+    getEditableSnapshot(h: ObjectHandle, m: MemberName, value: any, token?: any): ObjectSnapshot;
+    static takeSnapshot<T>(obj: T): T;
+    static dispose(obj: any): void;
+    static doDispose(ctx: Changeset, h: ObjectHandle): ObjectSnapshot;
+    private isNewSnapshotRequired;
+    acquire(outer: Changeset): void;
+    bumpBy(timestamp: number): void;
+    rebase(): ObjectSnapshot[] | undefined;
+    private merge;
+    applyOrDiscard(error?: any): Array<Subscriber>;
+    static sealObjectSnapshot(h: ObjectHandle, os: ObjectSnapshot): void;
+    static sealSubscription(subscription: Subscription | symbol, m: MemberName, typeName: string): void;
+    static freezeObjectSnapshot(os: ObjectSnapshot): ObjectSnapshot;
+    triggerGarbageCollection(): void;
+    private unlinkHistory;
+    static _init(): void;
+}
+export declare class Dump {
+    static valueHint: (value: any, m?: MemberName) => string;
+    static obj(h: ObjectHandle | undefined, m?: MemberName | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
+    static snapshot2(h: ObjectHandle, s: AbstractChangeset, m?: MemberName, o?: Subscription): string;
+    static snapshot(os: ObjectSnapshot, m?: MemberName): string;
+    static conflicts(conflicts: ObjectSnapshot[]): string;
+    static conflictingMemberHint(m: MemberName, ours: ObjectSnapshot, theirs: ObjectSnapshot): string;
+}
+export declare const EMPTY_SNAPSHOT: ObjectSnapshot;
+export declare const DefaultSnapshotOptions: SnapshotOptions;

package/build/dist/source/impl/Changeset.js

@@ -0,0 +1,356 @@
+import { Utils, UNDEF } from '../util/Utils';
+import { Log, misuse } from '../util/Dbg';
+import { Sealant } from '../util/Sealant';
+import { SealedArray } from '../util/SealedArray';
+import { SealedMap } from '../util/SealedMap';
+import { SealedSet } from '../util/SealedSet';
+import { ObjectSnapshot, ObjectHandle, Subscription, Meta } from './Data';
+export const MAX_REVISION = Number.MAX_SAFE_INTEGER;
+export const UNDEFINED_REVISION = MAX_REVISION - 1;
+Object.defineProperty(ObjectHandle.prototype, '#this', {
+    configurable: false, enumerable: false,
+    get() {
+        const result = {};
+        const data = Changeset.current().getRelevantSnapshot(this, '#this').data;
+        for (const m in data) {
+            const v = data[m];
+            if (v instanceof Subscription)
+                result[m] = v.content;
+            else if (v === Meta.Nonreactive)
+                result[m] = this.data[m];
+            else
+                result[m] = v;
+        }
+        return result;
+    },
+});
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_MAP = Utils.freezeMap(new Map());
+export class Changeset {
+    constructor(options) {
+        this.id = ++Changeset.idGen;
+        this.options = options !== null && options !== void 0 ? options : DefaultSnapshotOptions;
+        this.revision = UNDEFINED_REVISION;
+        this.bumper = 100;
+        this.items = new Map();
+        this.reactions = [];
+        this.sealed = false;
+    }
+    get hint() { var _a; return (_a = this.options.hint) !== null && _a !== void 0 ? _a : 'noname'; }
+    get timestamp() { return this.revision; }
+    seekSnapshot(h, m) {
+        let os = h.editing;
+        if (os && os.changeset !== this) {
+            os = this.items.get(h);
+            if (os)
+                h.editing = os;
+        }
+        if (!os) {
+            os = h.head;
+            while (os !== EMPTY_SNAPSHOT && os.changeset.timestamp > this.timestamp)
+                os = os.former.snapshot;
+        }
+        return os;
+    }
+    getRelevantSnapshot(h, m) {
+        const r = this.seekSnapshot(h, m);
+        if (r === EMPTY_SNAPSHOT)
+            throw misuse(`object ${Dump.obj(h)} doesn't exist in snapshot v${this.revision} (${this.hint})`);
+        return r;
+    }
+    getEditableSnapshot(h, m, value, token) {
+        let os = this.seekSnapshot(h, m);
+        const existing = os.data[m];
+        if (existing !== Meta.Nonreactive) {
+            if (this.isNewSnapshotRequired(h, os, m, existing, value, token)) {
+                this.bumpBy(os.changeset.timestamp);
+                const revision = m === Meta.Handle ? 1 : os.revision + 1;
+                const data = Object.assign({}, m === Meta.Handle ? value : os.data);
+                Meta.set(data, Meta.Handle, h);
+                Meta.set(data, Meta.Revision, new Subscription(revision));
+                os = new ObjectSnapshot(this, os, data);
+                this.items.set(h, os);
+                h.editing = os;
+                h.editors++;
+                if (Log.isOn && Log.opt.write)
+                    Log.write('║', ' ⎘⎘', `${Dump.obj(h)} - new snapshot is created (revision ${revision})`);
+            }
+        }
+        else
+            os = EMPTY_SNAPSHOT;
+        return os;
+    }
+    static takeSnapshot(obj) {
+        return obj[Meta.Handle]['#this'];
+    }
+    static dispose(obj) {
+        const ctx = Changeset.edit();
+        const h = Meta.get(obj, Meta.Handle);
+        if (h !== undefined)
+            Changeset.doDispose(ctx, h);
+    }
+    static doDispose(ctx, h) {
+        const os = ctx.getEditableSnapshot(h, Meta.Revision, Meta.Undefined);
+        if (os !== EMPTY_SNAPSHOT)
+            os.disposed = true;
+        return os;
+    }
+    isNewSnapshotRequired(h, os, m, existing, value, token) {
+        if (this.sealed && os.changeset !== EMPTY_SNAPSHOT.changeset)
+            throw misuse(`reactive property ${Dump.obj(h, m)} can only be modified inside transaction`);
+        if (m !== Meta.Handle && value !== Meta.Handle) {
+            if (os.changeset !== this || os.former.snapshot !== EMPTY_SNAPSHOT) {
+                if (this.options.token !== undefined && token !== this.options.token)
+                    throw misuse(`${this.hint} should not have side effects (trying to change ${Dump.snapshot(os, m)})`);
+            }
+            if (os === EMPTY_SNAPSHOT)
+                throw misuse(`member ${Dump.snapshot(os, m)} doesn't exist in snapshot v${this.revision} (${this.hint})`);
+        }
+        return os.changeset !== this && !this.sealed;
+    }
+    acquire(outer) {
+        if (!this.sealed && this.revision === UNDEFINED_REVISION) {
+            const ahead = this.options.token === undefined || outer.revision === UNDEFINED_REVISION;
+            this.revision = ahead ? Changeset.stampGen : outer.revision;
+            Changeset.pending.push(this);
+            if (Changeset.oldest === undefined)
+                Changeset.oldest = this;
+            if (Log.isOn && Log.opt.transaction)
+                Log.write('╔══', `v${this.revision}`, `${this.hint}`);
+        }
+    }
+    bumpBy(timestamp) {
+        if (timestamp > this.bumper)
+            this.bumper = timestamp;
+    }
+    rebase() {
+        let conflicts = undefined;
+        if (this.items.size > 0) {
+            this.items.forEach((os, h) => {
+                if (os.former.snapshot !== h.head) {
+                    const merged = this.merge(h, os);
+                    if (os.conflicts.size > 0) {
+                        if (!conflicts)
+                            conflicts = [];
+                        conflicts.push(os);
+                    }
+                    if (Log.isOn && Log.opt.transaction)
+                        Log.write('╠╝', '', `${Dump.snapshot2(h, os.changeset)} is merged with ${Dump.snapshot2(h, h.head.changeset)} among ${merged} properties with ${os.conflicts.size} conflicts.`);
+                }
+            });
+            if (this.options.token === undefined) {
+                if (this.bumper > 100) {
+                    this.bumper = this.revision;
+                    this.revision = ++Changeset.stampGen;
+                }
+                else
+                    this.revision = this.bumper + 1;
+            }
+            else {
+                this.revision = this.bumper;
+            }
+        }
+        return conflicts;
+    }
+    merge(h, ours) {
+        let counter = 0;
+        const head = h.head;
+        const headDisposed = head.disposed;
+        const oursDisposed = ours.disposed;
+        const merged = Object.assign({}, head.data);
+        ours.changes.forEach((o, m) => {
+            counter++;
+            merged[m] = ours.data[m];
+            if (headDisposed || oursDisposed) {
+                if (headDisposed !== oursDisposed) {
+                    if (headDisposed || this.options.standalone !== 'disposal') {
+                        if (Log.isOn && Log.opt.change)
+                            Log.write('║╠', '', `${Dump.snapshot2(h, ours.changeset, m)} <> ${Dump.snapshot2(h, head.changeset, m)}`, 0, ' *** CONFLICT ***');
+                        ours.conflicts.set(m, head);
+                    }
+                }
+            }
+            else {
+                const conflict = Changeset.isConflicting(head.data[m], ours.former.snapshot.data[m]);
+                if (conflict)
+                    ours.conflicts.set(m, head);
+                if (Log.isOn && Log.opt.change)
+                    Log.write('║╠', '', `${Dump.snapshot2(h, ours.changeset, m)} ${conflict ? '<>' : '=='} ${Dump.snapshot2(h, head.changeset, m)}`, 0, conflict ? ' *** CONFLICT ***' : undefined);
+            }
+        });
+        Utils.copyAllMembers(merged, ours.data);
+        ours.former.snapshot = head;
+        return counter;
+    }
+    applyOrDiscard(error) {
+        this.sealed = true;
+        this.items.forEach((os, h) => {
+            Changeset.sealObjectSnapshot(h, os);
+            h.editors--;
+            if (h.editors === 0)
+                h.editing = undefined;
+            if (!error) {
+                h.head = os;
+                if (Changeset.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
+                    Changeset.totalObjectSnapshotCount++;
+                    if (os.former.snapshot === EMPTY_SNAPSHOT)
+                        Changeset.totalObjectHandleCount++;
+                }
+            }
+        });
+        if (Log.isOn) {
+            if (Log.opt.change && !error) {
+                this.items.forEach((os, h) => {
+                    const members = [];
+                    os.changes.forEach((o, m) => members.push(m.toString()));
+                    const s = members.join(', ');
+                    Log.write('║', '√', `${Dump.snapshot2(h, os.changeset)} (${s}) is ${os.former.snapshot === EMPTY_SNAPSHOT ? 'constructed' : `applied on top of ${Dump.snapshot2(h, os.former.snapshot.changeset)}`}`);
+                });
+            }
+            if (Log.opt.transaction)
+                Log.write(this.revision < UNDEFINED_REVISION ? '╚══' : '═══', `v${this.revision}`, `${this.hint} - ${error ? 'CANCEL' : 'APPLY'}(${this.items.size})${error ? ` - ${error}` : ''}`);
+        }
+        if (!error)
+            Changeset.propagateAllChangesThroughSubscriptions(this);
+        return this.reactions;
+    }
+    static sealObjectSnapshot(h, os) {
+        if (!os.disposed)
+            os.changes.forEach((o, m) => Changeset.sealSubscription(os.data[m], m, h.proxy.constructor.name));
+        else
+            for (const m in os.former.snapshot.data)
+                os.data[m] = Meta.Undefined;
+        if (Log.isOn)
+            Changeset.freezeObjectSnapshot(os);
+    }
+    static sealSubscription(subscription, m, typeName) {
+        if (subscription instanceof Subscription) {
+            const value = subscription.content;
+            if (value !== undefined && value !== null) {
+                const sealedType = Object.getPrototypeOf(value)[Sealant.SealedType];
+                if (sealedType)
+                    subscription.content = Sealant.seal(value, sealedType, typeName, m);
+            }
+        }
+    }
+    static freezeObjectSnapshot(os) {
+        Object.freeze(os.data);
+        Utils.freezeSet(os.changes);
+        Utils.freezeMap(os.conflicts);
+        return os;
+    }
+    triggerGarbageCollection() {
+        if (this.revision !== 0) {
+            if (this === Changeset.oldest) {
+                const p = Changeset.pending;
+                p.sort((a, b) => a.revision - b.revision);
+                let i = 0;
+                while (i < p.length && p[i].sealed) {
+                    p[i].unlinkHistory();
+                    i++;
+                }
+                Changeset.pending = p.slice(i);
+                Changeset.oldest = Changeset.pending[0];
+                const now = Date.now();
+                if (now - Changeset.lastGarbageCollectionSummaryTimestamp > Changeset.garbageCollectionSummaryInterval) {
+                    Log.write('', '[G]', `Total object/snapshot count: ${Changeset.totalObjectHandleCount}/${Changeset.totalObjectSnapshotCount}`);
+                    Changeset.lastGarbageCollectionSummaryTimestamp = now;
+                }
+            }
+        }
+    }
+    unlinkHistory() {
+        if (Log.isOn && Log.opt.gc)
+            Log.write('', '[G]', `Dismiss history below v${this.revision}t${this.id} (${this.hint})`);
+        this.items.forEach((os, h) => {
+            if (Log.isOn && Log.opt.gc && os.former.snapshot !== EMPTY_SNAPSHOT)
+                Log.write(' ', '  ', `${Dump.snapshot2(h, os.former.snapshot.changeset)} is ready for GC because overwritten by ${Dump.snapshot2(h, os.changeset)}`);
+            if (Changeset.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
+                if (os.former.snapshot !== EMPTY_SNAPSHOT)
+                    Changeset.totalObjectSnapshotCount--;
+                if (os.disposed)
+                    Changeset.totalObjectHandleCount--;
+            }
+            os.former.snapshot = EMPTY_SNAPSHOT;
+        });
+        this.items = EMPTY_MAP;
+        this.reactions = EMPTY_ARRAY;
+        if (Log.isOn)
+            Object.freeze(this);
+    }
+    static _init() {
+        const boot = EMPTY_SNAPSHOT.changeset;
+        boot.acquire(boot);
+        boot.applyOrDiscard();
+        boot.triggerGarbageCollection();
+        Changeset.freezeObjectSnapshot(EMPTY_SNAPSHOT);
+        Changeset.idGen = 100;
+        Changeset.stampGen = 101;
+        Changeset.oldest = undefined;
+        SealedArray.prototype;
+        SealedMap.prototype;
+        SealedSet.prototype;
+    }
+}
+Changeset.idGen = -1;
+Changeset.stampGen = 1;
+Changeset.pending = [];
+Changeset.oldest = undefined;
+Changeset.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
+Changeset.lastGarbageCollectionSummaryTimestamp = Date.now();
+Changeset.totalObjectHandleCount = 0;
+Changeset.totalObjectSnapshotCount = 0;
+Changeset.current = UNDEF;
+Changeset.edit = UNDEF;
+Changeset.markUsed = UNDEF;
+Changeset.markEdited = UNDEF;
+Changeset.isConflicting = UNDEF;
+Changeset.propagateAllChangesThroughSubscriptions = (changeset) => { };
+Changeset.revokeAllSubscriptions = (changeset) => { };
+Changeset.enqueueReactionsToRun = (reactions) => { };
+export class Dump {
+    static obj(h, m, stamp, snapshotId, originSnapshotId, value) {
+        const member = m !== undefined ? `.${m.toString()}` : '';
+        let result;
+        if (h !== undefined) {
+            const v = value !== undefined && value !== Meta.Undefined ? `[=${Dump.valueHint(value)}]` : '';
+            if (stamp === undefined)
+                result = `${h.hint}${member}${v} #${h.id}`;
+            else
+                result = `${h.hint}${member}${v} #${h.id}t${snapshotId}v${stamp}${originSnapshotId !== undefined && originSnapshotId !== 0 ? `t${originSnapshotId}` : ''}`;
+        }
+        else
+            result = `boot${member}`;
+        return result;
+    }
+    static snapshot2(h, s, m, o) {
+        var _a;
+        return Dump.obj(h, m, s.timestamp, s.id, o === null || o === void 0 ? void 0 : o.originSnapshotId, (_a = o === null || o === void 0 ? void 0 : o.content) !== null && _a !== void 0 ? _a : Meta.Undefined);
+    }
+    static snapshot(os, m) {
+        const h = Meta.get(os.data, Meta.Handle);
+        const value = m !== undefined ? os.data[m] : undefined;
+        return Dump.obj(h, m, os.changeset.timestamp, os.changeset.id, value === null || value === void 0 ? void 0 : value.originSnapshotId);
+    }
+    static conflicts(conflicts) {
+        return conflicts.map(ours => {
+            const items = [];
+            ours.conflicts.forEach((theirs, m) => {
+                items.push(Dump.conflictingMemberHint(m, ours, theirs));
+            });
+            return items.join(', ');
+        }).join(', ');
+    }
+    static conflictingMemberHint(m, ours, theirs) {
+        return `${theirs.changeset.hint} (${Dump.snapshot(theirs, m)})`;
+    }
+}
+Dump.valueHint = (value, m) => '???';
+export const EMPTY_SNAPSHOT = new ObjectSnapshot(new Changeset({ hint: '<empty>' }), undefined, {});
+export const DefaultSnapshotOptions = Object.freeze({
+    hint: 'noname',
+    standalone: false,
+    journal: undefined,
+    logging: undefined,
+    token: undefined,
+});

package/build/dist/source/impl/Data.d.ts

@@ -0,0 +1,60 @@
+export { Meta } from './Meta';
+export interface AbstractChangeset {
+    readonly id: number;
+    readonly hint: string;
+    readonly timestamp: number;
+    readonly sealed: boolean;
+}
+export declare class Subscription {
+    content: any;
+    subscribers?: Set<Subscriber>;
+    get isOperation(): boolean;
+    get originSnapshotId(): number | undefined;
+    constructor(content: any);
+}
+export declare type StandaloneMode = boolean | 'isolated' | 'disposal';
+export interface Subscriber {
+    readonly order: number;
+    readonly subscriptions: Map<Subscription, SubscriptionInfo> | undefined;
+    readonly obsoleteSince: number;
+    hint(nop?: boolean): string;
+    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactions: Array<Subscriber>): void;
+    runIfNotUpToDate(now: boolean, nothrow: boolean): void;
+}
+export declare type MemberName = PropertyKey;
+export interface SubscriptionInfo {
+    readonly memberHint: string;
+    readonly usageCount: number;
+}
+export declare class ObjectSnapshot {
+    readonly changeset: AbstractChangeset;
+    readonly former: {
+        snapshot: ObjectSnapshot;
+    };
+    readonly data: any;
+    readonly changes: Set<MemberName>;
+    readonly conflicts: Map<MemberName, ObjectSnapshot>;
+    constructor(changeset: AbstractChangeset, former: ObjectSnapshot | undefined, data: object);
+    get revision(): number;
+    get disposed(): boolean;
+    set disposed(value: boolean);
+}
+export declare class ObjectHandle {
+    private static generator;
+    readonly id: number;
+    readonly data: any;
+    readonly proxy: any;
+    head: ObjectSnapshot;
+    editing?: ObjectSnapshot;
+    editors: number;
+    hint: string;
+    constructor(data: any, proxy: any, handler: ProxyHandler<ObjectHandle>, head: ObjectSnapshot, hint: string);
+    static getHint(obj: object, full: boolean): string | undefined;
+}
+export declare type PatchSet = Map<object, Map<MemberName, ValuePatch>>;
+export interface ValuePatch {
+    memberName: MemberName;
+    patchKind: 'update' | 'add' | 'remove';
+    freshValue: any;
+    formerValue: any;
+}

package/build/dist/source/impl/Data.js

@@ -0,0 +1,44 @@
+import { Log } from '../util/Dbg';
+import { Meta } from './Meta';
+export { Meta } from './Meta';
+export class Subscription {
+    constructor(content) { this.content = content; }
+    get isOperation() { return false; }
+    get originSnapshotId() { return 0; }
+}
+export class ObjectSnapshot {
+    constructor(changeset, former, data) {
+        this.changeset = changeset;
+        this.former = { snapshot: former || this };
+        this.data = data;
+        this.changes = new Set();
+        this.conflicts = new Map();
+        if (Log.isOn)
+            Object.freeze(this);
+    }
+    get revision() {
+        return this.data[Meta.Revision].content;
+    }
+    get disposed() { return this.revision < 0; }
+    set disposed(value) {
+        const rev = this.revision;
+        if (rev < 0 !== value)
+            this.data[Meta.Revision].content = ~rev;
+    }
+}
+export class ObjectHandle {
+    constructor(data, proxy, handler, head, hint) {
+        this.id = ++ObjectHandle.generator;
+        this.data = data;
+        this.proxy = proxy || new Proxy(this, handler);
+        this.head = head;
+        this.editing = undefined;
+        this.editors = 0;
+        this.hint = hint;
+    }
+    static getHint(obj, full) {
+        const h = Meta.get(obj, Meta.Handle);
+        return h !== undefined ? (full ? `${h.hint}#${h.id}` : h.hint) : undefined;
+    }
+}
+ObjectHandle.generator = 19;