reactronic 0.24.275 → 0.24.302

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

@@ -1,6 +1,7 @@
+import { Isolation } from "../Options.js";
 import { ObservableObject } from "./Mvcc.js";
-import { Meta, ValueSnapshot } from "./Data.js";
-import { Changeset, EMPTY_SNAPSHOT } from "./Changeset.js";
+import { Meta, FieldVersion } 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 ObservableObject {
@@ -22,7 +23,7 @@ export class JournalImpl extends Journal {
     get canUndo() { return this._edits.length > 0 && this._position > 0; }
     get canRedo() { return this._position < this._edits.length; }
     edited(p) {
-        Transaction.run({ hint: "EditJournal.edited", separation: "isolated" }, () => {
+        Transaction.run({ hint: "EditJournal.edited", isolation: Isolation.disjoinFromOuterAndInnerTransactions }, () => {
             const items = this._edits = this._edits.toMutable();
             if (items.length >= this._capacity)
                 items.shift();
@@ -40,7 +41,7 @@ export class JournalImpl extends Journal {
             throw new Error("not implemented");
     }
     undo(count = 1) {
-        Transaction.run({ hint: "Journal.undo", separation: "isolated" }, () => {
+        Transaction.run({ hint: "Journal.undo", isolation: Isolation.disjoinFromOuterAndInnerTransactions }, () => {
             let i = this._position - 1;
             while (i >= 0 && count > 0) {
                 const patch = this._edits[i];
@@ -52,7 +53,7 @@ export class JournalImpl extends Journal {
         });
     }
     redo(count = 1) {
-        Transaction.run({ hint: "Journal.redo", separation: "isolated" }, () => {
+        Transaction.run({ hint: "Journal.redo", isolation: Isolation.disjoinFromOuterAndInnerTransactions }, () => {
             let i = this._position;
             while (i < this._edits.length && count > 0) {
                 const patch = this._edits[i];
@@ -65,22 +66,22 @@ export class JournalImpl extends Journal {
     }
     static buildPatch(hint, items) {
         const patch = new Map();
-        items.forEach((os, h) => {
+        items.forEach((ov, h) => {
             const op = new Map();
-            const former = os.former.snapshot !== EMPTY_SNAPSHOT ? os.former.snapshot.data : undefined;
-            os.changes.forEach(m => {
+            const former = ov.former.objectVersion !== EMPTY_OBJECT_VERSION ? ov.former.objectVersion.data : undefined;
+            ov.changes.forEach(fk => {
                 const vp = {
-                    memberName: m, patchKind: "update",
-                    freshValue: unseal(os.data[m]), formerValue: undefined,
+                    fieldKey: fk, patchKind: "update",
+                    freshContent: unseal(ov.data[fk]), formerContent: undefined,
                 };
                 if (former)
-                    vp.formerValue = unseal(former[m]);
-                op.set(m, vp);
+                    vp.formerContent = unseal(former[fk]);
+                op.set(fk, vp);
             });
             if (!former) {
                 const vp = {
-                    memberName: Meta.Revision, patchKind: "remove",
-                    freshValue: Meta.Undefined, formerValue: undefined,
+                    fieldKey: Meta.Revision, patchKind: "remove",
+                    freshContent: Meta.Undefined, formerContent: undefined,
                 };
                 op.set(Meta.Revision, vp);
             }
@@ -93,15 +94,15 @@ export class JournalImpl extends Journal {
         patch.forEach((op, obj) => {
             const h = Meta.get(obj, Meta.Handle);
             const rev = op.get(Meta.Revision);
-            const disposed = rev && (undoing ? rev.formerValue : rev.freshValue) === Meta.Undefined;
+            const disposed = rev && (undoing ? rev.formerContent : rev.freshContent) === Meta.Undefined;
             if (!disposed) {
-                op.forEach((vp, m) => {
-                    const value = undoing ? vp.formerValue : vp.freshValue;
-                    const os = ctx.getEditableObjectSnapshot(h, m, value);
-                    if (os.changeset === ctx) {
-                        os.data[m] = new ValueSnapshot(value);
-                        const existing = os.former.snapshot.data[m];
-                        Changeset.markEdited(existing, value, existing !== value, os, m, h);
+                op.forEach((vp, fk) => {
+                    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);
+                        const existing = ov.former.objectVersion.data[fk];
+                        Changeset.markEdited(existing, content, existing !== content, ov, fk, h);
                     }
                 });
             }
@@ -115,21 +116,21 @@ export class JournalImpl extends Journal {
             let result = unsaved.get(obj);
             if (!result)
                 unsaved.set(obj, result = new Map());
-            op.forEach((vp, m) => {
-                let merged = result.get(m);
+            op.forEach((vp, fk) => {
+                let merged = result.get(fk);
                 if (!merged)
-                    result.set(m, merged = {
-                        memberName: m, patchKind: "update",
-                        freshValue: undefined, formerValue: undefined,
+                    result.set(fk, merged = {
+                        fieldKey: fk, patchKind: "update",
+                        freshContent: undefined, formerContent: undefined,
                     });
-                const value = undoing ? vp.formerValue : vp.freshValue;
-                const former = undoing ? vp.freshValue : vp.formerValue;
-                if (value !== merged.formerValue) {
-                    merged.freshValue = value;
-                    merged.formerValue = former;
+                const value = undoing ? vp.formerContent : vp.freshContent;
+                const former = undoing ? vp.freshContent : vp.formerContent;
+                if (value !== merged.formerContent) {
+                    merged.freshContent = value;
+                    merged.formerContent = former;
                 }
                 else {
-                    result.delete(m);
+                    result.delete(fk);
                     if (result.size === 0)
                         unsaved.delete(obj);
                 }
@@ -137,8 +138,8 @@ export class JournalImpl extends Journal {
         });
     }
 }
-function unseal(o) {
-    const result = o.content;
+function unseal(fv) {
+    const result = fv.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/Mvcc.d.ts

@@ -1,7 +1,7 @@
 import { F } from "../util/Utils.js";
-import { MemberOptions, Kind, Reentrance } from "../Options.js";
+import { MemberOptions, Kind, Reentrance, Isolation } from "../Options.js";
 import { LoggingOptions, ProfilingOptions } from "../Logging.js";
-import { MemberName, ObjectHandle, SeparationMode } from "./Data.js";
+import { FieldKey, ObjectHandle } from "./Data.js";
 import { Journal } from "./Journal.js";
 import { Indicator } from "./Indicator.js";
 export declare abstract class MvccObject {
@@ -18,7 +18,7 @@ export declare class OptionsImpl implements MemberOptions {
     readonly getter: Function;
     readonly setter: Function;
     readonly kind: Kind;
-    readonly separation: SeparationMode;
+    readonly isolation: Isolation;
     readonly order: number;
     readonly noSideEffects: boolean;
     readonly triggeringArgs: boolean;
@@ -41,14 +41,14 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     readonly isObservable: boolean;
     constructor(isObservable: boolean);
     getPrototypeOf(h: ObjectHandle): object | null;
-    get(h: ObjectHandle, m: MemberName, receiver: any): any;
-    set(h: ObjectHandle, m: MemberName, value: any, receiver: any): boolean;
-    has(h: ObjectHandle, m: MemberName): boolean;
-    defineProperty?(h: ObjectHandle, m: string | symbol, attributes: PropertyDescriptor): boolean;
-    getOwnPropertyDescriptor(h: ObjectHandle, m: MemberName): PropertyDescriptor | undefined;
+    get(h: ObjectHandle, fk: FieldKey, receiver: any): any;
+    set(h: ObjectHandle, fk: FieldKey, value: any, receiver: any): boolean;
+    has(h: ObjectHandle, fk: FieldKey): boolean;
+    defineProperty?(h: ObjectHandle, name: string | symbol, attributes: PropertyDescriptor): boolean;
+    getOwnPropertyDescriptor(h: ObjectHandle, fk: FieldKey): PropertyDescriptor | undefined;
     ownKeys(h: ObjectHandle): Array<string | symbol>;
-    static decorateData(isObservable: boolean, proto: any, member: MemberName): any;
-    static decorateOperation(implicit: boolean, decorator: Function, options: Partial<MemberOptions>, proto: any, member: MemberName, pd: PropertyDescriptor | undefined): any;
+    static decorateData(isObservable: 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 acquireHandle(obj: any): ObjectHandle;
     static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, isObservable: boolean): ObjectHandle;
@@ -56,6 +56,6 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     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, m: MemberName, options: OptionsImpl) => F<any>;
-    static rememberOperationOptions: (proto: any, m: MemberName, getter: Function | undefined, setter: Function | undefined, enumerable: boolean, configurable: boolean, options: Partial<MemberOptions>, implicit: boolean) => OptionsImpl;
+    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;
 }

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

@@ -1,8 +1,8 @@
 import { UNDEF } from "../util/Utils.js";
 import { Log, misuse } from "../util/Dbg.js";
-import { Kind, Reentrance } from "../Options.js";
-import { ObjectSnapshot, ObjectHandle, ValueSnapshot, Meta } from "./Data.js";
-import { Changeset, Dump, EMPTY_SNAPSHOT } from "./Changeset.js";
+import { Kind, Reentrance, Isolation } from "../Options.js";
+import { ObjectVersion, ObjectHandle, FieldVersion, Meta } from "./Data.js";
+import { Changeset, Dump, EMPTY_OBJECT_VERSION } from "./Changeset.js";
 export class MvccObject {
     constructor(observable) {
         const proto = new.target.prototype;
@@ -27,7 +27,7 @@ export class ObservableObject extends MvccObject {
 }
 const DEFAULT_OPTIONS = Object.freeze({
     kind: Kind.plain,
-    separation: false,
+    isolation: Isolation.joinToCurrentTransaction,
     order: 0,
     noSideEffects: false,
     triggeringArgs: false,
@@ -42,7 +42,7 @@ export class OptionsImpl {
         this.getter = getter !== undefined ? getter : existing.getter;
         this.setter = setter !== undefined ? setter : existing.setter;
         this.kind = merge(DEFAULT_OPTIONS.kind, existing.kind, patch.kind, implicit);
-        this.separation = merge(DEFAULT_OPTIONS.separation, existing.separation, patch.separation, implicit);
+        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);
@@ -66,92 +66,77 @@ export class Mvcc {
     getPrototypeOf(h) {
         return Reflect.getPrototypeOf(h.data);
     }
-    get(h, m, receiver) {
+    get(h, fk, receiver) {
         let result;
-        if (m !== Meta.Handle) {
+        if (fk !== Meta.Handle) {
             const cs = Changeset.current();
-            const os = cs.getObjectSnapshot(h, m);
-            result = os.data[m];
-            if (result instanceof ValueSnapshot && !result.isOperation) {
+            const ov = cs.getObjectVersion(h, fk);
+            result = ov.data[fk];
+            if (result instanceof FieldVersion && !result.isLaunch) {
                 if (this.isObservable)
-                    Changeset.markUsed(result, os, m, h, Kind.plain, false);
+                    Changeset.markUsed(result, ov, fk, h, Kind.plain, false);
                 result = result.content;
             }
             else
-                result = Reflect.get(h.data, m, receiver);
+                result = Reflect.get(h.data, fk, receiver);
         }
         else
             result = h;
         return result;
     }
-    set(h, m, value, receiver) {
-        const os = Changeset.edit().getEditableObjectSnapshot(h, m, value);
-        if (os !== EMPTY_SNAPSHOT) {
-            let curr = os.data[m];
-            if (curr !== undefined || (os.former.snapshot.changeset === EMPTY_SNAPSHOT.changeset && (m in h.data) === false)) {
-                if (curr === undefined || curr.content !== value || Mvcc.sensitivity) {
-                    const existing = curr === null || curr === void 0 ? void 0 : curr.content;
-                    if (os.former.snapshot.data[m] === curr) {
-                        curr = os.data[m] = new ValueSnapshot(value);
-                        Changeset.markEdited(existing, value, true, os, m, h);
-                    }
-                    else {
-                        curr.content = value;
-                        Changeset.markEdited(existing, value, true, os, m, h);
-                    }
-                }
-            }
-            else
-                Reflect.set(h.data, m, value, receiver);
-        }
+    set(h, fk, value, receiver) {
+        const cs = Changeset.edit();
+        const ov = cs.getEditableObjectVersion(h, fk, value);
+        if (ov !== EMPTY_OBJECT_VERSION)
+            cs.setFieldContent(h, fk, ov, value, receiver, Mvcc.sensitivity);
         else
-            h.data[m] = value;
+            h.data[fk] = value;
         return true;
     }
-    has(h, m) {
-        const os = Changeset.current().getObjectSnapshot(h, m);
-        return m in os.data || m in h.data;
+    has(h, fk) {
+        const ov = Changeset.current().getObjectVersion(h, fk);
+        return fk in ov.data || fk in h.data;
     }
-    defineProperty(h, m, attributes) {
+    defineProperty(h, name, attributes) {
         const result = attributes.get !== undefined && attributes.set !== undefined;
         if (result)
-            Object.defineProperty(h.data, m, attributes);
+            Object.defineProperty(h.data, name, attributes);
         return result;
     }
-    getOwnPropertyDescriptor(h, m) {
-        const os = Changeset.current().getObjectSnapshot(h, m);
-        const pd = Reflect.getOwnPropertyDescriptor(os.data, m);
+    getOwnPropertyDescriptor(h, fk) {
+        const ov = Changeset.current().getObjectVersion(h, fk);
+        const pd = Reflect.getOwnPropertyDescriptor(ov.data, fk);
         if (pd)
             pd.configurable = pd.writable = true;
         return pd;
     }
     ownKeys(h) {
-        const os = Changeset.current().getObjectSnapshot(h, Meta.Handle);
+        const ov = Changeset.current().getObjectVersion(h, Meta.Handle);
         const result = [];
-        for (const m of Object.getOwnPropertyNames(os.data)) {
-            const value = os.data[m];
-            if (!(value instanceof ValueSnapshot) || !value.isOperation)
-                result.push(m);
+        for (const fk of Object.getOwnPropertyNames(ov.data)) {
+            const field = ov.data[fk];
+            if (!(field instanceof FieldVersion) || !field.isLaunch)
+                result.push(fk);
         }
         return result;
     }
-    static decorateData(isObservable, proto, member) {
+    static decorateData(isObservable, proto, fk) {
         if (isObservable) {
-            Meta.acquire(proto, Meta.Initial)[member] = new ValueSnapshot(undefined);
+            Meta.acquire(proto, Meta.Initial)[fk] = new FieldVersion(undefined, 0);
             const get = function () {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.observable.get(h, member, this);
+                return Mvcc.observable.get(h, fk, this);
             };
             const set = function (value) {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.observable.set(h, member, value, this);
+                return Mvcc.observable.set(h, fk, value, this);
             };
             const enumerable = true;
             const configurable = false;
-            return Object.defineProperty(proto, member, { get, set, enumerable, configurable });
+            return Object.defineProperty(proto, fk, { get, set, enumerable, configurable });
         }
         else
-            Meta.acquire(proto, Meta.Initial)[member] = Meta.Raw;
+            Meta.acquire(proto, Meta.Initial)[fk] = Meta.Raw;
     }
     static decorateOperation(implicit, decorator, options, proto, member, pd) {
         var _a, _b, _c, _d;
@@ -192,22 +177,22 @@ export class Mvcc {
             if (obj !== Object(obj) || Array.isArray(obj))
                 throw misuse("only objects can be observable");
             const initial = Meta.getFrom(Object.getPrototypeOf(obj), Meta.Initial);
-            const os = new ObjectSnapshot(EMPTY_SNAPSHOT.changeset, EMPTY_SNAPSHOT, Object.assign({}, initial));
-            h = new ObjectHandle(obj, obj, Mvcc.observable, os, obj.constructor.name);
-            Meta.set(os.data, Meta.Handle, h);
+            const ov = new ObjectVersion(EMPTY_OBJECT_VERSION.changeset, EMPTY_OBJECT_VERSION, Object.assign({}, initial));
+            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(os.data, Meta.Revision, new ValueSnapshot(1));
+            Meta.set(ov.data, Meta.Revision, new FieldVersion(1, 0));
         }
         return h;
     }
     static createHandleForMvccObject(proto, data, blank, hint, isObservable) {
         const ctx = Changeset.edit();
         const mvcc = isObservable ? Mvcc.observable : Mvcc.transactional;
-        const h = new ObjectHandle(data, undefined, mvcc, EMPTY_SNAPSHOT, hint);
-        ctx.getEditableObjectSnapshot(h, Meta.Handle, blank);
+        const h = new ObjectHandle(data, undefined, mvcc, EMPTY_OBJECT_VERSION, hint);
+        ctx.getEditableObjectVersion(h, Meta.Handle, blank);
         if (!Mvcc.reactivityAutoStartDisabled)
-            for (const m in Meta.getFrom(proto, Meta.Reactive))
-                h.proxy[m][Meta.Controller].markObsolete();
+            for (const fk in Meta.getFrom(proto, Meta.Reactive))
+                h.proxy[fk][Meta.Controller].markObsolete();
         return h;
     }
     static setProfilingMode(isOn, options) {
@@ -253,10 +238,10 @@ Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.sensitivity = false;
 Mvcc.transactional = new Mvcc(false);
 Mvcc.observable = new Mvcc(true);
-Mvcc.createOperation = function (h, m, options) {
+Mvcc.createOperation = function (h, fk, options) {
     throw misuse("this implementation of createOperation should never be called");
 };
-Mvcc.rememberOperationOptions = function (proto, m, getter, setter, enumerable, configurable, options, implicit) {
+Mvcc.rememberOperationOptions = function (proto, fk, getter, setter, enumerable, configurable, options, implicit) {
     throw misuse("this implementation of rememberOperationOptions should never be called");
 };
 const EMPTY_PROP_DESCRIPTOR = {

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

@@ -36,6 +36,7 @@ export declare class MvccArray<T> extends MvccObject {
     reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
     reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
     reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+    find(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
     find<S extends T>(predicate: (this: void, value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
     findIndex(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number;
     fill(value: T, start?: number, end?: number): this;

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

@@ -47,12 +47,12 @@ export class MvccArray extends MvccObject {
     }
 }
 export class TransactionalArray extends MvccArray {
-    constructor(args) {
-        super(false, args !== undefined ? new Array(args) : new Array());
+    constructor(...args) {
+        super(false, new Array(...args));
     }
 }
 export class ObservableArray extends MvccArray {
-    constructor(args) {
-        super(true, args !== undefined ? new Array(args) : new Array());
+    constructor(...args) {
+        super(true, new Array(...args));
     }
 }

package/build/dist/source/core/{Reaction.d.ts → Operation.d.ts}

@@ -1,11 +1,11 @@
 import { F } from "../util/Utils.js";
-import { AbstractReaction, MemberOptions } from "../Options.js";
-import { MemberName, ObjectHandle, ValueSnapshot, Observer, Subscription, AbstractChangeset } from "./Data.js";
+import { Operation, MemberOptions } from "../Options.js";
+import { FieldKey, ObjectHandle, FieldVersion, Observer, Subscription, AbstractChangeset } from "./Data.js";
 import { Transaction } from "./Transaction.js";
 import { OptionsImpl } from "./Mvcc.js";
-export declare class ReactionImpl implements AbstractReaction<any> {
-    readonly objectHandle: ObjectHandle;
-    readonly memberName: MemberName;
+export declare class OperationImpl implements Operation<any> {
+    readonly ownerHandle: ObjectHandle;
+    readonly fieldKey: FieldKey;
     configure(options: Partial<MemberOptions>): MemberOptions;
     get options(): MemberOptions;
     get unobs(): any;
@@ -16,10 +16,10 @@ export declare class ReactionImpl implements AbstractReaction<any> {
     get isUpToDate(): boolean;
     markObsolete(): void;
     pullLastResult(args?: any[]): any;
-    constructor(h: ObjectHandle, m: MemberName);
+    constructor(h: ObjectHandle, fk: FieldKey);
     reuseOrRelaunch(weak: boolean, args: any[] | undefined): Launch;
-    static getControllerOf(method: F<any>): AbstractReaction<any>;
-    static configureImpl(self: ReactionImpl | undefined, options: Partial<MemberOptions>): MemberOptions;
+    static getControllerOf(method: F<any>): Operation<any>;
+    static configureImpl(self: OperationImpl | undefined, options: Partial<MemberOptions>): MemberOptions;
     static proceedWithinGivenLaunch<T>(launch: Launch | undefined, func: F<T>, ...args: any[]): T;
     static why(): string;
     static briefWhy(): string;
@@ -27,19 +27,19 @@ export declare class ReactionImpl implements AbstractReaction<any> {
     private peek;
     private use;
     private edit;
-    private acquireFromSnapshot;
+    private acquireFromObjectVersion;
     private relaunch;
     private static markObsolete;
 }
-declare class Launch extends ValueSnapshot implements Observer {
+declare class Launch extends FieldVersion implements Observer {
     static current?: Launch;
-    static queuedReactiveFunctions: Array<Observer>;
-    static deferredReactiveFunctions: Array<Launch>;
+    static queuedReactiveOperations: Array<Observer>;
+    static deferredReactiveOperations: Array<Launch>;
     readonly margin: number;
     readonly transaction: Transaction;
-    readonly reaction: ReactionImpl;
+    readonly operation: OperationImpl;
     readonly changeset: AbstractChangeset;
-    observables: Map<ValueSnapshot, Subscription> | undefined;
+    observables: Map<FieldVersion, Subscription> | undefined;
     options: OptionsImpl;
     cause: string | undefined;
     args: any[];
@@ -49,18 +49,18 @@ declare class Launch extends ValueSnapshot implements Observer {
     obsoleteDueTo: string | undefined;
     obsoleteSince: number;
     successor: Launch | undefined;
-    constructor(reaction: ReactionImpl, changeset: AbstractChangeset, former: Launch | OptionsImpl);
-    get isOperation(): boolean;
-    get originSnapshotId(): number;
+    constructor(transaction: Transaction, operation: OperationImpl, changeset: AbstractChangeset, former: Launch | OptionsImpl, clone: boolean);
+    get isLaunch(): boolean;
     hint(): string;
     get order(): number;
     get ["#this#"](): string;
+    clone(t: Transaction, cs: AbstractChangeset): FieldVersion;
     why(): string;
     briefWhy(): string;
     dependencies(): string[];
     wrap<T>(func: F<T>): F<T>;
     proceed(proxy: any, args: any[] | undefined): void;
-    markObsoleteDueTo(observable: ValueSnapshot, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, obsolete: Observer[]): void;
+    markObsoleteDueTo(observable: FieldVersion, fk: FieldKey, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, obsolete: Observer[]): void;
     relaunchIfNotUpToDate(now: boolean, nothrow: boolean): void;
     isNotUpToDate(): boolean;
     reenterOver(head: Launch): this;
@@ -77,9 +77,10 @@ declare class Launch extends ValueSnapshot implements Observer {
     private static isConflicting;
     private static propagateAllChangesThroughSubscriptions;
     private static revokeAllSubscriptions;
-    private static propagateMemberChangeThroughSubscriptions;
+    private static propagateFieldChangeThroughSubscriptions;
     private static enqueueReactiveFunctionsToRun;
-    private static processQueuedReactiveFunctions;
+    private static migrateFieldVersion;
+    private static processQueuedReactiveOperations;
     private unsubscribeFromAllObservables;
     private subscribeTo;
     private static canSubscribeTo;