reactronic 0.93.25025 → 0.94.25027

package/README.md

@@ -20,22 +20,23 @@ corresponding visual components for (re)rendering. All
 that is done in automatic, seamless, and fine-grained
 way. Reactronic **takes full care of tracking dependencies**
 between visual components (reactive functions) and
-application state (triggering objects).
+application state (observable objects).
 
 Transactional reactivity is based on four fundamental
 concepts:
 
-  - **Triggering Objects** - a set of objects that store
+  - **Observable Objects** - a set of objects that store
     data of an application (state) and cause reactions
     upon their changes;
-  - **Atomic Function** - a function that makes changes in
-    triggering objects in atomic way ("all or nothing");
-  - **Reactive Function** - a function that is
+  - **Atomic Block** - a code block that makes changes
+    in observable objects in atomic way ("all or
+    nothing");
+  - **Reaction** - a function that is
     (re-)executed in response to changes made in
-    triggering objects by atomic actions;
-  - **Cached Function** -  a function which result is
-    remembered and, if becomes obsolete, causes function
-    to re-execute on-demand.
+    observable objects by atomic actions;
+  - **Cache** -  a function which result is remembered
+    and, if becomes obsolete, causes 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.
@@ -47,7 +48,7 @@ Quick introduction and detailed description is below.
 Here is an example of transactional reactive code:
 
 ``` typescript
-class Demo extends TriggeringObject {
+class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -67,7 +68,7 @@ class Demo extends TriggeringObject {
 }
 ```
 
-In the example above, `Demo` is a triggering object,
+In the example above, `Demo` is an observable object,
 meaning that access to its fields are seamlessly tracked
 to determine dependent reactive and cached functions.
 Reactive function `printContact` reads `name` and `email`
@@ -79,11 +80,11 @@ Here is an example of a cached result that is
 (re-)computed on-demand:
 
 ``` typescript
-class Demo extends TriggeringObject {
+class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @cachedResult
+  @cached
   get contact(): string {
     return this.name + ' <' + this.email + '>'
   }
@@ -106,15 +107,15 @@ thus causing execution of depending reactive function
 `printContact` runs it reads `contact` and causes its
 re-computation.
 
-## Triggering Objects
+## Observable Objects
 
-Triggering objects (triggers) are aimed to store data of
+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 TriggeringObject {
+class MyModel extends ObservableObject {
   url: string = "https://github.com/nezaboodka/reactronic"
   content: string = "transactional reactive state management"
   timestamp: Date = Date.now()
@@ -122,19 +123,19 @@ class MyModel extends TriggeringObject {
 ```
 
 In the example above, the class `MyModel` is based on
-Reactronic's `TriggeringObject` class and all its
+Reactronic's `ObservableObject` class and all its
 properties `url`, `content`, and `timestamp` are hooked.
 
 ## Atomic Function
 
-Atomic function makes changes in triggering objects
+Atomic function makes changes in observable objects
 in atomic (transactional) way, thus provoking execution
 of dependent reactive and cached functions. Atomic
 function is instrumented with hooks to provide transparent atomicity
 (by implicit context switching and isolation).
 
 ``` typescript
-class MyModel extends TriggeringObject {
+class MyModel extends ObservableObject {
   // ...
   @atomic
   async load(url: string): Promise<void> {
@@ -181,18 +182,18 @@ chain of asynchronous operations is fully completed.
 ## Reactive & Cached Functions
 
 Reactive function is automatically and immediately called
-in response to changes in triggering objects made by
+in response to changes in observable objects made by
 atomic functions. Cached function is called on-demand to
 renew the result if it was marked as obsolete due to
 changes made by an atomic functions. Reactive and cached
 functions are instrumented with hooks to seamlessly
-subscribe to those triggering objects and other cached
+subscribe to those observable objects and other cached
 functions (dependencies), which are used during their
 execution.
 
 ``` tsx
 class MyView extends Component<{model: MyModel}> {
-  @cachedResult
+  @cached
   render(): React.JSX.Element {
     return (
       <div>
@@ -206,7 +207,7 @@ class MyView extends Component<{model: MyModel}> {
 
 ``` tsx
 class Component<P> extends React.Component<P> {
-  @cachedResult
+  @cached
   render(): React.JSX.Element {
     throw new Error('render method is undefined')
   }
@@ -220,7 +221,7 @@ class Component<P> extends React.Component<P> {
   } // EnsureUpToDate is subscribed to render
 
   shouldComponentUpdate(): boolean {
-    const r = ReactiveSystem.getController(this.render)
+    const r = ReactiveSystem.getDescriptor(this.render)
     return !r.isUpToDate
   }
 
@@ -249,14 +250,14 @@ cached value.
 
 In general case, all reactive and cached functions
 are automatically and immediately marked as obsolete
-when changes are made in those triggering objects and
+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 functions) or on-demand (for cached functions).
 
 Reactronic takes full care of tracking dependencies
-between all the triggering objects and reactive/cached
+between 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
@@ -322,22 +323,22 @@ NPM: `npm install reactronic`
 
 // Classes
 
-class TransactionalObject { }
-class TriggeringObject { }
+class AtomicObject { }
+class ObservableObject { }
 
 // Decorators & Operators
 
-function trigger(boolean) // field only
-function trigger(proto, prop) // field only
+function observable(boolean) // field only
+function observable(proto, prop) // field only
 function atomic(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 reaction(proto, prop, pd) // method only
+function cache(proto, prop, pd) // method only
+function options(value: Partial<ReactivityOptions>): F<any>
 
-function nonReactiveRun<T>(func: F<T>, ...args: any[]): T
-function sensitiveRun<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
+function runNonReactively<T>(func: F<T>, ...args: any[]): T
+function runSensitively<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
-// SnapshotOptions, MemberOptions, Kind, Reentrance, Indicator, LoggingOptions, ProfilingOptions
+// SnapshotOptions, ReactivityOptions, Kind, Reentrance, Indicator, LoggingOptions, ProfilingOptions
 
 export type SnapshotOptions = {
   readonly hint?: string
@@ -347,12 +348,12 @@ export type SnapshotOptions = {
   readonly token?: any
 }
 
-type MemberOptions = {
+type ReactivityOptions = {
   readonly kind: Kind
   readonly isolation: Isolation
   readonly order: number
   readonly noSideEffects: boolean
-  readonly triggeringArgs: boolean
+  readonly observableArgs: boolean
   readonly throttling: number // milliseconds, -1 is immediately, Number.MAX_SAFE_INTEGER is never
   readonly reentrance: Reentrance
   readonly journal: Journal | undefined
@@ -363,8 +364,8 @@ type MemberOptions = {
 enum Kind {
   plain = 0,
   atomic = 1,
-  reactive = 2,
-  cached = 3
+  reaction = 2,
+  cache = 3
 }
 
 enum Reentrance {

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

@@ -0,0 +1,32 @@
+export declare enum Mode {
+    default = 0,
+    autonomous = 1,
+    manualMount = 2,
+    rootNode = 4
+}
+export declare enum Priority {
+    realtime = 0,
+    normal = 1,
+    background = 2
+}
+export declare enum Kind {
+    plain = 0,
+    atomic = 1,
+    reactive = 2,
+    cached = 3
+}
+export declare enum Reentrance {
+    preventWithError = 1,
+    waitAndRestart = 0,
+    cancelPrevious = -1,
+    cancelAndWaitPrevious = -2,
+    overwritePrevious = -3,
+    runSideBySide = -4
+}
+export declare enum Isolation {
+    joinToCurrentTransaction = 0,
+    joinAsNestedTransaction = 1,
+    disjoinFromOuterTransaction = 2,
+    disjoinFromOuterAndInnerTransactions = 3,
+    disjoinForInternalDisposal = 4
+}

package/build/dist/source/Enums.js

@@ -0,0 +1,37 @@
+export var Mode;
+(function (Mode) {
+    Mode[Mode["default"] = 0] = "default";
+    Mode[Mode["autonomous"] = 1] = "autonomous";
+    Mode[Mode["manualMount"] = 2] = "manualMount";
+    Mode[Mode["rootNode"] = 4] = "rootNode";
+})(Mode || (Mode = {}));
+export var Priority;
+(function (Priority) {
+    Priority[Priority["realtime"] = 0] = "realtime";
+    Priority[Priority["normal"] = 1] = "normal";
+    Priority[Priority["background"] = 2] = "background";
+})(Priority || (Priority = {}));
+export var Kind;
+(function (Kind) {
+    Kind[Kind["plain"] = 0] = "plain";
+    Kind[Kind["atomic"] = 1] = "atomic";
+    Kind[Kind["reactive"] = 2] = "reactive";
+    Kind[Kind["cached"] = 3] = "cached";
+})(Kind || (Kind = {}));
+export var Reentrance;
+(function (Reentrance) {
+    Reentrance[Reentrance["preventWithError"] = 1] = "preventWithError";
+    Reentrance[Reentrance["waitAndRestart"] = 0] = "waitAndRestart";
+    Reentrance[Reentrance["cancelPrevious"] = -1] = "cancelPrevious";
+    Reentrance[Reentrance["cancelAndWaitPrevious"] = -2] = "cancelAndWaitPrevious";
+    Reentrance[Reentrance["overwritePrevious"] = -3] = "overwritePrevious";
+    Reentrance[Reentrance["runSideBySide"] = -4] = "runSideBySide";
+})(Reentrance || (Reentrance = {}));
+export var Isolation;
+(function (Isolation) {
+    Isolation[Isolation["joinToCurrentTransaction"] = 0] = "joinToCurrentTransaction";
+    Isolation[Isolation["joinAsNestedTransaction"] = 1] = "joinAsNestedTransaction";
+    Isolation[Isolation["disjoinFromOuterTransaction"] = 2] = "disjoinFromOuterTransaction";
+    Isolation[Isolation["disjoinFromOuterAndInnerTransactions"] = 3] = "disjoinFromOuterAndInnerTransactions";
+    Isolation[Isolation["disjoinForInternalDisposal"] = 4] = "disjoinForInternalDisposal";
+})(Isolation || (Isolation = {}));

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

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

package/build/dist/source/{ReactiveLoop.js → OperationEx.js}

@@ -7,20 +7,20 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { TriggeringObject } from "./core/Mvcc.js";
-import { reaction } from "./ReactiveSystem.js";
-export class ReactiveLoop extends TriggeringObject {
-    constructor(reactiveFunction) {
+import { ObservableObject } from "./core/Mvcc.js";
+import { reactive } from "./System.js";
+export class ReactiveOperationEx extends ObservableObject {
+    constructor(operation) {
         super();
-        this.reactiveFunction = reactiveFunction;
+        this.operation = operation;
     }
     launch() {
-        return this.reactiveFunction();
+        return this.operation();
     }
 }
 __decorate([
-    reaction,
+    reactive,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
-], ReactiveLoop.prototype, "launch", null);
+], ReactiveOperationEx.prototype, "launch", null);

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

@@ -1,5 +1,6 @@
 import { LoggingOptions } from "./Logging.js";
 export { LoggingLevel } from "./Logging.js";
+import { Kind, Reentrance, Isolation } from "./Enums.js";
 export type { LoggingOptions, ProfilingOptions } from "./Logging.js";
 import { Journal } from "./core/Journal.js";
 import { Indicator } from "./core/Indicator.js";
@@ -10,12 +11,12 @@ export type SnapshotOptions = {
     readonly logging?: Partial<LoggingOptions>;
     readonly token?: any;
 };
-export type MemberOptions = {
+export type ReactivityOptions = {
     readonly kind: Kind;
     readonly isolation: Isolation;
     readonly order: number;
     readonly noSideEffects: boolean;
-    readonly triggeringArgs: boolean;
+    readonly observableArgs: boolean;
     readonly throttling: number;
     readonly reentrance: Reentrance;
     readonly allowObsoleteToFinish: boolean;
@@ -23,35 +24,14 @@ export type MemberOptions = {
     readonly indicator: Indicator | null;
     readonly logging?: Partial<LoggingOptions>;
 };
-export declare enum Kind {
-    plain = 0,
-    atomic = 1,
-    reactive = 2,
-    cached = 3
-}
-export declare enum Reentrance {
-    preventWithError = 1,
-    waitAndRestart = 0,
-    cancelPrevious = -1,
-    cancelAndWaitPrevious = -2,
-    overwritePrevious = -3,
-    runSideBySide = -4
-}
-export declare enum Isolation {
-    joinToCurrentTransaction = 0,
-    joinAsNestedTransaction = 1,
-    disjoinFromOuterTransaction = 2,
-    disjoinFromOuterAndInnerTransactions = 3,
-    disjoinForInternalDisposal = 4
-}
-export type Operation<T> = {
-    readonly options: MemberOptions;
+export type ReactiveOperation<T> = {
+    readonly options: ReactivityOptions;
     readonly args: ReadonlyArray<any>;
     readonly result: T;
     readonly error: any;
     readonly stamp: number;
     readonly isReusable: boolean;
-    configure(options: Partial<MemberOptions>): MemberOptions;
+    configure(options: Partial<ReactivityOptions>): ReactivityOptions;
     markObsolete(): void;
-    pullLastResult(args?: any[]): T | undefined;
+    pullLastResult(args?: any[]): any;
 };

package/build/dist/source/Options.js

@@ -1,25 +1 @@
 export { LoggingLevel } from "./Logging.js";
-export var Kind;
-(function (Kind) {
-    Kind[Kind["plain"] = 0] = "plain";
-    Kind[Kind["atomic"] = 1] = "atomic";
-    Kind[Kind["reactive"] = 2] = "reactive";
-    Kind[Kind["cached"] = 3] = "cached";
-})(Kind || (Kind = {}));
-export var Reentrance;
-(function (Reentrance) {
-    Reentrance[Reentrance["preventWithError"] = 1] = "preventWithError";
-    Reentrance[Reentrance["waitAndRestart"] = 0] = "waitAndRestart";
-    Reentrance[Reentrance["cancelPrevious"] = -1] = "cancelPrevious";
-    Reentrance[Reentrance["cancelAndWaitPrevious"] = -2] = "cancelAndWaitPrevious";
-    Reentrance[Reentrance["overwritePrevious"] = -3] = "overwritePrevious";
-    Reentrance[Reentrance["runSideBySide"] = -4] = "runSideBySide";
-})(Reentrance || (Reentrance = {}));
-export var Isolation;
-(function (Isolation) {
-    Isolation[Isolation["joinToCurrentTransaction"] = 0] = "joinToCurrentTransaction";
-    Isolation[Isolation["joinAsNestedTransaction"] = 1] = "joinAsNestedTransaction";
-    Isolation[Isolation["disjoinFromOuterTransaction"] = 2] = "disjoinFromOuterTransaction";
-    Isolation[Isolation["disjoinFromOuterAndInnerTransactions"] = 3] = "disjoinFromOuterAndInnerTransactions";
-    Isolation[Isolation["disjoinForInternalDisposal"] = 4] = "disjoinForInternalDisposal";
-})(Isolation || (Isolation = {}));

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

@@ -1,5 +1,5 @@
-import { TriggeringObject } from "./core/Mvcc.js";
-export declare abstract class Pipe<T> extends TriggeringObject {
+import { ObservableObject } from "./core/Mvcc.js";
+export declare abstract class Pipe<T> extends ObservableObject {
     abstract readonly capacity: number;
     abstract readonly count: number;
     abstract put(...items: T[]): void;

package/build/dist/source/Pipe.js

@@ -1,4 +1,4 @@
-import { TriggeringObject } from "./core/Mvcc.js";
-export class Pipe extends TriggeringObject {
+import { ObservableObject } from "./core/Mvcc.js";
+export class Pipe extends ObservableObject {
     static create(hint, capacity) { throw new Error("not implemented"); }
 }

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

@@ -27,7 +27,7 @@ export declare class Ref<T = any> {
     constructor(owner: any, name: string, index?: number);
     get variable(): T;
     set variable(value: T);
-    unobs(): T;
+    nonReactively(): T;
     observe(): T;
     unobserve(): T;
     static sameRefs(v1: Ref, v2: Ref): boolean;

package/build/dist/source/Ref.js

@@ -1,4 +1,4 @@
-import { atomicRun, nonReactiveRun } from "./ReactiveSystem.js";
+import { runAtomically, runNonReactively } from "./System.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }
@@ -27,8 +27,8 @@ export class Ref {
         else
             this.owner[this.name][this.index] = value;
     }
-    unobs() {
-        return nonReactiveRun(() => this.variable);
+    nonReactively() {
+        return runNonReactively(() => this.variable);
     }
     observe() {
         return this.variable;
@@ -52,7 +52,7 @@ export class ToggleRef extends Ref {
     toggle() {
         const o = this.owner;
         const p = this.name;
-        atomicRun({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
+        runAtomically({ 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/System.d.ts

@@ -0,0 +1,29 @@
+import { F } from "./util/Utils.js";
+import { ReactiveOperation, ReactivityOptions, LoggingOptions, ProfilingOptions, SnapshotOptions } from "./Options.js";
+export declare class ReactiveSystem {
+    static why(brief?: boolean): string;
+    static getRevisionOf(obj: any): number;
+    static takeSnapshot<T>(obj: T): T;
+    static get reactivityAutoStartDisabled(): boolean;
+    static set reactivityAutoStartDisabled(value: boolean);
+    static get isLogging(): boolean;
+    static get loggingOptions(): LoggingOptions;
+    static setLoggingMode(isOn: boolean, options?: LoggingOptions): void;
+    static setLoggingHint<T extends object>(obj: T, name: string | undefined): void;
+    static getLoggingHint<T extends object>(obj: T, full?: boolean): string | undefined;
+    static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
+}
+export declare function runAtomically<T>(func: F<T>, ...args: any[]): T;
+export declare function runAtomically<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
+export declare function runNonReactively<T>(func: F<T>, ...args: any[]): T;
+export declare function runSensitively<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
+export declare function runContextually<T>(p: Promise<T>): Promise<T>;
+export declare function manageReactiveOperation<T>(method: F<T>): ReactiveOperation<T>;
+export declare function configureCurrentReactiveOperation(options: Partial<ReactivityOptions>): ReactivityOptions;
+export declare function disposeObservableObject(obj: any): void;
+export declare function observable(enabled: boolean): (proto: object, prop: PropertyKey) => any;
+export declare function observable<T>(proto: object, prop: PropertyKey): any;
+export declare function atomic(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<ReactivityOptions>): F<any>;

package/build/dist/source/{ReactiveSystem.js → System.js}

@@ -1,18 +1,14 @@
 import { Log } from "./util/Dbg.js";
-import { Kind, Isolation } from "./Options.js";
+import { Kind, Isolation } from "./Enums.js";
 import { Meta, ObjectHandle } from "./core/Data.js";
 import { Changeset } from "./core/Changeset.js";
 import { Mvcc } from "./core/Mvcc.js";
 import { Transaction } from "./core/Transaction.js";
-import { OperationImpl } from "./core/Operation.js";
+import { ReactiveOperationImpl } from "./core/Operation.js";
 export class ReactiveSystem {
-    static why(brief = false) { return brief ? OperationImpl.briefWhy() : OperationImpl.why(); }
-    static getOperation(method) { return OperationImpl.getControllerOf(method); }
-    static pullLastResult(method, args) { return ReactiveSystem.getOperation(method).pullLastResult(args); }
-    static configureCurrentOperation(options) { return OperationImpl.configureImpl(undefined, options); }
+    static why(brief = false) { return brief ? ReactiveOperationImpl.briefWhy() : ReactiveOperationImpl.why(); }
     static getRevisionOf(obj) { return obj[Meta.Revision]; }
     static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }
-    static dispose(obj) { Changeset.dispose(obj); }
     static get reactivityAutoStartDisabled() { return Mvcc.reactivityAutoStartDisabled; }
     static set reactivityAutoStartDisabled(value) { Mvcc.reactivityAutoStartDisabled = value; }
     static get isLogging() { return Log.isOn; }
@@ -22,7 +18,7 @@ export class ReactiveSystem {
     static getLoggingHint(obj, full = false) { return ObjectHandle.getHint(obj, full); }
     static setProfilingMode(isOn, options) { Mvcc.setProfilingMode(isOn, options); }
 }
-export function atomicRun(p1, p2, p3) {
+export function runAtomically(p1, p2, p3) {
     if (p1 instanceof Function) {
         if (p2 !== undefined)
             return Transaction.run(null, p1, ...p2);
@@ -36,16 +32,25 @@ export function atomicRun(p1, p2, p3) {
             return Transaction.run(p1, p2);
     }
 }
-export function nonReactiveRun(func, ...args) {
-    return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
+export function runNonReactively(func, ...args) {
+    return ReactiveOperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
 }
-export function sensitiveRun(sensitivity, func, ...args) {
+export function runSensitively(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);
 }
-export function contextualRun(p) {
+export function runContextually(p) {
     throw new Error("not implemented yet");
 }
-export function trigger(protoOrEnabled, prop) {
+export function manageReactiveOperation(method) {
+    return ReactiveOperationImpl.manageReactiveOperation(method);
+}
+export function configureCurrentReactiveOperation(options) {
+    return ReactiveOperationImpl.configureImpl(undefined, options);
+}
+export function disposeObservableObject(obj) {
+    Changeset.dispose(obj);
+}
+export function observable(protoOrEnabled, prop) {
     if (typeof (protoOrEnabled) === "boolean") {
         return (proto, prop) => {
             return Mvcc.decorateData(protoOrEnabled, proto, prop);
@@ -54,28 +59,28 @@ export function trigger(protoOrEnabled, prop) {
     else
         return Mvcc.decorateData(true, protoOrEnabled, prop);
 }
-export function atomicBlock(proto, prop, pd) {
+export function atomic(proto, prop, pd) {
     const opts = {
         kind: Kind.atomic,
         isolation: Isolation.joinToCurrentTransaction,
     };
-    return Mvcc.decorateOperation(true, atomicBlock, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, atomic, opts, proto, prop, pd);
 }
-export function reaction(proto, prop, pd) {
+export function reactive(proto, prop, pd) {
     const opts = {
         kind: Kind.reactive,
         isolation: Isolation.joinAsNestedTransaction,
         throttling: -1,
     };
-    return Mvcc.decorateOperation(true, reaction, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, reactive, opts, proto, prop, pd);
 }
-export function cache(proto, prop, pd) {
+export function cached(proto, prop, pd) {
     const opts = {
         kind: Kind.cached,
         isolation: Isolation.joinToCurrentTransaction,
         noSideEffects: true,
     };
-    return Mvcc.decorateOperation(true, cache, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, cached, opts, proto, prop, pd);
 }
 export function options(value) {
     return Mvcc.decorateOperationParametrized(options, value);

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

@@ -4,20 +4,22 @@ export type { MergedItem, MergeListReader } from "./util/MergeList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.js";
-export { Kind, Reentrance, Isolation, LoggingLevel } from "./Options.js";
-export type { Operation, MemberOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from "./Options.js";
+export { LoggingLevel } from "./Options.js";
+export { Mode, Priority, Kind, Reentrance, Isolation } from "./Enums.js";
+export type { ReactiveOperation, ReactivityOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from "./Options.js";
 export type { Worker } from "./Worker.js";
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from "./Ref.js";
 export type { BoolOnly, GivenTypeOnly } from "./Ref.js";
-export { TransactionalObject, TriggeringObject } from "./core/Mvcc.js";
-export { TransactionalArray, TriggeringArray } from "./core/MvccArray.js";
-export { TransactionalMap, TriggeringMap } from "./core/MvccMap.js";
+export { AtomicObject, ObservableObject } from "./core/Mvcc.js";
+export { AtomicArray, ObservableArray } from "./core/MvccArray.js";
+export { AtomicMap, ObservableMap } from "./core/MvccMap.js";
 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 { atomicRun, nonReactiveRun, sensitiveRun, contextualRun } from "./ReactiveSystem.js";
-export { ReactiveSystem, trigger, atomicBlock, reaction, cache, options } from "./ReactiveSystem.js";
-export { ReactiveLoop } from "./ReactiveLoop.js";
-export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
-export type { Script, ScriptAsync, Handler, ReactiveNodeDecl, ReactiveNodeDriver, ReactiveNodeContext } from "./core/ReactiveNode.js";
+export { runAtomically, runNonReactively, runSensitively, runContextually, manageReactiveOperation, configureCurrentReactiveOperation, disposeObservableObject } from "./System.js";
+export { ReactiveSystem, observable, atomic, reactive, cached, options } from "./System.js";
+export { ReactiveOperationEx } from "./OperationEx.js";
+export { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
+export { ReactiveTree } from "./core/Tree.js";
+export type { Script, ScriptAsync, Handler, ReactiveTreeNodeDecl, ReactiveTreeNodeDriver, ReactiveTreeNodeContext } from "./core/TreeNode.js";