reactronic 0.92.25004 → 0.92.25006

package/README.md

@@ -24,12 +24,12 @@ Transactional reactivity is based on four fundamental concepts:
 
   - **Observable Objects** - a set of objects that store data of an
     application (state);
-  - **Applying Function** - it makes changes in observable
+  - **Atomic Action** - a function that makes changes in observable
     objects in atomic way ("all or nothing");
-  - **Reaction Function** - it is executed automatically in
+  - **Reactive Process** - a function that is executed automatically in
     response to changes made by a transaction;
-  - **Cache Function** - its result is remembered and, if the becomes
-  obsolete, recomputed on-demand.
+  - **Cached Result** -  function result that is remembered and, if the becomes
+  obsolete, causes its function to re-execute 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.
@@ -45,13 +45,13 @@ class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @apply
+  @atomicAction
   saveContact(name: string, email: string): void {
     this.name = name
     this.email = email
   }
 
-  @reaction
+  @reactiveProcess
   printContact(): void {
     // depends on `name` and `email` and reacts to their changes
     if (this.email.indexOf('@') >= 0)
@@ -63,25 +63,26 @@ class Demo extends ObservableObject {
 
 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`.
+to determine dependent reactive processes and cached
+results. Reactive process `printContact` reads `name`
+and `email` fields, thus depends on them. It is executed
+automatically in response to changes of these fields
+made by the atomic action `saveContact`.
 
-Here is an example of a cached value (re-)computed on-demand:
+Here is an example of a cached result that is
+(re-)computed on-demand:
 
 ``` typescript
 class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @cache
+  @cachedResult
   get contact(): string {
     return this.name + ' <' + this.email + '>'
   }
 
-  @reaction
+  @reactiveProcess
   printContact(): void {
     if (this.contact !== '')
       Console.log(this.contact)
@@ -89,19 +90,22 @@ class Demo extends ObservableObject {
 }
 ```
 
-In the example above, the value of `contact` is computed from
-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
-reaction function `printContact`. When `printContact` function
-runs it reads `contact` and causes its re-computation.
+In the example above, the result of `contact` getter 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` result becomes obsolete,
+thus causing execution of depending reactive process
+`printContact`. When function of reactive process
+`printContact` runs it reads `contact` and causes its
+re-computation.
 
 ## Observable 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.
+Observable objects are aimed to 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 ObservableObject {
@@ -111,23 +115,23 @@ class MyModel extends ObservableObject {
 }
 ```
 
-In the example above, the class `MyModel` is based on Reactronic's
-`ObservableObject` class and all its properties `url`, `content`,
-and `timestamp` are hooked.
+In the example above, the class `MyModel` is based on
+Reactronic's `ObservableObject` class and all its
+properties `url`, `content`, and `timestamp` are hooked.
 
-## Apply
+## Atomic Action
 
-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).
+Atomic action makes changes in observable objects
+in atomic (transactional) way, thus provoking execution
+of dependent reactive processes and recalculation of
+dependent cached results. Atomic action function is
+instrumented with hooks to provide transparent atomicity
+(by implicit context switching and isolation).
 
 ``` typescript
 class MyModel extends ObservableObject {
   // ...
-  @apply
+  @atomicAction
   async load(url: string): Promise<void> {
     this.url = url
     this.content = await fetch(url)
@@ -136,49 +140,54 @@ class MyModel extends ObservableObject {
 }
 ```
 
-In the example above, the applying function `load` makes
-changes to `url`, `content` and `timestamp` properties. While
-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.
-
-Atomicity is achieved by making changes in an isolated data
-snapshot that is not visible outside of the running transaction
-until it is fully finished and applied. Multiple objects
-and their properties can be changed with full respect
-to the all-or-nothing principle. To do so, separate data
-snapshot is automatically maintained for each transaction.
-That is a logical snapshot that does not create a full copy
-of all the data.
-
-Compensating rollback operations are not needed in case of the
-transaction failure, because all the changes made by the transaction
-in its logical snapshot are simply discarded. In case the transaction
-is successfully applied, affected caches are marked as obsolete
-and corresponding caching functions are re-executed in a proper
-order (but only when all the data changes are fully applied).
-
-Asynchronous operations (promises) are supported out of the box
-during transaction execution. The transaction may consist of a set of
-asynchronous calls prolonging the transaction until completion of
-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
-
-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 cache functions (dependencies), which are used
-during their execution.
+In the example above, the atomic action `load` makes
+changes to `url`, `content` and `timestamp` properties.
+While atomic action is running, the changes are visible
+only inside the action itself. The new values become
+atomically visible outside of the action only upon its
+completion.
+
+Atomicity is achieved by making changes in an isolated
+data snapshot that is not visible outside of the running
+action until it is fully finished and applied. Multiple
+objects and their properties can be changed with full
+respect to the all-or-nothing principle. To do so,
+separate data snapshot is automatically maintained for
+each atomic action. That is a logical snapshot that does
+not create a full copy of all the data.
+
+Compensating rollback operations are not needed in case
+of the atomic action failure, because all the changes
+made by the atomic action in its logical snapshot are
+simply discarded. In case the atomic action is
+successfully applied, affected cached results are marked
+as obsolete and corresponding caching functions are
+re-executed in a proper order (but only when all the
+data changes are fully applied).
+
+Asynchronous operations (promises) are supported out of
+the box during atomic action execution. Atomic action
+may consist of a set of asynchronous calls prolonging
+the action until completion of all of them. An
+asynchronous call may spawn other asynchronous calls,
+which prolong atomic atomic execution until the whole
+chain of asynchronous operations is fully completed.
+
+## Reactive Process & Cached Result
+
+Reactive process function is automatically and
+immediately called in response to changes in observable
+objects made by atomic actions. Function of cached result
+is called on-demand to renew the result if it was marked
+as obsolete due to changes made by an atomic action.
+Functions of reactive processes and cached results are
+instrumented with hooks to seamlessly subscribe to those
+observable objects and other cached results
+(dependencies), which are used during their execution.
 
 ``` tsx
 class MyView extends Component<{model: MyModel}> {
-  @cache
+  @cachedResult
   render(): React.JSX.Element {
     return (
       <div>
@@ -192,72 +201,83 @@ class MyView extends Component<{model: MyModel}> {
 
 ``` tsx
 class Component<P> extends React.Component<P> {
-  @cache
+  @cachedResult
   render(): React.JSX.Element {
     throw new Error('render method is undefined')
   }
 
-  @reaction // called immediately in response to changes
+  @reactiveProcess // called in response to changes
   ensureUpToDate(): void {
-    if (this.shouldComponentUpdate())
-      Transaction.outside(() => this.setState({})) // ask React to re-render
-  } // ensureUpToDate is subscribed to render
+    if (this.shouldComponentUpdate()) {
+      // Ask React to re-render
+      Transaction.outside(() => this.setState({}))
+    }
+  } // EnsureUpToDate is subscribed to render
 
   shouldComponentUpdate(): boolean {
     return !RxSystem.getController(this.render).isUpToDate
   }
 
   componentDidMount(): void {
-    this.ensureUpToDate() // run to subscribe for the first time
+    // Run to subscribe for the first time
+    this.ensureUpToDate()
   }
 
   componentWillUnmount(): void {
-    apply(RxSystem.dispose, this)
+    atomicAction(RxSystem.dispose, this)
   }
 }
 ```
 
-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 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 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 reaction functions) or on-demand
-(for cache functions).
-
-Reactronic takes full care of tracking dependencies between
-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
-to a new one.
+In the example above, reactive process `refresh` is
+transparently subscribed to the cached result of
+function `render`. In turn, cached result of function
+`render` is subscribed to the properties `url` and
+`content` of a corresponding `MyModel` object. Once
+`url` or `content` values are changed, the `render`
+cached result becomes obsolete and causes the reactive
+process `refresh` to become obsolete and re-executed.
+While being executed, the reactive process function
+`refresh` enqueues re-rendering request to React, which
+calls `render` function causing it to renew its cached
+value.
+
+In general case, all reactive processes and cached
+results are automatically and immediately marked as
+obsolete when changes are made in those observable
+objects and other cached results that were used during
+their execution. And once marked, the functions are
+automatically executed again, either immediately (for
+reactive processes) or on-demand (for cached results).
+
+Reactronic takes full care of tracking dependencies
+between all the observable objects and reactive processes
+or cached results. 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 to a
+new one.
 
 ## Behavior Options
 
-There are multiple options to configure behavior of transactional reactivity.
+There are multiple options to configure behavior of
+transactional reactivity.
 
-**Order** options defines order of execution for reactions:
+**Order** options defines order of execution for
+reactive processes:
 
   - (TBD)
 
-**Throttling** option defines how often reaction is executed in case
-of recurring changes:
+**Throttling** option defines how often reactive process
+is executed in case of recurring changes:
 
   - `(ms)` - minimal delay in milliseconds between executions;
-  - `-1` - execute immediately once transaction is applied (synchronously);
+  - `-1` - execute immediately once atomic action is applied (synchronously);
   - `0` - execute immediately via event loop (asynchronously with zero timeout);
   - `>= Number.MAX_SAFE_INTEGER` - never execute (suspended reaction).
 
-**Reentrance** option defines how to handle reentrant calls of applying
-and reaction functions:
+**Reentrance** option defines how to handle reentrant calls of atomic
+actions and reactive processes:
 
   - `preventWithError` - fail with error if there is an existing call in progress;
   - `waitAndRestart` - wait for previous call to finish and then restart current one;
@@ -267,8 +287,8 @@ and reaction functions:
 
 **Indicator** is an object that maintains status of running functions,
 which it is attached to. A single indicator object can be shared between
-multiple transactional, reactive, and cached functions, thus maintaining
-consolidated status for all of them (busy, workers, etc).
+multiple atomic actions, reactive processes, and cached results, thus
+maintaining consolidated status for all of them (busy, workers, etc).
 
 ## Notes
 
@@ -305,9 +325,9 @@ class ObservableObject { }
 
 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 atomicAction(proto, prop, pd) // method only
+function reactiveProcess(proto, prop, pd) // method only
+function cachedResult(proto, prop, pd) // method only
 function options(value: Partial<MemberOptions>): F<any>
 
 function nonreactive<T>(func: F<T>, ...args: any[]): T
@@ -338,9 +358,9 @@ type MemberOptions = {
 
 enum Kind {
   plain = 0,
-  transaction = 1,
-  reaction = 2,
-  cache = 3
+  atomicAction = 1,
+  reactiveProcess = 2,
+  cachedResult = 3
 }
 
 enum Reentrance {

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 { apply } from "./ReactiveSystem.js";
+import { atomicAction } from "./ReactiveSystem.js";
 export class Clock extends ObservableObject {
     constructor(interval = 1000) {
         super();
@@ -40,13 +40,13 @@ export class Clock extends ObservableObject {
     }
 }
 __decorate([
-    apply,
+    atomicAction,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Boolean]),
     __metadata("design:returntype", void 0)
 ], Clock.prototype, "pause", null);
 __decorate([
-    apply,
+    atomicAction,
     __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,
-    apply = 1,
-    reaction = 2,
-    cache = 3
+    atomicAction = 1,
+    reactiveProcess = 2,
+    cachedResult = 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["apply"] = 1] = "apply";
-    Kind[Kind["reaction"] = 2] = "reaction";
-    Kind[Kind["cache"] = 3] = "cache";
+    Kind[Kind["atomicAction"] = 1] = "atomicAction";
+    Kind[Kind["reactiveProcess"] = 2] = "reactiveProcess";
+    Kind[Kind["cachedResult"] = 3] = "cachedResult";
 })(Kind || (Kind = {}));
 export var Reentrance;
 (function (Reentrance) {

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

@@ -1,6 +1,6 @@
 import { F } from "./util/Utils.js";
 import { ObservableObject } from "./core/Mvcc.js";
-export declare class Reaction<T> extends ObservableObject {
+export declare class ReactiveProcess<T> extends ObservableObject {
     protected action: F<T>;
     constructor(action: F<T>);
     protected launch(): T;

package/build/dist/source/Reaction.js

@@ -8,8 +8,8 @@ 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 { reaction } from "./ReactiveSystem.js";
-export class Reaction extends ObservableObject {
+import { reactiveProcess } from "./ReactiveSystem.js";
+export class ReactiveProcess extends ObservableObject {
     constructor(action) {
         super();
         this.action = action;
@@ -19,8 +19,8 @@ export class Reaction extends ObservableObject {
     }
 }
 __decorate([
-    reaction,
+    reactiveProcess,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
-], Reaction.prototype, "launch", null);
+], ReactiveProcess.prototype, "launch", null);

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

@@ -18,13 +18,15 @@ export declare class ReactiveSystem {
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
 }
 export declare function nonreactive<T>(func: F<T>, ...args: any[]): T;
+export declare function nonreactive2<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
+export declare function nonreactive2<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 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 atomicAction<T>(func: F<T>, ...args: any[]): T;
+export declare function atomicAction<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
+export declare function atomicAction(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 reactiveProcess(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function cachedResult(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function options(value: Partial<MemberOptions>): F<any>;

package/build/dist/source/ReactiveSystem.js

@@ -25,13 +25,31 @@ export class ReactiveSystem {
 export function nonreactive(func, ...args) {
     return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
 }
+export function nonreactive2(p1, p2, p3) {
+    if (p1 instanceof Function) {
+        return OperationImpl.proceedWithinGivenLaunch(undefined, () => {
+            if (p2 !== undefined)
+                return Transaction.run(null, p1, ...p2);
+            else
+                return Transaction.run(null, p1);
+        });
+    }
+    else {
+        return OperationImpl.proceedWithinGivenLaunch(undefined, () => {
+            if (p3 !== undefined)
+                return Transaction.run(p1, p2, ...p3);
+            else
+                return Transaction.run(p1, p2);
+        });
+    }
+}
 export function sensitive(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);
 }
 export function contextually(p) {
     throw new Error("not implemented yet");
 }
-export function apply(p1, p2, p3) {
+export function atomicAction(p1, p2, p3) {
     if (p1 instanceof Function) {
         if (p2 !== undefined)
             return Transaction.run(null, p1, ...p2);
@@ -46,10 +64,10 @@ export function apply(p1, p2, p3) {
     }
     else {
         const opts = {
-            kind: Kind.apply,
+            kind: Kind.atomicAction,
             isolation: Isolation.joinToCurrentTransaction,
         };
-        return Mvcc.decorateOperation(true, apply, opts, p1, p2, p3);
+        return Mvcc.decorateOperation(true, atomicAction, opts, p1, p2, p3);
     }
 }
 export function unobservable(proto, prop) {
@@ -58,21 +76,21 @@ export function unobservable(proto, prop) {
 export function observable(proto, prop) {
     return Mvcc.decorateData(true, proto, prop);
 }
-export function reaction(proto, prop, pd) {
+export function reactiveProcess(proto, prop, pd) {
     const opts = {
-        kind: Kind.reaction,
+        kind: Kind.reactiveProcess,
         isolation: Isolation.joinAsNestedTransaction,
         throttling: -1,
     };
-    return Mvcc.decorateOperation(true, reaction, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, reactiveProcess, opts, proto, prop, pd);
 }
-export function cache(proto, prop, pd) {
+export function cachedResult(proto, prop, pd) {
     const opts = {
-        kind: Kind.cache,
+        kind: Kind.cachedResult,
         isolation: Isolation.joinToCurrentTransaction,
         noSideEffects: true,
     };
-    return Mvcc.decorateOperation(true, cache, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, cachedResult, opts, proto, prop, pd);
 }
 export function options(value) {
     return Mvcc.decorateOperationParametrized(options, value);

package/build/dist/source/Ref.js

@@ -1,4 +1,4 @@
-import { apply, nonreactive } from "./ReactiveSystem.js";
+import { atomicAction, nonreactive } from "./ReactiveSystem.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }
@@ -52,7 +52,7 @@ export class ToggleRef extends Ref {
     toggle() {
         const o = this.owner;
         const p = this.name;
-        apply({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
+        atomicAction({ 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,8 +16,8 @@ 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, observable, unobservable, apply, reaction, cache, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
-export { Reaction } from "./Reaction.js";
+export { ReactiveSystem, observable, unobservable, atomicAction, reactiveProcess, cachedResult, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
+export { ReactiveProcess } 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";
 export { Clock } from "./Clock.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, observable, unobservable, apply, reaction, cache, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
-export { Reaction } from "./Reaction.js";
+export { ReactiveSystem, observable, unobservable, atomicAction, reactiveProcess, cachedResult, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
+export { ReactiveProcess } from "./Reaction.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export { Clock } from "./Clock.js";

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

@@ -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.apply && launch.cause !== BOOT_CAUSE &&
+        const isReusable = launch.options.kind !== Kind.atomicAction && 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.apply || !ror.isReusable) {
+                if (ror.launch.options.kind === Kind.atomicAction || !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.apply)
+        else if (this.operation.options.kind === Kind.atomicAction)
             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.reaction;
+                const isReactive = this.options.kind === Kind.reactiveProcess;
                 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.reaction)
+                            if (launch.options.kind === Kind.reactiveProcess)
                                 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.reaction)
+                    else if (this.options.kind === Kind.reactiveProcess)
                         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.apply ||
+        return !this.error && (this.options.kind === Kind.atomicAction ||
             !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.apply) {
+        if (kind !== Kind.atomicAction) {
             const launch = Launch.current;
-            if (launch && launch.options.kind !== Kind.apply &&
+            if (launch && launch.options.kind !== Kind.atomicAction &&
                 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.reaction && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
+        if (launch.options.kind === Kind.reactiveProcess && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.acquire(proto, Meta.Reactive);
             reactive[fk] = launch;
         }
-        else if (launch.options.kind === Kind.reaction && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
+        else if (launch.options.kind === Kind.reactiveProcess && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.getFrom(proto, Meta.Reactive);
             delete reactive[fk];
         }
@@ -744,8 +744,8 @@ function reactronicHookedThen(resolve, reject) {
             resolve = launch.wrap(resolve);
             reject = launch.wrap(reject);
         }
-        resolve = tran.wrap(resolve, false);
-        reject = tran.wrap(reject, true);
+        resolve = tran.wrapAsPending(resolve, false);
+        reject = tran.wrapAsPending(reject, true);
     }
     return ORIGINAL_PROMISE_THEN.call(this, resolve, reject);
 }

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, unobservable, reaction, nonreactive, apply } from "../ReactiveSystem.js";
+import { ReactiveSystem, options, unobservable, reactiveProcess, nonreactive, atomicAction } from "../ReactiveSystem.js";
 export var Mode;
 (function (Mode) {
     Mode[Mode["default"] = 0] = "default";
@@ -339,7 +339,7 @@ class ReactiveNodeImpl extends ReactiveNode {
                 node.outer = owner;
             else
                 node.outer = owner.outer;
-            apply({ isolation: Isolation.joinAsNestedTransaction }, () => {
+            atomicAction({ 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([
-    reaction,
+    reactiveProcess,
     options({
         reentrance: Reentrance.cancelAndWaitPrevious,
         allowObsoleteToFinish: true,
@@ -546,7 +546,7 @@ function triggerFinalization(slot, isLeader, individual) {
             else
                 gFirstToDispose = gLastToDispose = slot;
             if (gFirstToDispose === slot)
-                apply({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
+                atomicAction({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }

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

@@ -17,7 +17,7 @@ export declare abstract class Transaction implements Worker {
     abstract inspect<T>(func: F<T>, ...args: any[]): T;
     abstract apply(): void;
     abstract seal(): this;
-    abstract wrap<T>(func: F<T>, secondary: boolean): F<T>;
+    abstract wrapAsPending<T>(func: F<T>, secondary: boolean): F<T>;
     abstract cancel(error: Error, retryAfterOrIgnore?: Worker | null): this;
     abstract readonly isCanceled: boolean;
     abstract readonly isFinished: boolean;
@@ -33,7 +33,7 @@ export declare abstract class Transaction implements Worker {
 export declare class TransactionImpl extends Transaction {
     private static readonly none;
     private static curr;
-    private static inspection;
+    private static isInspectionMode;
     private static frameStartTime;
     private static frameOverCounter;
     readonly margin: number;
@@ -57,9 +57,9 @@ export declare class TransactionImpl extends Transaction {
     inspect<T>(func: F<T>, ...args: any[]): T;
     apply(): void;
     seal(): this;
-    wrap<T>(func: F<T>, error: boolean): F<T>;
-    private static wrapperEnter;
-    private static wrapperLeave;
+    wrapAsPending<T>(func: F<T>, secondary: boolean): F<T>;
+    private static preparePendingFunction;
+    private static runPendingFunction;
     cancel(error: Error, restartAfter?: Worker | null): this;
     get isCanceled(): boolean;
     get isFinished(): boolean;

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

@@ -50,15 +50,15 @@ export class TransactionImpl extends Transaction {
         return this.runImpl(undefined, func, ...args);
     }
     inspect(func, ...args) {
-        const restore = TransactionImpl.inspection;
+        const outer = TransactionImpl.isInspectionMode;
         try {
-            TransactionImpl.inspection = true;
+            TransactionImpl.isInspectionMode = true;
             if (Log.isOn && Log.opt.transaction)
                 Log.write(" ", " ", `T${this.id}[${this.hint}] is being inspected by T${TransactionImpl.curr.id}[${TransactionImpl.curr.hint}]`);
             return this.runImpl(undefined, func, ...args);
         }
         finally {
-            TransactionImpl.inspection = restore;
+            TransactionImpl.isInspectionMode = outer;
         }
     }
     apply() {
@@ -73,27 +73,27 @@ export class TransactionImpl extends Transaction {
             this.run(TransactionImpl.seal, this, undefined, undefined);
         return this;
     }
-    wrap(func, error) {
+    wrapAsPending(func, secondary) {
         this.guard();
         const self = this;
-        const inspect = TransactionImpl.inspection;
-        if (!inspect)
-            self.run(TransactionImpl.wrapperEnter, self, error);
+        const inspection = TransactionImpl.isInspectionMode;
+        if (!inspection)
+            self.run(TransactionImpl.preparePendingFunction, self, secondary);
         else
-            self.inspect(TransactionImpl.wrapperEnter, self, error);
-        const wrappedForTransaction = (...args) => {
-            if (!inspect)
-                return self.runImpl(undefined, TransactionImpl.wrapperLeave, self, error, func, ...args);
+            self.inspect(TransactionImpl.preparePendingFunction, self, secondary);
+        const wrappedAsPendingForTransaction = (...args) => {
+            if (!inspection)
+                return self.runImpl(undefined, TransactionImpl.runPendingFunction, self, secondary, func, ...args);
             else
-                return self.inspect(TransactionImpl.wrapperLeave, self, error, func, ...args);
+                return self.inspect(TransactionImpl.runPendingFunction, self, secondary, func, ...args);
         };
-        return wrappedForTransaction;
+        return wrappedAsPendingForTransaction;
     }
-    static wrapperEnter(t, error) {
-        if (!error)
+    static preparePendingFunction(t, secondary) {
+        if (!secondary)
             t.pending++;
     }
-    static wrapperLeave(t, error, func, ...args) {
+    static runPendingFunction(t, secondary, func, ...args) {
         t.pending--;
         const result = func(...args);
         return result;
@@ -118,10 +118,10 @@ export class TransactionImpl extends Transaction {
     }
     static run(options, func, ...args) {
         const t = TransactionImpl.acquire(options);
-        const root = t !== TransactionImpl.curr;
+        const isRoot = t !== TransactionImpl.curr;
         t.guard();
         let result = t.runImpl(options === null || options === void 0 ? void 0 : options.logging, func, ...args);
-        if (root) {
+        if (isRoot) {
             if (result instanceof Promise) {
                 result = TransactionImpl.outside(() => {
                     return t.wrapToRetry(t.wrapToWaitUntilFinish(result), func, ...args);
@@ -231,7 +231,7 @@ export class TransactionImpl extends Transaction {
             }
         }
         catch (e) {
-            if (!TransactionImpl.inspection)
+            if (!TransactionImpl.isInspectionMode)
                 this.cancel(e);
             throw e;
         }
@@ -460,7 +460,7 @@ export class TransactionImpl extends Transaction {
         return TransactionImpl.curr.changeset;
     }
     static getEditableChangeset() {
-        if (TransactionImpl.inspection)
+        if (TransactionImpl.isInspectionMode)
             throw misuse("cannot make changes during transaction inspection");
         return TransactionImpl.curr.changeset;
     }
@@ -474,7 +474,7 @@ export class TransactionImpl extends Transaction {
 }
 TransactionImpl.none = new TransactionImpl({ hint: "<none>" });
 TransactionImpl.curr = TransactionImpl.none;
-TransactionImpl.inspection = false;
+TransactionImpl.isInspectionMode = false;
 TransactionImpl.frameStartTime = 0;
 TransactionImpl.frameOverCounter = 0;
 TransactionImpl.migrateFieldVersion = function (fv, target) {

package/package.json

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