reactronic 0.21.600 → 0.21.604

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

@@ -24,6 +24,7 @@ export interface ProfilingOptions {
 }
 export declare const TraceLevel: {
     ErrorsOnly: TraceOptions;
+    Reactions: TraceOptions;
     Transactions: TraceOptions;
     Operations: TraceOptions;
     Debug: TraceOptions;

package/build/dist/source/Trace.js

@@ -20,6 +20,24 @@ exports.TraceLevel = {
         margin1: 0,
         margin2: 0,
     },
+    Reactions: {
+        silent: false,
+        transaction: false,
+        operation: false,
+        step: false,
+        monitor: false,
+        read: false,
+        write: false,
+        change: false,
+        obsolete: true,
+        error: true,
+        warning: true,
+        gc: false,
+        color: 37,
+        prefix: '',
+        margin1: 0,
+        margin2: 0,
+    },
     Transactions: {
         silent: false,
         transaction: true,

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

@@ -18,12 +18,13 @@ export interface Observer {
     readonly observables: Map<Observable, MemberInfo> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
-    markObsoleteDueTo(observable: Observable, cause: MemberInfo, since: number, reactions: Observer[]): void;
+    markObsoleteDueTo(observable: Observable, memberName: MemberName, snapshot: AbstractSnapshot, holder: ObjectHolder, outer: string, since: number, reactions: Observer[]): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
 }
 export declare type MemberName = PropertyKey;
 export interface MemberInfo {
-    readonly revision: ObjectRevision;
+    readonly holder: ObjectHolder;
+    readonly snapshot: AbstractSnapshot;
     readonly memberName: MemberName;
     readonly usageCount: number;
 }
@@ -33,7 +34,7 @@ export declare class ObjectRevision {
         revision: ObjectRevision;
     };
     readonly data: any;
-    readonly changes: Map<MemberName, Observer>;
+    readonly changes: Set<MemberName>;
     readonly conflicts: Map<MemberName, ObjectRevision>;
     constructor(snapshot: AbstractSnapshot, prev: ObjectRevision | undefined, data: object);
 }

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

@@ -16,7 +16,7 @@ class ObjectRevision {
         this.snapshot = snapshot;
         this.prev = { revision: prev || this };
         this.data = data;
-        this.changes = new Map();
+        this.changes = new Set();
         this.conflicts = new Map();
         if (Dbg_1.Dbg.isOn)
             Object.freeze(this);

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

@@ -1,7 +1,7 @@
 import { F } from '../util/Utils';
 import { MemberOptions } from '../Options';
 import { Controller } from '../Controller';
-import { ObjectRevision, MemberName, ObjectHolder, Observable, Observer, MemberInfo } from './Data';
+import { MemberName, ObjectHolder, Observable, Observer, MemberInfo, AbstractSnapshot } from './Data';
 import { Transaction } from './Transaction';
 import { OptionsImpl } from './Hooks';
 export declare class OperationController extends Controller<any> {
@@ -39,18 +39,18 @@ declare class Operation extends Observable implements Observer {
     readonly margin: number;
     readonly transaction: Transaction;
     readonly controller: OperationController;
-    readonly revision: ObjectRevision;
+    readonly snapshot: AbstractSnapshot;
     observables: Map<Observable, MemberInfo> | undefined;
     options: OptionsImpl;
-    cause: MemberInfo | undefined;
+    cause: string | undefined;
     args: any[];
     result: any;
     error: any;
     started: number;
-    obsoleteDueTo: MemberInfo | undefined;
+    obsoleteDueTo: string | undefined;
     obsoleteSince: number;
     successor: Operation | undefined;
-    constructor(controller: OperationController, revision: ObjectRevision, prev: Operation | OptionsImpl);
+    constructor(controller: OperationController, snapshot: AbstractSnapshot, prev: Operation | OptionsImpl);
     get isOperation(): boolean;
     get selfSnapshotId(): number;
     hint(): string;
@@ -61,7 +61,7 @@ declare class Operation extends Observable implements Observer {
     dependencies(): string[];
     wrap<T>(func: F<T>): F<T>;
     run(proxy: any, args: any[] | undefined): void;
-    markObsoleteDueTo(observable: Observable, cause: MemberInfo, since: number, reactions: Observer[]): void;
+    markObsoleteDueTo(observable: Observable, memberName: MemberName, snapshot: AbstractSnapshot, holder: ObjectHolder, outer: string, since: number, reactions: Observer[]): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
     isNotUpToDate(): boolean;
     reenterOver(head: Operation): this;
@@ -79,7 +79,7 @@ declare class Operation extends Observable implements Observer {
     private static propagateAllChangesThroughSubscriptions;
     private static revokeAllSubscriptions;
     private static propagateMemberChangeThroughSubscriptions;
-    private static enqueueDetectedReactions;
+    private static enqueueReactionsToRun;
     private static runQueuedReactionsLoop;
     private unsubscribeFromAllObservables;
     private subscribeTo;

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

@@ -12,7 +12,7 @@ const Hooks_1 = require("./Hooks");
 const TransactionJournal_1 = require("./TransactionJournal");
 const ROOT_ARGS = [];
 const ROOT_HOLDER = new Data_1.ObjectHolder(undefined, undefined, Hooks_1.Hooks.proxy, Snapshot_1.ROOT_REV, 'root-holder');
-const ROOT_TRIGGER = { revision: Snapshot_1.ROOT_REV, memberName: 'root-trigger', usageCount: 0 };
+const INITIAL_CAUSE = 'initial';
 class OperationController extends Controller_1.Controller {
     constructor(ownHolder, memberName) {
         super();
@@ -36,7 +36,7 @@ class OperationController extends Controller_1.Controller {
         const op = oc.operation;
         const opts = op.options;
         if (!oc.isUpToDate && oc.revision.data[Data_1.Meta.Disposed] === undefined
-            && (!weak || op.cause === ROOT_TRIGGER || !op.successor ||
+            && (!weak || op.cause === INITIAL_CAUSE || !op.successor ||
                 op.successor.transaction.isFinished)) {
             const outerOpts = (_a = Operation.current) === null || _a === void 0 ? void 0 : _a.options;
             const standalone = weak || opts.standalone || opts.kind === Options_1.Kind.Reaction ||
@@ -45,13 +45,13 @@ class OperationController extends Controller_1.Controller {
                     oc.revision.prev.revision !== Snapshot_1.ROOT_REV));
             const token = opts.noSideEffects ? this : undefined;
             const oc2 = this.run(oc, standalone, opts, token, args);
-            const ctx2 = oc2.operation.revision.snapshot;
+            const ctx2 = oc2.operation.snapshot;
             if (!weak || ctx === ctx2 || (ctx2.sealed && ctx.timestamp >= ctx2.timestamp))
                 oc = oc2;
         }
         else if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.operation && (opts.trace === undefined ||
             opts.trace.operation === undefined || opts.trace.operation === true))
-            Dbg_1.Dbg.log(Transaction_1.Transaction.current.isFinished ? '' : '║', ' (=)', `${Snapshot_1.Dump.rev(oc.revision, this.memberName)} result is reused from T${oc.operation.transaction.id}[${oc.operation.transaction.hint}]`);
+            Dbg_1.Dbg.log(Transaction_1.Transaction.current.isFinished ? '' : '║', ' (=)', `${Snapshot_1.Dump.rev2(oc.operation.controller.ownHolder, oc.snapshot, this.memberName)} result is reused from T${oc.operation.transaction.id}[${oc.operation.transaction.hint}]`);
         const t = oc.operation;
         Snapshot_1.Snapshot.markUsed(t, oc.revision, this.memberName, this.ownHolder, t.options.kind, weak);
         return t;
@@ -108,8 +108,8 @@ class OperationController extends Controller_1.Controller {
         const ctx = Snapshot_1.Snapshot.current();
         const r = ctx.seekRevision(this.ownHolder, this.memberName);
         const op = this.peekFromRevision(r, args);
-        const isValid = op.options.kind !== Options_1.Kind.Transaction && op.cause !== ROOT_TRIGGER &&
-            (ctx === op.revision.snapshot || ctx.timestamp < op.obsoleteSince) &&
+        const isValid = op.options.kind !== Options_1.Kind.Transaction && op.cause !== INITIAL_CAUSE &&
+            (ctx === op.snapshot || ctx.timestamp < op.obsoleteSince) &&
             (!op.options.sensitiveArgs || args === undefined ||
                 op.args.length === args.length && op.args.every((t, i) => t === args[i])) ||
             r.data[Data_1.Meta.Disposed] !== undefined;
@@ -126,8 +126,8 @@ class OperationController extends Controller_1.Controller {
         const ctx = Snapshot_1.Snapshot.edit();
         const r = ctx.getEditableRevision(h, m, Data_1.Meta.Holder, this);
         let op = this.peekFromRevision(r, undefined);
-        if (op.revision !== r) {
-            const op2 = new Operation(this, r, op);
+        if (op.snapshot !== r.snapshot) {
+            const op2 = new Operation(this, r.snapshot, op);
             r.data[m] = op2.reenterOver(op);
             ctx.bumpBy(r.prev.revision.snapshot.timestamp);
             Snapshot_1.Snapshot.markEdited(op, op2, true, r, m, h);
@@ -147,10 +147,10 @@ class OperationController extends Controller_1.Controller {
                 let op2 = r2.data[m];
                 if (op2.controller !== this) {
                     r2 = Snapshot_1.Snapshot.edit().getEditableRevision(h, m, Data_1.Meta.Holder, this);
-                    const t = new Operation(this, r2, op2);
+                    const t = new Operation(this, r2.snapshot, op2);
                     if (args)
                         t.args = args;
-                    t.cause = ROOT_TRIGGER;
+                    t.cause = INITIAL_CAUSE;
                     r2.data[m] = t;
                     Snapshot_1.Snapshot.markEdited(op2, t, true, r2, m, h);
                     op2 = t;
@@ -188,17 +188,17 @@ class OperationController extends Controller_1.Controller {
     static markObsolete(self) {
         const oc = self.peek(undefined);
         const ctx = oc.snapshot;
-        oc.operation.markObsoleteDueTo(oc.operation, { revision: Snapshot_1.ROOT_REV, memberName: self.memberName, usageCount: 0 }, ctx.timestamp, ctx.reactions);
+        oc.operation.markObsoleteDueTo(oc.operation, self.memberName, Snapshot_1.ROOT_REV.snapshot, ROOT_HOLDER, INITIAL_CAUSE, ctx.timestamp, ctx.reactions);
     }
 }
 exports.OperationController = OperationController;
 class Operation extends Data_1.Observable {
-    constructor(controller, revision, prev) {
+    constructor(controller, snapshot, prev) {
         super(undefined);
         this.margin = Operation.current ? Operation.current.margin + 1 : 1;
         this.transaction = Transaction_1.Transaction.current;
         this.controller = controller;
-        this.revision = revision;
+        this.snapshot = snapshot;
         this.observables = new Map();
         if (prev instanceof Operation) {
             this.options = prev.options;
@@ -216,28 +216,24 @@ class Operation extends Data_1.Observable {
         this.successor = undefined;
     }
     get isOperation() { return true; }
-    get selfSnapshotId() { return this.revision.snapshot.id; }
-    hint() { return `${Snapshot_1.Dump.rev(this.revision, this.controller.memberName)}`; }
+    get selfSnapshotId() { return this.snapshot.id; }
+    hint() { return `${Snapshot_1.Dump.rev2(this.controller.ownHolder, this.snapshot, this.controller.memberName)}`; }
     get order() { return this.options.order; }
     get ['#this']() {
         return `Operation: ${this.why()}`;
     }
     why() {
-        let ms = Date.now();
-        const prev = this.revision.prev.revision.data[this.controller.memberName];
-        if (prev instanceof Operation)
-            ms = prev.started !== 0 ? Math.abs(this.started || ms) - Math.abs(prev.started) : Infinity;
-        let trigger;
+        let cause;
         if (this.cause)
-            trigger = `   <<   ${propagationHint(this.cause, true).join('   <<   ')}`;
+            cause = `   <<   ${this.cause}`;
         else if (this.controller.options.kind === Options_1.Kind.Transaction)
-            trigger = '   <<   operation';
+            cause = '   <<   operation';
         else
-            trigger = `   <<   T${this.revision.snapshot.id}[${this.revision.snapshot.hint}]`;
-        return `${this.hint()}${trigger}   (${ms !== Infinity ? `${ms}ms since previous run` : 'initial run'})`;
+            cause = `   <<   T${this.snapshot.id}[${this.snapshot.hint}]`;
+        return `${this.hint()}${cause}`;
     }
     briefWhy() {
-        return this.cause ? propagationHint(this.cause, false)[0] : ROOT_HOLDER.hint;
+        return this.why();
     }
     dependencies() {
         throw (0, Dbg_1.misuse)('not implemented yet');
@@ -266,31 +262,33 @@ class Operation extends Data_1.Observable {
         else
             this.result = Promise.reject(this.error);
     }
-    markObsoleteDueTo(observable, cause, since, reactions) {
+    markObsoleteDueTo(observable, memberName, snapshot, holder, outer, since, reactions) {
         var _a, _b, _c;
         if (this.observables !== undefined) {
-            if (observable.isOperation || this !== cause.revision.changes.get(cause.memberName)) {
+            const skip = !observable.isOperation &&
+                snapshot === this.snapshot;
+            if (!skip) {
+                const why = `${Snapshot_1.Dump.rev2(holder, snapshot, memberName)}    <<    ${outer}`;
                 this.unsubscribeFromAllObservables();
-                this.obsoleteDueTo = cause;
+                this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
                 const isReaction = this.options.kind === Options_1.Kind.Reaction;
                 if (Dbg_1.Dbg.isOn && (Dbg_1.Dbg.trace.obsolete || ((_a = this.options.trace) === null || _a === void 0 ? void 0 : _a.obsolete)))
-                    Dbg_1.Dbg.log(Dbg_1.Dbg.trace.transaction && !Snapshot_1.Snapshot.current().sealed ? '║' : ' ', isReaction ? '█' : '▒', isReaction && cause.revision === Snapshot_1.ROOT_REV
+                    Dbg_1.Dbg.log(Dbg_1.Dbg.trace.transaction && !Snapshot_1.Snapshot.current().sealed ? '║' : ' ', isReaction ? '█' : '▒', isReaction && snapshot === Snapshot_1.ROOT_REV.snapshot
                         ? `${this.hint()} is a reaction and will run automatically (order ${this.options.order})`
-                        : `${this.hint()} is obsolete due to ${Snapshot_1.Dump.rev(cause.revision, cause.memberName)} since v${since}${isReaction ? ` and will run automatically (order ${this.options.order})` : ''}`);
+                        : `${this.hint()} is obsolete due to ${Snapshot_1.Dump.rev2(holder, snapshot, memberName)} since v${since}${isReaction ? ` and will run automatically (order ${this.options.order})` : ''}`);
                 if (isReaction)
                     reactions.push(this);
                 else
-                    (_b = this.observers) === null || _b === void 0 ? void 0 : _b.forEach(c => c.markObsoleteDueTo(this, { revision: this.revision, memberName: this.controller.memberName, usageCount: 0 }, since, reactions));
+                    (_b = this.observers) === null || _b === void 0 ? void 0 : _b.forEach(c => c.markObsoleteDueTo(this, this.controller.memberName, this.snapshot, this.controller.ownHolder, why, since, reactions));
                 const tran = this.transaction;
-                if (tran.snapshot === cause.revision.snapshot) {
-                    (0, Dbg_1.misuse)('not implemented: running reactions within original transaction');
+                if (tran.snapshot === snapshot) {
                 }
                 else if (!tran.isFinished && this !== observable)
-                    tran.cancel(new Error(`T${tran.id}[${tran.hint}] is canceled due to obsolete ${Snapshot_1.Dump.rev(cause.revision, cause.memberName)} changed by T${cause.revision.snapshot.id}[${cause.revision.snapshot.hint}]`), null);
+                    tran.cancel(new Error(`T${tran.id}[${tran.hint}] is canceled due to obsolete ${Snapshot_1.Dump.rev2(holder, snapshot, memberName)} changed by T${snapshot.id}[${snapshot.hint}]`), null);
             }
             else if (Dbg_1.Dbg.isOn && (Dbg_1.Dbg.trace.obsolete || ((_c = this.options.trace) === null || _c === void 0 ? void 0 : _c.obsolete)))
-                Dbg_1.Dbg.log(' ', 'x', `${this.hint()} is not obsolete due to its own change to ${Snapshot_1.Dump.rev(cause.revision, cause.memberName)}`);
+                Dbg_1.Dbg.log(' ', 'x', `${this.hint()} is not obsolete due to its own change to ${Snapshot_1.Dump.rev2(holder, snapshot, memberName)}`);
         }
     }
     runIfNotUpToDate(now, nothrow) {
@@ -407,6 +405,7 @@ class Operation extends Data_1.Observable {
             Dbg_1.Dbg.log('║', `${op}`, `${this.hint()} ${message}`, ms, highlight);
         if (ms > (main ? Hooks_1.Hooks.mainThreadBlockingWarningThreshold : Hooks_1.Hooks.asyncActionDurationWarningThreshold))
             Dbg_1.Dbg.log('', '[!]', this.why(), ms, main ? '    *** main thread is too busy ***' : '    *** async is too long ***');
+        this.cause = undefined;
         if (this.options.monitor)
             this.monitorLeave(this.options.monitor);
     }
@@ -451,19 +450,19 @@ class Operation extends Data_1.Observable {
                     ctx.bumpBy(r.snapshot.timestamp);
                 const t = weak ? -1 : ctx.timestamp;
                 if (!op.subscribeTo(observable, r, m, h, t))
-                    op.markObsoleteDueTo(observable, { revision: r, memberName: m, usageCount: 0 }, ctx.timestamp, ctx.reactions);
+                    op.markObsoleteDueTo(observable, m, r.snapshot, h, INITIAL_CAUSE, ctx.timestamp, ctx.reactions);
             }
         }
     }
     static markEdited(oldValue, newValue, edited, r, m, h) {
-        edited ? r.changes.set(m, Operation.current) : r.changes.delete(m);
+        edited ? r.changes.add(m) : r.changes.delete(m);
         if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.write)
-            edited ? Dbg_1.Dbg.log('║', '  ✎', `${Snapshot_1.Dump.rev(r, m)} is changed from ${valueHint(oldValue, m)} to ${valueHint(newValue, m)}`) : Dbg_1.Dbg.log('║', '  ✎', `${Snapshot_1.Dump.rev(r, m)} is changed from ${valueHint(oldValue, m)} to ${valueHint(newValue, m)}`, undefined, ' (same as previous)');
+            edited ? Dbg_1.Dbg.log('║', '  ✎', `${Snapshot_1.Dump.rev2(h, r.snapshot, m)} is changed from ${valueHint(oldValue, m)} to ${valueHint(newValue, m)}`) : Dbg_1.Dbg.log('║', '  ✎', `${Snapshot_1.Dump.rev2(h, r.snapshot, m)} is changed from ${valueHint(oldValue, m)} to ${valueHint(newValue, m)}`, undefined, ' (same as previous)');
     }
     static isConflicting(oldValue, newValue) {
         let result = oldValue !== newValue;
         if (result)
-            result = oldValue instanceof Operation && oldValue.cause !== ROOT_TRIGGER;
+            result = oldValue instanceof Operation && oldValue.cause !== INITIAL_CAUSE;
         return result;
     }
     static propagateAllChangesThroughSubscriptions(snapshot) {
@@ -483,30 +482,39 @@ class Operation extends Data_1.Observable {
     static revokeAllSubscriptions(snapshot) {
         snapshot.changeset.forEach((r, h) => r.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(true, snapshot.timestamp, r, m, h, undefined)));
     }
-    static propagateMemberChangeThroughSubscriptions(discard, timestamp, r, m, h, reactions) {
+    static propagateMemberChangeThroughSubscriptions(unsubscribe, timestamp, r, m, h, reactions) {
         var _a;
+        const curr = r.data[m];
         if (reactions) {
             const prev = r.prev.revision.data[m];
             if (prev !== undefined && prev instanceof Data_1.Observable) {
-                const cause = { revision: r, memberName: m, usageCount: 0 };
-                if (prev instanceof Operation && (prev.obsoleteSince === Snapshot_1.MAX_TIMESTAMP || prev.obsoleteSince <= 0)) {
-                    prev.obsoleteDueTo = cause;
-                    prev.obsoleteSince = timestamp;
-                    prev.unsubscribeFromAllObservables();
+                const why = `T${r.snapshot.id}[${r.snapshot.hint}]`;
+                if (prev instanceof Operation) {
+                    if ((prev.obsoleteSince === Snapshot_1.MAX_TIMESTAMP || prev.obsoleteSince <= 0)) {
+                        prev.obsoleteDueTo = why;
+                        prev.obsoleteSince = timestamp;
+                        prev.unsubscribeFromAllObservables();
+                    }
+                    const prevSuccessor = prev.successor;
+                    if (prevSuccessor !== curr) {
+                        if (prevSuccessor && !prevSuccessor.transaction.isFinished)
+                            prevSuccessor.transaction.cancel(new Error(`T${prevSuccessor.transaction.id}[${prevSuccessor.transaction.hint}] is canceled by T${r.snapshot.id}[${r.snapshot.hint}] and will not run anymore`), null);
+                    }
+                    else
+                        prev.successor = undefined;
                 }
-                (_a = prev.observers) === null || _a === void 0 ? void 0 : _a.forEach(c => c.markObsoleteDueTo(prev, cause, timestamp, reactions));
+                (_a = prev.observers) === null || _a === void 0 ? void 0 : _a.forEach(c => c.markObsoleteDueTo(prev, m, r.snapshot, h, why, timestamp, reactions));
             }
         }
-        const curr = r.data[m];
         if (curr instanceof Operation) {
-            if (curr.revision === r && curr.observables !== undefined) {
+            if (curr.snapshot === r.snapshot && curr.observables !== undefined) {
                 if (Hooks_1.Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
                     curr.observables.forEach((hint, v) => {
                         if (hint.usageCount > Hooks_1.Hooks.repetitiveUsageWarningThreshold)
-                            Dbg_1.Dbg.log('', '[!]', `${curr.hint()} uses ${Snapshot_1.Dump.rev(hint.revision, hint.memberName)} ${hint.usageCount} times (consider remembering it in a local variable)`, 0, ' *** WARNING ***');
+                            Dbg_1.Dbg.log('', '[!]', `${curr.hint()} uses ${Snapshot_1.Dump.rev2(hint.holder, hint.snapshot, hint.memberName)} ${hint.usageCount} times (consider remembering it in a local variable)`, 0, ' *** WARNING ***');
                     });
                 }
-                if (discard)
+                if (unsubscribe)
                     curr.unsubscribeFromAllObservables();
             }
         }
@@ -519,10 +527,10 @@ class Operation extends Data_1.Observable {
             curr.observers = undefined;
         }
     }
-    static enqueueDetectedReactions(snapshot) {
+    static enqueueReactionsToRun(reactions) {
         const queue = Operation.queuedReactions;
         const isReactionLoopRequired = queue.length === 0;
-        for (const r of snapshot.reactions)
+        for (const r of reactions)
             queue.push(r);
         if (isReactionLoopRequired)
             OperationController.runWithin(undefined, Operation.runQueuedReactionsLoop);
@@ -543,7 +551,7 @@ class Operation extends Data_1.Observable {
             var _a;
             value.observers.delete(this);
             if (Dbg_1.Dbg.isOn && (Dbg_1.Dbg.trace.read || ((_a = this.options.trace) === null || _a === void 0 ? void 0 : _a.read)))
-                Dbg_1.Dbg.log(Dbg_1.Dbg.trace.transaction && !Snapshot_1.Snapshot.current().sealed ? '║' : ' ', '-', `${this.hint()} is unsubscribed from ${Snapshot_1.Dump.rev(hint.revision, hint.memberName)}`);
+                Dbg_1.Dbg.log(Dbg_1.Dbg.trace.transaction && !Snapshot_1.Snapshot.current().sealed ? '║' : ' ', '-', `${this.hint()} is unsubscribed from ${Snapshot_1.Dump.rev2(hint.holder, hint.snapshot, hint.memberName)}`);
         });
         this.observables = undefined;
     }
@@ -559,18 +567,18 @@ class Operation extends Data_1.Observable {
             if (this.observables !== undefined) {
                 if (!observable.observers)
                     observable.observers = new Set();
-                const info = { revision: r, memberName: m, usageCount: times };
+                const info = { holder: h, snapshot: r.snapshot, memberName: m, usageCount: times };
                 observable.observers.add(this);
                 this.observables.set(observable, info);
                 if (Dbg_1.Dbg.isOn && (Dbg_1.Dbg.trace.read || ((_a = this.options.trace) === null || _a === void 0 ? void 0 : _a.read)))
-                    Dbg_1.Dbg.log('║', '  ∞ ', `${this.hint()} is subscribed to ${Snapshot_1.Dump.rev(r, m)}${info.usageCount > 1 ? ` (${info.usageCount} times)` : ''}`);
+                    Dbg_1.Dbg.log('║', '  ∞ ', `${this.hint()} is subscribed to ${Snapshot_1.Dump.rev2(h, r.snapshot, m)}${info.usageCount > 1 ? ` (${info.usageCount} times)` : ''}`);
             }
             else if (Dbg_1.Dbg.isOn && (Dbg_1.Dbg.trace.read || ((_b = this.options.trace) === null || _b === void 0 ? void 0 : _b.read)))
-                Dbg_1.Dbg.log('║', '  x ', `${this.hint()} is obsolete and is NOT subscribed to ${Snapshot_1.Dump.rev(r, m)}`);
+                Dbg_1.Dbg.log('║', '  x ', `${this.hint()} is obsolete and is NOT subscribed to ${Snapshot_1.Dump.rev2(h, r.snapshot, m)}`);
         }
         else {
             if (Dbg_1.Dbg.isOn && (Dbg_1.Dbg.trace.read || ((_c = this.options.trace) === null || _c === void 0 ? void 0 : _c.read)))
-                Dbg_1.Dbg.log('║', '  x ', `${this.hint()} is NOT subscribed to already obsolete ${Snapshot_1.Dump.rev(r, m)}`);
+                Dbg_1.Dbg.log('║', '  x ', `${this.hint()} is NOT subscribed to already obsolete ${Snapshot_1.Dump.rev2(h, r.snapshot, m)}`);
         }
         return ok;
     }
@@ -593,7 +601,7 @@ class Operation extends Data_1.Observable {
         let op = initial[m];
         const ctl = op ? op.controller : new OperationController(ROOT_HOLDER, m);
         const opts = op ? op.options : Hooks_1.OptionsImpl.INITIAL;
-        initial[m] = op = new Operation(ctl, Snapshot_1.ROOT_REV, new Hooks_1.OptionsImpl(getter, setter, opts, options, implicit));
+        initial[m] = op = new Operation(ctl, Snapshot_1.ROOT_REV.snapshot, new Hooks_1.OptionsImpl(getter, setter, opts, options, implicit));
         if (op.options.kind === Options_1.Kind.Reaction && op.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactions = Data_1.Meta.acquire(proto, Data_1.Meta.Reactions);
             reactions[m] = op;
@@ -606,14 +614,13 @@ class Operation extends Data_1.Observable {
     }
     static init() {
         Object.freeze(ROOT_ARGS);
-        Object.freeze(ROOT_TRIGGER);
         Dbg_1.Dbg.getMergedTraceOptions = getMergedTraceOptions;
         Snapshot_1.Snapshot.markUsed = Operation.markUsed;
         Snapshot_1.Snapshot.markEdited = Operation.markEdited;
         Snapshot_1.Snapshot.isConflicting = Operation.isConflicting;
         Snapshot_1.Snapshot.propagateAllChangesThroughSubscriptions = Operation.propagateAllChangesThroughSubscriptions;
         Snapshot_1.Snapshot.revokeAllSubscriptions = Operation.revokeAllSubscriptions;
-        Snapshot_1.Snapshot.enqueueDetectedReactions = Operation.enqueueDetectedReactions;
+        Snapshot_1.Snapshot.enqueueReactionsToRun = Operation.enqueueReactionsToRun;
         Hooks_1.Hooks.createControllerAndGetHook = Operation.createControllerAndGetHook;
         Hooks_1.Hooks.rememberOperationOptions = Operation.rememberOperationOptions;
         Promise.prototype.then = reactronicHookedThen;
@@ -642,18 +649,6 @@ class Operation extends Data_1.Observable {
 Operation.current = undefined;
 Operation.queuedReactions = [];
 Operation.deferredReactions = [];
-function propagationHint(cause, full) {
-    const result = [];
-    let observable = cause.revision.data[cause.memberName];
-    while (observable instanceof Operation && observable.obsoleteDueTo) {
-        full && result.push(Snapshot_1.Dump.rev(cause.revision, cause.memberName));
-        cause = observable.obsoleteDueTo;
-        observable = cause.revision.data[cause.memberName];
-    }
-    result.push(Snapshot_1.Dump.rev(cause.revision, cause.memberName));
-    full && result.push(cause.revision.snapshot.hint);
-    return result;
-}
 function valueHint(value, m) {
     let result = '';
     if (Array.isArray(value))
@@ -663,7 +658,7 @@ function valueHint(value, m) {
     else if (value instanceof Map)
         result = `Map(${value.size})`;
     else if (value instanceof Operation)
-        result = `${Snapshot_1.Dump.rev(value.revision, m)}`;
+        result = `${Snapshot_1.Dump.rev2(value.controller.ownHolder, value.snapshot, m)}`;
     else if (value === Data_1.Meta.Disposed)
         result = '<disposed>';
     else if (value !== undefined && value !== null)

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

@@ -17,8 +17,8 @@ export declare class Snapshot implements AbstractSnapshot {
     get timestamp(): number;
     private stamp;
     private bumper;
-    readonly changeset: Map<ObjectHolder, ObjectRevision>;
-    readonly reactions: Observer[];
+    changeset: Map<ObjectHolder, ObjectRevision>;
+    reactions: Observer[];
     sealed: boolean;
     constructor(options: SnapshotOptions | null);
     static current: () => Snapshot;
@@ -28,7 +28,7 @@ export declare class Snapshot implements AbstractSnapshot {
     static isConflicting: (oldValue: any, newValue: any) => boolean;
     static propagateAllChangesThroughSubscriptions: (snapshot: Snapshot) => void;
     static revokeAllSubscriptions: (snapshot: Snapshot) => void;
-    static enqueueDetectedReactions: (snapshot: Snapshot) => void;
+    static enqueueReactionsToRun: (reactions: Array<Observer>) => void;
     seekRevision(h: ObjectHolder, m: MemberName): ObjectRevision;
     getCurrentRevision(h: ObjectHolder, m: MemberName): ObjectRevision;
     getEditableRevision(h: ObjectHolder, m: MemberName, value: any, token?: any): ObjectRevision;
@@ -40,17 +40,17 @@ export declare class Snapshot implements AbstractSnapshot {
     bumpBy(timestamp: number): void;
     rebase(): ObjectRevision[] | undefined;
     private static merge;
-    applyOrDiscard(error?: any): void;
+    applyOrDiscard(error?: any): Array<Observer>;
     static sealObjectRevision(h: ObjectHolder, r: ObjectRevision): void;
     static sealObservable(observable: Observable | symbol, m: MemberName, typeName: string): void;
-    collectGarbage(): void;
     static freezeObjectRevision(r: ObjectRevision): ObjectRevision;
-    private triggerGarbageCollection;
+    triggerGarbageCollection(): void;
     private unlinkHistory;
     static _init(): void;
 }
 export declare class Dump {
     static obj(h: ObjectHolder | undefined, m?: MemberName | undefined, stamp?: number, op?: number, xop?: number, typeless?: boolean): string;
+    static rev2(h: ObjectHolder, s: AbstractSnapshot, m?: MemberName, value?: Observable): string;
     static rev(r: ObjectRevision, m?: MemberName): string;
     static conflicts(conflicts: ObjectRevision[]): string;
     static conflictingMemberHint(m: MemberName, ours: ObjectRevision, theirs: ObjectRevision): string;

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

@@ -27,6 +27,8 @@ Object.defineProperty(Data_1.ObjectHolder.prototype, '#this', {
         return result;
     },
 });
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_MAP = Utils_1.Utils.freezeMap(new Map());
 class Snapshot {
     constructor(options) {
         this.id = ++Snapshot.idGen;
@@ -128,14 +130,14 @@ class Snapshot {
         if (this.changeset.size > 0) {
             this.changeset.forEach((r, h) => {
                 if (r.prev.revision !== h.head) {
-                    const merged = Snapshot.merge(r, h.head);
+                    const merged = Snapshot.merge(h, r);
                     if (r.conflicts.size > 0) {
                         if (!conflicts)
                             conflicts = [];
                         conflicts.push(r);
                     }
                     if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.transaction)
-                        Dbg_1.Dbg.log('╠╝', '', `${Dump.rev(r)} is merged with ${Dump.rev(h.head)} among ${merged} properties with ${r.conflicts.size} conflicts.`);
+                        Dbg_1.Dbg.log('╠╝', '', `${Dump.rev2(h, r.snapshot)} is merged with ${Dump.rev2(h, h.head.snapshot)} among ${merged} properties with ${r.conflicts.size} conflicts.`);
                 }
             });
             if (this.options.token === undefined) {
@@ -152,8 +154,9 @@ class Snapshot {
         }
         return conflicts;
     }
-    static merge(ours, head) {
+    static merge(h, ours) {
         let counter = 0;
+        const head = h.head;
         const disposed = head.changes.has(Data_1.Meta.Disposed);
         const merged = Object.assign({}, head.data);
         ours.changes.forEach((o, m) => {
@@ -162,7 +165,7 @@ class Snapshot {
             if (disposed || m === Data_1.Meta.Disposed) {
                 if (disposed !== (m === Data_1.Meta.Disposed)) {
                     if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.change)
-                        Dbg_1.Dbg.log('║╠', '', `${Dump.rev(ours, m)} <> ${Dump.rev(head, m)}`, 0, ' *** CONFLICT ***');
+                        Dbg_1.Dbg.log('║╠', '', `${Dump.rev2(h, ours.snapshot, m)} <> ${Dump.rev2(h, head.snapshot, m)}`, 0, ' *** CONFLICT ***');
                     ours.conflicts.set(m, head);
                 }
             }
@@ -171,7 +174,7 @@ class Snapshot {
                 if (conflict)
                     ours.conflicts.set(m, head);
                 if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.change)
-                    Dbg_1.Dbg.log('║╠', '', `${Dump.rev(ours, m)} ${conflict ? '<>' : '=='} ${Dump.rev(head, m)}`, 0, conflict ? ' *** CONFLICT ***' : undefined);
+                    Dbg_1.Dbg.log('║╠', '', `${Dump.rev2(h, ours.snapshot, m)} ${conflict ? '<>' : '=='} ${Dump.rev2(h, head.snapshot, m)}`, 0, conflict ? ' *** CONFLICT ***' : undefined);
             }
         });
         Utils_1.Utils.copyAllMembers(merged, ours.data);
@@ -200,7 +203,7 @@ class Snapshot {
                     const members = [];
                     r.changes.forEach((o, m) => members.push(m.toString()));
                     const s = members.join(', ');
-                    Dbg_1.Dbg.log('║', '√', `${Dump.rev(r)} (${s}) is ${r.prev.revision === exports.ROOT_REV ? 'constructed' : `applied on top of ${Dump.rev(r.prev.revision)}`}`);
+                    Dbg_1.Dbg.log('║', '√', `${Dump.rev2(h, r.snapshot)} (${s}) is ${r.prev.revision === exports.ROOT_REV ? 'constructed' : `applied on top of ${Dump.rev2(h, r.prev.revision.snapshot)}`}`);
                 });
             }
             if (Dbg_1.Dbg.trace.transaction)
@@ -208,6 +211,7 @@ class Snapshot {
         }
         if (!error)
             Snapshot.propagateAllChangesThroughSubscriptions(this);
+        return this.reactions;
     }
     static sealObjectRevision(h, r) {
         if (!r.changes.has(Data_1.Meta.Disposed))
@@ -228,17 +232,9 @@ class Snapshot {
             }
         }
     }
-    collectGarbage() {
-        if (Dbg_1.Dbg.isOn) {
-            Utils_1.Utils.freezeMap(this.changeset);
-            Object.freeze(this.reactions);
-            Object.freeze(this);
-        }
-        this.triggerGarbageCollection();
-    }
     static freezeObjectRevision(r) {
         Object.freeze(r.data);
-        Utils_1.Utils.freezeMap(r.changes);
+        Utils_1.Utils.freezeSet(r.changes);
         Utils_1.Utils.freezeMap(r.conflicts);
         return r;
     }
@@ -267,23 +263,25 @@ class Snapshot {
             Dbg_1.Dbg.log('', '[G]', `Dismiss history below v${this.stamp}t${this.id} (${this.hint})`);
         this.changeset.forEach((r, h) => {
             if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.gc && r.prev.revision !== exports.ROOT_REV)
-                Dbg_1.Dbg.log(' ', '  ', `${Dump.rev(r.prev.revision)} is ready for GC because overwritten by ${Dump.rev(r)}`);
+                Dbg_1.Dbg.log(' ', '  ', `${Dump.rev2(h, r.prev.revision.snapshot)} is ready for GC because overwritten by ${Dump.rev2(h, r.snapshot)}`);
             if (Snapshot.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
-                if (r.prev.revision !== exports.ROOT_REV) {
+                if (r.prev.revision !== exports.ROOT_REV)
                     Snapshot.totalObjectRevisionCount--;
-                }
-                if (r.changes.has(Data_1.Meta.Disposed)) {
+                if (r.changes.has(Data_1.Meta.Disposed))
                     Snapshot.totalObjectHolderCount--;
-                }
             }
             r.prev.revision = exports.ROOT_REV;
         });
+        this.changeset = EMPTY_MAP;
+        this.reactions = EMPTY_ARRAY;
+        if (Dbg_1.Dbg.isOn)
+            Object.freeze(this);
     }
     static _init() {
         const root = exports.ROOT_REV.snapshot;
         root.acquire(root);
         root.applyOrDiscard();
-        root.collectGarbage();
+        root.triggerGarbageCollection();
         Snapshot.freezeObjectRevision(exports.ROOT_REV);
         Snapshot.idGen = 100;
         Snapshot.stampGen = 101;
@@ -309,7 +307,7 @@ Snapshot.markEdited = Utils_1.UNDEF;
 Snapshot.isConflicting = Utils_1.UNDEF;
 Snapshot.propagateAllChangesThroughSubscriptions = (snapshot) => { };
 Snapshot.revokeAllSubscriptions = (snapshot) => { };
-Snapshot.enqueueDetectedReactions = (snapshot) => { };
+Snapshot.enqueueReactionsToRun = (reactions) => { };
 class Dump {
     static obj(h, m, stamp, op, xop, typeless) {
         const member = m !== undefined ? `.${m.toString()}` : '';
@@ -317,6 +315,9 @@ class Dump {
             ? `root${member}`
             : stamp === undefined ? `${h.hint}${member} #${h.id}` : `${h.hint}${member} #${h.id}t${op}v${stamp}${xop !== undefined && xop !== 0 ? `t${xop}` : ''}`;
     }
+    static rev2(h, s, m, value) {
+        return Dump.obj(h, m, s.timestamp, s.id, value === null || value === void 0 ? void 0 : value.selfSnapshotId);
+    }
     static rev(r, m) {
         const h = Data_1.Meta.get(r.data, Data_1.Meta.Holder);
         const value = m !== undefined ? r.data[m] : undefined;

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

@@ -228,9 +228,9 @@ class TransactionImpl extends Transaction {
         finally {
             this.pending--;
             if (this.sealed && this.pending === 0) {
-                this.applyOrDiscard();
+                const reactions = this.applyOrDiscard();
                 TransactionImpl.curr = outer;
-                TransactionImpl.standalone(Snapshot_1.Snapshot.enqueueDetectedReactions, this.snapshot);
+                TransactionImpl.standalone(Snapshot_1.Snapshot.enqueueReactionsToRun, reactions);
             }
             else
                 TransactionImpl.curr = outer;
@@ -259,11 +259,12 @@ class TransactionImpl extends Transaction {
         throw (0, Dbg_1.error)(`T${this.id}[${this.hint}] conflicts with: ${Snapshot_1.Dump.conflicts(conflicts)}`, undefined);
     }
     applyOrDiscard() {
+        let reactions;
         try {
             if (Dbg_1.Dbg.isOn && Dbg_1.Dbg.trace.change)
                 Dbg_1.Dbg.log('╠═', '', '', undefined, 'changes');
-            this.snapshot.applyOrDiscard(this.canceled);
-            this.snapshot.collectGarbage();
+            reactions = this.snapshot.applyOrDiscard(this.canceled);
+            this.snapshot.triggerGarbageCollection();
             if (this.promise) {
                 if (this.canceled && !this.after)
                     this.reject(this.canceled);
@@ -277,6 +278,7 @@ class TransactionImpl extends Transaction {
             (0, Dbg_1.fatal)(e);
             throw e;
         }
+        return reactions;
     }
     acquirePromise() {
         if (!this.promise) {

package/build/dist/source/util/Utils.d.ts

@@ -1,7 +1,7 @@
 export declare type F<T> = (...args: any[]) => T;
 export declare class Utils {
-    static freezeSet<T>(obj?: Set<T>): void;
-    static freezeMap<K, V>(obj?: Map<K, V>): void;
+    static freezeSet<T>(obj?: Set<T>): Set<T> | undefined;
+    static freezeMap<K, V>(obj?: Map<K, V>): Map<K, V> | undefined;
     static copyAllMembers(source: any, target: any): any;
 }
 export declare function UNDEF(...args: any[]): never;

package/build/dist/source/util/Utils.js

@@ -19,6 +19,7 @@ class Utils {
             Object.defineProperty(obj, 'clear', pd);
             Object.freeze(obj);
         }
+        return obj;
     }
     static freezeMap(obj) {
         if (obj instanceof Map) {
@@ -28,6 +29,7 @@ class Utils {
             Object.defineProperty(obj, 'clear', pd);
             Object.freeze(obj);
         }
+        return obj;
     }
     static copyAllMembers(source, target) {
         for (const m of Object.getOwnPropertyNames(source))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.21.600",
+  "version": "0.21.604",
   "description": "Reactronic - Transactional Reactive State Management",
   "main": "build/dist/source/api.js",
   "types": "build/dist/source/api.d.ts",