reactronic 0.22.302 → 0.22.303

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

@@ -5,19 +5,19 @@ const Dbg_1 = require("../util/Dbg");
 const Options_1 = require("../Options");
 const Controller_1 = require("../Controller");
 const Data_1 = require("./Data");
-const Snapshot_1 = require("./Snapshot");
+const Changeset_1 = require("./Changeset");
 const Transaction_1 = require("./Transaction");
 const Monitor_1 = require("./Monitor");
 const Hooks_1 = require("./Hooks");
 const Journal_1 = require("./Journal");
 const BOOT_ARGS = [];
 const BOOT_CAUSE = '<boot>';
-const ROOT_HOLDER = new Data_1.DataHolder(undefined, undefined, Hooks_1.Hooks.proxy, Snapshot_1.ROOT_REV, '<root>');
+const EMPTY_HANDLE = new Data_1.ObjectHandle(undefined, undefined, Hooks_1.Hooks.handler, Changeset_1.EMPTY_SNAPSHOT, '<empty>');
 class OperationController extends Controller_1.Controller {
-    constructor(ownHolder, memberName) {
+    constructor(h, m) {
         super();
-        this.ownHolder = ownHolder;
-        this.memberName = memberName;
+        this.objectHandle = h;
+        this.memberName = m;
     }
     configure(options) { return OperationController.configureImpl(this, options); }
     get options() { return this.peek(undefined).operation.options; }
@@ -25,35 +25,35 @@ class OperationController extends Controller_1.Controller {
     get args() { return this.use().operation.args; }
     get result() { return this.useOrRun(true, undefined).content; }
     get error() { return this.use().operation.error; }
-    get stamp() { return this.use().revision.snapshot.timestamp; }
+    get stamp() { return this.use().snapshot.changeset.timestamp; }
     get isUpToDate() { return this.use().isUpToDate; }
-    markObsolete() { Transaction_1.Transaction.run({ hint: Dbg_1.Log.isOn ? `markObsolete(${Snapshot_1.Dump.obj(this.ownHolder, this.memberName)})` : 'markObsolete()' }, OperationController.markObsolete, this); }
+    markObsolete() { Transaction_1.Transaction.run({ hint: Dbg_1.Log.isOn ? `markObsolete(${Changeset_1.Dump.obj(this.objectHandle, this.memberName)})` : 'markObsolete()' }, OperationController.markObsolete, this); }
     pullLastResult(args) { return this.useOrRun(true, args).content; }
     useOrRun(weak, args) {
         var _a;
         let oc = this.peek(args);
-        const ctx = oc.snapshot;
+        const ctx = oc.changeset;
         const op = oc.operation;
         const opts = op.options;
-        if (!oc.isUpToDate && oc.revision.data[Data_1.Meta.Disposed] === undefined
+        if (!oc.isUpToDate && !oc.snapshot.disposed
             && (!weak || op.cause === BOOT_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 ||
                 (opts.kind === Options_1.Kind.Transaction && outerOpts && (outerOpts.noSideEffects || outerOpts.kind === Options_1.Kind.Cache)) ||
-                (opts.kind === Options_1.Kind.Cache && (oc.revision.snapshot.sealed ||
-                    oc.revision.former.revision !== Snapshot_1.ROOT_REV));
+                (opts.kind === Options_1.Kind.Cache && (oc.snapshot.changeset.sealed ||
+                    oc.snapshot.former.snapshot !== Changeset_1.EMPTY_SNAPSHOT));
             const token = opts.noSideEffects ? this : undefined;
             const oc2 = this.run(oc, standalone, opts, token, args);
-            const ctx2 = oc2.operation.snapshot;
+            const ctx2 = oc2.operation.changeset;
             if (!weak || ctx === ctx2 || (ctx2.sealed && ctx.timestamp >= ctx2.timestamp))
                 oc = oc2;
         }
         else if (Dbg_1.Log.isOn && Dbg_1.Log.opt.operation && (opts.logging === undefined ||
             opts.logging.operation === undefined || opts.logging.operation === true))
-            Dbg_1.Log.write(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}]`);
+            Dbg_1.Log.write(Transaction_1.Transaction.current.isFinished ? '' : '║', ' (=)', `${Changeset_1.Dump.snapshot2(oc.operation.controller.objectHandle, oc.changeset, 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);
+        Changeset_1.Changeset.markUsed(t, oc.snapshot, this.memberName, this.objectHandle, t.options.kind, weak);
         return t;
     }
     static of(method) {
@@ -105,75 +105,74 @@ class OperationController extends Controller_1.Controller {
         return op ? op.dependencies() : ['Rx.dependencies should be called from inside of reactive method'];
     }
     peek(args) {
-        const ctx = Snapshot_1.Snapshot.current();
-        const r = ctx.seekRevision(this.ownHolder, this.memberName);
-        const op = this.acquireFromRevision(r, args);
+        const ctx = Changeset_1.Changeset.current();
+        const os = ctx.seekSnapshot(this.objectHandle, this.memberName);
+        const op = this.acquireFromSnapshot(os, args);
         const isValid = op.options.kind !== Options_1.Kind.Transaction && op.cause !== BOOT_CAUSE &&
-            (ctx === op.snapshot || ctx.timestamp < op.obsoleteSince) &&
+            (ctx === op.changeset || ctx.timestamp < op.obsoleteSince) &&
             (!op.options.triggeringArgs || args === undefined ||
-                op.args.length === args.length && op.args.every((t, i) => t === args[i])) ||
-            r.data[Data_1.Meta.Disposed] !== undefined;
-        return { operation: op, isUpToDate: isValid, snapshot: ctx, revision: r };
+                op.args.length === args.length && op.args.every((t, i) => t === args[i])) || os.disposed;
+        return { operation: op, isUpToDate: isValid, changeset: ctx, snapshot: os };
     }
     use() {
         const oc = this.peek(undefined);
-        Snapshot_1.Snapshot.markUsed(oc.operation, oc.revision, this.memberName, this.ownHolder, oc.operation.options.kind, true);
+        Changeset_1.Changeset.markUsed(oc.operation, oc.snapshot, this.memberName, this.objectHandle, oc.operation.options.kind, true);
         return oc;
     }
     edit() {
-        const h = this.ownHolder;
+        const h = this.objectHandle;
         const m = this.memberName;
-        const ctx = Snapshot_1.Snapshot.edit();
-        const r = ctx.getEditableRevision(h, m, Data_1.Meta.Holder, this);
-        let op = this.acquireFromRevision(r, undefined);
-        if (op.snapshot !== r.snapshot) {
-            const op2 = new Operation(this, r.snapshot, op);
-            r.data[m] = op2.reenterOver(op);
-            ctx.bumpBy(r.former.revision.snapshot.timestamp);
-            Snapshot_1.Snapshot.markEdited(op, op2, true, r, m, h);
+        const ctx = Changeset_1.Changeset.edit();
+        const os = ctx.getEditableSnapshot(h, m, Data_1.Meta.Handle, this);
+        let op = this.acquireFromSnapshot(os, undefined);
+        if (op.changeset !== os.changeset) {
+            const op2 = new Operation(this, os.changeset, op);
+            os.data[m] = op2.reenterOver(op);
+            ctx.bumpBy(os.former.snapshot.changeset.timestamp);
+            Changeset_1.Changeset.markEdited(op, op2, true, os, m, h);
             op = op2;
         }
-        return { operation: op, isUpToDate: true, snapshot: ctx, revision: r };
+        return { operation: op, isUpToDate: true, changeset: ctx, snapshot: os };
     }
-    acquireFromRevision(r, args) {
+    acquireFromSnapshot(os, args) {
         const m = this.memberName;
-        let op = r.data[m];
+        let op = os.data[m];
         if (op.controller !== this) {
-            if (r.snapshot !== Snapshot_1.ROOT_REV.snapshot) {
-                const hint = Dbg_1.Log.isOn ? `${Snapshot_1.Dump.obj(this.ownHolder, m)}/boot` : 'MethodController/init';
-                const standalone = r.snapshot.sealed || r.former.revision !== Snapshot_1.ROOT_REV;
+            if (os.changeset !== Changeset_1.EMPTY_SNAPSHOT.changeset) {
+                const hint = Dbg_1.Log.isOn ? `${Changeset_1.Dump.obj(this.objectHandle, m)}/boot` : 'MethodController/init';
+                const standalone = os.changeset.sealed || os.former.snapshot !== Changeset_1.EMPTY_SNAPSHOT;
                 op = Transaction_1.Transaction.run({ hint, standalone, token: this }, () => {
-                    const h = this.ownHolder;
-                    let r2 = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
+                    const h = this.objectHandle;
+                    let r2 = Changeset_1.Changeset.current().getRelevantSnapshot(h, m);
                     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.snapshot, op2);
+                        r2 = Changeset_1.Changeset.edit().getEditableSnapshot(h, m, Data_1.Meta.Handle, this);
+                        const t = new Operation(this, r2.changeset, op2);
                         if (args)
                             t.args = args;
                         t.cause = BOOT_CAUSE;
                         r2.data[m] = t;
-                        Snapshot_1.Snapshot.markEdited(op2, t, true, r2, m, h);
+                        Changeset_1.Changeset.markEdited(op2, t, true, r2, m, h);
                         op2 = t;
                     }
                     return op2;
                 });
             }
             else {
-                const t = new Operation(this, r.snapshot, op);
+                const t = new Operation(this, os.changeset, op);
                 if (args)
                     t.args = args;
                 t.cause = BOOT_CAUSE;
-                r.data[m] = t;
+                os.data[m] = t;
                 op = t;
                 if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
-                    Dbg_1.Log.write('║', '  ⎘', `${Snapshot_1.Dump.obj(this.ownHolder, m)} is cloned outside of transaction`);
+                    Dbg_1.Log.write('║', ' ⎘⎘', `${Changeset_1.Dump.obj(this.objectHandle, m)} - new snapshot is created outside of transaction (revision ${os.revision})`);
             }
         }
         return op;
     }
     run(existing, standalone, options, token, args) {
-        const hint = Dbg_1.Log.isOn ? `${Snapshot_1.Dump.obj(this.ownHolder, this.memberName)}${args && args.length > 0 && (typeof args[0] === 'number' || typeof args[0] === 'string') ? ` - ${args[0]}` : ''}` : `${Snapshot_1.Dump.obj(this.ownHolder, this.memberName)}`;
+        const hint = Dbg_1.Log.isOn ? `${Changeset_1.Dump.obj(this.objectHandle, this.memberName)}${args && args.length > 0 && (typeof args[0] === 'number' || typeof args[0] === 'string') ? ` - ${args[0]}` : ''}` : `${Changeset_1.Dump.obj(this.objectHandle, this.memberName)}`;
         let oc = existing;
         const opts = { hint, standalone, journal: options.journal, logging: options.logging, token };
         const result = Transaction_1.Transaction.run(opts, (argsx) => {
@@ -181,7 +180,7 @@ class OperationController extends Controller_1.Controller {
                 oc = this.edit();
                 if (Dbg_1.Log.isOn && Dbg_1.Log.opt.operation)
                     Dbg_1.Log.write('║', '  𝑓', `${oc.operation.why()}`);
-                oc.operation.run(this.ownHolder.proxy, argsx);
+                oc.operation.run(this.objectHandle.proxy, argsx);
             }
             else {
                 oc = this.peek(argsx);
@@ -189,7 +188,7 @@ class OperationController extends Controller_1.Controller {
                     oc = this.edit();
                     if (Dbg_1.Log.isOn && Dbg_1.Log.opt.operation)
                         Dbg_1.Log.write('║', '  𝑓', `${oc.operation.why()}`);
-                    oc.operation.run(this.ownHolder.proxy, argsx);
+                    oc.operation.run(this.objectHandle.proxy, argsx);
                 }
             }
             return oc.operation.result;
@@ -199,18 +198,18 @@ class OperationController extends Controller_1.Controller {
     }
     static markObsolete(self) {
         const oc = self.peek(undefined);
-        const ctx = oc.snapshot;
-        oc.operation.markObsoleteDueTo(oc.operation, self.memberName, Snapshot_1.ROOT_REV.snapshot, ROOT_HOLDER, BOOT_CAUSE, ctx.timestamp, ctx.reactions);
+        const ctx = oc.changeset;
+        oc.operation.markObsoleteDueTo(oc.operation, self.memberName, Changeset_1.EMPTY_SNAPSHOT.changeset, EMPTY_HANDLE, BOOT_CAUSE, ctx.timestamp, ctx.reactions);
     }
 }
 exports.OperationController = OperationController;
 class Operation extends Data_1.Subscription {
-    constructor(controller, snapshot, former) {
+    constructor(controller, changeset, former) {
         super(undefined);
         this.margin = Operation.current ? Operation.current.margin + 1 : 1;
         this.transaction = Transaction_1.Transaction.current;
         this.controller = controller;
-        this.snapshot = snapshot;
+        this.changeset = changeset;
         this.subscriptions = new Map();
         if (former instanceof Operation) {
             this.options = former.options;
@@ -228,8 +227,8 @@ class Operation extends Data_1.Subscription {
         this.successor = undefined;
     }
     get isOperation() { return true; }
-    get originSnapshotId() { return this.snapshot.id; }
-    hint() { return `${Snapshot_1.Dump.rev2(this.controller.ownHolder, this.snapshot, this.controller.memberName)}`; }
+    get originSnapshotId() { return this.changeset.id; }
+    hint() { return `${Changeset_1.Dump.snapshot2(this.controller.objectHandle, this.changeset, this.controller.memberName)}`; }
     get order() { return this.options.order; }
     get ['#this']() {
         return `Operation: ${this.why()}`;
@@ -241,7 +240,7 @@ class Operation extends Data_1.Subscription {
         else if (this.controller.options.kind === Options_1.Kind.Transaction)
             cause = '   <<   operation';
         else
-            cause = `   <<   T${this.snapshot.id}[${this.snapshot.hint}]`;
+            cause = `   <<   T${this.changeset.id}[${this.changeset.hint}]`;
         return `${this.hint()}${cause}`;
     }
     briefWhy() {
@@ -268,39 +267,39 @@ class Operation extends Data_1.Subscription {
     run(proxy, args) {
         if (args)
             this.args = args;
-        this.obsoleteSince = Snapshot_1.MAX_TIMESTAMP;
+        this.obsoleteSince = Changeset_1.MAX_REVISION;
         if (!this.error)
             OperationController.runWithin(this, Operation.run, this, proxy);
         else
             this.result = Promise.reject(this.error);
     }
-    markObsoleteDueTo(subscription, memberName, snapshot, holder, outer, since, reactions) {
+    markObsoleteDueTo(subscription, m, changeset, h, outer, since, reactions) {
         var _a, _b, _c;
         if (this.subscriptions !== undefined) {
             const skip = !subscription.isOperation &&
-                snapshot === this.snapshot;
+                changeset === this.changeset;
             if (!skip) {
-                const why = `${Snapshot_1.Dump.rev2(holder, snapshot, memberName, subscription)}    <<    ${outer}`;
-                this.unsubscribeFromAllSubscriptions();
+                const why = `${Changeset_1.Dump.snapshot2(h, changeset, m, subscription)}    <<    ${outer}`;
+                const isReaction = this.options.kind === Options_1.Kind.Reaction;
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
-                const isReaction = this.options.kind === Options_1.Kind.Reaction;
                 if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.obsolete || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.obsolete)))
-                    Dbg_1.Log.write(Dbg_1.Log.opt.transaction && !Snapshot_1.Snapshot.current().sealed ? '║' : ' ', isReaction ? '█' : '▒', isReaction && snapshot === Snapshot_1.ROOT_REV.snapshot
+                    Dbg_1.Log.write(Dbg_1.Log.opt.transaction && !Changeset_1.Changeset.current().sealed ? '║' : ' ', isReaction ? '█' : '▒', isReaction && changeset === Changeset_1.EMPTY_SNAPSHOT.changeset
                         ? `${this.hint()} is a reaction 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})` : ''}`);
+                        : `${this.hint()} is obsolete due to ${Changeset_1.Dump.snapshot2(h, changeset, m)} since v${since}${isReaction ? ` and will run automatically (order ${this.options.order})` : ''}`);
+                this.unsubscribeFromAllSubscriptions();
                 if (isReaction)
                     reactions.push(this);
                 else
-                    (_b = this.subscribers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.controller.memberName, this.snapshot, this.controller.ownHolder, why, since, reactions));
+                    (_b = this.subscribers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.controller.memberName, this.changeset, this.controller.objectHandle, why, since, reactions));
                 const tran = this.transaction;
-                if (tran.snapshot === snapshot) {
+                if (tran.changeset === changeset) {
                 }
                 else if (!tran.isFinished && this !== subscription)
-                    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);
+                    tran.cancel(new Error(`T${tran.id}[${tran.hint}] is canceled due to obsolete ${Changeset_1.Dump.snapshot2(h, changeset, m)} changed by T${changeset.id}[${changeset.hint}]`), null);
             }
             else if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.obsolete || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.obsolete)))
-                Dbg_1.Log.write(' ', 'x', `${this.hint()} is not obsolete due to its own change to ${Snapshot_1.Dump.rev2(holder, snapshot, memberName)}`);
+                Dbg_1.Log.write(' ', 'x', `${this.hint()} is not obsolete due to its own change to ${Changeset_1.Dump.snapshot2(h, changeset, m)}`);
         }
     }
     runIfNotUpToDate(now, nothrow) {
@@ -384,7 +383,7 @@ class Operation extends Data_1.Subscription {
         if (this.options.monitor)
             this.monitorEnter(this.options.monitor);
         if (Dbg_1.Log.isOn && Dbg_1.Log.opt.operation)
-            Dbg_1.Log.write('║', '‾\\', `${this.hint()} - enter`, undefined, `    [ ${Snapshot_1.Dump.obj(this.controller.ownHolder, this.controller.memberName)} ]`);
+            Dbg_1.Log.write('║', '‾\\', `${this.hint()} - enter`, undefined, `    [ ${Changeset_1.Dump.obj(this.controller.objectHandle, this.controller.memberName)} ]`);
         this.started = Date.now();
     }
     leaveOrAsync() {
@@ -453,24 +452,24 @@ class Operation extends Data_1.Subscription {
         for (const x of reactions)
             x.runIfNotUpToDate(true, true);
     }
-    static markUsed(subscription, r, m, h, kind, weak) {
+    static markUsed(subscription, os, m, h, kind, weak) {
         if (kind !== Options_1.Kind.Transaction) {
             const op = Operation.current;
             if (op && op.options.kind !== Options_1.Kind.Transaction &&
-                op.transaction === Transaction_1.Transaction.current && m !== Data_1.Meta.Holder) {
-                const ctx = Snapshot_1.Snapshot.current();
-                if (ctx !== r.snapshot)
-                    ctx.bumpBy(r.snapshot.timestamp);
+                op.transaction === Transaction_1.Transaction.current && m !== Data_1.Meta.Handle) {
+                const ctx = Changeset_1.Changeset.current();
+                if (ctx !== os.changeset)
+                    ctx.bumpBy(os.changeset.timestamp);
                 const t = weak ? -1 : ctx.timestamp;
-                if (!op.subscribeTo(subscription, r, m, h, t))
-                    op.markObsoleteDueTo(subscription, m, r.snapshot, h, BOOT_CAUSE, ctx.timestamp, ctx.reactions);
+                if (!op.subscribeTo(subscription, os, m, h, t))
+                    op.markObsoleteDueTo(subscription, m, os.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.reactions);
             }
         }
     }
-    static markEdited(oldValue, newValue, edited, r, m, h) {
-        edited ? r.changes.add(m) : r.changes.delete(m);
+    static markEdited(oldValue, newValue, edited, os, m, h) {
+        edited ? os.changes.add(m) : os.changes.delete(m);
         if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
-            edited ? Dbg_1.Log.write('║', '  ✎', `${Snapshot_1.Dump.rev2(h, r.snapshot, m)} is changed from ${valueHint(oldValue, m)} to ${valueHint(newValue, m)}`) : Dbg_1.Log.write('║', '  ✎', `${Snapshot_1.Dump.rev2(h, r.snapshot, m)} is changed from ${valueHint(oldValue, m)} to ${valueHint(newValue, m)}`, undefined, ' (same as previous)');
+            edited ? Dbg_1.Log.write('║', '  ✎', `${Changeset_1.Dump.snapshot2(h, os.changeset, m)} is changed from ${valueHint(oldValue, m)} to ${valueHint(newValue, m)}`) : Dbg_1.Log.write('║', '  ✎', `${Changeset_1.Dump.snapshot2(h, os.changeset, m)} is changed from ${valueHint(oldValue, m)} to ${valueHint(newValue, m)}`, undefined, ' (same as previous)');
     }
     static isConflicting(oldValue, newValue) {
         let result = oldValue !== newValue;
@@ -478,32 +477,36 @@ class Operation extends Data_1.Subscription {
             result = oldValue instanceof Operation && oldValue.cause !== BOOT_CAUSE;
         return result;
     }
-    static propagateAllChangesThroughSubscriptions(snapshot) {
+    static propagateAllChangesThroughSubscriptions(changeset) {
         var _a;
-        const since = snapshot.timestamp;
-        const reactions = snapshot.reactions;
-        snapshot.changeset.forEach((r, h) => {
-            if (!r.changes.has(Data_1.Meta.Disposed))
-                r.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(false, since, r, m, h, reactions));
+        const since = changeset.timestamp;
+        const reactions = changeset.reactions;
+        changeset.items.forEach((os, h) => {
+            Operation.propagateMemberChangeThroughSubscriptions(false, since, os, Data_1.Meta.Revision, h, reactions);
+            if (!os.disposed)
+                os.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(false, since, os, m, h, reactions));
             else
-                for (const m in r.former.revision.data)
-                    Operation.propagateMemberChangeThroughSubscriptions(true, since, r, m, h, reactions);
+                for (const m in os.former.snapshot.data)
+                    Operation.propagateMemberChangeThroughSubscriptions(true, since, os, m, h, reactions);
         });
         reactions.sort(compareReactionsByOrder);
-        (_a = snapshot.options.journal) === null || _a === void 0 ? void 0 : _a.edited(Journal_1.JournalImpl.buildPatch(snapshot.hint, snapshot.changeset));
+        (_a = changeset.options.journal) === null || _a === void 0 ? void 0 : _a.edited(Journal_1.JournalImpl.buildPatch(changeset.hint, changeset.items));
     }
-    static revokeAllSubscriptions(snapshot) {
-        snapshot.changeset.forEach((r, h) => r.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(true, snapshot.timestamp, r, m, h, undefined)));
+    static revokeAllSubscriptions(changeset) {
+        changeset.items.forEach((os, h) => {
+            Operation.propagateMemberChangeThroughSubscriptions(true, changeset.timestamp, os, Data_1.Meta.Revision, h, undefined);
+            os.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(true, changeset.timestamp, os, m, h, undefined));
+        });
     }
-    static propagateMemberChangeThroughSubscriptions(unsubscribe, timestamp, r, m, h, reactions) {
+    static propagateMemberChangeThroughSubscriptions(unsubscribe, timestamp, os, m, h, reactions) {
         var _a;
-        const curr = r.data[m];
+        const curr = os.data[m];
         if (reactions) {
-            const former = r.former.revision.data[m];
+            const former = os.former.snapshot.data[m];
             if (former !== undefined && former instanceof Data_1.Subscription) {
-                const why = `T${r.snapshot.id}[${r.snapshot.hint}]`;
+                const why = `T${os.changeset.id}[${os.changeset.hint}]`;
                 if (former instanceof Operation) {
-                    if ((former.obsoleteSince === Snapshot_1.MAX_TIMESTAMP || former.obsoleteSince <= 0)) {
+                    if ((former.obsoleteSince === Changeset_1.MAX_REVISION || former.obsoleteSince <= 0)) {
                         former.obsoleteDueTo = why;
                         former.obsoleteSince = timestamp;
                         former.unsubscribeFromAllSubscriptions();
@@ -511,16 +514,16 @@ class Operation extends Data_1.Subscription {
                     const formerSuccessor = former.successor;
                     if (formerSuccessor !== curr) {
                         if (formerSuccessor && !formerSuccessor.transaction.isFinished)
-                            formerSuccessor.transaction.cancel(new Error(`T${formerSuccessor.transaction.id}[${formerSuccessor.transaction.hint}] is canceled by T${r.snapshot.id}[${r.snapshot.hint}] and will not run anymore`), null);
+                            formerSuccessor.transaction.cancel(new Error(`T${formerSuccessor.transaction.id}[${formerSuccessor.transaction.hint}] is canceled by T${os.changeset.id}[${os.changeset.hint}] and will not run anymore`), null);
                     }
                     else
                         former.successor = undefined;
                 }
-                (_a = former.subscribers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, m, r.snapshot, h, why, timestamp, reactions));
+                (_a = former.subscribers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, m, os.changeset, h, why, timestamp, reactions));
             }
         }
         if (curr instanceof Operation) {
-            if (curr.snapshot === r.snapshot && curr.subscriptions !== undefined) {
+            if (curr.changeset === os.changeset && curr.subscriptions !== undefined) {
                 if (Hooks_1.Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
                     curr.subscriptions.forEach((info, v) => {
                         if (info.usageCount > Hooks_1.Hooks.repetitiveUsageWarningThreshold)
@@ -558,13 +561,13 @@ class Operation extends Data_1.Subscription {
             var _a;
             value.subscribers.delete(this);
             if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
-                Dbg_1.Log.write(Dbg_1.Log.opt.transaction && !Snapshot_1.Snapshot.current().sealed ? '║' : ' ', '-', `${this.hint()} is unsubscribed from ${info.memberHint}`);
+                Dbg_1.Log.write(Dbg_1.Log.opt.transaction && !Changeset_1.Changeset.current().sealed ? '║' : ' ', '-', `${this.hint()} is unsubscribed from ${info.memberHint}`);
         });
         this.subscriptions = undefined;
     }
-    subscribeTo(subscription, r, m, h, timestamp) {
+    subscribeTo(subscription, os, m, h, timestamp) {
         var _a, _b, _c;
-        const ok = Operation.canSubscribe(subscription, r, m, h, timestamp);
+        const ok = Operation.canSubscribe(subscription, os, m, h, timestamp);
         if (ok) {
             let times = 0;
             if (Hooks_1.Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
@@ -574,23 +577,23 @@ class Operation extends Data_1.Subscription {
             if (this.subscriptions !== undefined) {
                 if (!subscription.subscribers)
                     subscription.subscribers = new Set();
-                const info = { memberHint: Snapshot_1.Dump.rev2(h, r.snapshot, m), usageCount: times };
+                const info = { memberHint: Changeset_1.Dump.snapshot2(h, os.changeset, m), usageCount: times };
                 subscription.subscribers.add(this);
                 this.subscriptions.set(subscription, info);
                 if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
-                    Dbg_1.Log.write('║', '  ∞ ', `${this.hint()} is subscribed to ${Snapshot_1.Dump.rev2(h, r.snapshot, m)}${info.usageCount > 1 ? ` (${info.usageCount} times)` : ''}`);
+                    Dbg_1.Log.write('║', '  ∞ ', `${this.hint()} is subscribed to ${Changeset_1.Dump.snapshot2(h, os.changeset, m)}${info.usageCount > 1 ? ` (${info.usageCount} times)` : ''}`);
             }
             else if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.read || ((_b = this.options.logging) === null || _b === void 0 ? void 0 : _b.read)))
-                Dbg_1.Log.write('║', '  x ', `${this.hint()} is obsolete and is NOT subscribed to ${Snapshot_1.Dump.rev2(h, r.snapshot, m)}`);
+                Dbg_1.Log.write('║', '  x ', `${this.hint()} is obsolete and is NOT subscribed to ${Changeset_1.Dump.snapshot2(h, os.changeset, m)}`);
         }
         else {
             if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.read || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.read)))
-                Dbg_1.Log.write('║', '  x ', `${this.hint()} is NOT subscribed to already obsolete ${Snapshot_1.Dump.rev2(h, r.snapshot, m)}`);
+                Dbg_1.Log.write('║', '  x ', `${this.hint()} is NOT subscribed to already obsolete ${Changeset_1.Dump.snapshot2(h, os.changeset, m)}`);
         }
         return ok;
     }
-    static canSubscribe(subscription, r, m, h, timestamp) {
-        let result = !r.snapshot.sealed || subscription === h.head.data[m];
+    static canSubscribe(subscription, os, m, h, timestamp) {
+        let result = !os.changeset.sealed || subscription === h.head.data[m];
         if (result && timestamp !== -1)
             result = !(subscription instanceof Operation && timestamp >= subscription.obsoleteSince);
         return result;
@@ -606,9 +609,9 @@ class Operation extends Data_1.Subscription {
     static rememberOperationOptions(proto, m, getter, setter, enumerable, configurable, options, implicit) {
         const initial = Data_1.Meta.acquire(proto, Data_1.Meta.Initial);
         let op = initial[m];
-        const ctl = op ? op.controller : new OperationController(ROOT_HOLDER, m);
+        const ctl = op ? op.controller : new OperationController(EMPTY_HANDLE, m);
         const opts = op ? op.options : Hooks_1.OptionsImpl.INITIAL;
-        initial[m] = op = new Operation(ctl, Snapshot_1.ROOT_REV.snapshot, new Hooks_1.OptionsImpl(getter, setter, opts, options, implicit));
+        initial[m] = op = new Operation(ctl, Changeset_1.EMPTY_SNAPSHOT.changeset, 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;
@@ -622,13 +625,13 @@ class Operation extends Data_1.Subscription {
     static init() {
         Object.freeze(BOOT_ARGS);
         Dbg_1.Log.getMergedLoggingOptions = getMergedLoggingOptions;
-        Snapshot_1.Dump.valueHint = valueHint;
-        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.enqueueReactionsToRun = Operation.enqueueReactionsToRun;
+        Changeset_1.Dump.valueHint = valueHint;
+        Changeset_1.Changeset.markUsed = Operation.markUsed;
+        Changeset_1.Changeset.markEdited = Operation.markEdited;
+        Changeset_1.Changeset.isConflicting = Operation.isConflicting;
+        Changeset_1.Changeset.propagateAllChangesThroughSubscriptions = Operation.propagateAllChangesThroughSubscriptions;
+        Changeset_1.Changeset.revokeAllSubscriptions = Operation.revokeAllSubscriptions;
+        Changeset_1.Changeset.enqueueReactionsToRun = Operation.enqueueReactionsToRun;
         Hooks_1.Hooks.createOperation = Operation.createOperation;
         Hooks_1.Hooks.rememberOperationOptions = Operation.rememberOperationOptions;
         Promise.prototype.then = reactronicHookedThen;
@@ -666,22 +669,20 @@ function valueHint(value, m) {
     else if (value instanceof Map)
         result = `Map(${value.size})`;
     else if (value instanceof Operation)
-        result = `${Snapshot_1.Dump.rev2(value.controller.ownHolder, value.snapshot, m)}`;
-    else if (value === Data_1.Meta.Disposed)
-        result = '<disposed>';
+        result = `${Changeset_1.Dump.snapshot2(value.controller.objectHandle, value.changeset, m)}`;
     else if (value === Data_1.Meta.Undefined)
-        result = '◌';
+        result = 'undefined';
     else if (typeof (value) === 'string')
         result = `"${value.toString().slice(0, 20)}"`;
     else if (value !== undefined && value !== null)
-        result = value.toString().slice(0, 20);
+        result = value.toString().slice(0, 40);
     else
-        result = '◌';
+        result = 'undefined';
     return result;
 }
 function getMergedLoggingOptions(local) {
     const t = Transaction_1.Transaction.current;
-    let res = Dbg_1.Log.merge(t.options.logging, t.id > 1 ? 31 + t.id % 6 : 37, t.id > 1 ? `T${t.id}` : `-${Snapshot_1.Snapshot.idGen.toString().replace(/[0-9]/g, '-')}`, Dbg_1.Log.global);
+    let res = Dbg_1.Log.merge(t.options.logging, t.id > 1 ? 31 + t.id % 6 : 37, t.id > 1 ? `T${t.id}` : `-${Changeset_1.Changeset.idGen.toString().replace(/[0-9]/g, '-')}`, Dbg_1.Log.global);
     res = Dbg_1.Log.merge({ margin1: t.margin }, undefined, undefined, res);
     if (Operation.current)
         res = Dbg_1.Log.merge({ margin2: Operation.current.margin }, undefined, undefined, res);

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

@@ -1,7 +1,7 @@
 import { F } from '../util/Utils';
 import { Worker } from '../Worker';
 import { SnapshotOptions } from '../Options';
-import { Snapshot } from './Snapshot';
+import { Changeset } from './Changeset';
 export declare abstract class Transaction implements Worker {
     static get current(): Transaction;
     abstract readonly id: number;
@@ -9,7 +9,7 @@ export declare abstract class Transaction implements Worker {
     abstract readonly options: SnapshotOptions;
     abstract readonly timestamp: number;
     abstract readonly error: Error | undefined;
-    abstract readonly snapshot: Snapshot;
+    abstract readonly changeset: Changeset;
     abstract readonly margin: number;
     abstract run<T>(func: F<T>, ...args: any[]): T;
     abstract inspect<T>(func: F<T>, ...args: any[]): T;