reactronic 0.94.25036 → 0.95.25040

package/README.md

@@ -20,23 +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 (observable objects).
+application state (signalling objects).
 
 Transactional reactivity is based on four fundamental
 concepts:
 
-  - **Observable Objects** - a set of objects that store
+  - **Signalling Objects** - a set of objects that store
     data of an application (state) and cause reactions
     upon their changes;
-  - **Atomic Block** - a code block that makes changes
-    in observable objects in atomic way ("all or
-    nothing");
-  - **Reaction** - a function that is
+  - **Transactional Function** - a function that makes
+    changes in signalling objects in atomic way ("all
+    or nothing");
+  - **Reactive Function** - a function that is
     (re-)executed in response to changes made in
-    observable objects by atomic actions;
-  - **Cache** -  a function which result is remembered
-    and, if becomes obsolete, causes function to
-    re-execute on-demand.
+    signalling objects by transactional functions;
+  - **Cache Function** -  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.
@@ -48,17 +48,17 @@ Quick introduction and detailed description is below.
 Here is an example of transactional reactive code:
 
 ``` typescript
-class Demo extends ObservableObject {
+class Demo extends SignallingObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @atomic
+  @transaction
   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)
@@ -68,28 +68,28 @@ class Demo extends ObservableObject {
 }
 ```
 
-In the example above, `Demo` is an observable object,
+In the example above, `Demo` is a signalling object,
 meaning that access to its fields are seamlessly tracked
 to determine dependent reactive and cached functions.
 Reactive 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 atomic
-function `saveContact`.
+in response to changes of these fields made by the
+transactional function `saveContact`.
 
 Here is an example of a cached result that is
 (re-)computed on-demand:
 
 ``` typescript
-class Demo extends ObservableObject {
+class Demo extends SignallingObject {
   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)
@@ -107,15 +107,15 @@ thus causing execution of depending reactive function
 `printContact` runs it reads `contact` and causes its
 re-computation.
 
-## Observable Objects
+## Signalling Objects
 
-Observable objects are aimed to store data of
+Signalling 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 {
+class MyModel extends SignallingObject {
   url: string = "https://github.com/nezaboodka/reactronic"
   content: string = "transactional reactive state management"
   timestamp: Date = Date.now()
@@ -123,21 +123,22 @@ class MyModel extends ObservableObject {
 ```
 
 In the example above, the class `MyModel` is based on
-Reactronic's `ObservableObject` class and all its
+Reactronic's `SignallingObject` class and all its
 properties `url`, `content`, and `timestamp` are hooked.
 
-## Atomic Function
+## Transactional Function
 
-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).
+Transactional function makes changes in signalling
+objects in atomic way ("all or nothing"), thus provoking
+execution of dependent reactive and cached functions.
+Transactional function is instrumented with hooks to
+provide transparent atomicity (by implicit context
+switching and isolation).
 
 ``` typescript
-class MyModel extends ObservableObject {
+class MyModel extends SignallingObject {
   // ...
-  @atomic
+  @transaction
   async load(url: string): Promise<void> {
     this.url = url
     this.content = await fetch(url)
@@ -146,9 +147,9 @@ class MyModel extends ObservableObject {
 }
 ```
 
-In the example above, the atomic function `load` makes
+In the example above, the transactional function `load` makes
 changes to `url`, `content` and `timestamp` properties.
-While atomic function is running, the changes are visible
+While transactional function is running, the changes are visible
 only inside the function itself. The new values become
 atomically visible outside of the function only upon its
 completion.
@@ -159,41 +160,41 @@ function 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 function. That is a logical snapshot that does
-not create a full copy of all the data.
+each transactional function. 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 function failure, because all the changes
-made by the atomic function in its logical snapshot are
-simply discarded. In case the atomic function is
+of a transactional function failure, because all the changes
+made by transactional function in its logical snapshot are
+simply discarded. In case a transaction function 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 function execution. Atomic function
-may consist of a set of asynchronous calls prolonging
-the function until completion of all of them. An
-asynchronous call may spawn other asynchronous calls,
-which prolong atomic atomic execution until the whole
+the box during transactional function execution.
+Transactional function may consist of a set of asynchronous
+calls prolonging the function until completion of all of
+them. An asynchronous call may spawn other asynchronous
+calls, which prolong transactional execution until the whole
 chain of asynchronous operations is fully completed.
 
 ## Reactive & Cached Functions
 
 Reactive function is automatically and immediately called
-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
+in response to changes in signalling objects made by
+transactional functions. Cached function is called on-demand
+to renew the result if it was marked as obsolete due to
+changes made by an transactional functions. Reactive and cached
 functions are instrumented with hooks to seamlessly
-subscribe to those observable objects and other cached
+subscribe to those signalling objects and other cached
 functions (dependencies), which are used during their
 execution.
 
 ``` tsx
 class MyView extends Component<{model: MyModel}> {
-  @cached
+  @cache
   render(): React.JSX.Element {
     return (
       <div>
@@ -207,12 +208,12 @@ class MyView extends Component<{model: MyModel}> {
 
 ``` tsx
 class Component<P> extends React.Component<P> {
-  @cached
+  @cache
   render(): React.JSX.Element {
     throw new Error('render method is undefined')
   }
 
-  @reactive // called in response to changes
+  @reaction // called in response to changes
   ensureUpToDate(): void {
     if (this.shouldComponentUpdate()) {
       // Ask React to re-render
@@ -231,7 +232,7 @@ class Component<P> extends React.Component<P> {
   }
 
   componentWillUnmount(): void {
-    atomicAction(disposeObservableObject, this)
+    runTransactional(disposeSignallingObject, this)
   }
 }
 ```
@@ -250,14 +251,14 @@ cached value.
 
 In general case, all reactive and cached functions
 are automatically and immediately marked as obsolete
-when changes are made in those observable objects and
+when changes are made in those signalling 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 observable objects and reactive/cached
+between all the signalling 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
@@ -277,11 +278,11 @@ reactive functions:
 is executed in case of recurring changes:
 
   - `(ms)` - minimal delay in milliseconds between executions;
-  - `-1` - execute immediately once atomic function is applied (synchronously);
+  - `-1` - execute immediately once transactional function changes are 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 atomic
+**Reentrance** option defines how to handle reentrant calls of transactional
 and reactive functions:
 
   - `preventWithError` - fail with error if there is an existing call in progress;
@@ -292,7 +293,7 @@ and reactive 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 atomic, reactive, and cached functions, thus maintaining
+multiple transactional, reactive, and cached functions, thus maintaining
 consolidated status for all of them (busy, workers, etc).
 
 ## Notes
@@ -323,20 +324,20 @@ NPM: `npm install reactronic`
 
 // Classes
 
-class AtomicObject { }
-class ObservableObject { }
+class TransactionalObject { }
+class SignallingObject { }
 
 // Decorators & Operators
 
-function observable(boolean) // field only
-function observable(proto, prop) // field only
-function atomic(proto, prop, pd) // method only
+function signal(boolean) // field only
+function signal(proto, prop) // field only
+function transaction(proto, prop, pd) // method only
 function reaction(proto, prop, pd) // method only
 function cache(proto, prop, pd) // method only
 function options(value: Partial<ReactivityOptions>): F<any>
 
-function runNonReactively<T>(func: F<T>, ...args: any[]): T
-function runSensitively<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
+function runNonReactive<T>(func: F<T>, ...args: any[]): T
+function runSensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
 // SnapshotOptions, ReactivityOptions, Kind, Reentrance, Indicator, LoggingOptions, ProfilingOptions
 
@@ -353,7 +354,7 @@ type ReactivityOptions = {
   readonly isolation: Isolation
   readonly order: number
   readonly noSideEffects: boolean
-  readonly observableArgs: boolean
+  readonly signalArgs: boolean
   readonly throttling: number // milliseconds, -1 is immediately, Number.MAX_SAFE_INTEGER is never
   readonly reentrance: Reentrance
   readonly journal: Journal | undefined
@@ -363,7 +364,7 @@ type ReactivityOptions = {
 
 enum Kind {
   plain = 0,
-  atomic = 1,
+  transaction = 1,
   reaction = 2,
   cache = 3
 }

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

@@ -10,9 +10,9 @@ export declare enum Priority {
 }
 export declare enum Kind {
     plain = 0,
-    atomic = 1,
-    reactive = 2,
-    cached = 3
+    transaction = 1,
+    reaction = 2,
+    cache = 3
 }
 export declare enum Reentrance {
     preventWithError = 1,

package/build/dist/source/Enums.js

@@ -13,9 +13,9 @@ export var 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["transaction"] = 1] = "transaction";
+    Kind[Kind["reaction"] = 2] = "reaction";
+    Kind[Kind["cache"] = 3] = "cache";
 })(Kind || (Kind = {}));
 export var Reentrance;
 (function (Reentrance) {

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

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

package/build/dist/source/OperationEx.js

@@ -7,9 +7,9 @@ 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 { ObservableObject } from "./core/Mvcc.js";
-import { reactive } from "./System.js";
-export class ReactiveOperationEx extends ObservableObject {
+import { SxObject } from "./core/Mvcc.js";
+import { reaction } from "./System.js";
+export class ReactionEx extends SxObject {
     constructor(operation) {
         super();
         this.operation = operation;
@@ -19,8 +19,8 @@ export class ReactiveOperationEx extends ObservableObject {
     }
 }
 __decorate([
-    reactive,
+    reaction,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
-], ReactiveOperationEx.prototype, "launch", null);
+], ReactionEx.prototype, "launch", null);

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

@@ -16,7 +16,7 @@ export type ReactivityOptions = {
     readonly isolation: Isolation;
     readonly order: number;
     readonly noSideEffects: boolean;
-    readonly observableArgs: boolean;
+    readonly signalArgs: boolean;
     readonly throttling: number;
     readonly reentrance: Reentrance;
     readonly allowObsoleteToFinish: boolean;
@@ -24,7 +24,7 @@ export type ReactivityOptions = {
     readonly indicator: Indicator | null;
     readonly logging?: Partial<LoggingOptions>;
 };
-export type ReactiveOperation<T> = {
+export type Reaction<T> = {
     readonly options: ReactivityOptions;
     readonly args: ReadonlyArray<any>;
     readonly result: T;

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

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

package/build/dist/source/Pipe.js

@@ -1,5 +1,5 @@
 import { misuse } from "./util/Dbg.js";
-import { ObservableObject } from "./core/Mvcc.js";
-export class Pipe extends ObservableObject {
+import { SxObject } from "./core/Mvcc.js";
+export class Pipe extends SxObject {
     static create(hint, capacity) { throw misuse("not implemented"); }
 }

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

@@ -28,8 +28,8 @@ export declare class Ref<T = any> {
     get variable(): T;
     set variable(value: T);
     nonReactively(): T;
-    observe(): T;
-    unobserve(): T;
+    signalling(): T;
+    nonSignalling(): T;
     static sameRefs(v1: Ref, v2: Ref): boolean;
     static similarRefs(v1: Ref, v2: Ref): boolean;
 }

package/build/dist/source/Ref.js

@@ -1,5 +1,5 @@
 import { misuse } from "./util/Dbg.js";
-import { runAtomically, runNonReactively } from "./System.js";
+import { runTransactional, runNonReactive } from "./System.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }
@@ -29,12 +29,12 @@ export class Ref {
             this.owner[this.name][this.index] = value;
     }
     nonReactively() {
-        return runNonReactively(() => this.variable);
+        return runNonReactive(() => this.variable);
     }
-    observe() {
+    signalling() {
         return this.variable;
     }
-    unobserve() {
+    nonSignalling() {
         throw misuse("not implemented");
     }
     static sameRefs(v1, v2) {
@@ -53,7 +53,7 @@ export class ToggleRef extends Ref {
     toggle() {
         const o = this.owner;
         const p = this.name;
-        runAtomically({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
+        runTransactional({ 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

@@ -1,5 +1,5 @@
 import { F } from "./util/Utils.js";
-import { ReactiveOperation, ReactivityOptions, LoggingOptions, ProfilingOptions, SnapshotOptions } from "./Options.js";
+import { Reaction, ReactivityOptions, LoggingOptions, ProfilingOptions, SnapshotOptions } from "./Options.js";
 export declare class ReactiveSystem {
     static why(brief?: boolean): string;
     static getRevisionOf(obj: any): number;
@@ -13,17 +13,17 @@ export declare class ReactiveSystem {
     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 runTransactional<T>(func: F<T>, ...args: any[]): T;
+export declare function runTransactional<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
+export declare function runNonReactive<T>(func: F<T>, ...args: any[]): T;
+export declare function runSensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
+export declare function runContextual<T>(p: Promise<T>): Promise<T>;
+export declare function manageReaction<T>(method: F<T>): Reaction<T>;
+export declare function configureCurrentReaction(options: Partial<ReactivityOptions>): ReactivityOptions;
+export declare function disposeSignallingObject(obj: any): void;
+export declare function signal(enabled: boolean): (proto: object, prop: PropertyKey) => any;
+export declare function signal<T>(proto: object, prop: PropertyKey): any;
+export declare function transaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function reaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function cache(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function options(value: Partial<ReactivityOptions>): F<any>;

package/build/dist/source/System.js

@@ -4,9 +4,9 @@ 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 { ReactiveOperationImpl } from "./core/Operation.js";
+import { ReactionImpl } from "./core/Operation.js";
 export class ReactiveSystem {
-    static why(brief = false) { return brief ? ReactiveOperationImpl.briefWhy() : ReactiveOperationImpl.why(); }
+    static why(brief = false) { return brief ? ReactionImpl.briefWhy() : ReactionImpl.why(); }
     static getRevisionOf(obj) { return obj[Meta.Revision]; }
     static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }
     static get reactivityAutoStartDisabled() { return Mvcc.reactivityAutoStartDisabled; }
@@ -18,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 runAtomically(p1, p2, p3) {
+export function runTransactional(p1, p2, p3) {
     if (p1 instanceof Function) {
         if (p2 !== undefined)
             return Transaction.run(null, p1, ...p2);
@@ -32,25 +32,25 @@ export function runAtomically(p1, p2, p3) {
             return Transaction.run(p1, p2);
     }
 }
-export function runNonReactively(func, ...args) {
-    return ReactiveOperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
+export function runNonReactive(func, ...args) {
+    return ReactionImpl.proceedWithinGivenLaunch(undefined, func, ...args);
 }
-export function runSensitively(sensitivity, func, ...args) {
+export function runSensitive(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);
 }
-export function runContextually(p) {
+export function runContextual(p) {
     throw misuse("not implemented yet");
 }
-export function manageReactiveOperation(method) {
-    return ReactiveOperationImpl.manageReactiveOperation(method);
+export function manageReaction(method) {
+    return ReactionImpl.manageReaction(method);
 }
-export function configureCurrentReactiveOperation(options) {
-    return ReactiveOperationImpl.configureImpl(undefined, options);
+export function configureCurrentReaction(options) {
+    return ReactionImpl.configureImpl(undefined, options);
 }
-export function disposeObservableObject(obj) {
+export function disposeSignallingObject(obj) {
     Changeset.dispose(obj);
 }
-export function observable(protoOrEnabled, prop) {
+export function signal(protoOrEnabled, prop) {
     if (typeof (protoOrEnabled) === "boolean") {
         return (proto, prop) => {
             return Mvcc.decorateData(protoOrEnabled, proto, prop);
@@ -59,28 +59,28 @@ export function observable(protoOrEnabled, prop) {
     else
         return Mvcc.decorateData(true, protoOrEnabled, prop);
 }
-export function atomic(proto, prop, pd) {
+export function transaction(proto, prop, pd) {
     const opts = {
-        kind: Kind.atomic,
+        kind: Kind.transaction,
         isolation: Isolation.joinToCurrentTransaction,
     };
-    return Mvcc.decorateOperation(true, atomic, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, transaction, 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/api.d.ts

@@ -1,25 +1,25 @@
 export { all, pause, proceedSyncOrAsync } from "./util/Utils.js";
 export { Uri } from "./util/Uri.js";
-export { ScriptedList } from "./util/ScriptedList.js";
-export type { LinkedItem, ScriptedListReader } from "./util/ScriptedList.js";
+export { ReconciliationList } from "./util/ReconciliationList.js";
+export type { LinkedItem, ReconciliationListReader } from "./util/ReconciliationList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.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 { Reaction, 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 { AtomicObject, ObservableObject } from "./core/Mvcc.js";
-export { AtomicArray, ObservableArray } from "./core/MvccArray.js";
-export { AtomicMap, ObservableMap } from "./core/MvccMap.js";
+export { TxObject, SxObject } from "./core/Mvcc.js";
+export { TxArray, SxArray } from "./core/MvccArray.js";
+export { TxMap, SxMap } 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 { 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 { runTransactional, runNonReactive, runSensitive, runContextual, manageReaction, configureCurrentReaction, disposeSignallingObject } from "./System.js";
+export { ReactiveSystem, signal, transaction, reaction, cache, options } from "./System.js";
+export { ReactionEx } from "./OperationEx.js";
 export { declare, derivative, launch, ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
 export type { Script, ScriptAsync, Handler, ReactiveTreeNodeDecl, ReactiveTreeNodeDriver, ReactiveTreeNodeContext } from "./core/TreeNode.js";