reactronic 0.22.315 → 0.22.316

package/README.md

@@ -195,7 +195,7 @@ class Component<P> extends React.Component<P> {
   @reaction // called immediately in response to changes
   ensureUpToDate(): void {
     if (this.shouldComponentUpdate())
-      Transaction.off(() => this.setState({})) // ask React to re-render
+      Transaction.outside(() => this.setState({})) // ask React to re-render
   } // ensureUpToDate is subscribed to render
 
   shouldComponentUpdate(): boolean {
@@ -291,11 +291,12 @@ NPM: `npm install reactronic`
 
 // Classes
 
+class TransactionalObject { }
 class ReactiveObject { }
 
 // Decorators & Operators
 
-function isnonreactive(proto, prop) // field only
+function raw(proto, prop) // field only
 function transaction(proto, prop, pd) // method only
 function reaction(proto, prop, pd) // method only
 function cached(proto, prop, pd) // method only
@@ -308,7 +309,7 @@ function sensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
 export interface SnapshotOptions {
   readonly hint?: string
-  readonly standalone?: StandaloneMode
+  readonly separation?: SeparationMode
   readonly journal?: Journal
   readonly logging?: Partial<LoggingOptions>
   readonly token?: any
@@ -316,7 +317,7 @@ export interface SnapshotOptions {
 
 interface MemberOptions {
   readonly kind: Kind
-  readonly standalone: StandaloneMode
+  readonly separation: SeparationMode
   readonly order: number
   readonly noSideEffects: boolean
   readonly triggeringArgs: boolean
@@ -436,8 +437,7 @@ class Reactronic {
   static why(short: boolean = false): string
   static getMethodCache<T>(method: F<T>): Cache<T>
   static configureCurrentOperation(options: Partial<Options>): Options
-  // static configureObject<T extends object>(obj: T, options: Partial<ObjectOptions>): void
-  // static assign<T, P extends keyof T>(obj: T, prop: P, value: T[P], sensitivity: Sensitivity)
+  static getRevisionOf(obj: any): number
   static takeSnapshot<T>(obj: T): T
   static dispose(obj: any): void
   static reactionsAutoStartDisabled: boolean

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

@@ -1,4 +1,4 @@
-import { ReactiveObject } from './impl/Hooks';
+import { ReactiveObject } from './impl/Mvcc';
 export declare abstract class Buffer<T> extends ReactiveObject {
     abstract readonly capacity: number;
     abstract readonly count: number;

package/build/dist/source/Buffer.js

@@ -1,4 +1,4 @@
-import { ReactiveObject } from './impl/Hooks';
+import { ReactiveObject } from './impl/Mvcc';
 export class Buffer extends ReactiveObject {
     static create(hint, capacity) { throw new Error('not implemented'); }
 }

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

@@ -1,18 +1,18 @@
 import { LoggingOptions } from './Logging';
-import { StandaloneMode } from './impl/Data';
+import { SeparationMode } from './impl/Data';
 export { LoggingOptions, ProfilingOptions, LoggingLevel } from './Logging';
 import { Journal } from './impl/Journal';
 import { Monitor } from './impl/Monitor';
 export interface SnapshotOptions {
     readonly hint?: string;
-    readonly standalone?: StandaloneMode;
+    readonly separation?: SeparationMode;
     readonly journal?: Journal;
     readonly logging?: Partial<LoggingOptions>;
     readonly token?: any;
 }
 export interface MemberOptions {
     readonly kind: Kind;
-    readonly standalone: StandaloneMode;
+    readonly separation: SeparationMode;
     readonly order: number;
     readonly noSideEffects: boolean;
     readonly triggeringArgs: boolean;

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

@@ -2,11 +2,11 @@ import { F } from './util/Utils';
 import { Controller } from './Controller';
 import { MemberOptions, LoggingOptions, ProfilingOptions } from './Options';
 export declare class Rx {
-    static getRevisionOf(obj: any): number;
     static why(brief?: boolean): string;
     static getController<T>(method: F<T>): Controller<T>;
     static pullLastResult<T>(method: F<Promise<T>>, args?: any[]): T | undefined;
     static configureCurrentOperation(options: Partial<MemberOptions>): MemberOptions;
+    static getRevisionOf(obj: any): number;
     static takeSnapshot<T>(obj: T): T;
     static dispose(obj: any): void;
     static get reactionsAutoStartDisabled(): boolean;
@@ -20,7 +20,7 @@ export declare class Rx {
 }
 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 isnonreactive(proto: object, prop: PropertyKey): any;
+export declare function raw(proto: object, prop: PropertyKey): any;
 export declare function transaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function reaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function cached(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;

package/build/dist/source/Rx.js

@@ -2,46 +2,46 @@ import { Log } from './util/Dbg';
 import { Kind } from './Options';
 import { Meta, ObjectHandle } from './impl/Data';
 import { Changeset } from './impl/Changeset';
-import { Hooks } from './impl/Hooks';
+import { Mvcc } from './impl/Mvcc';
 import { OperationController } from './impl/Operation';
 export class Rx {
-    static getRevisionOf(obj) { return obj[Meta.Revision]; }
     static why(brief = false) { return brief ? OperationController.briefWhy() : OperationController.why(); }
-    static getController(method) { return OperationController.of(method); }
+    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 getRevisionOf(obj) { return obj[Meta.Revision]; }
     static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }
     static dispose(obj) { Changeset.dispose(obj); }
-    static get reactionsAutoStartDisabled() { return Hooks.reactionsAutoStartDisabled; }
-    static set reactionsAutoStartDisabled(value) { Hooks.reactionsAutoStartDisabled = value; }
+    static get reactionsAutoStartDisabled() { return Mvcc.reactionsAutoStartDisabled; }
+    static set reactionsAutoStartDisabled(value) { Mvcc.reactionsAutoStartDisabled = value; }
     static get isLogging() { return Log.isOn; }
     static get loggingOptions() { return Log.opt; }
     static setLoggingMode(isOn, options) { Log.setMode(isOn, options); }
-    static setLoggingHint(obj, name) { Hooks.setHint(obj, name); }
+    static setLoggingHint(obj, name) { Mvcc.setHint(obj, name); }
     static getLoggingHint(obj, full = false) { return ObjectHandle.getHint(obj, full); }
-    static setProfilingMode(isOn, options) { Hooks.setProfilingMode(isOn, options); }
+    static setProfilingMode(isOn, options) { Mvcc.setProfilingMode(isOn, options); }
 }
 export function nonreactive(func, ...args) {
     return OperationController.runWithin(undefined, func, ...args);
 }
 export function sensitive(sensitivity, func, ...args) {
-    return Hooks.sensitive(sensitivity, func, ...args);
+    return Mvcc.sensitive(sensitivity, func, ...args);
 }
-export function isnonreactive(proto, prop) {
-    return Hooks.decorateData(false, proto, prop);
+export function raw(proto, prop) {
+    return Mvcc.decorateData(false, proto, prop);
 }
 export function transaction(proto, prop, pd) {
     const opts = { kind: Kind.Transaction };
-    return Hooks.decorateOperation(true, transaction, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, transaction, opts, proto, prop, pd);
 }
 export function reaction(proto, prop, pd) {
     const opts = { kind: Kind.Reaction, throttling: -1 };
-    return Hooks.decorateOperation(true, reaction, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, reaction, opts, proto, prop, pd);
 }
 export function cached(proto, prop, pd) {
     const opts = { kind: Kind.Cache, noSideEffects: true };
-    return Hooks.decorateOperation(true, cached, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, cached, opts, proto, prop, pd);
 }
 export function options(value) {
-    return Hooks.decorateOperationParametrized(options, value);
+    return Mvcc.decorateOperationParametrized(options, value);
 }

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

@@ -7,11 +7,11 @@ export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, Profi
 export { Worker } from './Worker';
 export { Controller } from './Controller';
 export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
-export { ReactiveObject } from './impl/Hooks';
-export { ReactiveArray } from './impl/ReactiveArray';
-export { ReactiveMap } from './impl/ReactiveMap';
+export { TransactionalObject, ReactiveObject } from './impl/Mvcc';
+export { TransactionalArray, ReactiveArray } from './impl/MvccArray';
+export { TransactionalMap, ReactiveMap } from './impl/MvccMap';
 export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';
 export { Journal } from './impl/Journal';
-export { Rx, nonreactive, sensitive, isnonreactive, transaction, reaction, cached, options } from './Rx';
+export { Rx, nonreactive, sensitive, raw, transaction, reaction, cached, options } from './Rx';

package/build/dist/source/api.js

@@ -6,11 +6,11 @@ export { SealedSet } from './util/SealedSet';
 export { Kind, Reentrance, LoggingLevel } from './Options';
 export { Controller } from './Controller';
 export { Ref, ToggleRef } from './Ref';
-export { ReactiveObject } from './impl/Hooks';
-export { ReactiveArray } from './impl/ReactiveArray';
-export { ReactiveMap } from './impl/ReactiveMap';
+export { TransactionalObject, ReactiveObject } from './impl/Mvcc';
+export { TransactionalArray, ReactiveArray } from './impl/MvccArray';
+export { TransactionalMap, ReactiveMap } from './impl/MvccMap';
 export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';
 export { Journal } from './impl/Journal';
-export { Rx, nonreactive, sensitive, isnonreactive, transaction, reaction, cached, options } from './Rx';
+export { Rx, nonreactive, sensitive, raw, transaction, reaction, cached, options } from './Rx';

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

@@ -7,11 +7,11 @@ import { SealedSet } from '../util/SealedSet';
 import { ObjectSnapshot, ObjectHandle, Subscription, Meta } from './Data';
 export const MAX_REVISION = Number.MAX_SAFE_INTEGER;
 export const UNDEFINED_REVISION = MAX_REVISION - 1;
-Object.defineProperty(ObjectHandle.prototype, '#this', {
+Object.defineProperty(ObjectHandle.prototype, '#this#', {
     configurable: false, enumerable: false,
     get() {
         const result = {};
-        const data = Changeset.current().getObjectSnapshot(this, '#this').data;
+        const data = Changeset.current().getObjectSnapshot(this, '#this#').data;
         for (const m in data) {
             const v = data[m];
             if (v instanceof Subscription)
@@ -81,7 +81,7 @@ export class Changeset {
         return os;
     }
     static takeSnapshot(obj) {
-        return obj[Meta.Handle]['#this'];
+        return obj[Meta.Handle]['#this#'];
     }
     static dispose(obj) {
         const ctx = Changeset.edit();
@@ -165,7 +165,7 @@ export class Changeset {
             merged[m] = ours.data[m];
             if (headDisposed || oursDisposed) {
                 if (headDisposed !== oursDisposed) {
-                    if (headDisposed || this.options.standalone !== 'disposal') {
+                    if (headDisposed || this.options.separation !== 'disposal') {
                         if (Log.isOn && Log.opt.change)
                             Log.write('║╠', '', `${Dump.snapshot2(h, ours.changeset, m)} <> ${Dump.snapshot2(h, head.changeset, m)}`, 0, ' *** CONFLICT ***');
                         ours.conflicts.set(m, head);
@@ -351,7 +351,7 @@ Dump.valueHint = (value, m) => '???';
 export const EMPTY_SNAPSHOT = new ObjectSnapshot(new Changeset({ hint: '<empty>' }), undefined, {});
 export const DefaultSnapshotOptions = Object.freeze({
     hint: 'noname',
-    standalone: false,
+    separation: false,
     journal: undefined,
     logging: undefined,
     token: undefined,

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

@@ -12,7 +12,7 @@ export declare class Subscription {
     get originSnapshotId(): number | undefined;
     constructor(content: any);
 }
-export declare type StandaloneMode = boolean | 'isolated' | 'disposal';
+export declare type SeparationMode = boolean | 'isolated' | 'disposal';
 export interface Subscriber {
     readonly order: number;
     readonly subscriptions: Map<Subscription, SubscriptionInfo> | undefined;

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

@@ -1,4 +1,4 @@
-import { ReactiveObject } from './Hooks';
+import { ReactiveObject } from './Mvcc';
 import { ObjectHandle, ObjectSnapshot, PatchSet } from './Data';
 export declare type Saver = (patch: PatchSet) => Promise<void>;
 export declare abstract class Journal extends ReactiveObject {

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

@@ -1,4 +1,4 @@
-import { ReactiveObject } from './Hooks';
+import { ReactiveObject } from './Mvcc';
 import { Meta, Subscription } from './Data';
 import { Changeset, EMPTY_SNAPSHOT } from './Changeset';
 import { Transaction } from './Transaction';
@@ -22,7 +22,7 @@ export class JournalImpl extends Journal {
     get canUndo() { return this._edits.length > 0 && this._position > 0; }
     get canRedo() { return this._position < this._edits.length; }
     edited(p) {
-        Transaction.run({ hint: 'EditJournal.edited', standalone: 'isolated' }, () => {
+        Transaction.run({ hint: 'EditJournal.edited', separation: 'isolated' }, () => {
             const items = this._edits = this._edits.toMutable();
             if (items.length >= this._capacity)
                 items.shift();
@@ -40,7 +40,7 @@ export class JournalImpl extends Journal {
             throw new Error('not implemented');
     }
     undo(count = 1) {
-        Transaction.run({ hint: 'Journal.undo', standalone: 'isolated' }, () => {
+        Transaction.run({ hint: 'Journal.undo', separation: 'isolated' }, () => {
             let i = this._position - 1;
             while (i >= 0 && count > 0) {
                 const patch = this._edits[i];
@@ -52,7 +52,7 @@ export class JournalImpl extends Journal {
         });
     }
     redo(count = 1) {
-        Transaction.run({ hint: 'Journal.redo', standalone: 'isolated' }, () => {
+        Transaction.run({ hint: 'Journal.redo', separation: 'isolated' }, () => {
             let i = this._position;
             while (i < this._edits.length && count > 0) {
                 const patch = this._edits[i];

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

@@ -1,5 +1,5 @@
 import { Worker } from '../Worker';
-import { ReactiveObject } from './Hooks';
+import { ReactiveObject } from './Mvcc';
 export declare abstract class Monitor extends ReactiveObject {
     abstract readonly isActive: boolean;
     abstract readonly counter: number;

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

@@ -1,4 +1,4 @@
-import { ReactiveObject, Hooks } from './Hooks';
+import { ReactiveObject, Mvcc } from './Mvcc';
 import { Transaction } from './Transaction';
 export class Monitor extends ReactiveObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
@@ -44,7 +44,7 @@ export class MonitorImpl extends Monitor {
     }
     static doCreate(hint, activationDelay, deactivationDelay, durationResolution) {
         const m = new MonitorImpl();
-        Hooks.setHint(m, hint);
+        Mvcc.setHint(m, hint);
         m.internals.activationDelay = activationDelay;
         m.internals.deactivationDelay = deactivationDelay;
         m.internals.durationResolution = durationResolution;
@@ -59,7 +59,7 @@ export class MonitorImpl extends Monitor {
         }
         if (delay >= 0) {
             if (mon.internals.activationTimeout === undefined)
-                mon.internals.activationTimeout = setTimeout(() => Transaction.run({ hint: 'Monitor.activate', standalone: 'isolated' }, MonitorImpl.activate, mon, -1), delay);
+                mon.internals.activationTimeout = setTimeout(() => Transaction.run({ hint: 'Monitor.activate', separation: 'isolated' }, MonitorImpl.activate, mon, -1), delay);
         }
         else if (active)
             mon.isActive = true;
@@ -67,7 +67,7 @@ export class MonitorImpl extends Monitor {
     static deactivate(mon, delay) {
         if (delay >= 0) {
             clearTimeout(mon.internals.deactivationTimeout);
-            mon.internals.deactivationTimeout = setTimeout(() => Transaction.run({ hint: 'Monitor.deactivate', standalone: 'isolated' }, MonitorImpl.deactivate, mon, -1), delay);
+            mon.internals.deactivationTimeout = setTimeout(() => Transaction.run({ hint: 'Monitor.deactivate', separation: 'isolated' }, MonitorImpl.deactivate, mon, -1), delay);
         }
         else if (mon.counter <= 0) {
             mon.isActive = false;

package/build/dist/source/impl/{Hooks.d.ts → Mvcc.d.ts}

@@ -1,21 +1,24 @@
 import { F } from '../util/Utils';
 import { MemberOptions, Kind, Reentrance } from '../Options';
 import { LoggingOptions, ProfilingOptions } from '../Logging';
-import { MemberName, ObjectHandle, StandaloneMode } from './Data';
+import { MemberName, ObjectHandle, SeparationMode } from './Data';
 import { Journal } from './Journal';
 import { Monitor } from './Monitor';
-export declare abstract class HookedObject {
+export declare abstract class MvccObject {
     protected constructor(reactive: boolean);
     [Symbol.toStringTag](): string;
 }
-export declare abstract class ReactiveObject extends HookedObject {
+export declare abstract class TransactionalObject extends MvccObject {
+    constructor();
+}
+export declare abstract class ReactiveObject extends MvccObject {
     constructor();
 }
 export declare class OptionsImpl implements MemberOptions {
     readonly getter: Function;
     readonly setter: Function;
     readonly kind: Kind;
-    readonly standalone: StandaloneMode;
+    readonly separation: SeparationMode;
     readonly order: number;
     readonly noSideEffects: boolean;
     readonly triggeringArgs: boolean;
@@ -27,14 +30,14 @@ export declare class OptionsImpl implements MemberOptions {
     static readonly INITIAL: Readonly<OptionsImpl>;
     constructor(getter: Function | undefined, setter: Function | undefined, existing: OptionsImpl, patch: Partial<OptionsImpl>, implicit: boolean);
 }
-export declare class Hooks implements ProxyHandler<ObjectHandle> {
+export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     static reactionsAutoStartDisabled: boolean;
     static repetitiveUsageWarningThreshold: number;
     static mainThreadBlockingWarningThreshold: number;
     static asyncActionDurationWarningThreshold: number;
     static sensitivity: boolean;
-    static readonly transactional: Hooks;
-    static readonly reactive: Hooks;
+    static readonly transactional: Mvcc;
+    static readonly reactive: Mvcc;
     readonly isReactive: boolean;
     constructor(isReactive: boolean);
     getPrototypeOf(h: ObjectHandle): object | null;
@@ -47,7 +50,7 @@ export declare class Hooks implements ProxyHandler<ObjectHandle> {
     static decorateOperation(implicit: boolean, decorator: Function, options: Partial<MemberOptions>, proto: any, member: MemberName, pd: PropertyDescriptor | undefined): any;
     static decorateOperationParametrized(decorator: Function, options: Partial<MemberOptions>): F<any>;
     static acquireHandle(obj: any): ObjectHandle;
-    static createHandleForReactronicObject(proto: any, data: any, blank: any, hint: string, reactive: boolean): ObjectHandle;
+    static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, reactive: boolean): ObjectHandle;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
     static sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
     static setHint<T>(obj: T, hint: string | undefined): T;

package/build/dist/source/impl/{Hooks.js → Mvcc.js}

@@ -3,11 +3,11 @@ import { Log, misuse } from '../util/Dbg';
 import { Kind, Reentrance } from '../Options';
 import { ObjectSnapshot, ObjectHandle, Subscription, Meta } from './Data';
 import { Changeset, Dump, EMPTY_SNAPSHOT } from './Changeset';
-export class HookedObject {
+export class MvccObject {
     constructor(reactive) {
         const proto = new.target.prototype;
         const initial = Meta.getFrom(proto, Meta.Initial);
-        const h = Hooks.createHandleForReactronicObject(proto, this, initial, new.target.name, reactive);
+        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, reactive);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
@@ -15,14 +15,19 @@ export class HookedObject {
         return Dump.obj(h);
     }
 }
-export class ReactiveObject extends HookedObject {
+export class TransactionalObject extends MvccObject {
+    constructor() {
+        super(false);
+    }
+}
+export class ReactiveObject extends MvccObject {
     constructor() {
         super(true);
     }
 }
 const DEFAULT_OPTIONS = Object.freeze({
     kind: Kind.Plain,
-    standalone: false,
+    separation: false,
     order: 0,
     noSideEffects: false,
     triggeringArgs: false,
@@ -37,7 +42,7 @@ export class OptionsImpl {
         this.getter = getter !== undefined ? getter : existing.getter;
         this.setter = setter !== undefined ? setter : existing.setter;
         this.kind = merge(DEFAULT_OPTIONS.kind, existing.kind, patch.kind, implicit);
-        this.standalone = merge(DEFAULT_OPTIONS.standalone, existing.standalone, patch.standalone, implicit);
+        this.separation = merge(DEFAULT_OPTIONS.separation, existing.separation, patch.separation, implicit);
         this.order = merge(DEFAULT_OPTIONS.order, existing.order, patch.order, implicit);
         this.noSideEffects = merge(DEFAULT_OPTIONS.noSideEffects, existing.noSideEffects, patch.noSideEffects, implicit);
         this.triggeringArgs = merge(DEFAULT_OPTIONS.triggeringArgs, existing.triggeringArgs, patch.triggeringArgs, implicit);
@@ -54,7 +59,7 @@ OptionsImpl.INITIAL = Object.freeze(new OptionsImpl(UNDEF, UNDEF, Object.assign(
 function merge(def, existing, patch, implicit) {
     return patch !== undefined && (existing === def || !implicit) ? patch : existing;
 }
-export class Hooks {
+export class Mvcc {
     constructor(isReactive) {
         this.isReactive = isReactive;
     }
@@ -84,7 +89,7 @@ export class Hooks {
         if (os !== EMPTY_SNAPSHOT) {
             let curr = os.data[m];
             if (curr !== undefined || (os.former.snapshot.changeset === EMPTY_SNAPSHOT.changeset && (m in h.data) === false)) {
-                if (curr === undefined || curr.content !== value || Hooks.sensitivity) {
+                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 Subscription(value);
@@ -127,12 +132,12 @@ export class Hooks {
     static decorateData(reactive, proto, m) {
         if (reactive) {
             const get = function () {
-                const h = Hooks.acquireHandle(this);
-                return Hooks.reactive.get(h, m, this);
+                const h = Mvcc.acquireHandle(this);
+                return Mvcc.reactive.get(h, m, this);
             };
             const set = function (value) {
-                const h = Hooks.acquireHandle(this);
-                return Hooks.reactive.set(h, m, value, this);
+                const h = Mvcc.acquireHandle(this);
+                return Mvcc.reactive.set(h, m, value, this);
             };
             const enumerable = true;
             const configurable = false;
@@ -147,11 +152,11 @@ export class Hooks {
             pd = EMPTY_PROP_DESCRIPTOR;
         const enumerable = (_a = pd.enumerable) !== null && _a !== void 0 ? _a : true;
         const configurable = (_b = pd.configurable) !== null && _b !== void 0 ? _b : true;
-        const opts = Hooks.rememberOperationOptions(proto, member, (_c = pd.value) !== null && _c !== void 0 ? _c : pd.get, (_d = pd.value) !== null && _d !== void 0 ? _d : pd.set, true, configurable, options, implicit);
+        const opts = Mvcc.rememberOperationOptions(proto, member, (_c = pd.value) !== null && _c !== void 0 ? _c : pd.get, (_d = pd.value) !== null && _d !== void 0 ? _d : pd.set, true, configurable, options, implicit);
         if (opts.getter === opts.setter) {
             const bootstrap = function () {
-                const h = Hooks.acquireHandle(this);
-                const operation = Hooks.createOperation(h, member, opts);
+                const h = Mvcc.acquireHandle(this);
+                const operation = Mvcc.createOperation(h, member, opts);
                 Object.defineProperty(h.data, member, { value: operation, enumerable, configurable });
                 return operation;
             };
@@ -159,8 +164,8 @@ export class Hooks {
         }
         else if (opts.setter === UNDEF) {
             const bootstrap = function () {
-                const h = Hooks.acquireHandle(this);
-                const operation = Hooks.createOperation(h, member, opts);
+                const h = Mvcc.acquireHandle(this);
+                const operation = Mvcc.createOperation(h, member, opts);
                 Object.defineProperty(h.data, member, { get: operation, enumerable, configurable });
                 return operation.call(this);
             };
@@ -171,7 +176,7 @@ export class Hooks {
     }
     static decorateOperationParametrized(decorator, options) {
         return function (proto, prop, pd) {
-            return Hooks.decorateOperation(false, decorator, options, proto, prop, pd);
+            return Mvcc.decorateOperation(false, decorator, options, proto, prop, pd);
         };
     }
     static acquireHandle(obj) {
@@ -181,71 +186,71 @@ export class Hooks {
                 throw misuse('only objects can be reactive');
             const initial = Meta.getFrom(Object.getPrototypeOf(obj), Meta.Initial);
             const os = new ObjectSnapshot(EMPTY_SNAPSHOT.changeset, EMPTY_SNAPSHOT, Object.assign({}, initial));
-            h = new ObjectHandle(obj, obj, Hooks.reactive, os, obj.constructor.name);
+            h = new ObjectHandle(obj, obj, Mvcc.reactive, os, obj.constructor.name);
             Meta.set(os.data, Meta.Handle, h);
             Meta.set(obj, Meta.Handle, h);
             Meta.set(os.data, Meta.Revision, new Subscription(1));
         }
         return h;
     }
-    static createHandleForReactronicObject(proto, data, blank, hint, reactive) {
+    static createHandleForMvccObject(proto, data, blank, hint, reactive) {
         const ctx = Changeset.edit();
-        const hooks = reactive ? Hooks.reactive : Hooks.transactional;
-        const h = new ObjectHandle(data, undefined, hooks, EMPTY_SNAPSHOT, hint);
+        const mvcc = reactive ? Mvcc.reactive : Mvcc.transactional;
+        const h = new ObjectHandle(data, undefined, mvcc, EMPTY_SNAPSHOT, hint);
         ctx.getEditableObjectSnapshot(h, Meta.Handle, blank);
-        if (!Hooks.reactionsAutoStartDisabled)
+        if (!Mvcc.reactionsAutoStartDisabled)
             for (const m in Meta.getFrom(proto, Meta.Reactions))
                 h.proxy[m][Meta.Controller].markObsolete();
         return h;
     }
     static setProfilingMode(isOn, options) {
         if (isOn) {
-            Hooks.repetitiveUsageWarningThreshold = options && options.repetitiveUsageWarningThreshold !== undefined ? options.repetitiveUsageWarningThreshold : 10;
-            Hooks.mainThreadBlockingWarningThreshold = options && options.mainThreadBlockingWarningThreshold !== undefined ? options.mainThreadBlockingWarningThreshold : 14;
-            Hooks.asyncActionDurationWarningThreshold = options && options.asyncActionDurationWarningThreshold !== undefined ? options.asyncActionDurationWarningThreshold : 300;
+            Mvcc.repetitiveUsageWarningThreshold = options && options.repetitiveUsageWarningThreshold !== undefined ? options.repetitiveUsageWarningThreshold : 10;
+            Mvcc.mainThreadBlockingWarningThreshold = options && options.mainThreadBlockingWarningThreshold !== undefined ? options.mainThreadBlockingWarningThreshold : 14;
+            Mvcc.asyncActionDurationWarningThreshold = options && options.asyncActionDurationWarningThreshold !== undefined ? options.asyncActionDurationWarningThreshold : 300;
             Changeset.garbageCollectionSummaryInterval = options && options.garbageCollectionSummaryInterval !== undefined ? options.garbageCollectionSummaryInterval : 100;
         }
         else {
-            Hooks.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
-            Hooks.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
-            Hooks.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
+            Mvcc.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
+            Mvcc.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
+            Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
             Changeset.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
         }
     }
     static sensitive(sensitivity, func, ...args) {
-        const restore = Hooks.sensitivity;
-        Hooks.sensitivity = sensitivity;
+        const restore = Mvcc.sensitivity;
+        Mvcc.sensitivity = sensitivity;
         try {
             return func(...args);
         }
         finally {
-            Hooks.sensitivity = restore;
+            Mvcc.sensitivity = restore;
         }
     }
     static setHint(obj, hint) {
         if (hint) {
-            const h = Hooks.acquireHandle(obj);
+            const h = Mvcc.acquireHandle(obj);
             h.hint = hint;
         }
         return obj;
     }
     static getHint(obj) {
-        const h = Hooks.acquireHandle(obj);
+        const h = Mvcc.acquireHandle(obj);
         return h.hint;
     }
 }
-Hooks.reactionsAutoStartDisabled = false;
-Hooks.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
-Hooks.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
-Hooks.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
-Hooks.sensitivity = false;
-Hooks.transactional = new Hooks(false);
-Hooks.reactive = new Hooks(true);
-Hooks.createOperation = function (h, m, options) {
-    throw misuse('createOperation should never be called');
+Mvcc.reactionsAutoStartDisabled = false;
+Mvcc.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
+Mvcc.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
+Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
+Mvcc.sensitivity = false;
+Mvcc.transactional = new Mvcc(false);
+Mvcc.reactive = new Mvcc(true);
+Mvcc.createOperation = function (h, m, options) {
+    throw misuse('this implementation of createOperation should never be called');
 };
-Hooks.rememberOperationOptions = function (proto, m, getter, setter, enumerable, configurable, options, implicit) {
-    throw misuse('rememberOperationOptions should never be called');
+Mvcc.rememberOperationOptions = function (proto, m, getter, setter, enumerable, configurable, options, implicit) {
+    throw misuse('this implementation of rememberOperationOptions should never be called');
 };
 const EMPTY_PROP_DESCRIPTOR = {
     configurable: true,