reactronic 0.91.25002 → 0.92.25003

package/README.md

@@ -17,18 +17,18 @@ Transactional reactivity means that state changes are being made in an
 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**
+way. Reactronic **takes full care of tracking dependencies**
 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);
-  - **Transactional Function** - makes changes in observable
+  - **Applying Function** - it makes changes in observable
     objects in atomic way ("all or nothing");
-  - **Reactive Function** - is executed automatically in
+  - **Reaction Function** - it is executed automatically in
     response to changes made by a transaction;
-  - **Cached Function** - its result is remembered and, if the becomes
+  - **Cache Function** - its result is remembered and, if the becomes
   obsolete, recomputed on-demand.
 
 Demo application built with Reactronic: https://nevod.io/#/playground.
@@ -45,13 +45,13 @@ class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @transactional
+  @apply
   saveContact(name: string, email: string): void {
     this.name = name
     this.email = email
   }
 
-  @reactive
+  @reaction
   printContact(): void {
     // depends on `name` and `email` and reacts to their changes
     if (this.email.indexOf('@') >= 0)
@@ -61,23 +61,27 @@ class Demo extends ObservableObject {
 }
 ```
 
-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` function.
+In the example above, `Demo` is an observable object,
+meaning that access to its fields are seamlessly tracked
+to determine dependent reactions and caches. Reaction
+function `printContact` reads `name` and `email` fields,
+thus depends on them. It is executed automatically in
+response to changes of these fields made by the applying
+function `saveContact`.
 
-Here is an example of cached value (re-)computed on-demand:
+Here is an example of a cached value (re-)computed on-demand:
 
 ``` typescript
 class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @cached
+  @cache
   get contact(): string {
     return this.name + ' <' + this.email + '>'
   }
 
-  @reactive
+  @reaction
   printContact(): void {
     if (this.contact !== '')
       Console.log(this.contact)
@@ -90,7 +94,7 @@ 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
+reaction function `printContact`. When `printContact` function
 runs it reads `contact` and causes its re-computation.
 
 ## Observable Objects
@@ -111,17 +115,19 @@ In the example above, the class `MyModel` is based on Reactronic's
 `ObservableObject` class and all its properties `url`, `content`,
 and `timestamp` are hooked.
 
-## Transactional Functions
+## Apply
 
-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
+Applying function makes changes in observable objects
+in transactional (atomic) way, thus provoking execution
+of dependent reactions and recalculation of dependent
+caches. Applying function is instrumented with hooks to
+provide transparent atomicity (by implicit context
 switching and isolation).
 
 ``` typescript
 class MyModel extends ObservableObject {
   // ...
-  @transactional
+  @apply
   async load(url: string): Promise<void> {
     this.url = url
     this.content = await fetch(url)
@@ -130,9 +136,9 @@ class MyModel extends ObservableObject {
 }
 ```
 
-In the example above, the transactional function `load` makes
+In the example above, the applying function `load` makes
 changes to `url`, `content` and `timestamp` properties. While
-transaction is running, the changes are visible only inside the
+applying transaction is running, the changes are visible only inside the
 transaction itself. The new values become atomically visible outside
 of the transaction only upon its completion.
 
@@ -159,21 +165,21 @@ 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.
 
-## Reactive & Cached Functions
+## Reaction & Cache
 
-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
+Reaction function is automatically and immediately called in
+response to changes in observable objects made by an applying function.
+Cache function is called on-demand to renew the value if it was
+marked as obsolete due to changes made by an applying function.
+Reaction and cache functions are instrumented with hooks
 to seamlessly subscribe to those observable objects and
-other cached functions (dependencies), which are used
+other cache functions (dependencies), which are used
 during their execution.
 
 ``` tsx
 class MyView extends Component<{model: MyModel}> {
-  @cached
-  render(): JSX.Element {
+  @cache
+  render(): React.JSX.Element {
     return (
       <div>
         <h1>{this.props.model.url}</h1>
@@ -186,12 +192,12 @@ class MyView extends Component<{model: MyModel}> {
 
 ``` tsx
 class Component<P> extends React.Component<P> {
-  @cached
-  render(): JSX.Element {
+  @cache
+  render(): React.JSX.Element {
     throw new Error('render method is undefined')
   }
 
-  @reactive // called immediately in response to changes
+  @reaction // called immediately in response to changes
   ensureUpToDate(): void {
     if (this.shouldComponentUpdate())
       Transaction.outside(() => this.setState({})) // ask React to re-render
@@ -206,29 +212,29 @@ class Component<P> extends React.Component<P> {
   }
 
   componentWillUnmount(): void {
-    Transaction.run(null, RxSystem.dispose, this)
+    apply(RxSystem.dispose, this)
   }
 }
 ```
 
-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
+In the example above, reaction function `refresh` is transparently subscribed
+to the cache function `render`. In turn, cache function `render` is
+subscribed to the properties `url` and `content` of a corresponding
 `MyModel` object. Once `url` or `content` values are changed, the
-`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` cache becomes obsolete and causes the reaction function `refresh` to become
+obsolete as well and re-executed. While being executed, the reaction function `refresh`
+enqueues re-rendering request to React, which calls
 `render` function causing it to renew its cached value.
 
-In general case, all reactive and cached functions are automatically and
+In general case, all reactions and caches are automatically and
 immediately marked as obsolete when changes are made in those observable
 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).
+either immediately (for reaction functions) or on-demand
+(for cache functions).
 
 Reactronic takes full care of tracking dependencies between
-all the observable objects and reactive/cached functions.
+all the observable objects and reaction/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
@@ -238,20 +244,20 @@ to a new one.
 
 There are multiple options to configure behavior of transactional reactivity.
 
-**Order** options defines order of execution for reactive functions:
+**Order** options defines order of execution for reactions:
 
   - (TBD)
 
-**Throttling** option defines how often reactive function is executed in case
+**Throttling** option defines how often reaction is executed in case
 of recurring changes:
 
   - `(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).
+  - `>= Number.MAX_SAFE_INTEGER` - never execute (suspended reaction).
 
-**Reentrance** option defines how to handle reentrant calls of transactional
-and reactive functions:
+**Reentrance** option defines how to handle reentrant calls of applying
+and reaction 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;
@@ -297,13 +303,14 @@ class ObservableObject { }
 
 // Decorators & Operators
 
-function raw(proto, prop) // field only
-function transaction(proto, prop, pd) // method only
-function reactive(proto, prop, pd) // method only
-function cached(proto, prop, pd) // method only
+function observable(proto, prop) // field only
+function unobservable(proto, prop) // field only
+function apply(proto, prop, pd) // method only
+function reaction(proto, prop, pd) // method only
+function cache(proto, prop, pd) // method only
 function options(value: Partial<MemberOptions>): F<any>
 
-function unobs<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, Indicator, LoggingOptions, ProfilingOptions
@@ -331,9 +338,9 @@ type MemberOptions = {
 
 enum Kind {
   plain = 0,
-  transactional = 1,
-  reactive = 2,
-  cached = 3
+  transaction = 1,
+  reaction = 2,
+  cache = 3
 }
 
 enum Reentrance {
@@ -414,24 +421,24 @@ class Transaction implements Worker {
   static isCanceled: boolean
 }
 
-// Controller
+// Operation
 
-abstract class Controller<T> {
+abstract class Operation<T> {
   readonly options: Options
   readonly args: ReadonlyArray<any>
   readonly value: T
   readonly error: any
   readonly stamp: number
-  readonly isUpToDate: boolean
+  readonly isReusable: boolean
 
   configure(options: Partial<Options>): Options
   markObsolete(): boolean
   pullLastResult(args?: any[]): T | undefined
 }
 
-// Reactronic
+// ReactiveSystem
 
-class Reactronic {
+class ReactiveSystem {
   static why(short: boolean = false): string
   static getMethodCache<T>(method: F<T>): Cache<T>
   static configureCurrentOperation(options: Partial<Options>): Options

package/build/dist/source/Clock.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { ObservableObject } from "./core/Mvcc.js";
-import { transactional } from "./ReactiveSystem.js";
+import { apply } from "./ReactiveSystem.js";
 export class Clock extends ObservableObject {
     constructor(interval = 1000) {
         super();
@@ -40,13 +40,13 @@ export class Clock extends ObservableObject {
     }
 }
 __decorate([
-    transactional,
+    apply,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Boolean]),
     __metadata("design:returntype", void 0)
 ], Clock.prototype, "pause", null);
 __decorate([
-    transactional,
+    apply,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)

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

@@ -25,9 +25,9 @@ export type MemberOptions = {
 };
 export declare enum Kind {
     plain = 0,
-    transactional = 1,
-    reactive = 2,
-    cached = 3
+    apply = 1,
+    reaction = 2,
+    cache = 3
 }
 export declare enum Reentrance {
     preventWithError = 1,

package/build/dist/source/Options.js

@@ -2,9 +2,9 @@ export { LoggingLevel } from "./Logging.js";
 export var Kind;
 (function (Kind) {
     Kind[Kind["plain"] = 0] = "plain";
-    Kind[Kind["transactional"] = 1] = "transactional";
-    Kind[Kind["reactive"] = 2] = "reactive";
-    Kind[Kind["cached"] = 3] = "cached";
+    Kind[Kind["apply"] = 1] = "apply";
+    Kind[Kind["reaction"] = 2] = "reaction";
+    Kind[Kind["cache"] = 3] = "cache";
 })(Kind || (Kind = {}));
 export var Reentrance;
 (function (Reentrance) {

package/build/dist/source/Reaction.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { ObservableObject } from "./core/Mvcc.js";
-import { reactive } from "./ReactiveSystem.js";
+import { reaction } from "./ReactiveSystem.js";
 export class Reaction extends ObservableObject {
     constructor(action) {
         super();
@@ -19,7 +19,7 @@ export class Reaction extends ObservableObject {
     }
 }
 __decorate([
-    reactive,
+    reaction,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)

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

@@ -1,5 +1,5 @@
 import { F } from "./util/Utils.js";
-import { Operation, MemberOptions, LoggingOptions, ProfilingOptions } from "./Options.js";
+import { Operation, MemberOptions, LoggingOptions, ProfilingOptions, SnapshotOptions } from "./Options.js";
 export declare class ReactiveSystem {
     static why(brief?: boolean): string;
     static getOperation<T>(method: F<T>): Operation<T>;
@@ -18,12 +18,14 @@ export declare class ReactiveSystem {
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
 }
 export declare function transaction<T>(action: F<T>, ...args: any[]): T;
-export declare function unobs<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 contextually<T>(p: Promise<T>): Promise<T>;
-export declare function raw(proto: object, prop: PropertyKey): any;
-export declare function obs(proto: object, prop: PropertyKey): 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 apply<T>(func: F<T>, ...args: any[]): T;
+export declare function apply<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
+export declare function apply(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function unobservable(proto: object, prop: PropertyKey): any;
+export declare function observable(proto: object, prop: PropertyKey): any;
+export declare function reaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function cache(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function options(value: Partial<MemberOptions>): F<any>;

package/build/dist/source/ReactiveSystem.js

@@ -25,7 +25,7 @@ export class ReactiveSystem {
 export function transaction(action, ...args) {
     return Transaction.run(null, action, ...args);
 }
-export function unobs(func, ...args) {
+export function nonreactive(func, ...args) {
     return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
 }
 export function sensitive(sensitivity, func, ...args) {
@@ -34,34 +34,48 @@ export function sensitive(sensitivity, func, ...args) {
 export function contextually(p) {
     throw new Error("not implemented yet");
 }
-export function raw(proto, prop) {
+export function apply(p1, p2, p3) {
+    if (p1 instanceof Function) {
+        if (p2 !== undefined)
+            return Transaction.run(null, p1, ...p2);
+        else
+            return Transaction.run(null, p1);
+    }
+    else if (p2 instanceof Function) {
+        if (p3 !== undefined)
+            return Transaction.run(p1, p2, ...p3);
+        else
+            return Transaction.run(p1, p2);
+    }
+    else {
+        const opts = {
+            kind: Kind.apply,
+            isolation: Isolation.joinToCurrentTransaction,
+        };
+        return Mvcc.decorateOperation(true, apply, opts, p1, p2, p3);
+    }
+}
+export function unobservable(proto, prop) {
     return Mvcc.decorateData(false, proto, prop);
 }
-export function obs(proto, prop) {
+export function observable(proto, prop) {
     return Mvcc.decorateData(true, proto, prop);
 }
-export function transactional(proto, prop, pd) {
-    const opts = {
-        kind: Kind.transactional,
-        isolation: Isolation.joinToCurrentTransaction,
-    };
-    return Mvcc.decorateOperation(true, transactional, opts, proto, prop, pd);
-}
-export function reactive(proto, prop, pd) {
+export function reaction(proto, prop, pd) {
     const opts = {
-        kind: Kind.reactive,
+        kind: Kind.reaction,
         isolation: Isolation.joinAsNestedTransaction,
         throttling: -1,
     };
-    return Mvcc.decorateOperation(true, reactive, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, reaction, opts, proto, prop, pd);
 }
-export function cached(proto, prop, pd) {
+export function cache(proto, prop, pd) {
     const opts = {
-        kind: Kind.cached,
+        kind: Kind.cache,
         isolation: Isolation.joinToCurrentTransaction,
         noSideEffects: true,
     };
-    return Mvcc.decorateOperation(true, cached, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, cache, opts, proto, prop, pd);
 }
 export function options(value) {
     return Mvcc.decorateOperationParametrized(options, value);

package/build/dist/source/Ref.js

@@ -1,5 +1,4 @@
-import { Transaction } from "./core/Transaction.js";
-import { unobs } from "./ReactiveSystem.js";
+import { apply, nonreactive } from "./ReactiveSystem.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }
@@ -29,7 +28,7 @@ export class Ref {
             this.owner[this.name][this.index] = value;
     }
     unobs() {
-        return unobs(() => this.variable);
+        return nonreactive(() => this.variable);
     }
     observe() {
         return this.variable;
@@ -53,7 +52,7 @@ export class ToggleRef extends Ref {
     toggle() {
         const o = this.owner;
         const p = this.name;
-        Transaction.run({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
+        apply({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
             const v = o[p];
             const isOn = v === this.valueOn || (v instanceof Ref && this.valueOn instanceof Ref &&
                 Ref.sameRefs(v, this.valueOn));

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

@@ -16,7 +16,7 @@ export { Changeset } from "./core/Changeset.js";
 export { Transaction } from "./core/Transaction.js";
 export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
-export { ReactiveSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, contextually, options } from "./ReactiveSystem.js";
+export { ReactiveSystem, observable, unobservable, apply, reaction, cache, transaction, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
 export { Reaction } from "./Reaction.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export type { Script, ScriptAsync, Handler, ReactiveNodeDecl, ReactiveNodeDriver, ReactiveNodeContext } from "./core/ReactiveNode.js";

package/build/dist/source/api.js

@@ -12,7 +12,7 @@ export { Changeset } from "./core/Changeset.js";
 export { Transaction } from "./core/Transaction.js";
 export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
-export { ReactiveSystem, raw, obs, transactional, reactive, cached, transaction, unobs, sensitive, contextually, options } from "./ReactiveSystem.js";
+export { ReactiveSystem, observable, unobservable, apply, reaction, cache, transaction, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
 export { Reaction } from "./Reaction.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export { Clock } from "./Clock.js";

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

@@ -8,7 +8,7 @@ export declare class OperationImpl implements Operation<any> {
     readonly fieldKey: FieldKey;
     configure(options: Partial<MemberOptions>): MemberOptions;
     get options(): MemberOptions;
-    get unobs(): any;
+    get nonreactive(): any;
     get args(): ReadonlyArray<any>;
     get result(): any;
     get error(): boolean;

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

@@ -12,7 +12,7 @@ const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.observable, EMP
 export class OperationImpl {
     configure(options) { return OperationImpl.configureImpl(this, options); }
     get options() { return this.peek(undefined).launch.options; }
-    get unobs() { return this.peek(undefined).launch.content; }
+    get nonreactive() { return this.peek(undefined).launch.content; }
     get args() { return this.use().launch.args; }
     get result() { return this.reuseOrRelaunch(true, undefined).content; }
     get error() { return this.use().launch.error; }
@@ -99,7 +99,7 @@ export class OperationImpl {
         const ov = ctx.lookupObjectVersion(this.ownerHandle, this.fieldKey, false);
         const launch = this.acquireFromObjectVersion(ov, args);
         const applied = this.ownerHandle.applied.data[this.fieldKey];
-        const isReusable = launch.options.kind !== Kind.transactional && launch.cause !== BOOT_CAUSE &&
+        const isReusable = launch.options.kind !== Kind.apply && launch.cause !== BOOT_CAUSE &&
             (ctx === launch.changeset || ctx.timestamp < launch.obsoleteSince || applied.obsoleteDueTo === undefined) &&
             (!launch.options.triggeringArgs || args === undefined ||
                 launch.args.length === args.length && launch.args.every((t, i) => t === args[i])) || ov.disposed;
@@ -175,7 +175,7 @@ export class OperationImpl {
             }
             else {
                 ror = this.peek(argsx);
-                if (ror.launch.options.kind === Kind.transactional || !ror.isReusable) {
+                if (ror.launch.options.kind === Kind.apply || !ror.isReusable) {
                     ror = this.edit();
                     if (Log.isOn && Log.opt.operation)
                         Log.write("║", "  o", `${ror.launch.why()}`);
@@ -251,7 +251,7 @@ class Launch extends FieldVersion {
         let cause;
         if (this.cause)
             cause = `   ◀◀   ${this.cause}`;
-        else if (this.operation.options.kind === Kind.transactional)
+        else if (this.operation.options.kind === Kind.apply)
             cause = "   ◀◀   operation";
         else
             cause = `   ◀◀   T${this.changeset.id}[${this.changeset.hint}]`;
@@ -294,7 +294,7 @@ class Launch extends FieldVersion {
                 changeset.id === this.lastEditorChangesetId;
             if (!skip) {
                 const why = `${Dump.snapshot2(h, changeset, fk, observable)}    ◀◀    ${outer}`;
-                const isReactive = this.options.kind === Kind.reactive;
+                const isReactive = this.options.kind === Kind.reaction;
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
                 if (Log.isOn && (Log.opt.obsolete || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.obsolete)))
@@ -326,14 +326,14 @@ class Launch extends FieldVersion {
                     const launch = this.operation.reuseOrRelaunch(false, undefined);
                     if (launch.result instanceof Promise)
                         launch.result.catch(error => {
-                            if (launch.options.kind === Kind.reactive)
+                            if (launch.options.kind === Kind.reaction)
                                 misuse(`reactive function ${launch.hint()} failed and will not run anymore: ${error}`, error);
                         });
                 }
                 catch (e) {
                     if (!nothrow)
                         throw e;
-                    else if (this.options.kind === Kind.reactive)
+                    else if (this.options.kind === Kind.reaction)
                         misuse(`reactive ${this.hint()} failed and will not run anymore: ${e}`, e);
                 }
             }
@@ -346,7 +346,7 @@ class Launch extends FieldVersion {
         }
     }
     isNotUpToDate() {
-        return !this.error && (this.options.kind === Kind.transactional ||
+        return !this.error && (this.options.kind === Kind.apply ||
             !this.successor || this.successor.transaction.isCanceled);
     }
     reenterOver(head) {
@@ -469,9 +469,9 @@ class Launch extends FieldVersion {
             x.relaunchIfNotUpToDate(true, true);
     }
     static markUsed(observable, ov, fk, h, kind, weak) {
-        if (kind !== Kind.transactional) {
+        if (kind !== Kind.apply) {
             const launch = Launch.current;
-            if (launch && launch.options.kind !== Kind.transactional &&
+            if (launch && launch.options.kind !== Kind.apply &&
                 launch.transaction === Transaction.current && fk !== Meta.Handle) {
                 const ctx = Changeset.current();
                 if (ctx !== ov.changeset)
@@ -652,11 +652,11 @@ class Launch extends FieldVersion {
         const rx = launch ? launch.operation : new OperationImpl(EMPTY_HANDLE, fk);
         const opts = launch ? launch.options : OptionsImpl.INITIAL;
         initial[fk] = launch = new Launch(Transaction.current, rx, EMPTY_OBJECT_VERSION.changeset, new OptionsImpl(getter, setter, opts, options, implicit), false);
-        if (launch.options.kind === Kind.reactive && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
+        if (launch.options.kind === Kind.reaction && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.acquire(proto, Meta.Reactive);
             reactive[fk] = launch;
         }
-        else if (launch.options.kind === Kind.reactive && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
+        else if (launch.options.kind === Kind.reaction && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.getFrom(proto, Meta.Reactive);
             delete reactive[fk];
         }

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

@@ -22,7 +22,7 @@ import { emitLetters, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js
 import { Isolation, Reentrance } from "../Options.js";
 import { ObservableObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
-import { ReactiveSystem, options, raw, reactive, unobs } from "../ReactiveSystem.js";
+import { ReactiveSystem, options, unobservable, reaction, nonreactive, apply } from "../ReactiveSystem.js";
 export var Mode;
 (function (Mode) {
     Mode[Mode["default"] = 0] = "default";
@@ -259,11 +259,11 @@ class ReactiveNodeContextImpl extends ObservableObject {
     }
 }
 __decorate([
-    raw,
+    unobservable,
     __metadata("design:type", Object)
 ], ReactiveNodeContextImpl.prototype, "next", void 0);
 __decorate([
-    raw,
+    unobservable,
     __metadata("design:type", ReactiveNodeVariable)
 ], ReactiveNodeContextImpl.prototype, "variable", void 0);
 class ReactiveNodeImpl extends ReactiveNode {
@@ -333,13 +333,13 @@ class ReactiveNodeImpl extends ReactiveNode {
     static setNodeVariableValue(variable, value) {
         const node = ReactiveNodeImpl.ownSlot.instance;
         const owner = node.owner;
-        const hostCtx = unobs(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
+        const hostCtx = nonreactive(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
             if (hostCtx)
                 node.outer = owner;
             else
                 node.outer = owner.outer;
-            Transaction.run({ isolation: Isolation.joinAsNestedTransaction }, () => {
+            apply({ isolation: Isolation.joinAsNestedTransaction }, () => {
                 const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
@@ -359,7 +359,7 @@ ReactiveNodeImpl.logging = undefined;
 ReactiveNodeImpl.grandNodeCount = 0;
 ReactiveNodeImpl.disposableNodeCount = 0;
 __decorate([
-    reactive,
+    reaction,
     options({
         reentrance: Reentrance.cancelAndWaitPrevious,
         allowObsoleteToFinish: true,
@@ -484,7 +484,7 @@ function triggerUpdateViaSlot(slot) {
                     });
                 });
             }
-            unobs(node.update, node.declaration.triggers);
+            nonreactive(node.update, node.declaration.triggers);
         }
         else
             updateNow(slot);
@@ -493,7 +493,7 @@ function triggerUpdateViaSlot(slot) {
 function mountOrRemountIfNecessary(node) {
     const driver = node.driver;
     if (node.stamp === Number.MAX_SAFE_INTEGER) {
-        unobs(() => {
+        nonreactive(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
             driver.runPreparation(node);
             if (!node.has(Mode.manualMount)) {
@@ -504,7 +504,7 @@ function mountOrRemountIfNecessary(node) {
         });
     }
     else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
-        unobs(() => driver.runMount(node));
+        nonreactive(() => driver.runMount(node));
 }
 function updateNow(slot) {
     const node = slot.instance;
@@ -537,7 +537,7 @@ function triggerFinalization(slot, isLeader, individual) {
         if (individual && node.key !== node.declaration.key && !driver.isPartition)
             console.log(`WARNING: it is recommended to assign explicit key for conditional element in order to avoid unexpected side effects: ${node.key}`);
         node.stamp = ~node.stamp;
-        const childrenAreLeaders = unobs(() => driver.runFinalization(node, isLeader));
+        const childrenAreLeaders = nonreactive(() => driver.runFinalization(node, isLeader));
         if (node.has(Mode.autonomous)) {
             slot.aux = undefined;
             const last = gLastToDispose;
@@ -546,7 +546,7 @@ function triggerFinalization(slot, isLeader, individual) {
             else
                 gFirstToDispose = gLastToDispose = slot;
             if (gFirstToDispose === slot)
-                Transaction.run({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
+                apply({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }

package/build/dist/source/util/MergeList.d.ts

@@ -6,13 +6,6 @@ export type MergeListReader<T> = {
     readonly removedCount: number;
     readonly isMergeInProgress: boolean;
     lookup(key: string): MergedItem<T> | undefined;
-    tryMergeAsExisting(key: string): MergedItem<T> | undefined;
-    mergeAsAdded(instance: T): MergedItem<T>;
-    mergeAsRemoved(item: MergedItem<T>): void;
-    move(item: MergedItem<T>, after: MergedItem<T>): void;
-    beginMerge(): void;
-    endMerge(error?: unknown): void;
-    resetAddedAndRemovedLists(): void;
     firstMergedItem(): MergedItem<T> | undefined;
     lastMergedItem(): MergedItem<T> | undefined;
     items(onlyAfter?: MergedItem<T>): Generator<MergedItem<T>>;

package/package.json

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