reactronic 0.93.25025 → 0.94.25027

package/build/dist/source/api.js

@@ -3,16 +3,18 @@ export { MergeList } 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 { LoggingLevel } from "./Options.js";
+export { Mode, Priority, Kind, Reentrance, Isolation } from "./Enums.js";
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } 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 { 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";

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

@@ -1,5 +1,6 @@
-import { Kind, SnapshotOptions } from "../Options.js";
-import { AbstractChangeset, ObjectVersion, FieldKey, ObjectHandle, FieldVersion, Reaction } from "./Data.js";
+import { Kind } from "../Enums.js";
+import { SnapshotOptions } from "../Options.js";
+import { AbstractChangeset, ObjectVersion, FieldKey, ObjectHandle, ContentFootprint, OperationFootprint } from "./Data.js";
 export declare const MAX_REVISION: number;
 export declare const UNDEFINED_REVISION: number;
 export declare class Changeset implements AbstractChangeset {
@@ -19,12 +20,12 @@ export declare class Changeset implements AbstractChangeset {
     private revision;
     private bumper;
     items: Map<ObjectHandle, ObjectVersion>;
-    obsolete: Reaction[];
+    obsolete: OperationFootprint[];
     sealed: boolean;
     constructor(options: SnapshotOptions | null, parent?: Changeset);
     static current: () => Changeset;
     static edit: () => Changeset;
-    static markUsed: (fv: FieldVersion, ov: ObjectVersion, fk: FieldKey, h: ObjectHandle, kind: Kind, weak: boolean) => void;
+    static markUsed: (cf: ContentFootprint, ov: ObjectVersion, fk: FieldKey, h: ObjectHandle, kind: Kind, weak: boolean) => void;
     static markEdited: (oldValue: any, newValue: any, edited: boolean, ov: ObjectVersion, fk: FieldKey, h: ObjectHandle) => void;
     static tryResolveConflict: (theirValue: any, ourFormerValue: any, ourValue: any) => {
         isResolved: boolean;
@@ -32,7 +33,7 @@ export declare class Changeset implements AbstractChangeset {
     };
     static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
     static revokeAllSubscriptions: (changeset: Changeset) => void;
-    static enqueueReactionsToRun: (reactions: Array<Reaction>) => void;
+    static enqueueReactionsToRun: (reactions: Array<OperationFootprint>) => void;
     lookupObjectVersion(h: ObjectHandle, fk: FieldKey, editing: boolean): ObjectVersion;
     getObjectVersion(h: ObjectHandle, fk: FieldKey): ObjectVersion;
     getEditableObjectVersion(h: ObjectHandle, fk: FieldKey, value: any, token?: any): ObjectVersion;
@@ -47,7 +48,7 @@ export declare class Changeset implements AbstractChangeset {
     private merge;
     seal(): void;
     sealObjectVersion(h: ObjectHandle, ov: ObjectVersion): void;
-    static sealFieldVersion(fv: FieldVersion | symbol, fk: FieldKey, typeName: string): void;
+    static sealFieldVersion(cf: ContentFootprint | symbol, fk: FieldKey, typeName: string): void;
     static freezeObjectVersion(ov: ObjectVersion): ObjectVersion;
     triggerGarbageCollection(): void;
     private unlinkHistory;
@@ -56,7 +57,7 @@ export declare class Changeset implements AbstractChangeset {
 export declare class Dump {
     static valueHint: (value: any) => string;
     static obj(h: ObjectHandle | undefined, fk?: FieldKey | undefined, stamp?: number, changesetId?: number, lastEditorChangesetId?: number, value?: any): string;
-    static snapshot2(h: ObjectHandle, s: AbstractChangeset, fk?: FieldKey, o?: FieldVersion): string;
+    static snapshot2(h: ObjectHandle, s: AbstractChangeset, fk?: FieldKey, cf?: ContentFootprint): string;
     static snapshot(ov: ObjectVersion, fk?: FieldKey): string;
     static conflicts(conflicts: ObjectVersion[]): string;
     static conflictingMemberHint(fk: FieldKey, ours: ObjectVersion, theirs: ObjectVersion): string;

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

@@ -4,8 +4,8 @@ import { Sealant } from "../util/Sealant.js";
 import { SealedArray } from "../util/SealedArray.js";
 import { SealedMap } from "../util/SealedMap.js";
 import { SealedSet } from "../util/SealedSet.js";
-import { Isolation } from "../Options.js";
-import { ObjectVersion, ObjectHandle, FieldVersion, Meta } from "./Data.js";
+import { Isolation } from "../Enums.js";
+import { ObjectVersion, ObjectHandle, ContentFootprint, Meta } from "./Data.js";
 export const MAX_REVISION = Number.MAX_SAFE_INTEGER;
 export const UNDEFINED_REVISION = MAX_REVISION - 1;
 Object.defineProperty(ObjectHandle.prototype, "#this#", {
@@ -15,7 +15,7 @@ Object.defineProperty(ObjectHandle.prototype, "#this#", {
         const data = Changeset.current().getObjectVersion(this, "#this#").data;
         for (const fk in data) {
             const v = data[fk];
-            if (v instanceof FieldVersion)
+            if (v instanceof ContentFootprint)
                 result[fk] = v.content;
             else if (v === Meta.Raw)
                 result[fk] = this.data[fk];
@@ -76,7 +76,7 @@ export class Changeset {
                 const revision = fk === Meta.Handle ? 1 : ov.revision + 1;
                 const data = Object.assign({}, fk === Meta.Handle ? value : ov.data);
                 Meta.set(data, Meta.Handle, h);
-                Meta.set(data, Meta.Revision, new FieldVersion(revision, this.id));
+                Meta.set(data, Meta.Revision, new ContentFootprint(revision, this.id));
                 ov = new ObjectVersion(this, ov, data);
                 this.items.set(h, ov);
                 h.editing = ov;
@@ -95,7 +95,7 @@ export class Changeset {
             if (existing === undefined || existing.content !== content || sensitivity) {
                 const existingContent = existing === null || existing === void 0 ? void 0 : existing.content;
                 if (ov.former.objectVersion.data[fk] === existing) {
-                    existing = ov.data[fk] = new FieldVersion(content, this.id);
+                    existing = ov.data[fk] = new ContentFootprint(content, this.id);
                     Changeset.markEdited(existingContent, content, true, ov, fk, h);
                 }
                 else {
@@ -125,7 +125,7 @@ export class Changeset {
     }
     isNewObjectVersionRequired(h, ov, fk, existing, value, token) {
         if (this.sealed && ov.changeset !== EMPTY_OBJECT_VERSION.changeset)
-            throw misuse(`triggering property ${Dump.obj(h, fk)} can only be modified inside transaction`);
+            throw misuse(`observable property ${Dump.obj(h, fk)} can only be modified inside transaction`);
         if (fk !== Meta.Handle) {
             if (value !== Meta.Handle) {
                 if (ov.changeset !== this || ov.former.objectVersion !== EMPTY_OBJECT_VERSION) {
@@ -190,8 +190,8 @@ export class Changeset {
         const merged = Object.assign({}, theirs.data);
         ours.changes.forEach((o, fk) => {
             counter++;
-            const ourFieldVersion = ours.data[fk];
-            merged[fk] = ourFieldVersion;
+            const ourContentFootprint = ours.data[fk];
+            merged[fk] = ourContentFootprint;
             if (theirsDisposed || oursDisposed) {
                 if (theirsDisposed !== oursDisposed) {
                     if (theirsDisposed || this.options.isolation !== Isolation.disjoinForInternalDisposal) {
@@ -204,10 +204,10 @@ export class Changeset {
             else {
                 const theirValue = theirs.data[fk];
                 const ourFormerValue = ours.former.objectVersion.data[fk];
-                const { isResolved, resolvedValue } = Changeset.tryResolveConflict(theirValue, ourFormerValue, ourFieldVersion);
+                const { isResolved, resolvedValue } = Changeset.tryResolveConflict(theirValue, ourFormerValue, ourContentFootprint);
                 if (!isResolved)
                     ours.conflicts.set(fk, theirs);
-                else if (resolvedValue.isLaunch)
+                else if (resolvedValue.isComputed)
                     merged[fk] = resolvedValue;
                 if (Log.isOn && Log.opt.change)
                     Log.write("║╠", "", `${Dump.snapshot2(h, ours.changeset, fk)} ${!isResolved ? "<>" : "=="} ${Dump.snapshot2(h, theirs.changeset, fk)}`, 0, !isResolved ? " *** CONFLICT ***" : undefined);
@@ -234,13 +234,13 @@ export class Changeset {
         if (h.editors === 0)
             h.editing = undefined;
     }
-    static sealFieldVersion(fv, fk, typeName) {
-        if (fv instanceof FieldVersion) {
-            const content = fv.content;
+    static sealFieldVersion(cf, fk, typeName) {
+        if (cf instanceof ContentFootprint) {
+            const content = cf.content;
             if (content !== undefined && content !== null) {
                 const sealedType = Object.getPrototypeOf(content)[Sealant.SealedType];
                 if (sealedType)
-                    fv.content = Sealant.seal(content, sealedType, typeName, fk);
+                    cf.content = Sealant.seal(content, sealedType, typeName, fk);
             }
         }
     }
@@ -334,14 +334,14 @@ export class Dump {
             result = `boot${member}`;
         return result;
     }
-    static snapshot2(h, s, fk, o) {
+    static snapshot2(h, s, fk, cf) {
         var _a;
-        return Dump.obj(h, fk, s.timestamp, s.id, o === null || o === void 0 ? void 0 : o.lastEditorChangesetId, (_a = o === null || o === void 0 ? void 0 : o.content) !== null && _a !== void 0 ? _a : Meta.Undefined);
+        return Dump.obj(h, fk, s.timestamp, s.id, cf === null || cf === void 0 ? void 0 : cf.lastEditorChangesetId, (_a = cf === null || cf === void 0 ? void 0 : cf.content) !== null && _a !== void 0 ? _a : Meta.Undefined);
     }
     static snapshot(ov, fk) {
         const h = Meta.get(ov.data, Meta.Handle);
-        const fv = fk !== undefined ? ov.data[fk] : undefined;
-        return Dump.obj(h, fk, ov.changeset.timestamp, ov.changeset.id, fv === null || fv === void 0 ? void 0 : fv.lastEditorChangesetId);
+        const cf = fk !== undefined ? ov.data[fk] : undefined;
+        return Dump.obj(h, fk, ov.changeset.timestamp, ov.changeset.id, cf === null || cf === void 0 ? void 0 : cf.lastEditorChangesetId);
     }
     static conflicts(conflicts) {
         return conflicts.map(ours => {

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

@@ -5,19 +5,19 @@ export type AbstractChangeset = {
     readonly timestamp: number;
     readonly sealed: boolean;
 };
-export declare class FieldVersion<T = any> {
+export declare class ContentFootprint<T = any> {
     content: T;
-    reactions?: Set<Reaction>;
+    subscribers?: Set<OperationFootprint>;
     lastEditorChangesetId: number;
-    get isLaunch(): boolean;
+    get isComputed(): boolean;
     constructor(content: T, lastEditorChangesetId: number);
 }
-export type Reaction = {
+export type OperationFootprint = {
     readonly order: number;
-    readonly triggers: Map<FieldVersion, Subscription> | undefined;
+    readonly observables: Map<ContentFootprint, Subscription> | undefined;
     readonly obsoleteSince: number;
     hint(nop?: boolean): string;
-    markObsoleteDueTo(trigger: FieldVersion, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, collector: Array<Reaction>): void;
+    markObsoleteDueTo(footprint: ContentFootprint, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, collector: Array<OperationFootprint>): void;
     relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
 };
 export type FieldKey = PropertyKey;

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

@@ -1,8 +1,8 @@
 import { Log } from "../util/Dbg.js";
 import { Meta } from "./Meta.js";
 export { Meta } from "./Meta.js";
-export class FieldVersion {
-    get isLaunch() { return false; }
+export class ContentFootprint {
+    get isComputed() { return false; }
     constructor(content, lastEditorChangesetId) { this.content = content; this.lastEditorChangesetId = lastEditorChangesetId; }
 }
 export class ObjectVersion {

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

@@ -1,6 +1,6 @@
 import { Worker } from "../Worker.js";
-import { TriggeringObject } from "./Mvcc.js";
-export declare abstract class Indicator extends TriggeringObject {
+import { ObservableObject } from "./Mvcc.js";
+export declare abstract class Indicator extends ObservableObject {
     abstract readonly isBusy: boolean;
     abstract readonly counter: number;
     abstract readonly workers: ReadonlySet<Worker>;

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

@@ -7,10 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Isolation } from "../Options.js";
-import { TriggeringObject, Mvcc } from "./Mvcc.js";
+import { Isolation } from "../Enums.js";
+import { ObservableObject, Mvcc } from "./Mvcc.js";
 import { Transaction } from "./Transaction.js";
-export class Indicator extends TriggeringObject {
+export class Indicator extends ObservableObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
         return IndicatorImpl.createImpl(hint, activationDelay, deactivationDelay, durationResolution);
     }

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

@@ -1,7 +1,7 @@
-import { TriggeringObject } from "./Mvcc.js";
+import { ObservableObject } from "./Mvcc.js";
 import { ObjectHandle, ObjectVersion, PatchSet } from "./Data.js";
 export type Saver = (patch: PatchSet) => Promise<void>;
-export declare abstract class Journal extends TriggeringObject {
+export declare abstract class Journal extends ObservableObject {
     abstract capacity: number;
     abstract readonly edits: ReadonlyArray<PatchSet>;
     abstract readonly unsaved: PatchSet;

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

@@ -1,10 +1,10 @@
-import { Isolation } from "../Options.js";
-import { TriggeringObject } from "./Mvcc.js";
-import { Meta, FieldVersion } from "./Data.js";
+import { Isolation } from "../Enums.js";
+import { ObservableObject } from "./Mvcc.js";
+import { Meta, ContentFootprint } from "./Data.js";
 import { Changeset, EMPTY_OBJECT_VERSION } from "./Changeset.js";
 import { Transaction } from "./Transaction.js";
 import { Sealant } from "../util/Sealant.js";
-export class Journal extends TriggeringObject {
+export class Journal extends ObservableObject {
     static create() { return new JournalImpl(); }
 }
 export class JournalImpl extends Journal {
@@ -100,7 +100,7 @@ export class JournalImpl extends Journal {
                     const content = undoing ? vp.formerContent : vp.freshContent;
                     const ov = ctx.getEditableObjectVersion(h, fk, content);
                     if (ov.changeset === ctx) {
-                        ov.data[fk] = new FieldVersion(content, ctx.id);
+                        ov.data[fk] = new ContentFootprint(content, ctx.id);
                         const existing = ov.former.objectVersion.data[fk];
                         Changeset.markEdited(existing, content, existing !== content, ov, fk, h);
                     }
@@ -138,8 +138,8 @@ export class JournalImpl extends Journal {
         });
     }
 }
-function unseal(fv) {
-    const result = fv.content;
+function unseal(cf) {
+    const result = cf.content;
     const createCopy = result === null || result === void 0 ? void 0 : result[Sealant.CreateCopy];
     return createCopy !== undefined ? createCopy.call(result) : result;
 }

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

@@ -1,7 +1,7 @@
 export declare abstract class Meta {
     static readonly Handle: unique symbol;
     static readonly Revision: unique symbol;
-    static readonly Controller: unique symbol;
+    static readonly Descriptor: unique symbol;
     static readonly Initial: unique symbol;
     static readonly Reactive: unique symbol;
     static readonly Raw: unique symbol;

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

@@ -22,7 +22,7 @@ export class Meta {
 }
 Meta.Handle = Symbol("rx-handle");
 Meta.Revision = Symbol("rx-revision");
-Meta.Controller = Symbol("rx-controller");
+Meta.Descriptor = Symbol("rx-descriptor");
 Meta.Initial = Symbol("rx-initial");
 Meta.Reactive = Symbol("rx-reactive");
 Meta.Raw = Symbol("rx-raw");

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

@@ -1,27 +1,28 @@
 import { F } from "../util/Utils.js";
-import { MemberOptions, Kind, Reentrance, Isolation } from "../Options.js";
+import { Kind, Reentrance, Isolation } from "../Enums.js";
+import { ReactivityOptions } from "../Options.js";
 import { LoggingOptions, ProfilingOptions } from "../Logging.js";
 import { FieldKey, ObjectHandle } from "./Data.js";
 import { Journal } from "./Journal.js";
 import { Indicator } from "./Indicator.js";
 export declare abstract class MvccObject {
-    protected constructor(isTriggering: boolean);
+    protected constructor(isObservable: boolean);
     [Symbol.toStringTag](): string;
 }
-export declare abstract class TransactionalObject extends MvccObject {
+export declare abstract class AtomicObject extends MvccObject {
     constructor();
 }
-export declare abstract class TriggeringObject extends MvccObject {
+export declare abstract class ObservableObject extends MvccObject {
     constructor();
 }
-export declare class OptionsImpl implements MemberOptions {
+export declare class OptionsImpl implements ReactivityOptions {
     readonly getter: Function;
     readonly setter: Function;
     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;
@@ -37,10 +38,10 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     static mainThreadBlockingWarningThreshold: number;
     static asyncActionDurationWarningThreshold: number;
     static sensitivity: boolean;
-    static readonly transactional: Mvcc;
-    static readonly triggering: Mvcc;
-    readonly isTriggering: boolean;
-    constructor(isTriggering: boolean);
+    static readonly atomic: Mvcc;
+    static readonly observable: Mvcc;
+    readonly isObservable: boolean;
+    constructor(isObservable: boolean);
     getPrototypeOf(h: ObjectHandle): object | null;
     get(h: ObjectHandle, fk: FieldKey, receiver: any): any;
     set(h: ObjectHandle, fk: FieldKey, value: any, receiver: any): boolean;
@@ -48,15 +49,15 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     defineProperty?(h: ObjectHandle, name: string | symbol, attributes: PropertyDescriptor): boolean;
     getOwnPropertyDescriptor(h: ObjectHandle, fk: FieldKey): PropertyDescriptor | undefined;
     ownKeys(h: ObjectHandle): Array<string | symbol>;
-    static decorateData(isTrigger: boolean, proto: any, fk: FieldKey): any;
-    static decorateOperation(implicit: boolean, decorator: Function, options: Partial<MemberOptions>, proto: any, member: FieldKey, pd: PropertyDescriptor | undefined): any;
-    static decorateOperationParametrized(decorator: Function, options: Partial<MemberOptions>): F<any>;
+    static decorateData(isObservable: boolean, proto: any, fk: FieldKey): any;
+    static decorateOperation(implicit: boolean, decorator: Function, options: Partial<ReactivityOptions>, proto: any, member: FieldKey, pd: PropertyDescriptor | undefined): any;
+    static decorateOperationParametrized(decorator: Function, options: Partial<ReactivityOptions>): F<any>;
     static acquireHandle(obj: any): ObjectHandle;
-    static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, isTriggering: boolean): ObjectHandle;
+    static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, isObservable: boolean): ObjectHandle;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
     static sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
     static setHint<T>(obj: T, hint: string | undefined): T;
     static getHint<T>(obj: T): string;
-    static createOperation: (h: ObjectHandle, fk: FieldKey, options: OptionsImpl) => F<any>;
-    static rememberOperationOptions: (proto: any, fk: FieldKey, getter: Function | undefined, setter: Function | undefined, enumerable: boolean, configurable: boolean, options: Partial<MemberOptions>, implicit: boolean) => OptionsImpl;
+    static createOperationDescriptor: (h: ObjectHandle, fk: FieldKey, options: OptionsImpl) => F<any>;
+    static rememberOperationOptions: (proto: any, fk: FieldKey, getter: Function | undefined, setter: Function | undefined, enumerable: boolean, configurable: boolean, options: Partial<ReactivityOptions>, implicit: boolean) => OptionsImpl;
 }

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

@@ -1,13 +1,13 @@
 import { UNDEF } from "../util/Utils.js";
 import { Log, misuse } from "../util/Dbg.js";
-import { Kind, Reentrance, Isolation } from "../Options.js";
-import { ObjectVersion, ObjectHandle, FieldVersion, Meta } from "./Data.js";
+import { Kind, Reentrance, Isolation } from "../Enums.js";
+import { ObjectVersion, ObjectHandle, ContentFootprint, Meta } from "./Data.js";
 import { Changeset, Dump, EMPTY_OBJECT_VERSION } from "./Changeset.js";
 export class MvccObject {
-    constructor(isTriggering) {
+    constructor(isObservable) {
         const proto = new.target.prototype;
         const initial = Meta.getFrom(proto, Meta.Initial);
-        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, isTriggering);
+        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, isObservable);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
@@ -15,12 +15,12 @@ export class MvccObject {
         return Dump.obj(h);
     }
 }
-export class TransactionalObject extends MvccObject {
+export class AtomicObject extends MvccObject {
     constructor() {
         super(false);
     }
 }
-export class TriggeringObject extends MvccObject {
+export class ObservableObject extends MvccObject {
     constructor() {
         super(true);
     }
@@ -30,7 +30,7 @@ const DEFAULT_OPTIONS = Object.freeze({
     isolation: Isolation.joinToCurrentTransaction,
     order: 0,
     noSideEffects: false,
-    triggeringArgs: false,
+    observableArgs: false,
     throttling: Number.MAX_SAFE_INTEGER,
     reentrance: Reentrance.preventWithError,
     allowObsoleteToFinish: false,
@@ -46,7 +46,7 @@ export class OptionsImpl {
         this.isolation = merge(DEFAULT_OPTIONS.isolation, existing.isolation, patch.isolation, implicit);
         this.order = merge(DEFAULT_OPTIONS.order, existing.order, patch.order, implicit);
         this.noSideEffects = merge(DEFAULT_OPTIONS.noSideEffects, existing.noSideEffects, patch.noSideEffects, implicit);
-        this.triggeringArgs = merge(DEFAULT_OPTIONS.triggeringArgs, existing.triggeringArgs, patch.triggeringArgs, implicit);
+        this.observableArgs = merge(DEFAULT_OPTIONS.observableArgs, existing.observableArgs, patch.observableArgs, implicit);
         this.throttling = merge(DEFAULT_OPTIONS.throttling, existing.throttling, patch.throttling, implicit);
         this.reentrance = merge(DEFAULT_OPTIONS.reentrance, existing.reentrance, patch.reentrance, implicit);
         this.allowObsoleteToFinish = merge(DEFAULT_OPTIONS.allowObsoleteToFinish, existing.allowObsoleteToFinish, patch.allowObsoleteToFinish, implicit);
@@ -62,8 +62,8 @@ function merge(def, existing, patch, implicit) {
     return patch !== undefined && (existing === def || !implicit) ? patch : existing;
 }
 export class Mvcc {
-    constructor(isTriggering) {
-        this.isTriggering = isTriggering;
+    constructor(isObservable) {
+        this.isObservable = isObservable;
     }
     getPrototypeOf(h) {
         return Reflect.getPrototypeOf(h.data);
@@ -74,8 +74,8 @@ export class Mvcc {
             const cs = Changeset.current();
             const ov = cs.getObjectVersion(h, fk);
             result = ov.data[fk];
-            if (result instanceof FieldVersion && !result.isLaunch) {
-                if (this.isTriggering)
+            if (result instanceof ContentFootprint && !result.isComputed) {
+                if (this.isObservable)
                     Changeset.markUsed(result, ov, fk, h, Kind.plain, false);
                 result = result.content;
             }
@@ -117,21 +117,21 @@ export class Mvcc {
         const result = [];
         for (const fk of Object.getOwnPropertyNames(ov.data)) {
             const field = ov.data[fk];
-            if (!(field instanceof FieldVersion) || !field.isLaunch)
+            if (!(field instanceof ContentFootprint) || !field.isComputed)
                 result.push(fk);
         }
         return result;
     }
-    static decorateData(isTrigger, proto, fk) {
-        if (isTrigger) {
-            Meta.acquire(proto, Meta.Initial)[fk] = new FieldVersion(undefined, 0);
+    static decorateData(isObservable, proto, fk) {
+        if (isObservable) {
+            Meta.acquire(proto, Meta.Initial)[fk] = new ContentFootprint(undefined, 0);
             const get = function () {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.triggering.get(h, fk, this);
+                return Mvcc.observable.get(h, fk, this);
             };
             const set = function (value) {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.triggering.set(h, fk, value, this);
+                return Mvcc.observable.set(h, fk, value, this);
             };
             const enumerable = true;
             const configurable = false;
@@ -150,7 +150,7 @@ export class Mvcc {
         if (opts.getter === opts.setter) {
             const bootstrap = function () {
                 const h = Mvcc.acquireHandle(this);
-                const operation = Mvcc.createOperation(h, member, opts);
+                const operation = Mvcc.createOperationDescriptor(h, member, opts);
                 Object.defineProperty(h.data, member, { value: operation, enumerable, configurable });
                 return operation;
             };
@@ -159,7 +159,7 @@ export class Mvcc {
         else if (opts.setter === UNDEF) {
             const bootstrap = function () {
                 const h = Mvcc.acquireHandle(this);
-                const operation = Mvcc.createOperation(h, member, opts);
+                const operation = Mvcc.createOperationDescriptor(h, member, opts);
                 Object.defineProperty(h.data, member, { get: operation, enumerable, configurable });
                 return operation.call(this);
             };
@@ -177,24 +177,24 @@ export class Mvcc {
         let h = obj[Meta.Handle];
         if (!h) {
             if (obj !== Object(obj) || Array.isArray(obj))
-                throw misuse("only objects can be triggering");
+                throw misuse("only objects can be observable");
             const initial = Meta.getFrom(Object.getPrototypeOf(obj), Meta.Initial);
             const ov = new ObjectVersion(EMPTY_OBJECT_VERSION.changeset, EMPTY_OBJECT_VERSION, Object.assign({}, initial));
-            h = new ObjectHandle(obj, obj, Mvcc.triggering, ov, obj.constructor.name);
+            h = new ObjectHandle(obj, obj, Mvcc.observable, ov, obj.constructor.name);
             Meta.set(ov.data, Meta.Handle, h);
             Meta.set(obj, Meta.Handle, h);
-            Meta.set(ov.data, Meta.Revision, new FieldVersion(1, 0));
+            Meta.set(ov.data, Meta.Revision, new ContentFootprint(1, 0));
         }
         return h;
     }
-    static createHandleForMvccObject(proto, data, blank, hint, isTriggering) {
+    static createHandleForMvccObject(proto, data, blank, hint, isObservable) {
         const ctx = Changeset.edit();
-        const mvcc = isTriggering ? Mvcc.triggering : Mvcc.transactional;
+        const mvcc = isObservable ? Mvcc.observable : Mvcc.atomic;
         const h = new ObjectHandle(data, undefined, mvcc, EMPTY_OBJECT_VERSION, hint);
         ctx.getEditableObjectVersion(h, Meta.Handle, blank);
         if (!Mvcc.reactivityAutoStartDisabled)
             for (const fk in Meta.getFrom(proto, Meta.Reactive))
-                h.proxy[fk][Meta.Controller].markObsolete();
+                h.proxy[fk][Meta.Descriptor].markObsolete();
         return h;
     }
     static setProfilingMode(isOn, options) {
@@ -238,10 +238,10 @@ Mvcc.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.sensitivity = false;
-Mvcc.transactional = new Mvcc(false);
-Mvcc.triggering = new Mvcc(true);
-Mvcc.createOperation = function (h, fk, options) {
-    throw misuse("this implementation of createOperation should never be called");
+Mvcc.atomic = new Mvcc(false);
+Mvcc.observable = new Mvcc(true);
+Mvcc.createOperationDescriptor = function (h, fk, options) {
+    throw misuse("this implementation of createOperationDescriptor should never be called");
 };
 Mvcc.rememberOperationOptions = function (proto, fk, getter, setter, enumerable, configurable, options, implicit) {
     throw misuse("this implementation of rememberOperationOptions should never be called");

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

@@ -1,7 +1,7 @@
 import { MvccObject } from "./Mvcc.js";
 export declare class MvccArray<T> extends MvccObject {
     private impl;
-    constructor(isTriggering: boolean, array: Array<T>);
+    constructor(isObservable: boolean, array: Array<T>);
     get length(): number;
     set length(n: number);
     getItem(n: number): T;
@@ -47,13 +47,13 @@ export declare class MvccArray<T> extends MvccObject {
     values(): IterableIterator<T>;
     private get mutable();
 }
-export declare class TransactionalArray<T> extends MvccArray<T> {
+export declare class AtomicArray<T> extends MvccArray<T> {
     constructor();
     constructor(arrayLength: number);
     constructor(arrayLength?: number);
     constructor(...items: T[]);
 }
-export declare class TriggeringArray<T> extends MvccArray<T> {
+export declare class ObservableArray<T> extends MvccArray<T> {
     constructor();
     constructor(arrayLength: number);
     constructor(arrayLength?: number);

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

@@ -1,8 +1,8 @@
 import { Sealant } from "../util/Sealant.js";
 import { MvccObject } from "./Mvcc.js";
 export class MvccArray extends MvccObject {
-    constructor(isTriggering, array) {
-        super(isTriggering);
+    constructor(isObservable, array) {
+        super(isObservable);
         this.impl = array;
     }
     get length() { return this.impl.length; }
@@ -46,12 +46,12 @@ export class MvccArray extends MvccObject {
         return this.impl;
     }
 }
-export class TransactionalArray extends MvccArray {
+export class AtomicArray extends MvccArray {
     constructor(...args) {
         super(false, new Array(...args));
     }
 }
-export class TriggeringArray extends MvccArray {
+export class ObservableArray extends MvccArray {
     constructor(...args) {
         super(true, new Array(...args));
     }

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

@@ -1,7 +1,7 @@
 import { MvccObject } from "./Mvcc.js";
 export declare class MvccMap<K, V> extends MvccObject {
     private impl;
-    constructor(isTriggering: boolean, map: Map<K, V>);
+    constructor(isObservable: boolean, map: Map<K, V>);
     clear(): void;
     delete(key: K): boolean;
     forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
@@ -15,11 +15,11 @@ export declare class MvccMap<K, V> extends MvccObject {
     [Symbol.toStringTag](): string;
     private get mutable();
 }
-export declare class TransactionalMap<K, V> extends MvccMap<K, V> {
+export declare class AtomicMap<K, V> extends MvccMap<K, V> {
     constructor();
     constructor(iterable?: Iterable<readonly [K, V]> | null);
 }
-export declare class TriggeringMap<K, V> extends MvccMap<K, V> {
+export declare class ObservableMap<K, V> extends MvccMap<K, V> {
     constructor();
     constructor(iterable?: Iterable<readonly [K, V]> | null);
 }