reactronic 0.22.320 → 0.22.410

package/README.md

@@ -9,7 +9,7 @@
 
 # **Reactronic** - Transactional Reactive State Management
 
-Reactronic is a JavaScript library that provides
+Reactronic is an experimental JavaScript library that provides
 [transactional reactive](https://blog.nezaboodka.com/post/2019/593-modern-database-should-natively-support-transactionally-reactive-programming)
 state management in a Web application.
 
@@ -23,13 +23,13 @@ between visual components (observers) and state (observable objects).
 Transactional reactivity is based on four fundamental concepts:
 
   - **Observable Objects** - a set of objects that store data of an
-    application (state) and maintain subscription lists;
-  - **Transaction** - a function that makes changes in observable
-    objects in transactional (atomic) way;
-  - **Reaction** - a function that is executed automatically in
+    application (state);
+  - **Transactional Function** - makes changes in observable
+    objects in atomic way ("all or nothing");
+  - **Reactive Function** - is executed automatically in
     response to changes made by a transaction;
-  - **Cache** - a computed value having associated function that is
-    executed on-demand to renew the value if it becomes obsolete.
+  - **Cached Function** - its result is remembered and, if the becomes
+  obsolete, recomputed on-demand.
 
 Demo application built with Reactronic: https://nevod.io/#/playground.
 Source code of the demo: https://gitlab.com/nezaboodka/nevod.web.public/-/blob/master/README.md.
@@ -38,21 +38,20 @@ Quick introduction and detailed description is below.
 
 ## Quick Introduction
 
-Here is an example of transactional reactive code with
-observable object, transaction and reaction:
+Here is an example of transactional reactive code:
 
 ``` typescript
 class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @transaction
+  @transactional
   saveContact(name: string, email: string): void {
     this.name = name
     this.email = email
   }
 
-  @reaction
+  @reactive
   printContact(): void {
     // depends on `name` and `email` and reacts to their changes
     if (this.email.indexOf('@') >= 0)
@@ -62,11 +61,11 @@ class Demo extends ObservableObject {
 }
 ```
 
-In the example above, `printContact` reaction depends on `name`
+In the example above, `printContact` function depends on `name`
 and `email` fields. It is executed automatically in response
-to changes of these fields made by `saveContact` transaction.
+to changes of these fields made by `saveContact` function.
 
-Here is an example of if cached value computed on-demand:
+Here is an example of cached value (re-)computed on-demand:
 
 ``` typescript
 class Demo extends ObservableObject {
@@ -78,7 +77,7 @@ class Demo extends ObservableObject {
     return this.name + ' <' + this.email + '>'
   }
 
-  @reaction
+  @reactive
   printContact(): void {
     if (this.contact !== '')
       Console.log(this.contact)
@@ -87,12 +86,12 @@ class Demo extends ObservableObject {
 ```
 
 In the example above, the value of `contact` is computed from
-source fields `name` and `email`. Once computed, the result is
-cached and is reused until source fields `name` and `email` are
-changed. Once source fields changed, `contact` value becomes
-invalidated, thus causing execution of depending reaction
-`printContact`. Then `printContact` reaction causes `contact`
-re-computation on the first use.
+source fields `name` and `email` upon first use. Once computed,
+the result is cached and is reused until source fields `name`
+and `email` are changed. Once source fields changed, `contact`
+value becomes obsolete, thus causing execution of depending
+reactive function `printContact`. When `printContact` function
+runs it reads `contact` and causes its re-computation.
 
 ## Observable Objects
 
@@ -112,17 +111,17 @@ In the example above, the class `MyModel` is based on Reactronic's
 `ObservableObject` class and all its properties `url`, `content`,
 and `timestamp` are hooked.
 
-## Transaction
+## Transactional Functions
 
-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).
+Transactional function 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 ObservableObject {
   // ...
-  @transaction
+  @transactional
   async load(url: string): Promise<void> {
     this.url = url
     this.content = await fetch(url)
@@ -160,16 +159,16 @@ all of them. An asynchronous call may spawn other asynchronous
 calls, which prolong transaction execution until the whole chain
 of asynchronous operations is fully completed.
 
-## Reaction & Cache
+## Reactive & Cached Functions
 
-Reaction is an code block that is immediately called in response to
-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
-observable objects and other cached functions (dependencies),
-which are used during their execution.
+Reactive function is automatically and immediately called in
+response to changes made by a transaction in observable objects.
+Cached function 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 observable objects and
+other cached functions (dependencies), which are used
+during their execution.
 
 ``` tsx
 class MyView extends Component<{model: MyModel}> {
@@ -192,7 +191,7 @@ class Component<P> extends React.Component<P> {
     throw new Error('render method is undefined')
   }
 
-  @reaction // called immediately in response to changes
+  @reactive // called immediately in response to changes
   ensureUpToDate(): void {
     if (this.shouldComponentUpdate())
       Transaction.outside(() => this.setState({})) // ask React to re-render
@@ -216,20 +215,20 @@ In the example above, reactive function `refresh` is transparently subscribed
 to the cached function `render`. In turn, the `render` function is
 subscribed to the `url` and `content` properties of a corresponding
 `MyModel` object. Once `url` or `content` values are changed, the
-`render` cache becomes obsolete and causes the `refresh` reaction to become
+`render` cache becomes obsolete and causes the `refresh` function to become
 obsolete as well and re-executed. While being executed, the `refresh`
 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
+In general case, all reactive and cached functions are automatically and
 immediately marked as obsolete when changes are made in those observable
-objects and cached functions that were used during their execution.
+objects and other 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 observable objects and reactions/caches.
+all the observable objects and reactive/cached functions.
 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
@@ -239,18 +238,20 @@ to a new one.
 
 There are multiple options to configure behavior of transactional reactivity.
 
-**Order** options defines order of reactions execution:
+**Order** options defines order of execution for reactive functions:
 
   - (TBD)
 
-**Throttling** option defines how often reaction is executed in case of recurring changes:
+**Throttling** option defines how often reactive function is executed in case
+of recurring changes:
 
-  - `(ms)` - minimal delay in milliseconds between reaction execution;
-  - `-1` - execute reaction immediately once transaction is applied (synchronously);
-  - `0` - execute reaction immediately via event loop (asynchronously with zero timeout);
-  - `>= Number.MAX_SAFE_INTEGER` - never execute reaction (disabled reaction).
+  - `(ms)` - minimal delay in milliseconds between executions;
+  - `-1` - execute immediately once transaction is applied (synchronously);
+  - `0` - execute immediately via event loop (asynchronously with zero timeout);
+  - `>= Number.MAX_SAFE_INTEGER` - never execute (suspended reactive function).
 
-**Reentrance** option defines how to handle reentrant calls of transactions and reactions:
+**Reentrance** option defines how to handle reentrant calls of transactional
+and reactive functions:
 
   - `PreventWithError` - fail with error if there is an existing call in progress;
   - `WaitAndRestart` - wait for previous call to finish and then restart current one;
@@ -258,9 +259,9 @@ There are multiple options to configure behavior of transactional reactivity.
   - `CancelAndWaitPrevious` - cancel previous call in favor of recent one (but wait until canceling is completed)
   - `RunSideBySide` - multiple simultaneous calls are allowed.
 
-**Monitor** is an object that maintains the status of running functions,
+**Monitor** is an object that maintains status of running functions,
 which it is attached to. A single monitor object can be shared between
-multiple transactions, reactions, and cache functions, thus maintaining
+multiple transactional, reactive, and cached functions, thus maintaining
 consolidated status for all of them (busy, workers, etc).
 
 ## Notes
@@ -298,11 +299,11 @@ class ObservableObject { }
 
 function raw(proto, prop) // field only
 function transaction(proto, prop, pd) // method only
-function reaction(proto, prop, pd) // method only
+function reactive(proto, prop, pd) // method only
 function cached(proto, prop, pd) // method only
 function options(value: Partial<MemberOptions>): F<any>
 
-function unobservable<T>(func: F<T>, ...args: any[]): T
+function nonreactive<T>(func: F<T>, ...args: any[]): T
 function sensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
 // SnapshotOptions, MemberOptions, Kind, Reentrance, Monitor, LoggingOptions, ProfilingOptions
@@ -330,9 +331,9 @@ interface MemberOptions {
 
 enum Kind {
   Plain = 0,
-  Transaction = 1,
-  Reaction = 2,
-  Cache = 3
+  Transactional = 1,
+  Reactive = 2,
+  Cached = 3
 }
 
 enum Reentrance {
@@ -344,12 +345,6 @@ enum Reentrance {
   RunSideBySide = -3 // multiple simultaneous calls are allowed
 }
 
-enum Sensitivity {
-  ReactOnFinalDifferenceOnly = 0, // default
-  ReactOnFinalAndIntermediateDifference = 1,
-  ReactEvenOnSameValueAssignment = 2,
-}
-
 class Monitor {
   readonly isActive: boolean
   readonly counter: number
@@ -440,7 +435,7 @@ class Reactronic {
   static getRevisionOf(obj: any): number
   static takeSnapshot<T>(obj: T): T
   static dispose(obj: any): void
-  static reactionsAutoStartDisabled: boolean
+  static reactivityAutoStartDisabled: boolean
   static readonly isLogging: boolean
   static readonly loggingOptions: LoggingOptions
   static setLoggingMode(isOn: boolean, options?: LoggingOptions)

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

@@ -1,6 +1,7 @@
 import { LoggingOptions } from './Logging';
 import { SeparationMode } from './impl/Data';
-export { LoggingOptions, ProfilingOptions, LoggingLevel } from './Logging';
+export { LoggingLevel } from './Logging';
+export type { LoggingOptions, ProfilingOptions } from './Logging';
 import { Journal } from './impl/Journal';
 import { Monitor } from './impl/Monitor';
 export interface SnapshotOptions {
@@ -24,9 +25,9 @@ export interface MemberOptions {
 }
 export declare enum Kind {
     Plain = 0,
-    Transaction = 1,
-    Reaction = 2,
-    Cache = 3
+    Transactional = 1,
+    Reactive = 2,
+    Cached = 3
 }
 export declare enum Reentrance {
     PreventWithError = 1,

package/build/dist/source/Options.js

@@ -2,9 +2,9 @@ export { LoggingLevel } from './Logging';
 export var Kind;
 (function (Kind) {
     Kind[Kind["Plain"] = 0] = "Plain";
-    Kind[Kind["Transaction"] = 1] = "Transaction";
-    Kind[Kind["Reaction"] = 2] = "Reaction";
-    Kind[Kind["Cache"] = 3] = "Cache";
+    Kind[Kind["Transactional"] = 1] = "Transactional";
+    Kind[Kind["Reactive"] = 2] = "Reactive";
+    Kind[Kind["Cached"] = 3] = "Cached";
 })(Kind || (Kind = {}));
 export var Reentrance;
 (function (Reentrance) {

package/build/dist/source/Ref.js

@@ -1,5 +1,5 @@
 import { Transaction } from './impl/Transaction';
-import { unobservable } from './Rx';
+import { nonreactive } from './Rx';
 export class Ref {
     constructor(owner, name, index = -1) {
         this.owner = owner;
@@ -19,7 +19,7 @@ export class Ref {
             this.owner[this.name][this.index] = value;
     }
     unobservable() {
-        return unobservable(() => this.variable);
+        return nonreactive(() => this.variable);
     }
     observe() {
         return this.variable;

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

@@ -9,8 +9,8 @@ export declare class Rx {
     static getRevisionOf(obj: any): number;
     static takeSnapshot<T>(obj: T): T;
     static dispose(obj: any): void;
-    static get reactionsAutoStartDisabled(): boolean;
-    static set reactionsAutoStartDisabled(value: boolean);
+    static get reactivityAutoStartDisabled(): boolean;
+    static set reactivityAutoStartDisabled(value: boolean);
     static get isLogging(): boolean;
     static get loggingOptions(): LoggingOptions;
     static setLoggingMode(isOn: boolean, options?: LoggingOptions): void;
@@ -18,10 +18,10 @@ 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 unobservable<T>(func: 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;
-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 transactional(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function reactive(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function cached(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function options(value: Partial<MemberOptions>): F<any>;

package/build/dist/source/Rx.js

@@ -12,8 +12,8 @@ export class Rx {
     static getRevisionOf(obj) { return obj[Meta.Revision]; }
     static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }
     static dispose(obj) { Changeset.dispose(obj); }
-    static get reactionsAutoStartDisabled() { return Mvcc.reactionsAutoStartDisabled; }
-    static set reactionsAutoStartDisabled(value) { Mvcc.reactionsAutoStartDisabled = value; }
+    static get reactivityAutoStartDisabled() { return Mvcc.reactivityAutoStartDisabled; }
+    static set reactivityAutoStartDisabled(value) { Mvcc.reactivityAutoStartDisabled = value; }
     static get isLogging() { return Log.isOn; }
     static get loggingOptions() { return Log.opt; }
     static setLoggingMode(isOn, options) { Log.setMode(isOn, options); }
@@ -21,7 +21,7 @@ export class Rx {
     static getLoggingHint(obj, full = false) { return ObjectHandle.getHint(obj, full); }
     static setProfilingMode(isOn, options) { Mvcc.setProfilingMode(isOn, options); }
 }
-export function unobservable(func, ...args) {
+export function nonreactive(func, ...args) {
     return OperationController.runWithin(undefined, func, ...args);
 }
 export function sensitive(sensitivity, func, ...args) {
@@ -30,16 +30,16 @@ export function sensitive(sensitivity, func, ...args) {
 export function raw(proto, prop) {
     return Mvcc.decorateData(false, proto, prop);
 }
-export function transaction(proto, prop, pd) {
-    const opts = { kind: Kind.Transaction };
-    return Mvcc.decorateOperation(true, transaction, opts, proto, prop, pd);
+export function transactional(proto, prop, pd) {
+    const opts = { kind: Kind.Transactional };
+    return Mvcc.decorateOperation(true, transactional, opts, proto, prop, pd);
 }
-export function reaction(proto, prop, pd) {
-    const opts = { kind: Kind.Reaction, throttling: -1 };
-    return Mvcc.decorateOperation(true, reaction, opts, proto, prop, pd);
+export function reactive(proto, prop, pd) {
+    const opts = { kind: Kind.Reactive, throttling: -1 };
+    return Mvcc.decorateOperation(true, reactive, opts, proto, prop, pd);
 }
 export function cached(proto, prop, pd) {
-    const opts = { kind: Kind.Cache, noSideEffects: true };
+    const opts = { kind: Kind.Cached, noSideEffects: true };
     return Mvcc.decorateOperation(true, cached, opts, proto, prop, pd);
 }
 export function options(value) {

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

@@ -1,12 +1,15 @@
 export { all, pause } from './util/Utils';
-export { Collection, Item, CollectionReader } from './util/Collection';
+export { Collection } from './util/Collection';
+export type { Item, CollectionReader } from './util/Collection';
 export { SealedArray } from './util/SealedArray';
 export { SealedMap } from './util/SealedMap';
 export { SealedSet } from './util/SealedSet';
-export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, ProfilingOptions, LoggingLevel } from './Options';
-export { Worker } from './Worker';
+export { Kind, Reentrance, LoggingLevel } from './Options';
+export type { MemberOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from './Options';
+export type { Worker } from './Worker';
 export { Controller } from './Controller';
-export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
+export { Ref, ToggleRef } from './Ref';
+export type { BoolOnly, GivenTypeOnly } from './Ref';
 export { TransactionalObject, ObservableObject } from './impl/Mvcc';
 export { TransactionalArray, ObservableArray } from './impl/MvccArray';
 export { TransactionalMap, ObservableMap } from './impl/MvccMap';
@@ -14,4 +17,4 @@ export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';
 export { Journal } from './impl/Journal';
-export { Rx, unobservable, sensitive, raw, transaction, reaction, cached, options } from './Rx';
+export { Rx, raw, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx';

package/build/dist/source/api.js

@@ -13,4 +13,4 @@ export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';
 export { Journal } from './impl/Journal';
-export { Rx, unobservable, sensitive, raw, transaction, reaction, cached, options } from './Rx';
+export { Rx, raw, transactional, reactive, cached, nonreactive, sensitive, options } from './Rx';

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

@@ -18,7 +18,7 @@ export declare class Changeset implements AbstractChangeset {
     private revision;
     private bumper;
     items: Map<ObjectHandle, ObjectSnapshot>;
-    reactions: Subscriber[];
+    reactive: Subscriber[];
     sealed: boolean;
     constructor(options: SnapshotOptions | null);
     static current: () => Changeset;
@@ -28,7 +28,7 @@ export declare class Changeset implements AbstractChangeset {
     static isConflicting: (oldValue: any, newValue: any) => boolean;
     static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
     static revokeAllSubscriptions: (changeset: Changeset) => void;
-    static enqueueReactionsToRun: (reactions: Array<Subscriber>) => void;
+    static enqueueReactiveFunctionsToRun: (reactive: Array<Subscriber>) => void;
     lookupObjectSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
     getObjectSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
     getEditableObjectSnapshot(h: ObjectHandle, m: MemberName, value: any, token?: any): ObjectSnapshot;

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

@@ -33,7 +33,7 @@ export class Changeset {
         this.revision = UNDEFINED_REVISION;
         this.bumper = 100;
         this.items = new Map();
-        this.reactions = [];
+        this.reactive = [];
         this.sealed = false;
     }
     get hint() { var _a; return (_a = this.options.hint) !== null && _a !== void 0 ? _a : 'noname'; }
@@ -214,7 +214,7 @@ export class Changeset {
         }
         if (!error)
             Changeset.propagateAllChangesThroughSubscriptions(this);
-        return this.reactions;
+        return this.reactive;
     }
     static sealObjectSnapshot(h, os) {
         if (!os.disposed)
@@ -276,7 +276,7 @@ export class Changeset {
             os.former.snapshot = EMPTY_SNAPSHOT;
         });
         this.items = EMPTY_MAP;
-        this.reactions = EMPTY_ARRAY;
+        this.reactive = EMPTY_ARRAY;
         if (Log.isOn)
             Object.freeze(this);
     }
@@ -309,7 +309,7 @@ Changeset.markEdited = UNDEF;
 Changeset.isConflicting = UNDEF;
 Changeset.propagateAllChangesThroughSubscriptions = (changeset) => { };
 Changeset.revokeAllSubscriptions = (changeset) => { };
-Changeset.enqueueReactionsToRun = (reactions) => { };
+Changeset.enqueueReactiveFunctionsToRun = (reactive) => { };
 export class Dump {
     static obj(h, m, stamp, snapshotId, originSnapshotId, value) {
         const member = m !== undefined ? `.${m.toString()}` : '';

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

@@ -18,7 +18,7 @@ export interface Subscriber {
     readonly subscriptions: Map<Subscription, SubscriptionInfo> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
-    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactions: Array<Subscriber>): void;
+    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Array<Subscriber>): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
 }
 export declare type MemberName = PropertyKey;

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

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

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

@@ -24,6 +24,6 @@ Meta.Handle = Symbol('rx-handle');
 Meta.Revision = Symbol('rx-revision');
 Meta.Controller = Symbol('rx-controller');
 Meta.Initial = Symbol('rx-initial');
-Meta.Reactions = Symbol('rx-reactions');
+Meta.Reactive = Symbol('rx-reactive');
 Meta.Raw = Symbol('rx-raw');
 Meta.Undefined = Symbol('rx-undefined');

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

@@ -31,7 +31,7 @@ export declare class OptionsImpl implements MemberOptions {
     constructor(getter: Function | undefined, setter: Function | undefined, existing: OptionsImpl, patch: Partial<OptionsImpl>, implicit: boolean);
 }
 export declare class Mvcc implements ProxyHandler<ObjectHandle> {
-    static reactionsAutoStartDisabled: boolean;
+    static reactivityAutoStartDisabled: boolean;
     static repetitiveUsageWarningThreshold: number;
     static mainThreadBlockingWarningThreshold: number;
     static asyncActionDurationWarningThreshold: number;

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

@@ -198,8 +198,8 @@ export class Mvcc {
         const mvcc = isObservable ? Mvcc.observable : Mvcc.transactional;
         const h = new ObjectHandle(data, undefined, mvcc, EMPTY_SNAPSHOT, hint);
         ctx.getEditableObjectSnapshot(h, Meta.Handle, blank);
-        if (!Mvcc.reactionsAutoStartDisabled)
-            for (const m in Meta.getFrom(proto, Meta.Reactions))
+        if (!Mvcc.reactivityAutoStartDisabled)
+            for (const m in Meta.getFrom(proto, Meta.Reactive))
                 h.proxy[m][Meta.Controller].markObsolete();
         return h;
     }
@@ -239,7 +239,7 @@ export class Mvcc {
         return h.hint;
     }
 }
-Mvcc.reactionsAutoStartDisabled = false;
+Mvcc.reactivityAutoStartDisabled = false;
 Mvcc.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;

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

@@ -1,6 +1,6 @@
 import { MvccObject } from './Mvcc';
 export declare class MvccArray<T> extends MvccObject {
-    private all;
+    private impl;
     constructor(isObservable: boolean, array: Array<T>);
     get length(): number;
     set length(n: number);

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

@@ -3,47 +3,47 @@ import { MvccObject } from './Mvcc';
 export class MvccArray extends MvccObject {
     constructor(isObservable, array) {
         super(isObservable);
-        this.all = array;
+        this.impl = array;
     }
-    get length() { return this.all.length; }
+    get length() { return this.impl.length; }
     set length(n) { this.mutable.length = n; }
-    getItem(n) { return this.all[n]; }
+    getItem(n) { return this.impl[n]; }
     setItem(n, item) { this.mutable[n] = item; }
-    toString() { return this.all.toString(); }
-    toLocaleString() { return this.all.toLocaleString(); }
+    toString() { return this.impl.toString(); }
+    toLocaleString() { return this.impl.toLocaleString(); }
     pop() { return this.mutable.pop(); }
     push(...items) { return this.mutable.push(...items); }
-    concat(...items) { return this.all.concat(...items); }
-    join(separator) { return this.all.join(separator); }
+    concat(...items) { return this.impl.concat(...items); }
+    join(separator) { return this.impl.join(separator); }
     reverse() { return this.mutable.reverse(); }
     shift() { return this.mutable.shift(); }
-    slice(start, end) { return this.all.slice(start, end); }
+    slice(start, end) { return this.impl.slice(start, end); }
     sort(compareFn) { this.mutable.sort(compareFn); return this; }
     splice(start, deleteCount, ...items) { return this.mutable.splice(start, deleteCount, ...items); }
     unshift(...items) { return this.mutable.unshift(...items); }
-    includes(searchElement, fromIndex) { return this.all.includes(searchElement, fromIndex); }
-    indexOf(searchElement, fromIndex) { return this.all.indexOf(searchElement, fromIndex); }
-    lastIndexOf(searchElement, fromIndex) { return this.all.lastIndexOf(searchElement, fromIndex); }
-    every(predicate, thisArg) { return this.all.every(predicate, thisArg); }
-    some(predicate, thisArg) { return this.all.some(predicate, thisArg); }
-    forEach(callbackfn, thisArg) { return this.all.forEach(callbackfn, thisArg); }
-    map(callbackfn, thisArg) { return this.all.map(callbackfn, thisArg); }
-    filter(predicate, thisArg) { return this.all.filter(predicate, thisArg); }
-    reduce(callbackfn, initialValue) { return initialValue !== undefined ? this.all.reduce(callbackfn, initialValue) : this.all.reduce(callbackfn); }
-    reduceRight(callbackfn, initialValue) { return initialValue !== undefined ? this.all.reduceRight(callbackfn, initialValue) : this.all.reduceRight(callbackfn); }
-    find(predicate, thisArg) { return this.all.find(predicate, thisArg); }
-    findIndex(predicate, thisArg) { return this.all.findIndex(predicate, thisArg); }
+    includes(searchElement, fromIndex) { return this.impl.includes(searchElement, fromIndex); }
+    indexOf(searchElement, fromIndex) { return this.impl.indexOf(searchElement, fromIndex); }
+    lastIndexOf(searchElement, fromIndex) { return this.impl.lastIndexOf(searchElement, fromIndex); }
+    every(predicate, thisArg) { return this.impl.every(predicate, thisArg); }
+    some(predicate, thisArg) { return this.impl.some(predicate, thisArg); }
+    forEach(callbackfn, thisArg) { return this.impl.forEach(callbackfn, thisArg); }
+    map(callbackfn, thisArg) { return this.impl.map(callbackfn, thisArg); }
+    filter(predicate, thisArg) { return this.impl.filter(predicate, thisArg); }
+    reduce(callbackfn, initialValue) { return initialValue !== undefined ? this.impl.reduce(callbackfn, initialValue) : this.impl.reduce(callbackfn); }
+    reduceRight(callbackfn, initialValue) { return initialValue !== undefined ? this.impl.reduceRight(callbackfn, initialValue) : this.impl.reduceRight(callbackfn); }
+    find(predicate, thisArg) { return this.impl.find(predicate, thisArg); }
+    findIndex(predicate, thisArg) { return this.impl.findIndex(predicate, thisArg); }
     fill(value, start, end) { this.mutable.fill(value, start, end); return this; }
     copyWithin(target, start, end) { this.mutable.copyWithin(target, start, end); return this; }
-    [Symbol.iterator]() { return this.all[Symbol.iterator](); }
-    entries() { return this.all.entries(); }
-    keys() { return this.all.keys(); }
-    values() { return this.all.values(); }
+    [Symbol.iterator]() { return this.impl[Symbol.iterator](); }
+    entries() { return this.impl.entries(); }
+    keys() { return this.impl.keys(); }
+    values() { return this.impl.values(); }
     get mutable() {
-        const createCopy = this.all[Sealant.CreateCopy];
+        const createCopy = this.impl[Sealant.CreateCopy];
         if (createCopy)
-            return this.all = createCopy.call(this.all);
-        return this.all;
+            return this.impl = createCopy.call(this.impl);
+        return this.impl;
     }
 }
 export class TransactionalArray extends MvccArray {

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

@@ -1,7 +1,7 @@
 import { Collection, Item, CollectionReader } from '../util/Collection';
 import { ObservableObject } from './Mvcc';
 export declare abstract class ObservableCollection<T> extends ObservableObject implements CollectionReader<T> {
-    protected abstract a: Collection<T>;
+    protected abstract impl: Collection<T>;
     get strict(): boolean;
     get count(): number;
     get addedCount(): number;

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

@@ -1,23 +1,23 @@
 import { ObservableObject } from './Mvcc';
 export class ObservableCollection extends ObservableObject {
-    get strict() { return this.a.strict; }
-    get count() { return this.a.count; }
-    get addedCount() { return this.a.addedCount; }
-    get removedCount() { return this.a.removedCount; }
-    get isMergeInProgress() { return this.a.isMergeInProgress; }
-    lookup(key) { return this.a.lookup(key); }
-    claim(key) { return this.a.claim(key); }
-    add(self) { return this.a.add(self); }
-    remove(item) { return this.a.remove(item); }
-    move(item, after) { this.a.move(item, after); }
-    beginMerge() { this.a.beginMerge(); }
-    endMerge(error) { this.a.endMerge(error); }
-    resetAddedAndRemovedLists() { this.a.resetAddedAndRemovedLists(); }
-    items() { return this.a.items(); }
-    addedItems(reset) { return this.a.addedItems(reset); }
-    removedItems(reset) { return this.a.removedItems(reset); }
-    isAdded(item) { return this.a.isAdded(item); }
-    isMoved(item) { return this.a.isMoved(item); }
-    isRemoved(item) { return this.a.isRemoved(item); }
-    isCurrent(item) { return this.a.isCurrent(item); }
+    get strict() { return this.impl.strict; }
+    get count() { return this.impl.count; }
+    get addedCount() { return this.impl.addedCount; }
+    get removedCount() { return this.impl.removedCount; }
+    get isMergeInProgress() { return this.impl.isMergeInProgress; }
+    lookup(key) { return this.impl.lookup(key); }
+    claim(key) { return this.impl.claim(key); }
+    add(self) { return this.impl.add(self); }
+    remove(item) { return this.impl.remove(item); }
+    move(item, after) { this.impl.move(item, after); }
+    beginMerge() { this.impl.beginMerge(); }
+    endMerge(error) { this.impl.endMerge(error); }
+    resetAddedAndRemovedLists() { this.impl.resetAddedAndRemovedLists(); }
+    items() { return this.impl.items(); }
+    addedItems(reset) { return this.impl.addedItems(reset); }
+    removedItems(reset) { return this.impl.removedItems(reset); }
+    isAdded(item) { return this.impl.isAdded(item); }
+    isMoved(item) { return this.impl.isMoved(item); }
+    isRemoved(item) { return this.impl.isRemoved(item); }
+    isCurrent(item) { return this.impl.isCurrent(item); }
 }

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

@@ -1,6 +1,6 @@
 import { MvccObject } from './Mvcc';
 export declare class MvccMap<K, V> extends MvccObject {
-    private all;
+    private impl;
     constructor(isObservable: boolean, map: Map<K, V>);
     clear(): void;
     delete(key: K): boolean;

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

@@ -3,29 +3,29 @@ import { MvccObject } from './Mvcc';
 export class MvccMap extends MvccObject {
     constructor(isObservable, map) {
         super(isObservable);
-        this.all = map;
+        this.impl = map;
     }
     clear() { this.mutable.clear(); }
     delete(key) { return this.mutable.delete(key); }
-    forEach(callbackfn, thisArg) { this.all.forEach(callbackfn, thisArg); }
-    get(key) { return this.all.get(key); }
-    has(key) { return this.all.has(key); }
+    forEach(callbackfn, thisArg) { this.impl.forEach(callbackfn, thisArg); }
+    get(key) { return this.impl.get(key); }
+    has(key) { return this.impl.has(key); }
     set(key, value) { this.mutable.set(key, value); return this; }
-    get size() { return this.all.size; }
-    entries() { return this.all.entries(); }
-    keys() { return this.all.keys(); }
-    values() { return this.all.values(); }
-    [Symbol.toStringTag]() { return this.all[Symbol.toStringTag]; }
+    get size() { return this.impl.size; }
+    entries() { return this.impl.entries(); }
+    keys() { return this.impl.keys(); }
+    values() { return this.impl.values(); }
+    [Symbol.toStringTag]() { return this.impl[Symbol.toStringTag]; }
     get mutable() {
-        const createCopy = this.all[Sealant.CreateCopy];
+        const createCopy = this.impl[Sealant.CreateCopy];
         if (createCopy)
-            return this.all = createCopy.call(this.all);
-        return this.all;
+            return this.impl = createCopy.call(this.impl);
+        return this.impl;
     }
 }
 export class TransactionalMap extends MvccMap {
     constructor(args) {
-        super(true, args !== undefined ? new Map(args) : new Map());
+        super(false, args !== undefined ? new Map(args) : new Map());
     }
 }
 export class ObservableMap extends MvccMap {

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

@@ -34,8 +34,8 @@ export declare class OperationController extends Controller<any> {
 }
 declare class Operation extends Subscription implements Subscriber {
     static current?: Operation;
-    static queuedReactions: Array<Subscriber>;
-    static deferredReactions: Array<Operation>;
+    static queuedReactiveFunctions: Array<Subscriber>;
+    static deferredReactiveFunctions: Array<Operation>;
     readonly margin: number;
     readonly transaction: Transaction;
     readonly controller: OperationController;
@@ -61,7 +61,7 @@ declare class Operation extends Subscription implements Subscriber {
     dependencies(): string[];
     wrap<T>(func: F<T>): F<T>;
     run(proxy: any, args: any[] | undefined): void;
-    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactions: Subscriber[]): void;
+    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactive: Subscriber[]): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
     isNotUpToDate(): boolean;
     reenterOver(head: Operation): this;
@@ -71,16 +71,16 @@ declare class Operation extends Subscription implements Subscriber {
     private leave;
     private monitorEnter;
     private monitorLeave;
-    private addToDeferredReactions;
-    private static processDeferredReactions;
+    private addToDeferredReactiveFunctions;
+    private static processDeferredReactiveFunctions;
     private static markUsed;
     private static markEdited;
     private static isConflicting;
     private static propagateAllChangesThroughSubscriptions;
     private static revokeAllSubscriptions;
     private static propagateMemberChangeThroughSubscriptions;
-    private static enqueueReactionsToRun;
-    private static runQueuedReactionsLoop;
+    private static enqueueReactiveFunctionsToRun;
+    private static runQueuedReactiveLoop;
     private unsubscribeFromAllSubscriptions;
     private subscribeTo;
     private static canSubscribe;

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

@@ -36,9 +36,9 @@ export class OperationController extends Controller {
             && (!weak || op.cause === BOOT_CAUSE || !op.successor ||
                 op.successor.transaction.isFinished)) {
             const outerOpts = (_a = Operation.current) === null || _a === void 0 ? void 0 : _a.options;
-            const separation = weak || opts.separation !== false || opts.kind === Kind.Reaction ||
-                (opts.kind === Kind.Transaction && outerOpts && (outerOpts.noSideEffects || outerOpts.kind === Kind.Cache)) ||
-                (opts.kind === Kind.Cache && (oc.snapshot.changeset.sealed ||
+            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));
             const token = opts.noSideEffects ? this : undefined;
             const oc2 = this.run(oc, separation, opts, token, args);
@@ -105,7 +105,7 @@ export class OperationController extends Controller {
         const ctx = Changeset.current();
         const os = ctx.lookupObjectSnapshot(this.objectHandle, this.memberName);
         const op = this.acquireFromSnapshot(os, args);
-        const isValid = op.options.kind !== Kind.Transaction && op.cause !== BOOT_CAUSE &&
+        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;
@@ -181,7 +181,7 @@ export class OperationController extends Controller {
             }
             else {
                 oc = this.peek(argsx);
-                if (oc.operation.options.kind === Kind.Transaction || !oc.isUpToDate) {
+                if (oc.operation.options.kind === Kind.Transactional || !oc.isUpToDate) {
                     oc = this.edit();
                     if (Log.isOn && Log.opt.operation)
                         Log.write('║', '  𝑓', `${oc.operation.why()}`);
@@ -196,7 +196,7 @@ export class OperationController extends Controller {
     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.reactions);
+        oc.operation.markObsoleteDueTo(oc.operation, self.memberName, EMPTY_SNAPSHOT.changeset, EMPTY_HANDLE, BOOT_CAUSE, ctx.timestamp, ctx.reactive);
     }
 }
 class Operation extends Subscription {
@@ -233,7 +233,7 @@ class Operation extends Subscription {
         let cause;
         if (this.cause)
             cause = `   <<   ${this.cause}`;
-        else if (this.controller.options.kind === Kind.Transaction)
+        else if (this.controller.options.kind === Kind.Transactional)
             cause = '   <<   operation';
         else
             cause = `   <<   T${this.changeset.id}[${this.changeset.hint}]`;
@@ -269,25 +269,25 @@ class Operation extends Subscription {
         else
             this.result = Promise.reject(this.error);
     }
-    markObsoleteDueTo(subscription, m, changeset, h, outer, since, reactions) {
+    markObsoleteDueTo(subscription, m, changeset, h, outer, since, reactive) {
         var _a, _b, _c;
         if (this.subscriptions !== undefined) {
             const skip = !subscription.isOperation &&
                 changeset === this.changeset;
             if (!skip) {
                 const why = `${Dump.snapshot2(h, changeset, m, subscription)}    <<    ${outer}`;
-                const isReaction = this.options.kind === Kind.Reaction;
+                const isReactive = this.options.kind === Kind.Reactive;
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
                 if (Log.isOn && (Log.opt.obsolete || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.obsolete)))
-                    Log.write(Log.opt.transaction && !Changeset.current().sealed ? '║' : ' ', isReaction ? '█' : '▒', isReaction && changeset === EMPTY_SNAPSHOT.changeset
-                        ? `${this.hint()} is a reaction and will run automatically (order ${this.options.order})`
-                        : `${this.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, m)} since v${since}${isReaction ? ` and will run automatically (order ${this.options.order})` : ''}`);
+                    Log.write(Log.opt.transaction && !Changeset.current().sealed ? '║' : ' ', isReactive ? '█' : '▒', isReactive && changeset === EMPTY_SNAPSHOT.changeset
+                        ? `${this.hint()} is a reactive and will run automatically (order ${this.options.order})`
+                        : `${this.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, m)} since v${since}${isReactive ? ` and will run automatically (order ${this.options.order})` : ''}`);
                 this.unsubscribeFromAllSubscriptions();
-                if (isReaction)
-                    reactions.push(this);
+                if (isReactive)
+                    reactive.push(this);
                 else
-                    (_b = this.subscribers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.controller.memberName, this.changeset, this.controller.objectHandle, why, since, reactions));
+                    (_b = this.subscribers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.controller.memberName, this.changeset, this.controller.objectHandle, why, since, reactive));
                 const tran = this.transaction;
                 if (tran.changeset === changeset) {
                 }
@@ -308,15 +308,15 @@ class Operation extends Subscription {
                     const op = this.controller.useOrRun(false, undefined);
                     if (op.result instanceof Promise)
                         op.result.catch(error => {
-                            if (op.options.kind === Kind.Reaction)
-                                misuse(`reaction ${op.hint()} failed and will not run anymore: ${error}`, error);
+                            if (op.options.kind === Kind.Reactive)
+                                misuse(`reactive function ${op.hint()} failed and will not run anymore: ${error}`, error);
                         });
                 }
                 catch (e) {
                     if (!nothrow)
                         throw e;
-                    else if (this.options.kind === Kind.Reaction)
-                        misuse(`reaction ${this.hint()} failed and will not run anymore: ${e}`, e);
+                    else if (this.options.kind === Kind.Reactive)
+                        misuse(`reactive ${this.hint()} failed and will not run anymore: ${e}`, e);
                 }
             }
         }
@@ -324,11 +324,11 @@ class Operation extends Subscription {
             if (hold > 0)
                 setTimeout(() => this.runIfNotUpToDate(true, true), hold);
             else
-                this.addToDeferredReactions();
+                this.addToDeferredReactiveFunctions();
         }
     }
     isNotUpToDate() {
-        return !this.error && (this.options.kind === Kind.Transaction ||
+        return !this.error && (this.options.kind === Kind.Transactional ||
             !this.successor || this.successor.transaction.isCanceled);
     }
     reenterOver(head) {
@@ -437,28 +437,28 @@ class Operation extends Subscription {
             this.transaction.whenFinished().then(leave, leave);
         });
     }
-    addToDeferredReactions() {
-        Operation.deferredReactions.push(this);
-        if (Operation.deferredReactions.length === 1)
-            setTimeout(Operation.processDeferredReactions, 0);
+    addToDeferredReactiveFunctions() {
+        Operation.deferredReactiveFunctions.push(this);
+        if (Operation.deferredReactiveFunctions.length === 1)
+            setTimeout(Operation.processDeferredReactiveFunctions, 0);
     }
-    static processDeferredReactions() {
-        const reactions = Operation.deferredReactions;
-        Operation.deferredReactions = [];
-        for (const x of reactions)
+    static processDeferredReactiveFunctions() {
+        const deferred = Operation.deferredReactiveFunctions;
+        Operation.deferredReactiveFunctions = [];
+        for (const x of deferred)
             x.runIfNotUpToDate(true, true);
     }
     static markUsed(subscription, os, m, h, kind, weak) {
-        if (kind !== Kind.Transaction) {
+        if (kind !== Kind.Transactional) {
             const op = Operation.current;
-            if (op && op.options.kind !== Kind.Transaction &&
+            if (op && op.options.kind !== Kind.Transactional &&
                 op.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(subscription, os, m, h, t))
-                    op.markObsoleteDueTo(subscription, m, os.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.reactions);
+                    op.markObsoleteDueTo(subscription, m, os.changeset, h, BOOT_CAUSE, ctx.timestamp, ctx.reactive);
             }
         }
     }
@@ -476,16 +476,16 @@ class Operation extends Subscription {
     static propagateAllChangesThroughSubscriptions(changeset) {
         var _a;
         const since = changeset.timestamp;
-        const reactions = changeset.reactions;
+        const reactive = changeset.reactive;
         changeset.items.forEach((os, h) => {
-            Operation.propagateMemberChangeThroughSubscriptions(false, since, os, Meta.Revision, h, reactions);
+            Operation.propagateMemberChangeThroughSubscriptions(false, since, os, Meta.Revision, h, reactive);
             if (!os.disposed)
-                os.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(false, since, os, m, h, reactions));
+                os.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(false, since, os, m, h, reactive));
             else
                 for (const m in os.former.snapshot.data)
-                    Operation.propagateMemberChangeThroughSubscriptions(true, since, os, m, h, reactions);
+                    Operation.propagateMemberChangeThroughSubscriptions(true, since, os, m, h, reactive);
         });
-        reactions.sort(compareReactionsByOrder);
+        reactive.sort(compareReactiveFunctionsByOrder);
         (_a = changeset.options.journal) === null || _a === void 0 ? void 0 : _a.edited(JournalImpl.buildPatch(changeset.hint, changeset.items));
     }
     static revokeAllSubscriptions(changeset) {
@@ -494,10 +494,10 @@ class Operation extends Subscription {
             os.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(true, changeset.timestamp, os, m, h, undefined));
         });
     }
-    static propagateMemberChangeThroughSubscriptions(unsubscribe, timestamp, os, m, h, reactions) {
+    static propagateMemberChangeThroughSubscriptions(unsubscribe, timestamp, os, m, h, reactive) {
         var _a;
         const curr = os.data[m];
-        if (reactions) {
+        if (reactive) {
             const former = os.former.snapshot.data[m];
             if (former !== undefined && former instanceof Subscription) {
                 const why = `T${os.changeset.id}[${os.changeset.hint}]`;
@@ -515,7 +515,7 @@ class Operation extends Subscription {
                     else
                         former.successor = undefined;
                 }
-                (_a = former.subscribers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, m, os.changeset, h, why, timestamp, reactions));
+                (_a = former.subscribers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, m, os.changeset, h, why, timestamp, reactive));
             }
         }
         if (curr instanceof Operation) {
@@ -533,23 +533,23 @@ class Operation extends Subscription {
         else if (curr instanceof Subscription && curr.subscribers) {
         }
     }
-    static enqueueReactionsToRun(reactions) {
-        const queue = Operation.queuedReactions;
-        const isReactionLoopRequired = queue.length === 0;
-        for (const r of reactions)
+    static enqueueReactiveFunctionsToRun(reactive) {
+        const queue = Operation.queuedReactiveFunctions;
+        const isReactiveLoopRequired = queue.length === 0;
+        for (const r of reactive)
             queue.push(r);
-        if (isReactionLoopRequired)
-            OperationController.runWithin(undefined, Operation.runQueuedReactionsLoop);
+        if (isReactiveLoopRequired)
+            OperationController.runWithin(undefined, Operation.runQueuedReactiveLoop);
     }
-    static runQueuedReactionsLoop() {
-        const queue = Operation.queuedReactions;
+    static runQueuedReactiveLoop() {
+        const queue = Operation.queuedReactiveFunctions;
         let i = 0;
         while (i < queue.length) {
-            const reaction = queue[i];
-            reaction.runIfNotUpToDate(false, true);
+            const reactive = queue[i];
+            reactive.runIfNotUpToDate(false, true);
             i++;
         }
-        Operation.queuedReactions = [];
+        Operation.queuedReactiveFunctions = [];
     }
     unsubscribeFromAllSubscriptions() {
         var _a;
@@ -608,13 +608,13 @@ class Operation extends Subscription {
         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.Reaction && op.options.throttling < Number.MAX_SAFE_INTEGER) {
-            const reactions = Meta.acquire(proto, Meta.Reactions);
-            reactions[m] = op;
+        if (op.options.kind === Kind.Reactive && op.options.throttling < Number.MAX_SAFE_INTEGER) {
+            const reactive = Meta.acquire(proto, Meta.Reactive);
+            reactive[m] = op;
         }
-        else if (op.options.kind === Kind.Reaction && op.options.throttling >= Number.MAX_SAFE_INTEGER) {
-            const reactions = Meta.getFrom(proto, Meta.Reactions);
-            delete reactions[m];
+        else if (op.options.kind === Kind.Reactive && op.options.throttling >= Number.MAX_SAFE_INTEGER) {
+            const reactive = Meta.getFrom(proto, Meta.Reactive);
+            delete reactive[m];
         }
         return op.options;
     }
@@ -627,7 +627,7 @@ class Operation extends Subscription {
         Changeset.isConflicting = Operation.isConflicting;
         Changeset.propagateAllChangesThroughSubscriptions = Operation.propagateAllChangesThroughSubscriptions;
         Changeset.revokeAllSubscriptions = Operation.revokeAllSubscriptions;
-        Changeset.enqueueReactionsToRun = Operation.enqueueReactionsToRun;
+        Changeset.enqueueReactiveFunctionsToRun = Operation.enqueueReactiveFunctionsToRun;
         Mvcc.createOperation = Operation.createOperation;
         Mvcc.rememberOperationOptions = Operation.rememberOperationOptions;
         Promise.prototype.then = reactronicHookedThen;
@@ -654,8 +654,8 @@ class Operation extends Subscription {
     }
 }
 Operation.current = undefined;
-Operation.queuedReactions = [];
-Operation.deferredReactions = [];
+Operation.queuedReactiveFunctions = [];
+Operation.deferredReactiveFunctions = [];
 function valueHint(value, m) {
     let result = '';
     if (Array.isArray(value))
@@ -704,7 +704,7 @@ function reactronicHookedThen(resolve, reject) {
     }
     return ORIGINAL_PROMISE_THEN.call(this, resolve, reject);
 }
-function compareReactionsByOrder(a, b) {
+function compareReactiveFunctionsByOrder(a, b) {
     return a.order - b.order;
 }
 export function resolveReturn(value) {

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

@@ -224,9 +224,9 @@ class TransactionImpl extends Transaction {
         finally {
             this.pending--;
             if (this.sealed && this.pending === 0) {
-                const reactions = this.applyOrDiscard();
+                const reactive = this.applyOrDiscard();
                 TransactionImpl.curr = outer;
-                TransactionImpl.outside(Changeset.enqueueReactionsToRun, reactions);
+                TransactionImpl.outside(Changeset.enqueueReactiveFunctionsToRun, reactive);
             }
             else
                 TransactionImpl.curr = outer;
@@ -255,11 +255,11 @@ class TransactionImpl extends Transaction {
         throw error(`T${this.id}[${this.hint}] conflicts with: ${Dump.conflicts(conflicts)}`, undefined);
     }
     applyOrDiscard() {
-        let reactions;
+        let reactive;
         try {
             if (Log.isOn && Log.opt.change)
                 Log.write('╠═', '', '', undefined, 'changes');
-            reactions = this.changeset.applyOrDiscard(this.canceled);
+            reactive = this.changeset.applyOrDiscard(this.canceled);
             this.changeset.triggerGarbageCollection();
             if (this.promise) {
                 if (this.canceled && !this.after)
@@ -274,7 +274,7 @@ class TransactionImpl extends Transaction {
             fatal(e);
             throw e;
         }
-        return reactions;
+        return reactive;
     }
     acquirePromise() {
         if (!this.promise) {

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "reactronic",
-  "version": "0.22.320",
+  "version": "0.22.410",
   "description": "Reactronic - Transactional Reactive State Management",
+  "icon": "reactronic.png",
   "type": "module",
   "main": "build/dist/source/api.js",
   "types": "build/dist/source/api.d.ts",