reactronic 0.23.106 → 0.23.108

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

@@ -0,0 +1,18 @@
+import { F } from 'util/Utils.js';
+import { MemberOptions } from './Options.js';
+export interface AbstractReaction<T> {
+    readonly options: MemberOptions;
+    readonly args: ReadonlyArray<any>;
+    readonly result: T;
+    readonly error: any;
+    readonly stamp: number;
+    readonly isUpToDate: boolean;
+    configure(options: Partial<MemberOptions>): MemberOptions;
+    markObsolete(): void;
+    pullLastResult(args?: any[]): T | undefined;
+}
+export declare class Reaction<T> {
+    protected action: F<T>;
+    constructor(action: F<T>);
+    protected launch(): T;
+}

package/build/dist/source/Reaction.js

@@ -0,0 +1,24 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { reactive } from 'Rx.js';
+export class Reaction {
+    constructor(action) {
+        this.action = action;
+    }
+    launch() {
+        return this.action();
+    }
+}
+__decorate([
+    reactive,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], Reaction.prototype, "launch", null);

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

@@ -1,9 +1,9 @@
 import { F } from './util/Utils.js';
-import { Controller } from './Controller.js';
+import { AbstractReaction } from './Reaction.js';
 import { MemberOptions, LoggingOptions, ProfilingOptions } from './Options.js';
 export declare class Rx {
     static why(brief?: boolean): string;
-    static getController<T>(method: F<T>): Controller<T>;
+    static getReaction<T>(method: F<T>): AbstractReaction<T>;
     static pullLastResult<T>(method: F<Promise<T>>, args?: any[]): T | undefined;
     static configureCurrentOperation(options: Partial<MemberOptions>): MemberOptions;
     static getRevisionOf(obj: any): number;
@@ -18,6 +18,7 @@ export declare class Rx {
     static getLoggingHint<T extends object>(obj: T, full?: boolean): string | undefined;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
 }
+export declare function transaction<T>(action: F<T>, ...args: any[]): T;
 export declare function nonreactive<T>(func: F<T>, ...args: any[]): T;
 export declare function sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
 export declare function raw(proto: object, prop: PropertyKey): any;

package/build/dist/source/Rx.js

@@ -3,12 +3,13 @@ import { Kind } from './Options.js';
 import { Meta, ObjectHandle } from './impl/Data.js';
 import { Changeset } from './impl/Changeset.js';
 import { Mvcc } from './impl/Mvcc.js';
-import { OperationController } from './impl/Operation.js';
+import { Transaction } from './impl/Transaction.js';
+import { ReactionImpl } from './impl/Reaction.js';
 export class Rx {
-    static why(brief = false) { return brief ? OperationController.briefWhy() : OperationController.why(); }
-    static getController(method) { return OperationController.getControllerOf(method); }
-    static pullLastResult(method, args) { return Rx.getController(method).pullLastResult(args); }
-    static configureCurrentOperation(options) { return OperationController.configureImpl(undefined, options); }
+    static why(brief = false) { return brief ? ReactionImpl.briefWhy() : ReactionImpl.why(); }
+    static getReaction(method) { return ReactionImpl.getControllerOf(method); }
+    static pullLastResult(method, args) { return Rx.getReaction(method).pullLastResult(args); }
+    static configureCurrentOperation(options) { return ReactionImpl.configureImpl(undefined, options); }
     static getRevisionOf(obj) { return obj[Meta.Revision]; }
     static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }
     static dispose(obj) { Changeset.dispose(obj); }
@@ -21,8 +22,11 @@ export class Rx {
     static getLoggingHint(obj, full = false) { return ObjectHandle.getHint(obj, full); }
     static setProfilingMode(isOn, options) { Mvcc.setProfilingMode(isOn, options); }
 }
+export function transaction(action, ...args) {
+    return Transaction.run(null, action, ...args);
+}
 export function nonreactive(func, ...args) {
-    return OperationController.runWithin(undefined, func, ...args);
+    return ReactionImpl.proceedWithinGivenLaunch(undefined, func, ...args);
 }
 export function sensitive(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);

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

@@ -1,13 +1,13 @@
 export { all, pause } from './util/Utils.js';
 export { MergeList } from './util/MergeList.js';
-export type { MergeItem as Item, MergeListReader } from './util/MergeList.js';
+export type { MergeItem, MergeListReader } from './util/MergeList.js';
 export { SealedArray } from './util/SealedArray.js';
 export { SealedMap } from './util/SealedMap.js';
 export { SealedSet } from './util/SealedSet.js';
 export { Kind, Reentrance, LoggingLevel } from './Options.js';
 export type { MemberOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from './Options.js';
 export type { Worker } from './Worker.js';
-export { Controller } from './Controller.js';
+export type { AbstractReaction } from './Reaction.js';
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from './Ref.js';
 export type { BoolOnly, GivenTypeOnly } from './Ref.js';
 export { TransactionalObject, ObservableObject } from './impl/Mvcc.js';
@@ -17,5 +17,5 @@ export { Changeset } from './impl/Changeset.js';
 export { Transaction } from './impl/Transaction.js';
 export { Monitor } from './impl/Monitor.js';
 export { Journal } from './impl/Journal.js';
-export { Rx, raw, observable, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx.js';
+export { Rx, raw, observable, transactional, reactive, cached, transaction, nonreactive, sensitive, options } from './Rx.js';
 export { Clock } from './Clock.js';

package/build/dist/source/api.js

@@ -4,7 +4,6 @@ export { SealedArray } from './util/SealedArray.js';
 export { SealedMap } from './util/SealedMap.js';
 export { SealedSet } from './util/SealedSet.js';
 export { Kind, Reentrance, LoggingLevel } from './Options.js';
-export { Controller } from './Controller.js';
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from './Ref.js';
 export { TransactionalObject, ObservableObject } from './impl/Mvcc.js';
 export { TransactionalArray, ObservableArray } from './impl/MvccArray.js';
@@ -13,5 +12,5 @@ export { Changeset } from './impl/Changeset.js';
 export { Transaction } from './impl/Transaction.js';
 export { Monitor } from './impl/Monitor.js';
 export { Journal } from './impl/Journal.js';
-export { Rx, raw, observable, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx.js';
+export { Rx, raw, observable, transactional, reactive, cached, transaction, nonreactive, sensitive, options } from './Rx.js';
 export { Clock } from './Clock.js';

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

@@ -1,5 +1,5 @@
 import { Kind, SnapshotOptions } from '../Options.js';
-import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, ObservableValue, Observer } from './Data.js';
+import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, MvccValue, Observer } from './Data.js';
 export declare const MAX_REVISION: number;
 export declare const UNDEFINED_REVISION: number;
 export declare class Changeset implements AbstractChangeset {
@@ -18,12 +18,12 @@ export declare class Changeset implements AbstractChangeset {
     private revision;
     private bumper;
     items: Map<ObjectHandle, ObjectSnapshot>;
-    reactive: Observer[];
+    obsolete: Observer[];
     sealed: boolean;
     constructor(options: SnapshotOptions | null);
     static current: () => Changeset;
     static edit: () => Changeset;
-    static markUsed: (observable: ObservableValue, os: ObjectSnapshot, m: MemberName, h: ObjectHandle, kind: Kind, weak: boolean) => void;
+    static markUsed: (observable: MvccValue, os: ObjectSnapshot, m: MemberName, h: ObjectHandle, kind: Kind, weak: boolean) => void;
     static markEdited: (oldValue: any, newValue: any, edited: boolean, os: ObjectSnapshot, m: MemberName, h: ObjectHandle) => void;
     static isConflicting: (oldValue: any, newValue: any) => boolean;
     static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
@@ -42,7 +42,7 @@ export declare class Changeset implements AbstractChangeset {
     private merge;
     applyOrDiscard(error?: any): Array<Observer>;
     static sealObjectSnapshot(h: ObjectHandle, os: ObjectSnapshot): void;
-    static sealObservableValue(o: ObservableValue | symbol, m: MemberName, typeName: string): void;
+    static sealMvccValue(o: MvccValue | symbol, m: MemberName, typeName: string): void;
     static freezeObjectSnapshot(os: ObjectSnapshot): ObjectSnapshot;
     triggerGarbageCollection(): void;
     private unlinkHistory;
@@ -51,7 +51,7 @@ export declare class Changeset implements AbstractChangeset {
 export declare class Dump {
     static valueHint: (value: any) => string;
     static obj(h: ObjectHandle | undefined, m?: MemberName | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
-    static snapshot2(h: ObjectHandle, s: AbstractChangeset, m?: MemberName, o?: ObservableValue): string;
+    static snapshot2(h: ObjectHandle, s: AbstractChangeset, m?: MemberName, o?: MvccValue): string;
     static snapshot(os: ObjectSnapshot, m?: MemberName): string;
     static conflicts(conflicts: ObjectSnapshot[]): string;
     static conflictingMemberHint(m: MemberName, ours: ObjectSnapshot, theirs: ObjectSnapshot): string;

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

@@ -4,7 +4,7 @@ import { Sealant } from '../util/Sealant.js';
 import { SealedArray } from '../util/SealedArray.js';
 import { SealedMap } from '../util/SealedMap.js';
 import { SealedSet } from '../util/SealedSet.js';
-import { ObjectSnapshot, ObjectHandle, ObservableValue, Meta } from './Data.js';
+import { ObjectSnapshot, ObjectHandle, MvccValue, Meta } from './Data.js';
 export const MAX_REVISION = Number.MAX_SAFE_INTEGER;
 export const UNDEFINED_REVISION = MAX_REVISION - 1;
 Object.defineProperty(ObjectHandle.prototype, '#this#', {
@@ -14,7 +14,7 @@ Object.defineProperty(ObjectHandle.prototype, '#this#', {
         const data = Changeset.current().getObjectSnapshot(this, '#this#').data;
         for (const m in data) {
             const v = data[m];
-            if (v instanceof ObservableValue)
+            if (v instanceof MvccValue)
                 result[m] = v.content;
             else if (v === Meta.Raw)
                 result[m] = this.data[m];
@@ -35,7 +35,7 @@ export class Changeset {
         this.revision = UNDEFINED_REVISION;
         this.bumper = 100;
         this.items = new Map();
-        this.reactive = [];
+        this.obsolete = [];
         this.sealed = false;
     }
     lookupObjectSnapshot(h, m) {
@@ -67,7 +67,7 @@ export class Changeset {
                 const revision = m === Meta.Handle ? 1 : os.revision + 1;
                 const data = Object.assign({}, m === Meta.Handle ? value : os.data);
                 Meta.set(data, Meta.Handle, h);
-                Meta.set(data, Meta.Revision, new ObservableValue(revision));
+                Meta.set(data, Meta.Revision, new MvccValue(revision));
                 os = new ObjectSnapshot(this, os, data);
                 this.items.set(h, os);
                 h.editing = os;
@@ -214,19 +214,19 @@ export class Changeset {
         }
         if (!error)
             Changeset.propagateAllChangesThroughSubscriptions(this);
-        return this.reactive;
+        return this.obsolete;
     }
     static sealObjectSnapshot(h, os) {
         if (!os.disposed)
-            os.changes.forEach((o, m) => Changeset.sealObservableValue(os.data[m], m, h.proxy.constructor.name));
+            os.changes.forEach((o, m) => Changeset.sealMvccValue(os.data[m], m, h.proxy.constructor.name));
         else
             for (const m in os.former.snapshot.data)
                 os.data[m] = Meta.Undefined;
         if (Log.isOn)
             Changeset.freezeObjectSnapshot(os);
     }
-    static sealObservableValue(o, m, typeName) {
-        if (o instanceof ObservableValue) {
+    static sealMvccValue(o, m, typeName) {
+        if (o instanceof MvccValue) {
             const value = o.content;
             if (value !== undefined && value !== null) {
                 const sealedType = Object.getPrototypeOf(value)[Sealant.SealedType];
@@ -276,7 +276,7 @@ export class Changeset {
             os.former.snapshot = EMPTY_SNAPSHOT;
         });
         this.items = EMPTY_MAP;
-        this.reactive = EMPTY_ARRAY;
+        this.obsolete = EMPTY_ARRAY;
         if (Log.isOn)
             Object.freeze(this);
     }

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

@@ -5,7 +5,7 @@ export interface AbstractChangeset {
     readonly timestamp: number;
     readonly sealed: boolean;
 }
-export declare class ObservableValue {
+export declare class MvccValue {
     content: any;
     observers?: Set<Observer>;
     get isOperation(): boolean;
@@ -15,11 +15,11 @@ export declare class ObservableValue {
 export type SeparationMode = boolean | 'isolated' | 'disposal';
 export interface Observer {
     readonly order: number;
-    readonly observables: Map<ObservableValue, Subscription> | undefined;
+    readonly observables: Map<MvccValue, Subscription> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
-    markObsoleteDueTo(observable: ObservableValue, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Array<Observer>): void;
-    runIfNotUpToDate(now: boolean, nothrow: boolean): void;
+    markObsoleteDueTo(observable: MvccValue, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Array<Observer>): void;
+    relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
 }
 export type MemberName = PropertyKey;
 export interface Subscription {

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

@@ -1,7 +1,7 @@
 import { Log } from '../util/Dbg.js';
 import { Meta } from './Meta.js';
 export { Meta } from './Meta.js';
-export class ObservableValue {
+export class MvccValue {
     get isOperation() { return false; }
     get originSnapshotId() { return 0; }
     constructor(content) { this.content = content; }

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

@@ -1,5 +1,5 @@
 import { ObservableObject } from './Mvcc.js';
-import { Meta, ObservableValue } from './Data.js';
+import { Meta, MvccValue } from './Data.js';
 import { Changeset, EMPTY_SNAPSHOT } from './Changeset.js';
 import { Transaction } from './Transaction.js';
 import { Sealant } from '../util/Sealant.js';
@@ -99,7 +99,7 @@ export class JournalImpl extends Journal {
                     const value = undoing ? vp.formerValue : vp.freshValue;
                     const os = ctx.getEditableObjectSnapshot(h, m, value);
                     if (os.changeset === ctx) {
-                        os.data[m] = new ObservableValue(value);
+                        os.data[m] = new MvccValue(value);
                         const existing = os.former.snapshot.data[m];
                         Changeset.markEdited(existing, value, existing !== value, os, m, h);
                     }

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

@@ -1,7 +1,7 @@
 import { UNDEF } from '../util/Utils.js';
 import { Log, misuse } from '../util/Dbg.js';
 import { Kind, Reentrance } from '../Options.js';
-import { ObjectSnapshot, ObjectHandle, ObservableValue, Meta } from './Data.js';
+import { ObjectSnapshot, ObjectHandle, MvccValue, Meta } from './Data.js';
 import { Changeset, Dump, EMPTY_SNAPSHOT } from './Changeset.js';
 export class MvccObject {
     constructor(observable) {
@@ -72,7 +72,7 @@ export class Mvcc {
             const cs = Changeset.current();
             const os = cs.getObjectSnapshot(h, m);
             result = os.data[m];
-            if (result instanceof ObservableValue && !result.isOperation) {
+            if (result instanceof MvccValue && !result.isOperation) {
                 if (this.isObservable)
                     Changeset.markUsed(result, os, m, h, Kind.Plain, false);
                 result = result.content;
@@ -92,7 +92,7 @@ export class Mvcc {
                 if (curr === undefined || curr.content !== value || Mvcc.sensitivity) {
                     const existing = curr === null || curr === void 0 ? void 0 : curr.content;
                     if (os.former.snapshot.data[m] === curr) {
-                        curr = os.data[m] = new ObservableValue(value);
+                        curr = os.data[m] = new MvccValue(value);
                         Changeset.markEdited(existing, value, true, os, m, h);
                     }
                     else {
@@ -130,14 +130,14 @@ export class Mvcc {
         const result = [];
         for (const m of Object.getOwnPropertyNames(os.data)) {
             const value = os.data[m];
-            if (!(value instanceof ObservableValue) || !value.isOperation)
+            if (!(value instanceof MvccValue) || !value.isOperation)
                 result.push(m);
         }
         return result;
     }
     static decorateData(isObservable, proto, member) {
         if (isObservable) {
-            Meta.acquire(proto, Meta.Initial)[member] = new ObservableValue(undefined);
+            Meta.acquire(proto, Meta.Initial)[member] = new MvccValue(undefined);
             const get = function () {
                 const h = Mvcc.acquireHandle(this);
                 return Mvcc.observable.get(h, member, this);
@@ -196,7 +196,7 @@ export class Mvcc {
             h = new ObjectHandle(obj, obj, Mvcc.observable, os, obj.constructor.name);
             Meta.set(os.data, Meta.Handle, h);
             Meta.set(obj, Meta.Handle, h);
-            Meta.set(os.data, Meta.Revision, new ObservableValue(1));
+            Meta.set(os.data, Meta.Revision, new MvccValue(1));
         }
         return h;
     }

package/build/dist/source/impl/{Operation.d.ts → Reaction.d.ts}

@@ -1,10 +1,10 @@
 import { F } from '../util/Utils.js';
 import { MemberOptions } from '../Options.js';
-import { Controller } from '../Controller.js';
-import { MemberName, ObjectHandle, ObservableValue, Observer, Subscription, AbstractChangeset } from './Data.js';
+import { AbstractReaction } from '../Reaction.js';
+import { MemberName, ObjectHandle, MvccValue, Observer, Subscription, AbstractChangeset } from './Data.js';
 import { Transaction } from './Transaction.js';
 import { OptionsImpl } from './Mvcc.js';
-export declare class OperationController extends Controller<any> {
+export declare class ReactionImpl implements AbstractReaction<any> {
     readonly objectHandle: ObjectHandle;
     readonly memberName: MemberName;
     configure(options: Partial<MemberOptions>): MemberOptions;
@@ -18,10 +18,10 @@ export declare class OperationController extends Controller<any> {
     markObsolete(): void;
     pullLastResult(args?: any[]): any;
     constructor(h: ObjectHandle, m: MemberName);
-    useOrRun(weak: boolean, args: any[] | undefined): Operation;
-    static getControllerOf(method: F<any>): Controller<any>;
-    static configureImpl(self: OperationController | undefined, options: Partial<MemberOptions>): MemberOptions;
-    static runWithin<T>(op: Operation | undefined, func: F<T>, ...args: any[]): T;
+    reuseOrRelaunch(weak: boolean, args: any[] | undefined): Launch;
+    static getControllerOf(method: F<any>): AbstractReaction<any>;
+    static configureImpl(self: ReactionImpl | undefined, options: Partial<MemberOptions>): MemberOptions;
+    static proceedWithinGivenLaunch<T>(launch: Launch | undefined, func: F<T>, ...args: any[]): T;
     static why(): string;
     static briefWhy(): string;
     static dependencies(): string[];
@@ -29,18 +29,18 @@ export declare class OperationController extends Controller<any> {
     private use;
     private edit;
     private acquireFromSnapshot;
-    private run;
+    private relaunch;
     private static markObsolete;
 }
-declare class Operation extends ObservableValue implements Observer {
-    static current?: Operation;
+declare class Launch extends MvccValue implements Observer {
+    static current?: Launch;
     static queuedReactiveFunctions: Array<Observer>;
-    static deferredReactiveFunctions: Array<Operation>;
+    static deferredReactiveFunctions: Array<Launch>;
     readonly margin: number;
     readonly transaction: Transaction;
-    readonly controller: OperationController;
+    readonly reaction: ReactionImpl;
     readonly changeset: AbstractChangeset;
-    observables: Map<ObservableValue, Subscription> | undefined;
+    observables: Map<MvccValue, Subscription> | undefined;
     options: OptionsImpl;
     cause: string | undefined;
     args: any[];
@@ -49,8 +49,8 @@ declare class Operation extends ObservableValue implements Observer {
     started: number;
     obsoleteDueTo: string | undefined;
     obsoleteSince: number;
-    successor: Operation | undefined;
-    constructor(controller: OperationController, changeset: AbstractChangeset, former: Operation | OptionsImpl);
+    successor: Launch | undefined;
+    constructor(reaction: ReactionImpl, changeset: AbstractChangeset, former: Launch | OptionsImpl);
     get isOperation(): boolean;
     get originSnapshotId(): number;
     hint(): string;
@@ -60,12 +60,12 @@ declare class Operation extends ObservableValue implements Observer {
     briefWhy(): string;
     dependencies(): string[];
     wrap<T>(func: F<T>): F<T>;
-    run(proxy: any, args: any[] | undefined): void;
-    markObsoleteDueTo(observable: ObservableValue, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Observer[]): void;
-    runIfNotUpToDate(now: boolean, nothrow: boolean): void;
+    proceed(proxy: any, args: any[] | undefined): void;
+    markObsoleteDueTo(observable: MvccValue, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, obsolete: Observer[]): void;
+    relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
     isNotUpToDate(): boolean;
-    reenterOver(head: Operation): this;
-    private static run;
+    reenterOver(head: Launch): this;
+    private static proceed;
     private enter;
     private leaveOrAsync;
     private leave;
@@ -80,7 +80,7 @@ declare class Operation extends ObservableValue implements Observer {
     private static revokeAllSubscriptions;
     private static propagateMemberChangeThroughSubscriptions;
     private static enqueueReactiveFunctionsToRun;
-    private static runQueuedReactiveLoop;
+    private static runQueuedReactiveFunctions;
     private unsubscribeFromAllObservables;
     private subscribeTo;
     private static canSubscribeTo;

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

@@ -1,7 +1,6 @@
 import { Log, misuse } from '../util/Dbg.js';
 import { Kind, Reentrance } from '../Options.js';
-import { Controller } from '../Controller.js';
-import { ObjectHandle, ObservableValue, Meta } from './Data.js';
+import { ObjectHandle, MvccValue, Meta } from './Data.js';
 import { Changeset, Dump, EMPTY_SNAPSHOT, MAX_REVISION } from './Changeset.js';
 import { Transaction } from './Transaction.js';
 import { MonitorImpl } from './Monitor.js';
@@ -10,47 +9,46 @@ 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 OperationController extends Controller {
-    configure(options) { return OperationController.configureImpl(this, options); }
-    get options() { return this.peek(undefined).operation.options; }
-    get unobservable() { return this.peek(undefined).operation.content; }
-    get args() { return this.use().operation.args; }
-    get result() { return this.useOrRun(true, undefined).content; }
-    get error() { return this.use().operation.error; }
+export class ReactionImpl {
+    configure(options) { return ReactionImpl.configureImpl(this, options); }
+    get options() { return this.peek(undefined).launch.options; }
+    get unobservable() { 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 isUpToDate() { return this.use().isUpToDate; }
-    markObsolete() { Transaction.run({ hint: Log.isOn ? `markObsolete(${Dump.obj(this.objectHandle, this.memberName)})` : 'markObsolete()' }, OperationController.markObsolete, this); }
-    pullLastResult(args) { return this.useOrRun(true, args).content; }
+    markObsolete() { Transaction.run({ hint: Log.isOn ? `markObsolete(${Dump.obj(this.objectHandle, this.memberName)})` : 'markObsolete()' }, ReactionImpl.markObsolete, this); }
+    pullLastResult(args) { return this.reuseOrRelaunch(true, args).content; }
     constructor(h, m) {
-        super();
         this.objectHandle = h;
         this.memberName = m;
     }
-    useOrRun(weak, args) {
+    reuseOrRelaunch(weak, args) {
         var _a;
-        let oc = this.peek(args);
-        const ctx = oc.changeset;
-        const op = oc.operation;
-        const opts = op.options;
-        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;
+        let ror = this.peek(args);
+        const ctx = ror.changeset;
+        const launch = ror.launch;
+        const opts = launch.options;
+        if (!ror.isUpToDate && !ror.snapshot.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 && (oc.snapshot.changeset.sealed ||
-                    oc.snapshot.former.snapshot !== EMPTY_SNAPSHOT));
+                (opts.kind === Kind.Cached && (ror.snapshot.changeset.sealed ||
+                    ror.snapshot.former.snapshot !== EMPTY_SNAPSHOT));
             const token = opts.noSideEffects ? this : undefined;
-            const oc2 = this.run(oc, separation, opts, token, args);
-            const ctx2 = oc2.operation.changeset;
+            const ror2 = this.relaunch(ror, separation, opts, token, args);
+            const ctx2 = ror2.launch.changeset;
             if (!weak || ctx === ctx2 || (ctx2.sealed && ctx.timestamp >= ctx2.timestamp))
-                oc = oc2;
+                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(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;
-        Changeset.markUsed(t, oc.snapshot, this.memberName, this.objectHandle, t.options.kind, weak);
+            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}]`);
+        const t = ror.launch;
+        Changeset.markUsed(t, ror.snapshot, this.memberName, this.objectHandle, t.options.kind, weak);
         return t;
     }
     static getControllerOf(method) {
@@ -60,154 +58,154 @@ export class OperationController extends Controller {
         return ctl;
     }
     static configureImpl(self, options) {
-        let op;
+        let launch;
         if (self)
-            op = self.edit().operation;
+            launch = self.edit().launch;
         else
-            op = Operation.current;
-        if (!op)
+            launch = Launch.current;
+        if (!launch)
             throw misuse('reactronic decorator is only applicable to methods');
-        op.options = new OptionsImpl(op.options.getter, op.options.setter, op.options, options, false);
+        launch.options = new OptionsImpl(launch.options.getter, launch.options.setter, launch.options, options, false);
         if (Log.isOn && Log.opt.write)
-            Log.write('║', '  =', `${op.hint()}.options are changed`);
-        return op.options;
+            Log.write('║', '  =', `${launch.hint()}.options are changed`);
+        return launch.options;
     }
-    static runWithin(op, func, ...args) {
+    static proceedWithinGivenLaunch(launch, func, ...args) {
         let result = undefined;
-        const outer = Operation.current;
+        const outer = Launch.current;
         try {
-            Operation.current = op;
+            Launch.current = launch;
             result = func(...args);
         }
         catch (e) {
-            if (op)
-                op.error = e;
+            if (launch)
+                launch.error = e;
             throw e;
         }
         finally {
-            Operation.current = outer;
+            Launch.current = outer;
         }
         return result;
     }
     static why() {
         var _a, _b;
-        return (_b = (_a = Operation.current) === null || _a === void 0 ? void 0 : _a.why()) !== null && _b !== void 0 ? _b : BOOT_CAUSE;
+        return (_b = (_a = Launch.current) === null || _a === void 0 ? void 0 : _a.why()) !== null && _b !== void 0 ? _b : BOOT_CAUSE;
     }
     static briefWhy() {
         var _a, _b;
-        return (_b = (_a = Operation.current) === null || _a === void 0 ? void 0 : _a.briefWhy()) !== null && _b !== void 0 ? _b : BOOT_CAUSE;
+        return (_b = (_a = Launch.current) === null || _a === void 0 ? void 0 : _a.briefWhy()) !== null && _b !== void 0 ? _b : BOOT_CAUSE;
     }
     static dependencies() {
-        const op = Operation.current;
-        return op ? op.dependencies() : ['Rx.dependencies should be called from inside of reactive method'];
+        const l = Launch.current;
+        return l ? l.dependencies() : ['Rx.dependencies should be called from inside of reactive method'];
     }
     peek(args) {
         const ctx = Changeset.current();
         const os = ctx.lookupObjectSnapshot(this.objectHandle, this.memberName);
-        const op = this.acquireFromSnapshot(os, args);
-        const isValid = op.options.kind !== Kind.Transactional && op.cause !== BOOT_CAUSE &&
-            (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])) || os.disposed;
-        return { operation: op, isUpToDate: isValid, changeset: ctx, snapshot: os };
+        const launch = this.acquireFromSnapshot(os, 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 };
     }
     use() {
-        const oc = this.peek(undefined);
-        Changeset.markUsed(oc.operation, oc.snapshot, this.memberName, this.objectHandle, oc.operation.options.kind, true);
-        return oc;
+        const ror = this.peek(undefined);
+        Changeset.markUsed(ror.launch, ror.snapshot, this.memberName, this.objectHandle, ror.launch.options.kind, true);
+        return ror;
     }
     edit() {
         const h = this.objectHandle;
         const m = this.memberName;
         const ctx = Changeset.edit();
         const os = ctx.getEditableObjectSnapshot(h, m, 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);
+        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(op, op2, true, os, m, h);
-            op = op2;
+            Changeset.markEdited(launch, relaunch, true, os, m, h);
+            launch = relaunch;
         }
-        return { operation: op, isUpToDate: true, changeset: ctx, snapshot: os };
+        return { launch, isUpToDate: true, changeset: ctx, snapshot: os };
     }
     acquireFromSnapshot(os, args) {
         const m = this.memberName;
-        let op = os.data[m];
-        if (op.controller !== this) {
+        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;
-                op = Transaction.run({ hint, separation, token: this }, () => {
+                launch = Transaction.run({ hint, separation, token: this }, () => {
                     const h = this.objectHandle;
-                    let r2 = Changeset.current().getObjectSnapshot(h, m);
-                    let op2 = r2.data[m];
-                    if (op2.controller !== this) {
-                        r2 = Changeset.edit().getEditableObjectSnapshot(h, m, Meta.Handle, this);
-                        const t = new Operation(this, r2.changeset, op2);
+                    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);
                         if (args)
                             t.args = args;
                         t.cause = BOOT_CAUSE;
-                        r2.data[m] = t;
-                        Changeset.markEdited(op2, t, true, r2, m, h);
-                        op2 = t;
+                        r.data[m] = t;
+                        Changeset.markEdited(relaunch, t, true, r, m, h);
+                        relaunch = t;
                     }
-                    return op2;
+                    return relaunch;
                 });
             }
             else {
-                const t = new Operation(this, os.changeset, op);
+                const initialLaunch = new Launch(this, os.changeset, launch);
                 if (args)
-                    t.args = args;
-                t.cause = BOOT_CAUSE;
-                os.data[m] = t;
-                op = t;
+                    initialLaunch.args = args;
+                initialLaunch.cause = BOOT_CAUSE;
+                os.data[m] = initialLaunch;
+                launch = initialLaunch;
                 if (Log.isOn && Log.opt.write)
                     Log.write('║', ' ++', `${Dump.obj(this.objectHandle, m)} is initialized (revision ${os.revision})`);
             }
         }
-        return op;
+        return launch;
     }
-    run(existing, separation, options, token, args) {
+    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)}`;
-        let oc = existing;
+        let ror = existing;
         const opts = { hint, separation, journal: options.journal, logging: options.logging, token };
         const result = Transaction.run(opts, (argsx) => {
-            if (!oc.operation.transaction.isCanceled) {
-                oc = this.edit();
+            if (!ror.launch.transaction.isCanceled) {
+                ror = this.edit();
                 if (Log.isOn && Log.opt.operation)
-                    Log.write('║', '  o', `${oc.operation.why()}`);
-                oc.operation.run(this.objectHandle.proxy, argsx);
+                    Log.write('║', '  o', `${ror.launch.why()}`);
+                ror.launch.proceed(this.objectHandle.proxy, argsx);
             }
             else {
-                oc = this.peek(argsx);
-                if (oc.operation.options.kind === Kind.Transactional || !oc.isUpToDate) {
-                    oc = this.edit();
+                ror = this.peek(argsx);
+                if (ror.launch.options.kind === Kind.Transactional || !ror.isUpToDate) {
+                    ror = this.edit();
                     if (Log.isOn && Log.opt.operation)
-                        Log.write('║', '  o', `${oc.operation.why()}`);
-                    oc.operation.run(this.objectHandle.proxy, argsx);
+                        Log.write('║', '  o', `${ror.launch.why()}`);
+                    ror.launch.proceed(this.objectHandle.proxy, argsx);
                 }
             }
-            return oc.operation.result;
+            return ror.launch.result;
         }, args);
-        oc.operation.result = result;
-        return oc;
+        ror.launch.result = result;
+        return ror;
     }
     static markObsolete(self) {
-        const oc = self.peek(undefined);
-        const ctx = oc.changeset;
-        oc.operation.markObsoleteDueTo(oc.operation, self.memberName, EMPTY_SNAPSHOT.changeset, EMPTY_HANDLE, BOOT_CAUSE, ctx.timestamp, ctx.reactive);
+        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);
     }
 }
-class Operation extends ObservableValue {
-    constructor(controller, changeset, former) {
+class Launch extends MvccValue {
+    constructor(reaction, changeset, former) {
         super(undefined);
-        this.margin = Operation.current ? Operation.current.margin + 1 : 1;
+        this.margin = Launch.current ? Launch.current.margin + 1 : 1;
         this.transaction = Transaction.current;
-        this.controller = controller;
+        this.reaction = reaction;
         this.changeset = changeset;
         this.observables = new Map();
-        if (former instanceof Operation) {
+        if (former instanceof Launch) {
             this.options = former.options;
             this.args = former.args;
             this.cause = former.obsoleteDueTo;
@@ -224,7 +222,7 @@ class Operation extends ObservableValue {
     }
     get isOperation() { return true; }
     get originSnapshotId() { return this.changeset.id; }
-    hint() { return `${Dump.snapshot2(this.controller.objectHandle, this.changeset, this.controller.memberName)}`; }
+    hint() { return `${Dump.snapshot2(this.reaction.objectHandle, this.changeset, this.reaction.memberName)}`; }
     get order() { return this.options.order; }
     get ['#this#']() {
         return `Operation: ${this.why()}`;
@@ -233,7 +231,7 @@ class Operation extends ObservableValue {
         let cause;
         if (this.cause)
             cause = `   ◀◀   ${this.cause}`;
-        else if (this.controller.options.kind === Kind.Transactional)
+        else if (this.reaction.options.kind === Kind.Transactional)
             cause = '   ◀◀   operation';
         else
             cause = `   ◀◀   T${this.changeset.id}[${this.changeset.hint}]`;
@@ -250,7 +248,7 @@ class Operation extends ObservableValue {
             if (Log.isOn && Log.opt.step && this.result)
                 Log.writeAs({ margin2: this.margin }, '║', '‾\\', `${this.hint()} - step in  `, 0, '        │');
             const started = Date.now();
-            const result = OperationController.runWithin(this, func, ...args);
+            const result = ReactionImpl.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 ? '        │' : '');
@@ -260,16 +258,16 @@ class Operation extends ObservableValue {
         };
         return wrappedForOperation;
     }
-    run(proxy, args) {
+    proceed(proxy, args) {
         if (args)
             this.args = args;
         this.obsoleteSince = MAX_REVISION;
         if (!this.error)
-            OperationController.runWithin(this, Operation.run, this, proxy);
+            ReactionImpl.proceedWithinGivenLaunch(this, Launch.proceed, this, proxy);
         else
             this.result = Promise.reject(this.error);
     }
-    markObsoleteDueTo(observable, m, changeset, h, outer, since, reactive) {
+    markObsoleteDueTo(observable, m, changeset, h, outer, since, obsolete) {
         var _a, _b, _c;
         if (this.observables !== undefined) {
             const skip = !observable.isOperation &&
@@ -285,9 +283,9 @@ class Operation extends ObservableValue {
                         : `${this.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, m)} since s${since}${isReactive ? ` and will run automatically (order ${this.options.order})` : ''}`);
                 this.unsubscribeFromAllObservables();
                 if (isReactive)
-                    reactive.push(this);
+                    obsolete.push(this);
                 else
-                    (_b = this.observers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.controller.memberName, this.changeset, this.controller.objectHandle, why, since, reactive));
+                    (_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));
                 const tran = this.transaction;
                 if (tran.changeset === changeset) {
                 }
@@ -298,18 +296,18 @@ class Operation extends ObservableValue {
                 Log.write(' ', 'x', `${this.hint()} is not obsolete due to its own change to ${Dump.snapshot2(h, changeset, m)}`);
         }
     }
-    runIfNotUpToDate(now, nothrow) {
+    relaunchIfNotUpToDate(now, nothrow) {
         const t = this.options.throttling;
         const interval = Date.now() + this.started;
         const hold = t ? t - interval : 0;
         if (now || hold < 0) {
             if (this.isNotUpToDate()) {
                 try {
-                    const op = this.controller.useOrRun(false, undefined);
-                    if (op.result instanceof Promise)
-                        op.result.catch(error => {
-                            if (op.options.kind === Kind.Reactive)
-                                misuse(`reactive function ${op.hint()} failed and will not run anymore: ${error}`, error);
+                    const launch = this.reaction.reuseOrRelaunch(false, undefined);
+                    if (launch.result instanceof Promise)
+                        launch.result.catch(error => {
+                            if (launch.options.kind === Kind.Reactive)
+                                misuse(`reactive function ${launch.hint()} failed and will not run anymore: ${error}`, error);
                         });
                 }
                 catch (e) {
@@ -322,7 +320,7 @@ class Operation extends ObservableValue {
         }
         else if (t < Number.MAX_SAFE_INTEGER) {
             if (hold > 0)
-                setTimeout(() => this.runIfNotUpToDate(true, true), hold);
+                setTimeout(() => this.relaunchIfNotUpToDate(true, true), hold);
             else
                 this.addToDeferredReactiveFunctions();
         }
@@ -366,20 +364,20 @@ class Operation extends ObservableValue {
             this.error = error;
         return this;
     }
-    static run(op, proxy) {
-        op.enter();
+    static proceed(launch, proxy) {
+        launch.enter();
         try {
-            op.result = op.options.getter.call(proxy, ...op.args);
+            launch.result = launch.options.getter.call(proxy, ...launch.args);
         }
         finally {
-            op.leaveOrAsync();
+            launch.leaveOrAsync();
         }
     }
     enter() {
         if (this.options.monitor)
             this.monitorEnter(this.options.monitor);
         if (Log.isOn && Log.opt.operation)
-            Log.write('║', '‾\\', `${this.hint()} - enter`, undefined, `    [ ${Dump.obj(this.controller.objectHandle, this.controller.memberName)} ]`);
+            Log.write('║', '‾\\', `${this.hint()} - enter`, undefined, `    [ ${Dump.obj(this.reaction.objectHandle, this.reaction.memberName)} ]`);
         this.started = Date.now();
     }
     leaveOrAsync() {
@@ -422,7 +420,7 @@ class Operation extends ObservableValue {
             separation: 'isolated',
             logging: Log.isOn && Log.opt.monitor ? undefined : Log.global
         };
-        OperationController.runWithin(undefined, Transaction.run, options, MonitorImpl.enter, mon, this.transaction);
+        ReactionImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, MonitorImpl.enter, mon, this.transaction);
     }
     monitorLeave(mon) {
         Transaction.outside(() => {
@@ -432,33 +430,33 @@ class Operation extends ObservableValue {
                     separation: 'isolated',
                     logging: Log.isOn && Log.opt.monitor ? undefined : Log.DefaultLevel
                 };
-                OperationController.runWithin(undefined, Transaction.run, options, MonitorImpl.leave, mon, this.transaction);
+                ReactionImpl.proceedWithinGivenLaunch(undefined, Transaction.run, options, MonitorImpl.leave, mon, this.transaction);
             };
             this.transaction.whenFinished().then(leave, leave);
         });
     }
     addToDeferredReactiveFunctions() {
-        Operation.deferredReactiveFunctions.push(this);
-        if (Operation.deferredReactiveFunctions.length === 1)
-            setTimeout(Operation.processDeferredReactiveFunctions, 0);
+        Launch.deferredReactiveFunctions.push(this);
+        if (Launch.deferredReactiveFunctions.length === 1)
+            setTimeout(Launch.processDeferredReactiveFunctions, 0);
     }
     static processDeferredReactiveFunctions() {
-        const deferred = Operation.deferredReactiveFunctions;
-        Operation.deferredReactiveFunctions = [];
+        const deferred = Launch.deferredReactiveFunctions;
+        Launch.deferredReactiveFunctions = [];
         for (const x of deferred)
-            x.runIfNotUpToDate(true, true);
+            x.relaunchIfNotUpToDate(true, true);
     }
     static markUsed(observable, os, m, h, kind, weak) {
         if (kind !== Kind.Transactional) {
-            const op = Operation.current;
-            if (op && op.options.kind !== Kind.Transactional &&
-                op.transaction === Transaction.current && m !== Meta.Handle) {
+            const launch = Launch.current;
+            if (launch && launch.options.kind !== Kind.Transactional &&
+                launch.transaction === Transaction.current && m !== Meta.Handle) {
                 const ctx = Changeset.current();
                 if (ctx !== os.changeset)
                     ctx.bumpBy(os.changeset.timestamp);
                 const t = weak ? -1 : ctx.timestamp;
-                if (!op.subscribeTo(observable, os, m, h, t))
-                    op.markObsoleteDueTo(observable, m, h.head.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.reactive);
+                if (!launch.subscribeTo(observable, os, m, h, t))
+                    launch.markObsoleteDueTo(observable, m, h.head.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.obsolete);
             }
         }
     }
@@ -470,38 +468,38 @@ class Operation extends ObservableValue {
     static isConflicting(oldValue, newValue) {
         let result = oldValue !== newValue;
         if (result)
-            result = oldValue instanceof Operation && oldValue.cause !== BOOT_CAUSE;
+            result = oldValue instanceof Launch && oldValue.cause !== BOOT_CAUSE;
         return result;
     }
     static propagateAllChangesThroughSubscriptions(changeset) {
         var _a;
         const since = changeset.timestamp;
-        const reactive = changeset.reactive;
+        const obsolete = changeset.obsolete;
         changeset.items.forEach((os, h) => {
-            Operation.propagateMemberChangeThroughSubscriptions(false, since, os, Meta.Revision, h, reactive);
+            Launch.propagateMemberChangeThroughSubscriptions(false, since, os, Meta.Revision, h, obsolete);
             if (!os.disposed)
-                os.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(false, since, os, m, h, reactive));
+                os.changes.forEach((o, m) => Launch.propagateMemberChangeThroughSubscriptions(false, since, os, m, h, obsolete));
             else
                 for (const m in os.former.snapshot.data)
-                    Operation.propagateMemberChangeThroughSubscriptions(true, since, os, m, h, reactive);
+                    Launch.propagateMemberChangeThroughSubscriptions(true, since, os, m, h, obsolete);
         });
-        reactive.sort(compareReactiveFunctionsByOrder);
+        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) => {
-            Operation.propagateMemberChangeThroughSubscriptions(true, changeset.timestamp, os, Meta.Revision, h, undefined);
-            os.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(true, changeset.timestamp, os, m, h, undefined));
+            Launch.propagateMemberChangeThroughSubscriptions(true, changeset.timestamp, os, Meta.Revision, h, undefined);
+            os.changes.forEach((o, m) => Launch.propagateMemberChangeThroughSubscriptions(true, changeset.timestamp, os, m, h, undefined));
         });
     }
-    static propagateMemberChangeThroughSubscriptions(unsubscribe, timestamp, os, m, h, reactive) {
+    static propagateMemberChangeThroughSubscriptions(unsubscribe, timestamp, os, m, h, obsolete) {
         var _a;
         const curr = os.data[m];
-        if (reactive) {
+        if (obsolete !== undefined) {
             const former = os.former.snapshot.data[m];
-            if (former !== undefined && former instanceof ObservableValue) {
+            if (former !== undefined && former instanceof MvccValue) {
                 const why = `T${os.changeset.id}[${os.changeset.hint}]`;
-                if (former instanceof Operation) {
+                if (former instanceof Launch) {
                     if ((former.obsoleteSince === MAX_REVISION || former.obsoleteSince <= 0)) {
                         former.obsoleteDueTo = why;
                         former.obsoleteSince = timestamp;
@@ -515,10 +513,10 @@ class Operation extends ObservableValue {
                     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, reactive));
+                (_a = former.observers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, m, os.changeset, h, why, timestamp, obsolete));
             }
         }
-        if (curr instanceof Operation) {
+        if (curr instanceof Launch) {
             if (curr.changeset === os.changeset && curr.observables !== undefined) {
                 if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
                     curr.observables.forEach((info, v) => {
@@ -530,26 +528,26 @@ class Operation extends ObservableValue {
                     curr.unsubscribeFromAllObservables();
             }
         }
-        else if (curr instanceof ObservableValue && curr.observers) {
+        else if (curr instanceof MvccValue && curr.observers) {
         }
     }
     static enqueueReactiveFunctionsToRun(reactive) {
-        const queue = Operation.queuedReactiveFunctions;
+        const queue = Launch.queuedReactiveFunctions;
         const isReactiveLoopRequired = queue.length === 0;
         for (const r of reactive)
             queue.push(r);
         if (isReactiveLoopRequired)
-            OperationController.runWithin(undefined, Operation.runQueuedReactiveLoop);
+            ReactionImpl.proceedWithinGivenLaunch(undefined, Launch.runQueuedReactiveFunctions);
     }
-    static runQueuedReactiveLoop() {
-        const queue = Operation.queuedReactiveFunctions;
+    static runQueuedReactiveFunctions() {
+        const queue = Launch.queuedReactiveFunctions;
         let i = 0;
         while (i < queue.length) {
             const reactive = queue[i];
-            reactive.runIfNotUpToDate(false, true);
+            reactive.relaunchIfNotUpToDate(false, true);
             i++;
         }
-        Operation.queuedReactiveFunctions = [];
+        Launch.queuedReactiveFunctions = [];
     }
     unsubscribeFromAllObservables() {
         var _a;
@@ -563,7 +561,7 @@ class Operation extends ObservableValue {
     }
     subscribeTo(observable, os, m, h, timestamp) {
         var _a, _b, _c;
-        const ok = Operation.canSubscribeTo(observable, os, m, h, timestamp);
+        const ok = Launch.canSubscribeTo(observable, os, m, h, timestamp);
         if (ok) {
             let times = 0;
             if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
@@ -592,71 +590,71 @@ class Operation extends ObservableValue {
         const observableHead = h.head.data[m];
         let result = observable === observableHead || (!os.changeset.sealed && os.former.snapshot.data[m] === observableHead);
         if (result && timestamp !== -1)
-            result = !(observable instanceof Operation && timestamp >= observable.obsoleteSince);
+            result = !(observable instanceof Launch && timestamp >= observable.obsoleteSince);
         return result;
     }
     static createOperation(h, m, options) {
-        const ctl = new OperationController(h, m);
+        const rx = new ReactionImpl(h, m);
         const operation = (...args) => {
-            return ctl.useOrRun(false, args).result;
+            return rx.reuseOrRelaunch(false, args).result;
         };
-        Meta.set(operation, Meta.Controller, ctl);
+        Meta.set(operation, Meta.Controller, rx);
         return operation;
     }
     static rememberOperationOptions(proto, m, getter, setter, enumerable, configurable, options, implicit) {
         const initial = Meta.acquire(proto, Meta.Initial);
-        let op = initial[m];
-        const ctl = op ? op.controller : new OperationController(EMPTY_HANDLE, m);
-        const opts = op ? op.options : OptionsImpl.INITIAL;
-        initial[m] = op = new Operation(ctl, EMPTY_SNAPSHOT.changeset, new OptionsImpl(getter, setter, opts, options, implicit));
-        if (op.options.kind === Kind.Reactive && op.options.throttling < Number.MAX_SAFE_INTEGER) {
+        let launch = initial[m];
+        const rx = launch ? launch.reaction : new ReactionImpl(EMPTY_HANDLE, m);
+        const opts = launch ? launch.options : OptionsImpl.INITIAL;
+        initial[m] = launch = new Launch(rx, EMPTY_SNAPSHOT.changeset, new OptionsImpl(getter, setter, opts, options, implicit));
+        if (launch.options.kind === Kind.Reactive && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.acquire(proto, Meta.Reactive);
-            reactive[m] = op;
+            reactive[m] = launch;
         }
-        else if (op.options.kind === Kind.Reactive && op.options.throttling >= Number.MAX_SAFE_INTEGER) {
+        else if (launch.options.kind === Kind.Reactive && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.getFrom(proto, Meta.Reactive);
             delete reactive[m];
         }
-        return op.options;
+        return launch.options;
     }
     static init() {
         Object.freeze(BOOT_ARGS);
         Log.getMergedLoggingOptions = getMergedLoggingOptions;
         Dump.valueHint = valueHint;
-        Changeset.markUsed = Operation.markUsed;
-        Changeset.markEdited = Operation.markEdited;
-        Changeset.isConflicting = Operation.isConflicting;
-        Changeset.propagateAllChangesThroughSubscriptions = Operation.propagateAllChangesThroughSubscriptions;
-        Changeset.revokeAllSubscriptions = Operation.revokeAllSubscriptions;
-        Changeset.enqueueReactiveFunctionsToRun = Operation.enqueueReactiveFunctionsToRun;
-        Mvcc.createOperation = Operation.createOperation;
-        Mvcc.rememberOperationOptions = Operation.rememberOperationOptions;
+        Changeset.markUsed = Launch.markUsed;
+        Changeset.markEdited = Launch.markEdited;
+        Changeset.isConflicting = Launch.isConflicting;
+        Changeset.propagateAllChangesThroughSubscriptions = Launch.propagateAllChangesThroughSubscriptions;
+        Changeset.revokeAllSubscriptions = Launch.revokeAllSubscriptions;
+        Changeset.enqueueReactiveFunctionsToRun = Launch.enqueueReactiveFunctionsToRun;
+        Mvcc.createOperation = Launch.createOperation;
+        Mvcc.rememberOperationOptions = Launch.rememberOperationOptions;
         Promise.prototype.then = reactronicHookedThen;
         try {
             Object.defineProperty(globalThis, 'rWhy', {
-                get: OperationController.why, configurable: false, enumerable: false,
+                get: ReactionImpl.why, configurable: false, enumerable: false,
             });
             Object.defineProperty(globalThis, 'rBriefWhy', {
-                get: OperationController.briefWhy, configurable: false, enumerable: false,
+                get: ReactionImpl.briefWhy, configurable: false, enumerable: false,
             });
         }
         catch (e) {
         }
         try {
             Object.defineProperty(global, 'rWhy', {
-                get: OperationController.why, configurable: false, enumerable: false,
+                get: ReactionImpl.why, configurable: false, enumerable: false,
             });
             Object.defineProperty(global, 'rBriefWhy', {
-                get: OperationController.briefWhy, configurable: false, enumerable: false,
+                get: ReactionImpl.briefWhy, configurable: false, enumerable: false,
             });
         }
         catch (e) {
         }
     }
 }
-Operation.current = undefined;
-Operation.queuedReactiveFunctions = [];
-Operation.deferredReactiveFunctions = [];
+Launch.current = undefined;
+Launch.queuedReactiveFunctions = [];
+Launch.deferredReactiveFunctions = [];
 function valueHint(value) {
     let result = '';
     if (Array.isArray(value))
@@ -665,8 +663,8 @@ function valueHint(value) {
         result = `Set(${value.size})`;
     else if (value instanceof Map)
         result = `Map(${value.size})`;
-    else if (value instanceof Operation)
-        result = `#${value.controller.objectHandle.id}t${value.changeset.id}s${value.changeset.timestamp}${value.originSnapshotId !== undefined && value.originSnapshotId !== 0 ? `t${value.originSnapshotId}` : ''}`;
+    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}` : ''}`;
     else if (value === Meta.Undefined)
         result = 'undefined';
     else if (typeof (value) === 'string')
@@ -681,8 +679,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 (Operation.current)
-        res = Log.merge({ margin2: Operation.current.margin }, undefined, undefined, res);
+    if (Launch.current)
+        res = Log.merge({ margin2: Launch.current.margin }, undefined, undefined, res);
     if (local)
         res = Log.merge(local, undefined, undefined, res);
     return res;
@@ -695,17 +693,17 @@ function reactronicHookedThen(resolve, reject) {
             resolve = resolveReturn;
         if (!reject)
             reject = rejectRethrow;
-        const op = Operation.current;
-        if (op) {
-            resolve = op.wrap(resolve);
-            reject = op.wrap(reject);
+        const launch = Launch.current;
+        if (launch) {
+            resolve = launch.wrap(resolve);
+            reject = launch.wrap(reject);
         }
         resolve = tran.wrap(resolve, false);
         reject = tran.wrap(reject, true);
     }
     return ORIGINAL_PROMISE_THEN.call(this, resolve, reject);
 }
-function compareReactiveFunctionsByOrder(a, b) {
+function compareObserversByOrder(a, b) {
     return a.order - b.order;
 }
 export function resolveReturn(value) {
@@ -714,4 +712,4 @@ export function resolveReturn(value) {
 export function rejectRethrow(error) {
     throw error;
 }
-Operation.init();
+Launch.init();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.23.106",
+  "version": "0.23.108",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",

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

@@ -1,12 +0,0 @@
-import { MemberOptions } from './Options.js';
-export declare abstract class Controller<T> {
-    abstract readonly options: MemberOptions;
-    abstract readonly args: ReadonlyArray<any>;
-    abstract readonly result: T;
-    abstract readonly error: any;
-    abstract readonly stamp: number;
-    abstract readonly isUpToDate: boolean;
-    abstract configure(options: Partial<MemberOptions>): MemberOptions;
-    abstract markObsolete(): void;
-    abstract pullLastResult(args?: any[]): T | undefined;
-}

package/build/dist/source/Controller.js

@@ -1,2 +0,0 @@
-export class Controller {
-}