reactronic 0.22.314 → 0.22.317

package/README.md

@@ -18,13 +18,13 @@ isolated data snapshot and then, once atomically applied, are
 **consistently propagated** to corresponding visual components for
 (re)rendering. All that is done in automatic, seamless, and fine-grained
 way, because reactronic **takes full care of tracking dependencies**
-between visual components (subscribers) and state (reactive objects).
+between visual components (observers) and state (observable objects).
 
 Transactional reactivity is based on four fundamental concepts:
 
-  - **Reactive Objects** - a set of objects that store data of an
+  - **Observable Objects** - a set of objects that store data of an
     application (state) and maintain subscription lists;
-  - **Transaction** - a function that makes changes in reactive
+  - **Transaction** - a function that makes changes in observable
     objects in transactional (atomic) way;
   - **Reaction** - a function that is executed automatically in
     response to changes made by a transaction;
@@ -39,10 +39,10 @@ Quick introduction and detailed description is below.
 ## Quick Introduction
 
 Here is an example of transactional reactive code with
-reactive object, transaction and reaction:
+observable object, transaction and reaction:
 
 ``` typescript
-class Demo extends ReactiveObject {
+class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -69,7 +69,7 @@ to changes of these fields made by `saveContact` transaction.
 Here is an example of if cached value computed on-demand:
 
 ``` typescript
