reactronic 0.93.25026 → 0.94.25027

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

@@ -1,6 +1,6 @@
 import { Log, misuse } from "../util/Dbg.js";
-import { Kind, Reentrance, Isolation } from "../Options.js";
-import { ObjectHandle, FieldVersion, Meta } from "./Data.js";
+import { Kind, Reentrance, Isolation } from "../Enums.js";
+import { ObjectHandle, ContentFootprint, 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";
@@ -8,17 +8,17 @@ 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.triggering, EMPTY_OBJECT_VERSION, "<boot>");
-export class OperationImpl {
-    configure(options) { return OperationImpl.configureImpl(this, options); }
-    get options() { return this.peek(undefined).launch.options; }
-    get nonreactive() { return this.peek(undefined).launch.content; }
-    get args() { return this.use().launch.args; }
+const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.observable, EMPTY_OBJECT_VERSION, "<boot>");
+export class ReactiveOperationImpl {
+    configure(options) { return ReactiveOperationImpl.configureImpl(this, options); }
+    get options() { return this.peek(undefined).footprint.options; }
+    get nonreactive() { return this.peek(undefined).footprint.content; }
+    get args() { return this.use().footprint.args; }
     get result() { return this.reuseOrRelaunch(true, undefined).content; }
-    get error() { return this.use().launch.error; }
+    get error() { return this.use().footprint.error; }
     get stamp() { return this.use().objectVersion.changeset.timestamp; }
     get isReusable() { return this.use().isReusable; }
-    markObsolete() { Transaction.run({ hint: Log.isOn ? `markObsolete(${Dump.obj(this.ownerHandle, this.fieldKey)})` : "markObsolete()" }, OperationImpl.markObsolete, this); }
+    markObsolete() { Transaction.run({ hint: Log.isOn ? `markObsolete(${Dump.obj(this.ownerHandle, this.fieldKey)})` : "markObsolete()" }, ReactiveOperationImpl.markObsolete, this); }
     pullLastResult(args) { return this.reuseOrRelaunch(true, args).content; }
     constructor(h, fk) {
         this.ownerHandle = h;
@@ -27,87 +27,87 @@ export class OperationImpl {
     reuseOrRelaunch(weak, args) {
         let ror = this.peek(args);
         const ctx = ror.changeset;
-        const launch = ror.launch;
-        const opts = launch.options;
+        const footprint = ror.footprint;
+        const opts = footprint.options;
         if (!ror.isReusable && !ror.objectVersion.disposed
-            && (!weak || launch.cause === BOOT_CAUSE || !launch.successor ||
-                launch.successor.transaction.isFinished)) {
+            && (!weak || footprint.cause === BOOT_CAUSE || !footprint.successor ||
+                footprint.successor.transaction.isFinished)) {
             const isolation = !weak ? opts.isolation : Isolation.disjoinFromOuterTransaction;
             const token = opts.noSideEffects ? this : undefined;
             const ror2 = this.relaunch(ror, isolation, opts, token, args);
-            const ctx2 = ror2.launch.changeset;
+            const ctx2 = ror2.footprint.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.operation.ownerHandle, ror.changeset, this.fieldKey)} result is reused from T${ror.launch.transaction.id}[${ror.launch.transaction.hint}]`);
-        const t = ror.launch;
+            Log.write(Transaction.current.isFinished ? "" : "║", " (=)", `${Dump.snapshot2(ror.footprint.descriptor.ownerHandle, ror.changeset, this.fieldKey)} result is reused from T${ror.footprint.transaction.id}[${ror.footprint.transaction.hint}]`);
+        const t = ror.footprint;
         Changeset.markUsed(t, ror.objectVersion, this.fieldKey, this.ownerHandle, t.options.kind, weak);
         return t;
     }
-    static getControllerOf(method) {
-        const ctl = Meta.get(method, Meta.Controller);
+    static manageReactiveOperation(method) {
+        const ctl = Meta.get(method, Meta.Descriptor);
         if (!ctl)
             throw misuse(`given method is not decorated as reactronic one: ${method.name}`);
         return ctl;
     }
     static configureImpl(self, options) {
-        let launch;
+        let footprint;
         if (self)
-            launch = self.edit().launch;
+            footprint = self.edit().footprint;
         else
-            launch = Launch.current;
-        if (!launch)
+            footprint = OperationFootprintImpl.current;
+        if (!footprint)
             throw misuse("reactronic decorator is only applicable to methods");
-        launch.options = new OptionsImpl(launch.options.getter, launch.options.setter, launch.options, options, false);
+        footprint.options = new OptionsImpl(footprint.options.getter, footprint.options.setter, footprint.options, options, false);
         if (Log.isOn && Log.opt.write)
-            Log.write("║", "  =", `${launch.hint()}.options are changed`);
-        return launch.options;
+            Log.write("║", "  =", `${footprint.hint()}.options are changed`);
+        return footprint.options;
     }
-    static proceedWithinGivenLaunch(launch, func, ...args) {
+    static proceedWithinGivenLaunch(footprint, func, ...args) {
         let result = undefined;
-        const outer = Launch.current;
+        const outer = OperationFootprintImpl.current;
         try {
-            Launch.current = launch;
+            OperationFootprintImpl.current = footprint;
             result = func(...args);
         }
         catch (e) {
-            if (launch)
-                launch.error = e;
+            if (footprint)
+                footprint.error = e;
             throw e;
         }
         finally {
-            Launch.current = outer;
+            OperationFootprintImpl.current = outer;
         }
         return result;
     }
     static why() {
         var _a, _b;
-        return (_b = (_a = Launch.current) === null || _a === void 0 ? void 0 : _a.why()) !== null && _b !== void 0 ? _b : BOOT_CAUSE;
+        return (_b = (_a = OperationFootprintImpl.current) === null || _a === void 0 ? void 0 : _a.why()) !== null && _b !== void 0 ? _b : BOOT_CAUSE;
     }
     static briefWhy() {
         var _a, _b;
-        return (_b = (_a = Launch.current) === null || _a === void 0 ? void 0 : _a.briefWhy()) !== null && _b !== void 0 ? _b : BOOT_CAUSE;
+        return (_b = (_a = OperationFootprintImpl.current) === null || _a === void 0 ? void 0 : _a.briefWhy()) !== null && _b !== void 0 ? _b : BOOT_CAUSE;
     }
     static dependencies() {
-        const l = Launch.current;
+        const l = OperationFootprintImpl.current;
         return l ? l.dependencies() : ["RxSystem.dependencies should be called from inside of reactive method"];
     }
     peek(args) {
         const ctx = Changeset.current();
         const ov = ctx.lookupObjectVersion(this.ownerHandle, this.fieldKey, false);
-        const launch = this.acquireFromObjectVersion(ov, args);
+        const footprint = this.acquireFromObjectVersion(ov, args);
         const applied = this.ownerHandle.applied.data[this.fieldKey];
-        const isReusable = launch.options.kind !== Kind.atomic && launch.cause !== BOOT_CAUSE &&
-            (ctx === launch.changeset || ctx.timestamp < launch.obsoleteSince || applied.obsoleteDueTo === undefined) &&
-            (!launch.options.triggeringArgs || args === undefined ||
-                launch.args.length === args.length && launch.args.every((t, i) => t === args[i])) || ov.disposed;
-        return { launch, isReusable, changeset: ctx, objectVersion: ov };
+        const isReusable = footprint.options.kind !== Kind.atomic && footprint.cause !== BOOT_CAUSE &&
+            (ctx === footprint.changeset || ctx.timestamp < footprint.obsoleteSince || applied.obsoleteDueTo === undefined) &&
+            (!footprint.options.observableArgs || args === undefined ||
+                footprint.args.length === args.length && footprint.args.every((t, i) => t === args[i])) || ov.disposed;
+        return { footprint, isReusable, changeset: ctx, objectVersion: ov };
     }
     use() {
         const ror = this.peek(undefined);
-        Changeset.markUsed(ror.launch, ror.objectVersion, this.fieldKey, this.ownerHandle, ror.launch.options.kind, true);
+        Changeset.markUsed(ror.footprint, ror.objectVersion, this.fieldKey, this.ownerHandle, ror.footprint.options.kind, true);
         return ror;
     }
     edit() {
@@ -115,94 +115,94 @@ export class OperationImpl {
         const fk = this.fieldKey;
         const ctx = Changeset.edit();
         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);
+        let footprint = this.acquireFromObjectVersion(ov, undefined);
+        if (footprint.changeset !== ov.changeset) {
+            const newFootprint = new OperationFootprintImpl(Transaction.current, this, ov.changeset, footprint, false);
+            ov.data[fk] = newFootprint.reenterOver(footprint);
             ctx.bumpBy(ov.former.objectVersion.changeset.timestamp);
-            Changeset.markEdited(launch, relaunch, true, ov, fk, h);
-            launch = relaunch;
+            Changeset.markEdited(footprint, newFootprint, true, ov, fk, h);
+            footprint = newFootprint;
         }
-        return { launch, isReusable: true, changeset: ctx, objectVersion: ov };
+        return { footprint, isReusable: true, changeset: ctx, objectVersion: ov };
     }
     acquireFromObjectVersion(ov, args) {
         const fk = this.fieldKey;
-        let launch = ov.data[fk];
-        if (launch.operation !== this) {
+        let footprint = ov.data[fk];
+        if (footprint.descriptor !== this) {
             if (ov.changeset !== EMPTY_OBJECT_VERSION.changeset) {
-                const hint = Log.isOn ? `${Dump.obj(this.ownerHandle, fk)}/init` : "MethodController/init";
+                const hint = Log.isOn ? `${Dump.obj(this.ownerHandle, fk)}/init` : "OperationDescriptor/init";
                 const isolation = Isolation.joinToCurrentTransaction;
-                launch = Transaction.run({ hint, isolation, token: this }, () => {
+                footprint = 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) {
+                    let newFootprint = r.data[fk];
+                    if (newFootprint.descriptor !== this) {
                         r = Changeset.edit().getEditableObjectVersion(h, fk, Meta.Handle, this);
-                        const t = new Launch(Transaction.current, this, r.changeset, relaunch, false);
+                        const t = new OperationFootprintImpl(Transaction.current, this, r.changeset, newFootprint, false);
                         if (args)
                             t.args = args;
                         t.cause = BOOT_CAUSE;
                         r.data[fk] = t;
-                        Changeset.markEdited(relaunch, t, true, r, fk, h);
-                        relaunch = t;
+                        Changeset.markEdited(newFootprint, t, true, r, fk, h);
+                        newFootprint = t;
                     }
-                    return relaunch;
+                    return newFootprint;
                 });
             }
             else {
-                const initialLaunch = new Launch(Transaction.current, this, ov.changeset, launch, false);
+                const initialFootprint = new OperationFootprintImpl(Transaction.current, this, ov.changeset, footprint, false);
                 if (args)
-                    initialLaunch.args = args;
-                initialLaunch.cause = BOOT_CAUSE;
-                ov.data[fk] = initialLaunch;
-                launch = initialLaunch;
+                    initialFootprint.args = args;
+                initialFootprint.cause = BOOT_CAUSE;
+                ov.data[fk] = initialFootprint;
+                footprint = initialFootprint;
                 if (Log.isOn && Log.opt.write)
                     Log.write("║", " ++", `${Dump.obj(this.ownerHandle, fk)} is initialized (revision ${ov.revision})`);
             }
         }
-        return launch;
+        return footprint;
     }
     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, isolation, journal: options.journal, logging: options.logging, token };
         const result = Transaction.run(opts, (argsx) => {
-            if (!ror.launch.transaction.isCanceled) {
+            if (!ror.footprint.transaction.isCanceled) {
                 ror = this.edit();
                 if (Log.isOn && Log.opt.operation)
-                    Log.write("║", "  o", `${ror.launch.why()}`);
-                ror.launch.proceed(this.ownerHandle.proxy, argsx);
+                    Log.write("║", "  o", `${ror.footprint.why()}`);
+                ror.footprint.proceed(this.ownerHandle.proxy, argsx);
             }
             else {
                 ror = this.peek(argsx);
-                if (ror.launch.options.kind === Kind.atomic || !ror.isReusable) {
+                if (ror.footprint.options.kind === Kind.atomic || !ror.isReusable) {
                     ror = this.edit();
                     if (Log.isOn && Log.opt.operation)
-                        Log.write("║", "  o", `${ror.launch.why()}`);
-                    ror.launch.proceed(this.ownerHandle.proxy, argsx);
+                        Log.write("║", "  o", `${ror.footprint.why()}`);
+                    ror.footprint.proceed(this.ownerHandle.proxy, argsx);
                 }
             }
-            return ror.launch.result;
+            return ror.footprint.result;
         }, args);
-        ror.launch.result = result;
+        ror.footprint.result = result;
         return ror;
     }
     static markObsolete(self) {
         const ror = self.peek(undefined);
         const ctx = ror.changeset;
-        const obsolete = ror.launch.transaction.isFinished ? ctx.obsolete : ror.launch.transaction.changeset.obsolete;
-        ror.launch.markObsoleteDueTo(ror.launch, self.fieldKey, EMPTY_OBJECT_VERSION.changeset, EMPTY_HANDLE, BOOT_CAUSE, ctx.timestamp, obsolete);
+        const obsolete = ror.footprint.transaction.isFinished ? ctx.obsolete : ror.footprint.transaction.changeset.obsolete;
+        ror.footprint.markObsoleteDueTo(ror.footprint, self.fieldKey, EMPTY_OBJECT_VERSION.changeset, EMPTY_HANDLE, BOOT_CAUSE, ctx.timestamp, obsolete);
     }
 }
-class Launch extends FieldVersion {
-    constructor(transaction, operation, changeset, former, clone) {
+class OperationFootprintImpl extends ContentFootprint {
+    constructor(transaction, descriptor, changeset, former, clone) {
         super(undefined, 0);
-        this.margin = Launch.current ? Launch.current.margin + 1 : 1;
+        this.margin = OperationFootprintImpl.current ? OperationFootprintImpl.current.margin + 1 : 1;
         this.transaction = transaction;
-        this.operation = operation;
+        this.descriptor = descriptor;
         this.changeset = changeset;
-        this.triggers = new Map();
-        if (former instanceof Launch) {
+        this.observables = new Map();
+        if (former instanceof OperationFootprintImpl) {
             this.options = former.options;
             this.cause = former.obsoleteDueTo;
             this.args = former.args;
@@ -238,20 +238,20 @@ class Launch extends FieldVersion {
             this.successor = undefined;
         }
     }
-    get isLaunch() { return true; }
-    hint() { return `${Dump.snapshot2(this.operation.ownerHandle, this.changeset, this.operation.fieldKey, this)}`; }
+    get isComputed() { return true; }
+    hint() { return `${Dump.snapshot2(this.descriptor.ownerHandle, this.changeset, this.descriptor.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);
+        return new OperationFootprintImpl(t, this.descriptor, cs, this, true);
     }
     why() {
         let cause;
         if (this.cause)
             cause = `   ◀◀   ${this.cause}`;
-        else if (this.operation.options.kind === Kind.atomic)
+        else if (this.descriptor.options.kind === Kind.atomic)
             cause = "   ◀◀   operation";
         else
             cause = `   ◀◀   T${this.changeset.id}[${this.changeset.hint}]`;
@@ -268,7 +268,7 @@ class Launch extends FieldVersion {
             if (Log.isOn && Log.opt.step && this.result)
                 Log.writeAs({ margin2: this.margin }, "║", "‾\\", `${this.hint()} - step in  `, 0, "        │");
             const started = Date.now();
-            const result = OperationImpl.proceedWithinGivenLaunch(this, func, ...args);
+            const result = ReactiveOperationImpl.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 ? "        │" : "");
@@ -283,37 +283,37 @@ class Launch extends FieldVersion {
             this.args = args;
         this.obsoleteSince = MAX_REVISION;
         if (!this.error)
-            OperationImpl.proceedWithinGivenLaunch(this, Launch.proceed, this, proxy);
+            ReactiveOperationImpl.proceedWithinGivenLaunch(this, OperationFootprintImpl.proceed, this, proxy);
         else
             this.result = Promise.reject(this.error);
     }
-    markObsoleteDueTo(trigger, fk, changeset, h, outer, since, collector) {
+    markObsoleteDueTo(footprint, fk, changeset, h, outer, since, collector) {
         var _a, _b, _c;
-        if (this.triggers !== undefined) {
-            const skip = !trigger.isLaunch &&
+        if (this.observables !== undefined) {
+            const skip = !footprint.isComputed &&
                 changeset.id === this.lastEditorChangesetId;
             if (!skip) {
-                const why = `${Dump.snapshot2(h, changeset, fk, trigger)}    ◀◀    ${outer}`;
-                const isReaction = this.options.kind === Kind.reaction;
+                const why = `${Dump.snapshot2(h, changeset, fk, footprint)}    ◀◀    ${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 ? "║" : " ", isReaction ? "█" : "▒", isReaction && changeset === EMPTY_OBJECT_VERSION.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, fk)} since s${since}${isReaction ? ` and will run automatically (order ${this.options.order})` : ""}`);
-                this.unsubscribeFromAllTriggers();
-                if (isReaction)
+                        : `${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)
                     collector.push(this);
                 else
-                    (_b = this.reactions) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.operation.fieldKey, this.changeset, this.operation.ownerHandle, why, since, collector));
+                    (_b = this.subscribers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.descriptor.fieldKey, this.changeset, this.descriptor.ownerHandle, why, since, collector));
                 const tran = this.transaction;
                 if (tran.changeset === changeset) {
                 }
-                else if (!tran.isFinished && this !== trigger && !this.options.allowObsoleteToFinish)
+                else if (!tran.isFinished && this !== footprint && !this.options.allowObsoleteToFinish)
                     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, fk, trigger)}`);
+                Log.write(" ", "x", `${this.hint()} is not obsolete due to its own change to ${Dump.snapshot2(h, changeset, fk, footprint)}`);
         }
     }
     relaunchIfNotUpToDate(now, nothrow) {
@@ -323,17 +323,17 @@ class Launch extends FieldVersion {
         if (now || hold < 0) {
             if (this.isNotUpToDate()) {
                 try {
-                    const launch = this.operation.reuseOrRelaunch(false, undefined);
-                    if (launch.result instanceof Promise)
-                        launch.result.catch(error => {
-                            if (launch.options.kind === Kind.reaction)
-                                misuse(`reactive function ${launch.hint()} failed and will not run anymore: ${error}`, error);
+                    const footprint = this.descriptor.reuseOrRelaunch(false, undefined);
+                    if (footprint.result instanceof Promise)
+                        footprint.result.catch(error => {
+                            if (footprint.options.kind === Kind.reactive)
+                                misuse(`reactive function ${footprint.hint()} failed and will not run anymore: ${error}`, error);
                         });
                 }
                 catch (e) {
                     if (!nothrow)
                         throw e;
-                    else if (this.options.kind === Kind.reaction)
+                    else if (this.options.kind === Kind.reactive)
                         misuse(`reactive ${this.hint()} failed and will not run anymore: ${e}`, e);
                 }
             }
@@ -384,22 +384,22 @@ class Launch extends FieldVersion {
             this.error = error;
         return this;
     }
-    static proceed(launch, proxy) {
-        launch.enter();
+    static proceed(footprint, proxy) {
+        footprint.enter();
         try {
-            if (launch.options.getter === undefined)
+            if (footprint.options.getter === undefined)
                 console.log("(!)");
-            launch.result = launch.options.getter.call(proxy, ...launch.args);
+            footprint.result = footprint.options.getter.call(proxy, ...footprint.args);
         }
         finally {
-            launch.leaveOrAsync();
+            footprint.leaveOrAsync();
         }
     }
     enter() {
         if (this.options.indicator)
             this.indicatorEnter(this.options.indicator);
         if (Log.isOn && Log.opt.operation)
-            Log.write("║", "‾\\", `${this.hint()} - enter`, undefined, `    [ ${Dump.obj(this.operation.ownerHandle, this.operation.fieldKey)} ]`);
+            Log.write("║", "‾\\", `${this.hint()} - enter`, undefined, `    [ ${Dump.obj(this.descriptor.ownerHandle, this.descriptor.fieldKey)} ]`);
         this.started = Date.now();
     }
     leaveOrAsync() {
@@ -442,7 +442,7 @@ class Launch extends FieldVersion {
             isolation: Isolation.disjoinFromOuterAndInnerTransactions,
             logging: Log.isOn && Log.opt.indicator ? undefined : Log.global
         };
-        OperationImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, IndicatorImpl.enter, mon, this.transaction);
+        ReactiveOperationImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, IndicatorImpl.enter, mon, this.transaction);
     }
     indicatorLeave(mon) {
         Transaction.outside(() => {
@@ -452,33 +452,33 @@ class Launch extends FieldVersion {
                     isolation: Isolation.disjoinFromOuterAndInnerTransactions,
                     logging: Log.isOn && Log.opt.indicator ? undefined : Log.DefaultLevel
                 };
-                OperationImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, IndicatorImpl.leave, mon, this.transaction);
+                ReactiveOperationImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, IndicatorImpl.leave, mon, this.transaction);
             };
             this.transaction.whenFinished().then(leave, leave);
         });
     }
     addToDeferredReactiveFunctions() {
-        Launch.deferredReactiveOperations.push(this);
-        if (Launch.deferredReactiveOperations.length === 1)
-            setTimeout(Launch.processDeferredReactiveFunctions, 0);
+        OperationFootprintImpl.deferredReactions.push(this);
+        if (OperationFootprintImpl.deferredReactions.length === 1)
+            setTimeout(OperationFootprintImpl.processDeferredReactions, 0);
     }
-    static processDeferredReactiveFunctions() {
-        const deferred = Launch.deferredReactiveOperations;
-        Launch.deferredReactiveOperations = [];
+    static processDeferredReactions() {
+        const deferred = OperationFootprintImpl.deferredReactions;
+        OperationFootprintImpl.deferredReactions = [];
         for (const x of deferred)
             x.relaunchIfNotUpToDate(true, true);
     }
-    static markUsed(trigger, ov, fk, h, kind, weak) {
+    static markUsed(footprint, ov, fk, h, kind, weak) {
         if (kind !== Kind.atomic) {
-            const launch = Launch.current;
-            if (launch && launch.options.kind !== Kind.atomic &&
-                launch.transaction === Transaction.current && fk !== Meta.Handle) {
+            const subscriber = OperationFootprintImpl.current;
+            if (subscriber && subscriber.options.kind !== Kind.atomic &&
+                subscriber.transaction === Transaction.current && fk !== Meta.Handle) {
                 const ctx = Changeset.current();
                 if (ctx !== ov.changeset)
                     ctx.bumpBy(ov.changeset.timestamp);
                 const t = weak ? -1 : ctx.timestamp;
-                if (!launch.subscribeTo(trigger, ov, fk, h, t))
-                    launch.markObsoleteDueTo(trigger, fk, h.applied.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
+                if (!subscriber.subscribeTo(footprint, ov, fk, h, t))
+                    subscriber.markObsoleteDueTo(footprint, fk, h.applied.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
             }
         }
     }
@@ -491,11 +491,11 @@ class Launch extends FieldVersion {
         let isResolved = theirValue === ourFormerValue;
         let resolvedValue = ourValue;
         if (!isResolved) {
-            if (ourValue instanceof Launch && ourValue.obsoleteDueTo === undefined) {
+            if (ourValue instanceof OperationFootprintImpl && ourValue.obsoleteDueTo === undefined) {
                 isResolved = true;
                 resolvedValue = ourValue;
             }
-            else if (theirValue instanceof Launch && (theirValue.obsoleteDueTo === undefined || theirValue.cause === BOOT_CAUSE)) {
+            else if (theirValue instanceof OperationFootprintImpl && (theirValue.obsoleteDueTo === undefined || theirValue.cause === BOOT_CAUSE)) {
                 isResolved = true;
                 resolvedValue = theirValue;
             }
@@ -507,20 +507,20 @@ class Launch extends FieldVersion {
         const since = changeset.timestamp;
         const obsolete = changeset.obsolete;
         changeset.items.forEach((ov, h) => {
-            Launch.propagateFieldChangeThroughSubscriptions(false, since, ov, Meta.Revision, h, obsolete);
+            OperationFootprintImpl.propagateFieldChangeThroughSubscriptions(false, since, ov, Meta.Revision, h, obsolete);
             if (!ov.disposed)
-                ov.changes.forEach((o, fk) => Launch.propagateFieldChangeThroughSubscriptions(false, since, ov, fk, h, obsolete));
+                ov.changes.forEach((o, fk) => OperationFootprintImpl.propagateFieldChangeThroughSubscriptions(false, since, ov, fk, h, obsolete));
             else
                 for (const fk in ov.former.objectVersion.data)
-                    Launch.propagateFieldChangeThroughSubscriptions(true, since, ov, fk, h, obsolete);
+                    OperationFootprintImpl.propagateFieldChangeThroughSubscriptions(true, since, ov, fk, h, obsolete);
         });
         obsolete.sort(compareReactionsByOrder);
         (_a = changeset.options.journal) === null || _a === void 0 ? void 0 : _a.edited(JournalImpl.buildPatch(changeset.hint, changeset.items));
     }
     static revokeAllSubscriptions(changeset) {
         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));
+            OperationFootprintImpl.propagateFieldChangeThroughSubscriptions(true, changeset.timestamp, ov, Meta.Revision, h, undefined);
+            ov.changes.forEach((o, fk) => OperationFootprintImpl.propagateFieldChangeThroughSubscriptions(true, changeset.timestamp, ov, fk, h, undefined));
         });
     }
     static propagateFieldChangeThroughSubscriptions(unsubscribe, timestamp, ov, fk, h, collector) {
@@ -528,13 +528,13 @@ class Launch extends FieldVersion {
         const curr = ov.data[fk];
         if (collector !== undefined) {
             const former = ov.former.objectVersion.data[fk];
-            if (former !== undefined && former instanceof FieldVersion) {
+            if (former !== undefined && former instanceof ContentFootprint) {
                 const why = `T${ov.changeset.id}[${ov.changeset.hint}]`;
-                if (former instanceof Launch) {
+                if (former instanceof OperationFootprintImpl) {
                     if ((former.obsoleteSince === MAX_REVISION || former.obsoleteSince <= 0)) {
                         former.obsoleteDueTo = why;
                         former.obsoleteSince = timestamp;
-                        former.unsubscribeFromAllTriggers();
+                        former.unsubscribeFromAllObservables();
                     }
                     const formerSuccessor = former.successor;
                     if (formerSuccessor !== curr) {
@@ -544,163 +544,163 @@ class Launch extends FieldVersion {
                     else
                         former.successor = undefined;
                 }
-                (_a = former.reactions) === null || _a === void 0 ? void 0 : _a.forEach(s => {
+                (_a = former.subscribers) === null || _a === void 0 ? void 0 : _a.forEach(s => {
                     const t = s.transaction;
                     const o = t.isFinished ? collector : t.changeset.obsolete;
                     return s.markObsoleteDueTo(former, fk, ov.changeset, h, why, timestamp, o);
                 });
             }
         }
-        if (curr instanceof Launch) {
-            if (curr.changeset === ov.changeset && curr.triggers !== undefined) {
+        if (curr instanceof OperationFootprintImpl) {
+            if (curr.changeset === ov.changeset && curr.observables !== undefined) {
                 if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
-                    curr.triggers.forEach((info, v) => {
+                    curr.observables.forEach((info, v) => {
                         if (info.usageCount > Mvcc.repetitiveUsageWarningThreshold)
                             Log.write("", "[!]", `${curr.hint()} uses ${info.memberHint} ${info.usageCount} times (consider remembering it in a local variable)`, 0, " *** WARNING ***");
                     });
                 }
                 if (unsubscribe)
-                    curr.unsubscribeFromAllTriggers();
+                    curr.unsubscribeFromAllObservables();
             }
         }
-        else if (curr instanceof FieldVersion && curr.reactions) {
+        else if (curr instanceof ContentFootprint && curr.subscribers) {
         }
     }
     static enqueueReactionsToRun(reactions) {
-        const queue = Launch.queuedReactions;
+        const queue = OperationFootprintImpl.queuedReactions;
         const isKickOff = queue.length === 0;
         for (const r of reactions)
             queue.push(r);
         if (isKickOff)
-            OperationImpl.proceedWithinGivenLaunch(undefined, Launch.processQueuedReactions);
+            ReactiveOperationImpl.proceedWithinGivenLaunch(undefined, OperationFootprintImpl.processQueuedReactions);
     }
-    static migrateFieldVersion(fv, target) {
+    static migrateContentFootprint(cf, target) {
         let result;
-        if (fv instanceof Launch)
-            result = new Launch(target, fv.operation, target.changeset, fv, true);
+        if (cf instanceof OperationFootprintImpl)
+            result = new OperationFootprintImpl(target, cf.descriptor, target.changeset, cf, true);
         else
-            result = new FieldVersion(fv.content, fv.lastEditorChangesetId);
+            result = new ContentFootprint(cf.content, cf.lastEditorChangesetId);
         return result;
     }
     static processQueuedReactions() {
-        const queue = Launch.queuedReactions;
+        const queue = OperationFootprintImpl.queuedReactions;
         let i = 0;
         while (i < queue.length) {
             const reactive = queue[i];
             reactive.relaunchIfNotUpToDate(false, true);
             i++;
         }
-        Launch.queuedReactions = [];
+        OperationFootprintImpl.queuedReactions = [];
     }
-    unsubscribeFromAllTriggers() {
+    unsubscribeFromAllObservables() {
         var _a;
-        (_a = this.triggers) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
+        (_a = this.observables) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
             var _a;
-            value.reactions.delete(this);
+            value.subscribers.delete(this);
             if (Log.isOn && (Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
                 Log.write(Log.opt.transaction && !Changeset.current().sealed ? "║" : " ", "-", `${this.hint()} is unsubscribed from ${info.memberHint}`);
         });
-        this.triggers = undefined;
+        this.observables = undefined;
     }
-    subscribeTo(trigger, ov, fk, h, timestamp) {
+    subscribeTo(footprint, ov, fk, h, timestamp) {
         var _a, _b, _c;
         const parent = this.transaction.changeset.parent;
-        const ok = Launch.canSubscribeTo(trigger, ov, parent, fk, h, timestamp);
+        const ok = OperationFootprintImpl.canSubscribeTo(footprint, ov, parent, fk, h, timestamp);
         if (ok) {
             let times = 0;
             if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
-                const existing = this.triggers.get(trigger);
+                const existing = this.observables.get(footprint);
                 times = existing ? existing.usageCount + 1 : 1;
             }
-            if (this.triggers !== undefined) {
-                if (!trigger.reactions)
-                    trigger.reactions = new Set();
+            if (this.observables !== undefined) {
+                if (!footprint.subscribers)
+                    footprint.subscribers = new Set();
                 const subscription = { memberHint: Dump.snapshot2(h, ov.changeset, fk), usageCount: times };
-                trigger.reactions.add(this);
-                this.triggers.set(trigger, subscription);
+                footprint.subscribers.add(this);
+                this.observables.set(footprint, 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, ov.changeset, fk, trigger)}${subscription.usageCount > 1 ? ` (${subscription.usageCount} times)` : ""}`);
+                    Log.write("║", "  ∞", `${this.hint()} is subscribed to ${Dump.snapshot2(h, ov.changeset, fk, footprint)}${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, ov.changeset, fk, trigger)}`);
+                Log.write("║", "  x", `${this.hint()} is obsolete and is NOT subscribed to ${Dump.snapshot2(h, ov.changeset, fk, footprint)}`);
         }
         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, ov.changeset, fk, trigger)}`);
+                Log.write("║", "  x", `${this.hint()} is NOT subscribed to already obsolete ${Dump.snapshot2(h, ov.changeset, fk, footprint)}`);
         }
         return ok;
     }
-    static canSubscribeTo(trigger, ov, parent, fk, h, timestamp) {
+    static canSubscribeTo(footprint, ov, parent, fk, h, timestamp) {
         const parentSnapshot = parent ? parent.lookupObjectVersion(h, fk, false) : h.applied;
-        const parentTrigger = parentSnapshot.data[fk];
-        let result = trigger === parentTrigger || (!ov.changeset.sealed && ov.former.objectVersion.data[fk] === parentTrigger);
+        const parentFootprint = parentSnapshot.data[fk];
+        let result = footprint === parentFootprint || (!ov.changeset.sealed && ov.former.objectVersion.data[fk] === parentFootprint);
         if (result && timestamp !== -1)
-            result = !(trigger instanceof Launch && timestamp >= trigger.obsoleteSince);
+            result = !(footprint instanceof OperationFootprintImpl && timestamp >= footprint.obsoleteSince);
         return result;
     }
-    static createOperation(h, fk, options) {
-        const rx = new OperationImpl(h, fk);
+    static createOperationDescriptor(h, fk, options) {
+        const ctl = new ReactiveOperationImpl(h, fk);
         const operation = (...args) => {
-            return rx.reuseOrRelaunch(false, args).result;
+            return ctl.reuseOrRelaunch(false, args).result;
         };
-        Meta.set(operation, Meta.Controller, rx);
+        Meta.set(operation, Meta.Descriptor, ctl);
         return operation;
     }
     static rememberOperationOptions(proto, fk, getter, setter, enumerable, configurable, options, implicit) {
         const initial = Meta.acquire(proto, Meta.Initial);
-        let launch = initial[fk];
-        const rx = launch ? launch.operation : new OperationImpl(EMPTY_HANDLE, fk);
-        const opts = launch ? launch.options : OptionsImpl.INITIAL;
-        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.reaction && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
+        let footprint = initial[fk];
+        const ctl = footprint ? footprint.descriptor : new ReactiveOperationImpl(EMPTY_HANDLE, fk);
+        const opts = footprint ? footprint.options : OptionsImpl.INITIAL;
+        initial[fk] = footprint = new OperationFootprintImpl(Transaction.current, ctl, EMPTY_OBJECT_VERSION.changeset, new OptionsImpl(getter, setter, opts, options, implicit), false);
+        if (footprint.options.kind === Kind.reactive && footprint.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.acquire(proto, Meta.Reactive);
-            reactive[fk] = launch;
+            reactive[fk] = footprint;
         }
-        else if (launch.options.kind === Kind.reaction && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
+        else if (footprint.options.kind === Kind.reactive && footprint.options.throttling >= Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.getFrom(proto, Meta.Reactive);
             delete reactive[fk];
         }
-        return launch.options;
+        return footprint.options;
     }
     static init() {
         Object.freeze(BOOT_ARGS);
         Log.getMergedLoggingOptions = getMergedLoggingOptions;
         Dump.valueHint = valueHint;
-        Changeset.markUsed = Launch.markUsed;
-        Changeset.markEdited = Launch.markEdited;
-        Changeset.tryResolveConflict = Launch.tryResolveConflict;
-        Changeset.propagateAllChangesThroughSubscriptions = Launch.propagateAllChangesThroughSubscriptions;
-        Changeset.revokeAllSubscriptions = Launch.revokeAllSubscriptions;
-        Changeset.enqueueReactionsToRun = Launch.enqueueReactionsToRun;
-        TransactionImpl.migrateFieldVersion = Launch.migrateFieldVersion;
-        Mvcc.createOperation = Launch.createOperation;
-        Mvcc.rememberOperationOptions = Launch.rememberOperationOptions;
+        Changeset.markUsed = OperationFootprintImpl.markUsed;
+        Changeset.markEdited = OperationFootprintImpl.markEdited;
+        Changeset.tryResolveConflict = OperationFootprintImpl.tryResolveConflict;
+        Changeset.propagateAllChangesThroughSubscriptions = OperationFootprintImpl.propagateAllChangesThroughSubscriptions;
+        Changeset.revokeAllSubscriptions = OperationFootprintImpl.revokeAllSubscriptions;
+        Changeset.enqueueReactionsToRun = OperationFootprintImpl.enqueueReactionsToRun;
+        TransactionImpl.migrateContentFootprint = OperationFootprintImpl.migrateContentFootprint;
+        Mvcc.createOperationDescriptor = OperationFootprintImpl.createOperationDescriptor;
+        Mvcc.rememberOperationOptions = OperationFootprintImpl.rememberOperationOptions;
         Promise.prototype.then = reactronicHookedThen;
         try {
             Object.defineProperty(globalThis, "rWhy", {
-                get: OperationImpl.why, configurable: false, enumerable: false,
+                get: ReactiveOperationImpl.why, configurable: false, enumerable: false,
             });
             Object.defineProperty(globalThis, "rBriefWhy", {
-                get: OperationImpl.briefWhy, configurable: false, enumerable: false,
+                get: ReactiveOperationImpl.briefWhy, configurable: false, enumerable: false,
             });
         }
         catch (e) {
         }
         try {
             Object.defineProperty(global, "rWhy", {
-                get: OperationImpl.why, configurable: false, enumerable: false,
+                get: ReactiveOperationImpl.why, configurable: false, enumerable: false,
             });
             Object.defineProperty(global, "rBriefWhy", {
-                get: OperationImpl.briefWhy, configurable: false, enumerable: false,
+                get: ReactiveOperationImpl.briefWhy, configurable: false, enumerable: false,
             });
         }
         catch (e) {
         }
     }
 }
-Launch.current = undefined;
-Launch.queuedReactions = [];
-Launch.deferredReactiveOperations = [];
+OperationFootprintImpl.current = undefined;
+OperationFootprintImpl.queuedReactions = [];
+OperationFootprintImpl.deferredReactions = [];
 function valueHint(value) {
     let result = "";
     if (Array.isArray(value))
@@ -709,8 +709,8 @@ function valueHint(value) {
         result = `Set(${value.size})`;
     else if (value instanceof Map)
         result = `Map(${value.size})`;
-    else if (value instanceof Launch)
-        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 instanceof OperationFootprintImpl)
+        result = `#${value.descriptor.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")
@@ -725,8 +725,8 @@ function getMergedLoggingOptions(local) {
     const t = Transaction.current;
     let res = Log.merge(t.options.logging, t.id > 1 ? 31 + t.id % 6 : 37, t.id > 1 ? `T${t.id}` : `-${Changeset.idGen.toString().replace(/[0-9]/g, "-")}`, Log.global);
     res = Log.merge({ margin1: t.margin }, undefined, undefined, res);
-    if (Launch.current)
-        res = Log.merge({ margin2: Launch.current.margin }, undefined, undefined, res);
+    if (OperationFootprintImpl.current)
+        res = Log.merge({ margin2: OperationFootprintImpl.current.margin }, undefined, undefined, res);
     if (local)
         res = Log.merge(local, undefined, undefined, res);
     return res;
@@ -739,10 +739,10 @@ function reactronicHookedThen(resolve, reject) {
             resolve = resolveReturn;
         if (!reject)
             reject = rejectRethrow;
-        const launch = Launch.current;
-        if (launch) {
-            resolve = launch.wrap(resolve);
-            reject = launch.wrap(reject);
+        const footprint = OperationFootprintImpl.current;
+        if (footprint) {
+            resolve = footprint.wrap(resolve);
+            reject = footprint.wrap(reject);
         }
         resolve = tran.wrapAsPending(resolve, false);
         reject = tran.wrapAsPending(reject, true);
@@ -758,4 +758,4 @@ export function resolveReturn(value) {
 export function rejectRethrow(error) {
     throw error;
 }
-Launch.init();
+OperationFootprintImpl.init();