reactronic 0.24.275 → 0.24.302

package/build/dist/source/core/{Reaction.js → Operation.js}

@@ -1,54 +1,49 @@
 import { Log, misuse } from "../util/Dbg.js";
-import { Kind, Reentrance } from "../Options.js";
-import { ObjectHandle, ValueSnapshot, Meta } from "./Data.js";
-import { Changeset, Dump, EMPTY_SNAPSHOT, MAX_REVISION } from "./Changeset.js";
-import { Transaction } from "./Transaction.js";
+import { Kind, Reentrance, Isolation } from "../Options.js";
+import { ObjectHandle, FieldVersion, Meta } from "./Data.js";
+import { Changeset, Dump, EMPTY_OBJECT_VERSION, MAX_REVISION } from "./Changeset.js";
+import { Transaction, TransactionImpl } from "./Transaction.js";
 import { IndicatorImpl } from "./Indicator.js";
 import { Mvcc, OptionsImpl } from "./Mvcc.js";
 import { JournalImpl } from "./Journal.js";
 const BOOT_ARGS = [];
 const BOOT_CAUSE = "<boot>";
-const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.observable, EMPTY_SNAPSHOT, "<boot>");
-export class ReactionImpl {
-    configure(options) { return ReactionImpl.configureImpl(this, options); }
+const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.observable, EMPTY_OBJECT_VERSION, "<boot>");
+export class OperationImpl {
+    configure(options) { return OperationImpl.configureImpl(this, options); }
     get options() { return this.peek(undefined).launch.options; }
     get unobs() { return this.peek(undefined).launch.content; }
     get args() { return this.use().launch.args; }
     get result() { return this.reuseOrRelaunch(true, undefined).content; }
     get error() { return this.use().launch.error; }
-    get stamp() { return this.use().snapshot.changeset.timestamp; }
+    get stamp() { return this.use().objectVersion.changeset.timestamp; }
     get isUpToDate() { return this.use().isUpToDate; }
-    markObsolete() { Transaction.run({ hint: Log.isOn ? `markObsolete(${Dump.obj(this.objectHandle, this.memberName)})` : "markObsolete()" }, ReactionImpl.markObsolete, this); }
+    markObsolete() { Transaction.run({ hint: Log.isOn ? `markObsolete(${Dump.obj(this.ownerHandle, this.fieldKey)})` : "markObsolete()" }, OperationImpl.markObsolete, this); }
     pullLastResult(args) { return this.reuseOrRelaunch(true, args).content; }
-    constructor(h, m) {
-        this.objectHandle = h;
-        this.memberName = m;
+    constructor(h, fk) {
+        this.ownerHandle = h;
+        this.fieldKey = fk;
     }
     reuseOrRelaunch(weak, args) {
-        var _a;
         let ror = this.peek(args);
         const ctx = ror.changeset;
         const launch = ror.launch;
         const opts = launch.options;
-        if (!ror.isUpToDate && !ror.snapshot.disposed
+        if (!ror.isUpToDate && !ror.objectVersion.disposed
             && (!weak || launch.cause === BOOT_CAUSE || !launch.successor ||
                 launch.successor.transaction.isFinished)) {
-            const outerOpts = (_a = Launch.current) === null || _a === void 0 ? void 0 : _a.options;
-            const separation = weak || opts.separation !== false || opts.kind === Kind.reactive ||
-                (opts.kind === Kind.transactional && outerOpts && (outerOpts.noSideEffects || outerOpts.kind === Kind.cached)) ||
-                (opts.kind === Kind.cached && (ror.snapshot.changeset.sealed ||
-                    ror.snapshot.former.snapshot !== EMPTY_SNAPSHOT));
+            const isolation = !weak ? opts.isolation : Isolation.disjoinFromOuterTransaction;
             const token = opts.noSideEffects ? this : undefined;
-            const ror2 = this.relaunch(ror, separation, opts, token, args);
+            const ror2 = this.relaunch(ror, isolation, opts, token, args);
             const ctx2 = ror2.launch.changeset;
             if (!weak || ctx === ctx2 || (ctx2.sealed && ctx.timestamp >= ctx2.timestamp))
                 ror = ror2;
         }
         else if (Log.isOn && Log.opt.operation && (opts.logging === undefined ||
             opts.logging.operation === undefined || opts.logging.operation === true))
-            Log.write(Transaction.current.isFinished ? "" : "║", " (=)", `${Dump.snapshot2(ror.launch.reaction.objectHandle, ror.changeset, this.memberName)} result is reused from T${ror.launch.transaction.id}[${ror.launch.transaction.hint}]`);
+            Log.write(Transaction.current.isFinished ? "" : "║", " (=)", `${Dump.snapshot2(ror.launch.operation.ownerHandle, ror.changeset, this.fieldKey)} result is reused from T${ror.launch.transaction.id}[${ror.launch.transaction.hint}]`);
         const t = ror.launch;
-        Changeset.markUsed(t, ror.snapshot, this.memberName, this.objectHandle, t.options.kind, weak);
+        Changeset.markUsed(t, ror.objectVersion, this.fieldKey, this.ownerHandle, t.options.kind, weak);
         return t;
     }
     static getControllerOf(method) {
@@ -101,81 +96,81 @@ export class ReactionImpl {
     }
     peek(args) {
         const ctx = Changeset.current();
-        const os = ctx.lookupObjectSnapshot(this.objectHandle, this.memberName);
-        const launch = this.acquireFromSnapshot(os, args);
+        const ov = ctx.lookupObjectVersion(this.ownerHandle, this.fieldKey, false);
+        const launch = this.acquireFromObjectVersion(ov, args);
         const isValid = launch.options.kind !== Kind.transactional && launch.cause !== BOOT_CAUSE &&
             (ctx === launch.changeset || ctx.timestamp < launch.obsoleteSince) &&
             (!launch.options.triggeringArgs || args === undefined ||
-                launch.args.length === args.length && launch.args.every((t, i) => t === args[i])) || os.disposed;
-        return { launch, isUpToDate: isValid, changeset: ctx, snapshot: os };
+                launch.args.length === args.length && launch.args.every((t, i) => t === args[i])) || ov.disposed;
+        return { launch, isUpToDate: isValid, changeset: ctx, objectVersion: ov };
     }
     use() {
         const ror = this.peek(undefined);
-        Changeset.markUsed(ror.launch, ror.snapshot, this.memberName, this.objectHandle, ror.launch.options.kind, true);
+        Changeset.markUsed(ror.launch, ror.objectVersion, this.fieldKey, this.ownerHandle, ror.launch.options.kind, true);
         return ror;
     }
     edit() {
-        const h = this.objectHandle;
-        const m = this.memberName;
+        const h = this.ownerHandle;
+        const fk = this.fieldKey;
         const ctx = Changeset.edit();
-        const os = ctx.getEditableObjectSnapshot(h, m, Meta.Handle, this);
-        let launch = this.acquireFromSnapshot(os, undefined);
-        if (launch.changeset !== os.changeset) {
-            const relaunch = new Launch(this, os.changeset, launch);
-            os.data[m] = relaunch.reenterOver(launch);
-            ctx.bumpBy(os.former.snapshot.changeset.timestamp);
-            Changeset.markEdited(launch, relaunch, true, os, m, h);
+        const ov = ctx.getEditableObjectVersion(h, fk, Meta.Handle, this);
+        let launch = this.acquireFromObjectVersion(ov, undefined);
+        if (launch.changeset !== ov.changeset) {
+            const relaunch = new Launch(Transaction.current, this, ov.changeset, launch, false);
+            ov.data[fk] = relaunch.reenterOver(launch);
+            ctx.bumpBy(ov.former.objectVersion.changeset.timestamp);
+            Changeset.markEdited(launch, relaunch, true, ov, fk, h);
             launch = relaunch;
         }
-        return { launch, isUpToDate: true, changeset: ctx, snapshot: os };
-    }
-    acquireFromSnapshot(os, args) {
-        const m = this.memberName;
-        let launch = os.data[m];
-        if (launch.reaction !== this) {
-            if (os.changeset !== EMPTY_SNAPSHOT.changeset) {
-                const hint = Log.isOn ? `${Dump.obj(this.objectHandle, m)}/init` : "MethodController/init";
-                const separation = os.changeset.sealed || os.former.snapshot !== EMPTY_SNAPSHOT;
-                launch = Transaction.run({ hint, separation, token: this }, () => {
-                    const h = this.objectHandle;
-                    let r = Changeset.current().getObjectSnapshot(h, m);
-                    let relaunch = r.data[m];
-                    if (relaunch.reaction !== this) {
-                        r = Changeset.edit().getEditableObjectSnapshot(h, m, Meta.Handle, this);
-                        const t = new Launch(this, r.changeset, relaunch);
+        return { launch, isUpToDate: true, changeset: ctx, objectVersion: ov };
+    }
+    acquireFromObjectVersion(ov, args) {
+        const fk = this.fieldKey;
+        let launch = ov.data[fk];
+        if (launch.operation !== this) {
+            if (ov.changeset !== EMPTY_OBJECT_VERSION.changeset) {
+                const hint = Log.isOn ? `${Dump.obj(this.ownerHandle, fk)}/init` : "MethodController/init";
+                const isolation = Isolation.joinToCurrentTransaction;
+                launch = Transaction.run({ hint, isolation, token: this }, () => {
+                    const h = this.ownerHandle;
+                    let r = Changeset.current().getObjectVersion(h, fk);
+                    let relaunch = r.data[fk];
+                    if (relaunch.operation !== this) {
+                        r = Changeset.edit().getEditableObjectVersion(h, fk, Meta.Handle, this);
+                        const t = new Launch(Transaction.current, this, r.changeset, relaunch, false);
                         if (args)
                             t.args = args;
                         t.cause = BOOT_CAUSE;
-                        r.data[m] = t;
-                        Changeset.markEdited(relaunch, t, true, r, m, h);
+                        r.data[fk] = t;
+                        Changeset.markEdited(relaunch, t, true, r, fk, h);
                         relaunch = t;
                     }
                     return relaunch;
                 });
             }
             else {
-                const initialLaunch = new Launch(this, os.changeset, launch);
+                const initialLaunch = new Launch(Transaction.current, this, ov.changeset, launch, false);
                 if (args)
                     initialLaunch.args = args;
                 initialLaunch.cause = BOOT_CAUSE;
-                os.data[m] = initialLaunch;
+                ov.data[fk] = initialLaunch;
                 launch = initialLaunch;
                 if (Log.isOn && Log.opt.write)
-                    Log.write("║", " ++", `${Dump.obj(this.objectHandle, m)} is initialized (revision ${os.revision})`);
+                    Log.write("║", " ++", `${Dump.obj(this.ownerHandle, fk)} is initialized (revision ${ov.revision})`);
             }
         }
         return launch;
     }
-    relaunch(existing, separation, options, token, args) {
-        const hint = Log.isOn ? `${Dump.obj(this.objectHandle, this.memberName)}${args && args.length > 0 && (typeof args[0] === "number" || typeof args[0] === "string") ? ` - ${args[0]}` : ""}` : `${Dump.obj(this.objectHandle, this.memberName)}`;
+    relaunch(existing, isolation, options, token, args) {
+        const hint = Log.isOn ? `${Dump.obj(this.ownerHandle, this.fieldKey)}${args && args.length > 0 && (typeof args[0] === "number" || typeof args[0] === "string") ? ` - ${args[0]}` : ""}` : `${Dump.obj(this.ownerHandle, this.fieldKey)}`;
         let ror = existing;
-        const opts = { hint, separation, journal: options.journal, logging: options.logging, token };
+        const opts = { hint, isolation, journal: options.journal, logging: options.logging, token };
         const result = Transaction.run(opts, (argsx) => {
             if (!ror.launch.transaction.isCanceled) {
                 ror = this.edit();
                 if (Log.isOn && Log.opt.operation)
                     Log.write("║", "  o", `${ror.launch.why()}`);
-                ror.launch.proceed(this.objectHandle.proxy, argsx);
+                ror.launch.proceed(this.ownerHandle.proxy, argsx);
             }
             else {
                 ror = this.peek(argsx);
@@ -183,7 +178,7 @@ export class ReactionImpl {
                     ror = this.edit();
                     if (Log.isOn && Log.opt.operation)
                         Log.write("║", "  o", `${ror.launch.why()}`);
-                    ror.launch.proceed(this.objectHandle.proxy, argsx);
+                    ror.launch.proceed(this.ownerHandle.proxy, argsx);
                 }
             }
             return ror.launch.result;
@@ -194,44 +189,67 @@ export class ReactionImpl {
     static markObsolete(self) {
         const ror = self.peek(undefined);
         const ctx = ror.changeset;
-        ror.launch.markObsoleteDueTo(ror.launch, self.memberName, EMPTY_SNAPSHOT.changeset, EMPTY_HANDLE, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
+        ror.launch.markObsoleteDueTo(ror.launch, self.fieldKey, EMPTY_OBJECT_VERSION.changeset, EMPTY_HANDLE, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
     }
 }
-class Launch extends ValueSnapshot {
-    constructor(reaction, changeset, former) {
-        super(undefined);
+class Launch extends FieldVersion {
+    constructor(transaction, operation, changeset, former, clone) {
+        super(undefined, 0);
         this.margin = Launch.current ? Launch.current.margin + 1 : 1;
-        this.transaction = Transaction.current;
-        this.reaction = reaction;
+        this.transaction = transaction;
+        this.operation = operation;
         this.changeset = changeset;
         this.observables = new Map();
         if (former instanceof Launch) {
             this.options = former.options;
-            this.args = former.args;
             this.cause = former.obsoleteDueTo;
+            this.args = former.args;
+            if (clone) {
+                this.lastEditorChangesetId = former.lastEditorChangesetId;
+                this.result = former.result;
+                this.error = former.error;
+                this.started = former.started;
+                this.obsoleteSince = former.obsoleteSince;
+                this.obsoleteDueTo = former.obsoleteDueTo;
+                this.successor = former.successor;
+            }
+            else {
+                this.lastEditorChangesetId = changeset.id;
+                this.result = undefined;
+                this.error = undefined;
+                this.started = 0;
+                this.obsoleteSince = 0;
+                this.obsoleteDueTo = undefined;
+                this.successor = undefined;
+            }
         }
         else {
+            this.lastEditorChangesetId = changeset.id;
             this.options = former;
-            this.args = BOOT_ARGS;
             this.cause = undefined;
+            this.args = BOOT_ARGS;
+            this.result = undefined;
+            this.error = undefined;
+            this.started = 0;
+            this.obsoleteSince = 0;
+            this.obsoleteDueTo = undefined;
+            this.successor = undefined;
         }
-        this.started = 0;
-        this.obsoleteSince = 0;
-        this.obsoleteDueTo = undefined;
-        this.successor = undefined;
-    }
-    get isOperation() { return true; }
-    get originSnapshotId() { return this.changeset.id; }
-    hint() { return `${Dump.snapshot2(this.reaction.objectHandle, this.changeset, this.reaction.memberName)}`; }
+    }
+    get isLaunch() { return true; }
+    hint() { return `${Dump.snapshot2(this.operation.ownerHandle, this.changeset, this.operation.fieldKey, this)}`; }
     get order() { return this.options.order; }
     get ["#this#"]() {
         return `Operation: ${this.why()}`;
     }
+    clone(t, cs) {
+        return new Launch(t, this.operation, cs, this, true);
+    }
     why() {
         let cause;
         if (this.cause)
             cause = `   ◀◀   ${this.cause}`;
-        else if (this.reaction.options.kind === Kind.transactional)
+        else if (this.operation.options.kind === Kind.transactional)
             cause = "   ◀◀   operation";
         else
             cause = `   ◀◀   T${this.changeset.id}[${this.changeset.hint}]`;
@@ -248,7 +266,7 @@ class Launch extends ValueSnapshot {
             if (Log.isOn && Log.opt.step && this.result)
                 Log.writeAs({ margin2: this.margin }, "║", "‾\\", `${this.hint()} - step in  `, 0, "        │");
             const started = Date.now();
-            const result = ReactionImpl.proceedWithinGivenLaunch(this, func, ...args);
+            const result = OperationImpl.proceedWithinGivenLaunch(this, func, ...args);
             const ms = Date.now() - started;
             if (Log.isOn && Log.opt.step && this.result)
                 Log.writeAs({ margin2: this.margin }, "║", "_/", `${this.hint()} - step out `, 0, this.started > 0 ? "        │" : "");
@@ -263,37 +281,37 @@ class Launch extends ValueSnapshot {
             this.args = args;
         this.obsoleteSince = MAX_REVISION;
         if (!this.error)
-            ReactionImpl.proceedWithinGivenLaunch(this, Launch.proceed, this, proxy);
+            OperationImpl.proceedWithinGivenLaunch(this, Launch.proceed, this, proxy);
         else
             this.result = Promise.reject(this.error);
     }
-    markObsoleteDueTo(observable, m, changeset, h, outer, since, obsolete) {
+    markObsoleteDueTo(observable, fk, changeset, h, outer, since, obsolete) {
         var _a, _b, _c;
         if (this.observables !== undefined) {
-            const skip = !observable.isOperation &&
-                changeset === this.changeset;
+            const skip = !observable.isLaunch &&
+                changeset.id === this.lastEditorChangesetId;
             if (!skip) {
-                const why = `${Dump.snapshot2(h, changeset, m, observable)}    ◀◀    ${outer}`;
+                const why = `${Dump.snapshot2(h, changeset, fk, observable)}    ◀◀    ${outer}`;
                 const isReactive = this.options.kind === Kind.reactive;
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
                 if (Log.isOn && (Log.opt.obsolete || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.obsolete)))
-                    Log.write(Log.opt.transaction && !Changeset.current().sealed ? "║" : " ", isReactive ? "█" : "▒", isReactive && changeset === EMPTY_SNAPSHOT.changeset
+                    Log.write(Log.opt.transaction && !Changeset.current().sealed ? "║" : " ", isReactive ? "█" : "▒", isReactive && changeset === EMPTY_OBJECT_VERSION.changeset
                         ? `${this.hint()} is reactive and will run automatically (order ${this.options.order})`
-                        : `${this.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, m)} since s${since}${isReactive ? ` and will run automatically (order ${this.options.order})` : ""}`);
+                        : `${this.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, fk)} since s${since}${isReactive ? ` and will run automatically (order ${this.options.order})` : ""}`);
                 this.unsubscribeFromAllObservables();
                 if (isReactive)
                     obsolete.push(this);
                 else
-                    (_b = this.observers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.reaction.memberName, this.changeset, this.reaction.objectHandle, why, since, obsolete));
+                    (_b = this.observers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.operation.fieldKey, this.changeset, this.operation.ownerHandle, why, since, obsolete));
                 const tran = this.transaction;
                 if (tran.changeset === changeset) {
                 }
                 else if (!tran.isFinished && this !== observable)
-                    tran.cancel(new Error(`T${tran.id}[${tran.hint}] is canceled due to obsolete ${Dump.snapshot2(h, changeset, m)} changed by T${changeset.id}[${changeset.hint}]`), null);
+                    tran.cancel(new Error(`T${tran.id}[${tran.hint}] is canceled due to obsolete ${Dump.snapshot2(h, changeset, fk)} changed by T${changeset.id}[${changeset.hint}]`), null);
             }
             else if (Log.isOn && (Log.opt.obsolete || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.obsolete)))
-                Log.write(" ", "x", `${this.hint()} is not obsolete due to its own change to ${Dump.snapshot2(h, changeset, m)}`);
+                Log.write(" ", "x", `${this.hint()} is not obsolete due to its own change to ${Dump.snapshot2(h, changeset, fk, observable)}`);
         }
     }
     relaunchIfNotUpToDate(now, nothrow) {
@@ -303,7 +321,7 @@ class Launch extends ValueSnapshot {
         if (now || hold < 0) {
             if (this.isNotUpToDate()) {
                 try {
-                    const launch = this.reaction.reuseOrRelaunch(false, undefined);
+                    const launch = this.operation.reuseOrRelaunch(false, undefined);
                     if (launch.result instanceof Promise)
                         launch.result.catch(error => {
                             if (launch.options.kind === Kind.reactive)
@@ -367,6 +385,8 @@ class Launch extends ValueSnapshot {
     static proceed(launch, proxy) {
         launch.enter();
         try {
+            if (launch.options.getter === undefined)
+                console.log("(!)");
             launch.result = launch.options.getter.call(proxy, ...launch.args);
         }
         finally {
@@ -377,7 +397,7 @@ class Launch extends ValueSnapshot {
         if (this.options.indicator)
             this.indicatorEnter(this.options.indicator);
         if (Log.isOn && Log.opt.operation)
-            Log.write("║", "‾\\", `${this.hint()} - enter`, undefined, `    [ ${Dump.obj(this.reaction.objectHandle, this.reaction.memberName)} ]`);
+            Log.write("║", "‾\\", `${this.hint()} - enter`, undefined, `    [ ${Dump.obj(this.operation.ownerHandle, this.operation.fieldKey)} ]`);
         this.started = Date.now();
     }
     leaveOrAsync() {
@@ -417,53 +437,53 @@ class Launch extends ValueSnapshot {
     indicatorEnter(mon) {
         const options = {
             hint: "Indicator.enter",
-            separation: "isolated",
+            isolation: Isolation.disjoinFromOuterAndInnerTransactions,
             logging: Log.isOn && Log.opt.indicator ? undefined : Log.global
         };
-        ReactionImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, IndicatorImpl.enter, mon, this.transaction);
+        OperationImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, IndicatorImpl.enter, mon, this.transaction);
     }
     indicatorLeave(mon) {
         Transaction.outside(() => {
             const leave = () => {
                 const options = {
                     hint: "Indicator.leave",
-                    separation: "isolated",
+                    isolation: Isolation.disjoinFromOuterAndInnerTransactions,
                     logging: Log.isOn && Log.opt.indicator ? undefined : Log.DefaultLevel
                 };
-                ReactionImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, IndicatorImpl.leave, mon, this.transaction);
+                OperationImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, IndicatorImpl.leave, mon, this.transaction);
             };
             this.transaction.whenFinished().then(leave, leave);
         });
     }
     addToDeferredReactiveFunctions() {
-        Launch.deferredReactiveFunctions.push(this);
-        if (Launch.deferredReactiveFunctions.length === 1)
+        Launch.deferredReactiveOperations.push(this);
+        if (Launch.deferredReactiveOperations.length === 1)
             setTimeout(Launch.processDeferredReactiveFunctions, 0);
     }
     static processDeferredReactiveFunctions() {
-        const deferred = Launch.deferredReactiveFunctions;
-        Launch.deferredReactiveFunctions = [];
+        const deferred = Launch.deferredReactiveOperations;
+        Launch.deferredReactiveOperations = [];
         for (const x of deferred)
             x.relaunchIfNotUpToDate(true, true);
     }
-    static markUsed(observable, os, m, h, kind, weak) {
+    static markUsed(observable, ov, fk, h, kind, weak) {
         if (kind !== Kind.transactional) {
             const launch = Launch.current;
             if (launch && launch.options.kind !== Kind.transactional &&
-                launch.transaction === Transaction.current && m !== Meta.Handle) {
+                launch.transaction === Transaction.current && fk !== Meta.Handle) {
                 const ctx = Changeset.current();
-                if (ctx !== os.changeset)
-                    ctx.bumpBy(os.changeset.timestamp);
+                if (ctx !== ov.changeset)
+                    ctx.bumpBy(ov.changeset.timestamp);
                 const t = weak ? -1 : ctx.timestamp;
-                if (!launch.subscribeTo(observable, os, m, h, t))
-                    launch.markObsoleteDueTo(observable, m, h.head.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
+                if (!launch.subscribeTo(observable, ov, fk, h, t))
+                    launch.markObsoleteDueTo(observable, fk, h.applied.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
             }
         }
     }
-    static markEdited(oldValue, newValue, edited, os, m, h) {
-        edited ? os.changes.add(m) : os.changes.delete(m);
+    static markEdited(oldValue, newValue, edited, ov, fk, h) {
+        edited ? ov.changes.add(fk) : ov.changes.delete(fk);
         if (Log.isOn && Log.opt.write)
-            edited ? Log.write("║", "  =", `${Dump.snapshot2(h, os.changeset, m)} is changed: ${valueHint(oldValue)} ▸▸ ${valueHint(newValue)}`) : Log.write("║", "  =", `${Dump.snapshot2(h, os.changeset, m)} is changed: ${valueHint(oldValue)} ▸▸ ${valueHint(newValue)}`, undefined, " (same as previous)");
+            edited ? Log.write("║", "  =", `${Dump.snapshot2(h, ov.changeset, fk)} is changed: ${valueHint(oldValue)} ▸▸ ${valueHint(newValue)}`) : Log.write("║", "  =", `${Dump.snapshot2(h, ov.changeset, fk)} is changed: ${valueHint(oldValue)} ▸▸ ${valueHint(newValue)}`, undefined, " (same as previous)");
     }
     static isConflicting(oldValue, newValue) {
         let result = oldValue !== newValue;
@@ -475,30 +495,30 @@ class Launch extends ValueSnapshot {
         var _a;
         const since = changeset.timestamp;
         const obsolete = changeset.obsolete;
-        changeset.items.forEach((os, h) => {
-            Launch.propagateMemberChangeThroughSubscriptions(false, since, os, Meta.Revision, h, obsolete);
-            if (!os.disposed)
-                os.changes.forEach((o, m) => Launch.propagateMemberChangeThroughSubscriptions(false, since, os, m, h, obsolete));
+        changeset.items.forEach((ov, h) => {
+            Launch.propagateFieldChangeThroughSubscriptions(false, since, ov, Meta.Revision, h, obsolete);
+            if (!ov.disposed)
+                ov.changes.forEach((o, fk) => Launch.propagateFieldChangeThroughSubscriptions(false, since, ov, fk, h, obsolete));
             else
-                for (const m in os.former.snapshot.data)
-                    Launch.propagateMemberChangeThroughSubscriptions(true, since, os, m, h, obsolete);
+                for (const fk in ov.former.objectVersion.data)
+                    Launch.propagateFieldChangeThroughSubscriptions(true, since, ov, fk, h, obsolete);
         });
         obsolete.sort(compareObserversByOrder);
         (_a = changeset.options.journal) === null || _a === void 0 ? void 0 : _a.edited(JournalImpl.buildPatch(changeset.hint, changeset.items));
     }
     static revokeAllSubscriptions(changeset) {
-        changeset.items.forEach((os, h) => {
-            Launch.propagateMemberChangeThroughSubscriptions(true, changeset.timestamp, os, Meta.Revision, h, undefined);
-            os.changes.forEach((o, m) => Launch.propagateMemberChangeThroughSubscriptions(true, changeset.timestamp, os, m, h, undefined));
+        changeset.items.forEach((ov, h) => {
+            Launch.propagateFieldChangeThroughSubscriptions(true, changeset.timestamp, ov, Meta.Revision, h, undefined);
+            ov.changes.forEach((o, fk) => Launch.propagateFieldChangeThroughSubscriptions(true, changeset.timestamp, ov, fk, h, undefined));
         });
     }
-    static propagateMemberChangeThroughSubscriptions(unsubscribe, timestamp, os, m, h, obsolete) {
+    static propagateFieldChangeThroughSubscriptions(unsubscribe, timestamp, ov, fk, h, obsolete) {
         var _a;
-        const curr = os.data[m];
+        const curr = ov.data[fk];
         if (obsolete !== undefined) {
-            const former = os.former.snapshot.data[m];
-            if (former !== undefined && former instanceof ValueSnapshot) {
-                const why = `T${os.changeset.id}[${os.changeset.hint}]`;
+            const former = ov.former.objectVersion.data[fk];
+            if (former !== undefined && former instanceof FieldVersion) {
+                const why = `T${ov.changeset.id}[${ov.changeset.hint}]`;
                 if (former instanceof Launch) {
                     if ((former.obsoleteSince === MAX_REVISION || former.obsoleteSince <= 0)) {
                         former.obsoleteDueTo = why;
@@ -508,16 +528,16 @@ class Launch extends ValueSnapshot {
                     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${os.changeset.id}[${os.changeset.hint}] and will not run anymore`), null);
+                            formerSuccessor.transaction.cancel(new Error(`T${formerSuccessor.transaction.id}[${formerSuccessor.transaction.hint}] is canceled by T${ov.changeset.id}[${ov.changeset.hint}] and will not run anymore`), null);
                     }
                     else
                         former.successor = undefined;
                 }
-                (_a = former.observers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, m, os.changeset, h, why, timestamp, obsolete));
+                (_a = former.observers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, fk, ov.changeset, h, why, timestamp, obsolete));
             }
         }
         if (curr instanceof Launch) {
-            if (curr.changeset === os.changeset && curr.observables !== undefined) {
+            if (curr.changeset === ov.changeset && curr.observables !== undefined) {
                 if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
                     curr.observables.forEach((info, v) => {
                         if (info.usageCount > Mvcc.repetitiveUsageWarningThreshold)
@@ -528,26 +548,34 @@ class Launch extends ValueSnapshot {
                     curr.unsubscribeFromAllObservables();
             }
         }
-        else if (curr instanceof ValueSnapshot && curr.observers) {
+        else if (curr instanceof FieldVersion && curr.observers) {
         }
     }
     static enqueueReactiveFunctionsToRun(reactive) {
-        const queue = Launch.queuedReactiveFunctions;
+        const queue = Launch.queuedReactiveOperations;
         const isReactiveLoopRequired = queue.length === 0;
         for (const r of reactive)
             queue.push(r);
         if (isReactiveLoopRequired)
-            ReactionImpl.proceedWithinGivenLaunch(undefined, Launch.processQueuedReactiveFunctions);
+            OperationImpl.proceedWithinGivenLaunch(undefined, Launch.processQueuedReactiveOperations);
+    }
+    static migrateFieldVersion(fv, target) {
+        let result;
+        if (fv instanceof Launch)
+            result = new Launch(target, fv.operation, target.changeset, fv, true);
+        else
+            result = new FieldVersion(fv.content, fv.lastEditorChangesetId);
+        return result;
     }
-    static processQueuedReactiveFunctions() {
-        const queue = Launch.queuedReactiveFunctions;
+    static processQueuedReactiveOperations() {
+        const queue = Launch.queuedReactiveOperations;
         let i = 0;
         while (i < queue.length) {
             const reactive = queue[i];
             reactive.relaunchIfNotUpToDate(false, true);
             i++;
         }
-        Launch.queuedReactiveFunctions = [];
+        Launch.queuedReactiveOperations = [];
     }
     unsubscribeFromAllObservables() {
         var _a;
@@ -559,9 +587,10 @@ class Launch extends ValueSnapshot {
         });
         this.observables = undefined;
     }
-    subscribeTo(observable, os, m, h, timestamp) {
+    subscribeTo(observable, ov, fk, h, timestamp) {
         var _a, _b, _c;
-        const ok = Launch.canSubscribeTo(observable, os, m, h, timestamp);
+        const parent = this.transaction.changeset.parent;
+        const ok = Launch.canSubscribeTo(observable, ov, parent, fk, h, timestamp);
         if (ok) {
             let times = 0;
             if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
@@ -571,49 +600,50 @@ class Launch extends ValueSnapshot {
             if (this.observables !== undefined) {
                 if (!observable.observers)
                     observable.observers = new Set();
-                const subscription = { memberHint: Dump.snapshot2(h, os.changeset, m), usageCount: times };
+                const subscription = { memberHint: Dump.snapshot2(h, ov.changeset, fk), usageCount: times };
                 observable.observers.add(this);
                 this.observables.set(observable, subscription);
                 if (Log.isOn && (Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
-                    Log.write("║", "  ∞", `${this.hint()} is subscribed to ${Dump.snapshot2(h, os.changeset, m)}${subscription.usageCount > 1 ? ` (${subscription.usageCount} times)` : ""}`);
+                    Log.write("║", "  ∞", `${this.hint()} is subscribed to ${Dump.snapshot2(h, ov.changeset, fk, observable)}${subscription.usageCount > 1 ? ` (${subscription.usageCount} times)` : ""}`);
             }
             else if (Log.isOn && (Log.opt.read || ((_b = this.options.logging) === null || _b === void 0 ? void 0 : _b.read)))
-                Log.write("║", "  x", `${this.hint()} is obsolete and is NOT subscribed to ${Dump.snapshot2(h, os.changeset, m)}`);
+                Log.write("║", "  x", `${this.hint()} is obsolete and is NOT subscribed to ${Dump.snapshot2(h, ov.changeset, fk, observable)}`);
         }
         else {
             if (Log.isOn && (Log.opt.read || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.read)))
-                Log.write("║", "  x", `${this.hint()} is NOT subscribed to already obsolete ${Dump.snapshot2(h, os.changeset, m)}`);
+                Log.write("║", "  x", `${this.hint()} is NOT subscribed to already obsolete ${Dump.snapshot2(h, ov.changeset, fk, observable)}`);
         }
         return ok;
     }
-    static canSubscribeTo(observable, os, m, h, timestamp) {
-        const observableHead = h.head.data[m];
-        let result = observable === observableHead || (!os.changeset.sealed && os.former.snapshot.data[m] === observableHead);
+    static canSubscribeTo(observable, ov, parent, fk, h, timestamp) {
+        const parentSnapshot = parent ? parent.lookupObjectVersion(h, fk, false) : h.applied;
+        const observableParent = parentSnapshot.data[fk];
+        let result = observable === observableParent || (!ov.changeset.sealed && ov.former.objectVersion.data[fk] === observableParent);
         if (result && timestamp !== -1)
             result = !(observable instanceof Launch && timestamp >= observable.obsoleteSince);
         return result;
     }
-    static createOperation(h, m, options) {
-        const rx = new ReactionImpl(h, m);
+    static createOperation(h, fk, options) {
+        const rx = new OperationImpl(h, fk);
         const operation = (...args) => {
             return rx.reuseOrRelaunch(false, args).result;
         };
         Meta.set(operation, Meta.Controller, rx);
         return operation;
     }
-    static rememberOperationOptions(proto, m, getter, setter, enumerable, configurable, options, implicit) {
+    static rememberOperationOptions(proto, fk, getter, setter, enumerable, configurable, options, implicit) {
         const initial = Meta.acquire(proto, Meta.Initial);
-        let launch = initial[m];
-        const rx = launch ? launch.reaction : new ReactionImpl(EMPTY_HANDLE, m);
+        let launch = initial[fk];
+        const rx = launch ? launch.operation : new OperationImpl(EMPTY_HANDLE, fk);
         const opts = launch ? launch.options : OptionsImpl.INITIAL;
-        initial[m] = launch = new Launch(rx, EMPTY_SNAPSHOT.changeset, new OptionsImpl(getter, setter, opts, options, implicit));
+        initial[fk] = launch = new Launch(Transaction.current, rx, EMPTY_OBJECT_VERSION.changeset, new OptionsImpl(getter, setter, opts, options, implicit), false);
         if (launch.options.kind === Kind.reactive && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.acquire(proto, Meta.Reactive);
-            reactive[m] = launch;
+            reactive[fk] = launch;
         }
         else if (launch.options.kind === Kind.reactive && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.getFrom(proto, Meta.Reactive);
-            delete reactive[m];
+            delete reactive[fk];
         }
         return launch.options;
     }
@@ -627,25 +657,26 @@ class Launch extends ValueSnapshot {
         Changeset.propagateAllChangesThroughSubscriptions = Launch.propagateAllChangesThroughSubscriptions;
         Changeset.revokeAllSubscriptions = Launch.revokeAllSubscriptions;
         Changeset.enqueueReactiveFunctionsToRun = Launch.enqueueReactiveFunctionsToRun;
+        TransactionImpl.migrateFieldVersion = Launch.migrateFieldVersion;
         Mvcc.createOperation = Launch.createOperation;
         Mvcc.rememberOperationOptions = Launch.rememberOperationOptions;
         Promise.prototype.then = reactronicHookedThen;
         try {
             Object.defineProperty(globalThis, "rWhy", {
-                get: ReactionImpl.why, configurable: false, enumerable: false,
+                get: OperationImpl.why, configurable: false, enumerable: false,
             });
             Object.defineProperty(globalThis, "rBriefWhy", {
-                get: ReactionImpl.briefWhy, configurable: false, enumerable: false,
+                get: OperationImpl.briefWhy, configurable: false, enumerable: false,
             });
         }
         catch (e) {
         }
         try {
             Object.defineProperty(global, "rWhy", {
-                get: ReactionImpl.why, configurable: false, enumerable: false,
+                get: OperationImpl.why, configurable: false, enumerable: false,
             });
             Object.defineProperty(global, "rBriefWhy", {
-                get: ReactionImpl.briefWhy, configurable: false, enumerable: false,
+                get: OperationImpl.briefWhy, configurable: false, enumerable: false,
             });
         }
         catch (e) {
@@ -653,8 +684,8 @@ class Launch extends ValueSnapshot {
     }
 }
 Launch.current = undefined;
-Launch.queuedReactiveFunctions = [];
-Launch.deferredReactiveFunctions = [];
+Launch.queuedReactiveOperations = [];
+Launch.deferredReactiveOperations = [];
 function valueHint(value) {
     let result = "";
     if (Array.isArray(value))
@@ -664,7 +695,7 @@ function valueHint(value) {
     else if (value instanceof Map)
         result = `Map(${value.size})`;
     else if (value instanceof Launch)
-        result = `#${value.reaction.objectHandle.id}t${value.changeset.id}s${value.changeset.timestamp}${value.originSnapshotId !== undefined && value.originSnapshotId !== 0 ? `t${value.originSnapshotId}` : ""}`;
+        result = `#${value.operation.ownerHandle.id}t${value.changeset.id}s${value.changeset.timestamp}${value.lastEditorChangesetId !== undefined && value.lastEditorChangesetId !== 0 ? `t${value.lastEditorChangesetId}` : ""}`;
     else if (value === Meta.Undefined)
         result = "undefined";
     else if (typeof (value) === "string")