-class Demo extends ReactiveObject {
+class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -94,14 +94,14 @@ invalidated, thus causing execution of depending reaction
 `printContact`. Then `printContact` reaction causes `contact`
 re-computation on the first use.
 
-## Reactive Objects
+## Observable Objects
 
-Reactive objects store data of an application. All such objects
+Observable objects store data of an application. All such objects
 are transparently hooked to track access to their properties,
 both on reads and writes.
 
 ``` typescript
-class MyModel extends ReactiveObject {
+class MyModel extends ObservableObject {
   url: string = "https://github.com/nezaboodka/reactronic"
   content: string = "transactional reactive state management"
   timestamp: Date = Date.now()
@@ -109,18 +109,18 @@ class MyModel extends ReactiveObject {
 ```
 
 In the example above, the class `MyModel` is based on Reactronic's
-`ReactiveObject` class and all its properties `url`, `content`,
+`ObservableObject` class and all its properties `url`, `content`,
 and `timestamp` are hooked.
 
 ## Transaction
 
-Transaction is a function that makes changes in reactive objects
+Transaction is a function that makes changes in observable objects
 in transactional (atomic) way. Such a function is instrumented with hooks
 to provide transparent atomicity (by implicit context switching
 and isolation).
 
 ``` typescript
-class MyModel extends ReactiveObject {
+class MyModel extends ObservableObject {
   // ...
   @transaction
   async load(url: string): Promise<void> {
@@ -163,12 +163,12 @@ of asynchronous operations is fully completed.
 ## Reaction & Cache
 
 Reaction is an code block that is immediately called in response to
-changes made by a transaction in reactive objects. Cache is a
+changes made by a transaction in observable objects. Cache is a
 computed value having an associated function that is called
 on-demand to renew the value if it was marked as obsolete due to changes
 made by a transaction. Reactive and cached functions are
 instrumented with hooks to seamlessly subscribe to those
-reactive objects and other cached functions (dependencies),
+observable objects and other cached functions (dependencies),
 which are used during their execution.
 
 ``` tsx
@@ -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 {
@@ -222,14 +222,14 @@ function enqueues re-rendering request to React, which calls
 `render` function causing it to renew its cached value.
 
 In general case, all reactions and caches are automatically and
-immediately marked as obsolete when changes are made in those reactive
+immediately marked as obsolete when changes are made in those observable
 objects and cached functions that were used during their execution.
 And once marked, the functions are automatically executed again,
 either immediately (for @reactive functions) or on-demand
 (for @cached functions).
 
 Reactronic takes full care of tracking dependencies between
-all the reactive objects and reactions/caches.
+all the observable objects and reactions/caches.
 With Reactronic, you no longer need to create data change events
 in one set of objects, subscribe to these events in other objects,
 and manually maintain switching from the previous object version
@@ -291,11 +291,12 @@ NPM: `npm install reactronic`
 
 // Classes
 
-class ReactiveObject { }
+class TransactionalObject { }
+class ObservableObject { }
 
 // 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,5 +1,5 @@
-import { ReactiveObject } from './impl/Hooks';
-export declare abstract class Buffer<T> extends ReactiveObject {
+import { ObservableObject } from './impl/Mvcc';
+export declare abstract class Buffer<T> extends ObservableObject {
     abstract readonly capacity: number;
     abstract readonly count: number;
     abstract put(...items: T[]): void;

package/build/dist/source/Buffer.js

@@ -1,4 +1,4 @@
-import { ReactiveObject } from './impl/Hooks';
-export class Buffer extends ReactiveObject {
+import { ObservableObject } from './impl/Mvcc';
+export class Buffer extends ObservableObject {
     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

@@ -1,5 +1,5 @@
 export { all, pause } from './util/Utils';
-export { Collection } from './util/Collection';
+export { Collection, Item, CollectionReader } from './util/Collection';
 export { SealedArray } from './util/SealedArray';
 export { SealedMap } from './util/SealedMap';
 export { SealedSet } from './util/SealedSet';
@@ -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, ObservableObject } from './impl/Mvcc';
+export { TransactionalArray, ObservableArray } from './impl/MvccArray';
+export { TransactionalMap, ObservableMap } 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, ObservableObject } from './impl/Mvcc';
+export { TransactionalArray, ObservableArray } from './impl/MvccArray';
+export { TransactionalMap, ObservableMap } 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,16 +7,16 @@ 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)
                 result[m] = v.content;
-            else if (v === Meta.Nonreactive)
+            else if (v === Meta.Raw)
                 result[m] = this.data[m];
             else
                 result[m] = v;
@@ -61,7 +61,7 @@ export class Changeset {
     getEditableObjectSnapshot(h, m, value, token) {
         let os = this.lookupObjectSnapshot(h, m);
         const existing = os.data[m];
-        if (existing !== Meta.Nonreactive) {
+        if (existing !== Meta.Raw) {
             if (this.isNewSnapshotRequired(h, os, m, existing, value, token)) {
                 this.bumpBy(os.changeset.timestamp);
                 const revision = m === Meta.Handle ? 1 : os.revision + 1;
@@ -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();
@@ -97,7 +97,7 @@ export class Changeset {
     }
     isNewSnapshotRequired(h, os, m, existing, value, token) {
         if (this.sealed && os.changeset !== EMPTY_SNAPSHOT.changeset)
-            throw misuse(`reactive property ${Dump.obj(h, m)} can only be modified inside transaction`);
+            throw misuse(`observable property ${Dump.obj(h, m)} can only be modified inside transaction`);
         if (m !== Meta.Handle) {
             if (value !== Meta.Handle) {
                 if (os.changeset !== this || os.former.snapshot !== EMPTY_SNAPSHOT) {
@@ -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,7 +1,7 @@
-import { ReactiveObject } from './Hooks';
+import { ObservableObject } from './Mvcc';
 import { ObjectHandle, ObjectSnapshot, PatchSet } from './Data';
 export declare type Saver = (patch: PatchSet) => Promise<void>;
-export declare abstract class Journal extends ReactiveObject {
+export declare abstract class Journal extends ObservableObject {
     abstract capacity: number;
     abstract readonly edits: ReadonlyArray<PatchSet>;
     abstract readonly unsaved: PatchSet;

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

@@ -1,9 +1,9 @@
-import { ReactiveObject } from './Hooks';
+import { ObservableObject } from './Mvcc';
 import { Meta, Subscription } from './Data';
 import { Changeset, EMPTY_SNAPSHOT } from './Changeset';
 import { Transaction } from './Transaction';
 import { Sealant } from '../util/Sealant';
-export class Journal extends ReactiveObject {
+export class Journal extends ObservableObject {
     static create() { return new JournalImpl(); }
 }
 export class JournalImpl extends Journal {
@@ -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/Meta.d.ts

@@ -4,7 +4,7 @@ export declare abstract class Meta {
     static readonly Controller: unique symbol;
     static readonly Initial: unique symbol;
     static readonly Reactions: unique symbol;
-    static readonly Nonreactive: unique symbol;
+    static readonly Raw: unique symbol;
     static readonly Undefined: unique symbol;
     static get<T>(obj: any, sym: symbol): T;
     static set(obj: any, sym: symbol, value: any): any;

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

@@ -25,5 +25,5 @@ Meta.Revision = Symbol('rx-revision');
 Meta.Controller = Symbol('rx-controller');
 Meta.Initial = Symbol('rx-initial');
 Meta.Reactions = Symbol('rx-reactions');
-Meta.Nonreactive = Symbol('rx-nonreactive');
+Meta.Raw = Symbol('rx-raw');
 Meta.Undefined = Symbol('rx-undefined');

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

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

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

@@ -1,6 +1,6 @@
-import { ReactiveObject, Hooks } from './Hooks';
+import { ObservableObject, Mvcc } from './Mvcc';
 import { Transaction } from './Transaction';
-export class Monitor extends ReactiveObject {
+export class Monitor extends ObservableObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
         return MonitorImpl.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 {
-    protected constructor(reactive: boolean);
+export declare abstract class MvccObject {
+    protected constructor(observable: boolean);
     [Symbol.toStringTag](): string;
 }
-export declare abstract class ReactiveObject extends HookedObject {
+export declare abstract class TransactionalObject extends MvccObject {
+    constructor();
+}
+export declare abstract class ObservableObject 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,27 +30,27 @@ 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;
-    readonly isReactive: boolean;
-    constructor(isReactive: boolean);
+    static readonly transactional: Mvcc;
+    static readonly observable: Mvcc;
+    readonly isObservable: boolean;
+    constructor(isObservable: boolean);
     getPrototypeOf(h: ObjectHandle): object | null;
     get(h: ObjectHandle, m: MemberName, receiver: any): any;
     set(h: ObjectHandle, m: MemberName, value: any, receiver: any): boolean;
     has(h: ObjectHandle, m: MemberName): boolean;
     getOwnPropertyDescriptor(h: ObjectHandle, m: MemberName): PropertyDescriptor | undefined;
     ownKeys(h: ObjectHandle): Array<string | symbol>;
-    static decorateData(reactive: boolean, proto: any, m: MemberName): any;
+    static decorateData(isObservable: boolean, proto: any, m: MemberName): any;
     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, isObservable: 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;