reactronic 0.24.274 → 0.24.301

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

@@ -1,8 +1,9 @@
 import { LoggingOptions } from "../Logging.js";
 import { MergeListReader, MergedItem } from "../util/MergeList.js";
 import { MemberOptions } from "../Options.js";
-export type Delegate<T> = (el: T, basis: () => void) => void;
-export type SimpleDelegate<T = unknown, R = void> = (el: T) => R;
+export type Script<T> = (el: T, basis: () => void) => void;
+export type ScriptAsync<T> = (el: T, basis: () => Promise<void>) => Promise<void>;
+export type Handler<T = unknown, R = void> = (el: T) => R;
 export declare enum Mode {
     default = 0,
     independentUpdate = 1,
@@ -35,7 +36,7 @@ export declare abstract class RxNode<E = unknown> {
     static readonly longFrameDuration = 300;
     static currentUpdatePriority: Priority;
     static frameDuration: number;
-    static declare<E = void>(driver: RxNodeDriver<E>, declaration?: RxNodeDecl<E>, preset?: RxNodeDecl<E>): RxNode<E>;
+    static declare<E = void>(driver: RxNodeDriver<E>, declaration?: RxNodeDecl<E>, basis?: RxNodeDecl<E>): RxNode<E>;
     static get isFirstUpdate(): boolean;
     static get key(): string;
     static get stamp(): number;
@@ -48,31 +49,32 @@ export declare abstract class RxNode<E = unknown> {
     static triggerDeactivation(node: RxNode<any>): void;
     static updateNestedNodesThenDo(action: (error: unknown) => void): void;
     static markAsMounted(node: RxNode<any>, yes: boolean): void;
-    static findMatchingHost<E = unknown, R = unknown>(node: RxNode<E>, match: SimpleDelegate<RxNode<E>, boolean>): RxNode<R> | undefined;
-    static findMatchingPrevSibling<E = unknown, R = unknown>(node: RxNode<E>, match: SimpleDelegate<RxNode<E>, boolean>): RxNode<R> | undefined;
-    static forEachChildRecursively<E = unknown>(node: RxNode<E>, action: SimpleDelegate<RxNode<E>>): void;
+    static findMatchingHost<E = unknown, R = unknown>(node: RxNode<E>, match: Handler<RxNode<E>, boolean>): RxNode<R> | undefined;
+    static findMatchingPrevSibling<E = unknown, R = unknown>(node: RxNode<E>, match: Handler<RxNode<E>, boolean>): RxNode<R> | undefined;
+    static forEachChildRecursively<E = unknown>(node: RxNode<E>, action: Handler<RxNode<E>>): void;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
 export type RxNodeDecl<E = unknown> = {
-    script?: Delegate<E>;
+    script?: Script<E>;
+    scriptAsync?: ScriptAsync<E>;
     key?: string;
     mode?: Mode;
-    creation?: Delegate<E>;
-    destruction?: Delegate<E>;
+    creation?: Script<E>;
+    destruction?: Script<E>;
     triggers?: unknown;
-    preset?: RxNodeDecl<E>;
+    basis?: RxNodeDecl<E>;
 };
 export type RxNodeDriver<E = unknown> = {
     readonly name: string;
     readonly isPartition: boolean;
-    readonly predefine?: SimpleDelegate<E>;
+    readonly initialize?: Handler<E>;
     allocate(node: RxNode<E>): E;
     create(node: RxNode<E>): void;
     destroy(node: RxNode<E>, isLeader: boolean): boolean;
     mount(node: RxNode<E>): void;
     update(node: RxNode<E>): void | Promise<void>;
-    child(ownerNode: RxNode<E>, childDriver: RxNodeDriver<any>, childDeclaration?: RxNodeDecl<any>, childPreset?: RxNodeDecl<any>): MergedItem<RxNode> | undefined;
+    child(ownerNode: RxNode<E>, childDriver: RxNodeDriver<any>, childDeclaration?: RxNodeDecl<any>, childBasis?: RxNodeDecl<any>): MergedItem<RxNode> | undefined;
     getHost(node: RxNode<E>): RxNode<E>;
 };
 export type RxNodeContext<T extends Object = Object> = {
@@ -81,14 +83,14 @@ export type RxNodeContext<T extends Object = Object> = {
 export declare abstract class BaseDriver<E = unknown> implements RxNodeDriver<E> {
     readonly name: string;
     readonly isPartition: boolean;
-    readonly predefine?: SimpleDelegate<E, void> | undefined;
-    constructor(name: string, isPartition: boolean, predefine?: SimpleDelegate<E, void> | undefined);
+    readonly initialize?: Handler<E, void> | undefined;
+    constructor(name: string, isPartition: boolean, initialize?: Handler<E, void> | undefined);
     abstract allocate(node: RxNode<E>): E;
     create(node: RxNode<E>): void;
     destroy(node: RxNode<E>, isLeader: boolean): boolean;
     mount(node: RxNode<E>): void;
     update(node: RxNode<E>): void | Promise<void>;
-    child(ownerNode: RxNode<E>, childDriver: RxNodeDriver<any>, childDeclaration?: RxNodeDecl<any>, childPreset?: RxNodeDecl<any>): MergedItem<RxNode> | undefined;
+    child(ownerNode: RxNode<E>, childDriver: RxNodeDriver<any>, childDeclaration?: RxNodeDecl<any>, childBasis?: RxNodeDecl<any>): MergedItem<RxNode> | undefined;
     getHost(node: RxNode<E>): RxNode<E>;
 }
 export declare class RxNodeVariable<T extends Object = Object> {

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

@@ -18,7 +18,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { MergeList } from "../util/MergeList.js";
 import { emitLetters, getCallerInfo } from "../util/Utils.js";
-import { Reentrance } from "../Options.js";
+import { Isolation, Reentrance } from "../Options.js";
 import { ObservableObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
 import { RxSystem, options, raw, reactive, unobs } from "../RxSystem.js";
@@ -35,16 +35,16 @@ export var Priority;
     Priority[Priority["background"] = 2] = "background";
 })(Priority || (Priority = {}));
 export class RxNode {
-    static declare(driver, declaration, preset) {
+    static declare(driver, declaration, basis) {
         let result;
         if (declaration)
-            declaration.preset = preset;
+            declaration.basis = basis;
         else
-            declaration = preset !== null && preset !== void 0 ? preset : {};
+            declaration = basis !== null && basis !== void 0 ? basis : {};
         let key = declaration.key;
         const owner = gOwnSeat === null || gOwnSeat === void 0 ? void 0 : gOwnSeat.instance;
         if (owner) {
-            let existing = owner.driver.child(owner, driver, declaration, preset);
+            let existing = owner.driver.child(owner, driver, declaration, basis);
             const children = owner.children;
             existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(key = key || generateKey(owner), undefined, "nested elements can be declared inside update function only"));
             if (existing) {
@@ -144,26 +144,26 @@ RxNode.longFrameDuration = 300;
 RxNode.currentUpdatePriority = Priority.realtime;
 RxNode.frameDuration = RxNode.longFrameDuration;
 export class BaseDriver {
-    constructor(name, isPartition, predefine) {
+    constructor(name, isPartition, initialize) {
         this.name = name;
         this.isPartition = isPartition;
-        this.predefine = predefine;
+        this.initialize = initialize;
     }
     create(node) {
         var _a;
-        (_a = this.predefine) === null || _a === void 0 ? void 0 : _a.call(this, node.element);
-        invokeOnCreateViaPresetChain(node.element, node.declaration);
+        (_a = this.initialize) === null || _a === void 0 ? void 0 : _a.call(this, node.element);
+        invokeCreationUsingBasisChain(node.element, node.declaration);
     }
     destroy(node, isLeader) {
-        invokeOnDestroyViaPresetChain(node.element, node.declaration);
+        invokeDestructionUsingBasisChain(node.element, node.declaration);
         return isLeader;
     }
     mount(node) {
     }
     update(node) {
-        invokeScriptViaPresetChain(node.element, node.declaration);
+        invokeScriptUsingBasisChain(node.element, node.declaration);
     }
-    child(ownerNode, childDriver, childDeclaration, childPreset) {
+    child(ownerNode, childDriver, childDeclaration, childBasis) {
         return undefined;
     }
     getHost(node) {
@@ -194,33 +194,33 @@ function generateKey(owner) {
         result = `·${lettered}`;
     return result;
 }
-function getModeViaPresetChain(declaration) {
+function getModeUsingBasisChain(declaration) {
     var _a;
-    return (_a = declaration === null || declaration === void 0 ? void 0 : declaration.mode) !== null && _a !== void 0 ? _a : ((declaration === null || declaration === void 0 ? void 0 : declaration.preset) ? getModeViaPresetChain(declaration === null || declaration === void 0 ? void 0 : declaration.preset) : Mode.default);
+    return (_a = declaration === null || declaration === void 0 ? void 0 : declaration.mode) !== null && _a !== void 0 ? _a : ((declaration === null || declaration === void 0 ? void 0 : declaration.basis) ? getModeUsingBasisChain(declaration === null || declaration === void 0 ? void 0 : declaration.basis) : Mode.default);
 }
-function invokeOnCreateViaPresetChain(element, declaration) {
-    const preset = declaration.preset;
-    const creation = declaration.creation;
-    if (creation)
-        creation(element, preset ? () => invokeOnCreateViaPresetChain(element, preset) : NOP);
-    else if (preset)
-        invokeOnCreateViaPresetChain(element, preset);
-}
-function invokeScriptViaPresetChain(element, declaration) {
-    const preset = declaration.preset;
+function invokeScriptUsingBasisChain(element, declaration) {
+    const basis = declaration.basis;
     const script = declaration.script;
     if (script)
-        script(element, preset ? () => invokeScriptViaPresetChain(element, preset) : NOP);
-    else if (preset)
-        invokeScriptViaPresetChain(element, preset);
+        script(element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP);
+    else if (basis)
+        invokeScriptUsingBasisChain(element, basis);
+}
+function invokeCreationUsingBasisChain(element, declaration) {
+    const basis = declaration.basis;
+    const creation = declaration.creation;
+    if (creation)
+        creation(element, basis ? () => invokeCreationUsingBasisChain(element, basis) : NOP);
+    else if (basis)
+        invokeCreationUsingBasisChain(element, basis);
 }
-function invokeOnDestroyViaPresetChain(element, declaration) {
-    const preset = declaration.preset;
+function invokeDestructionUsingBasisChain(element, declaration) {
+    const basis = declaration.basis;
     const destruction = declaration.destruction;
     if (destruction)
-        destruction(element, preset ? () => invokeOnDestroyViaPresetChain(element, preset) : NOP);
-    else if (preset)
-        invokeOnDestroyViaPresetChain(element, preset);
+        destruction(element, basis ? () => invokeDestructionUsingBasisChain(element, basis) : NOP);
+    else if (basis)
+        invokeDestructionUsingBasisChain(element, basis);
 }
 class RxNodeContextImpl extends ObservableObject {
     constructor(variable, value) {
@@ -273,7 +273,7 @@ class RxNodeImpl extends RxNode {
     set strictOrder(value) { this.children.isStrict = value; }
     get isMoved() { return this.owner.children.isMoved(this.seat); }
     has(mode) {
-        return (getModeViaPresetChain(this.declaration) & mode) === mode;
+        return (getModeUsingBasisChain(this.declaration) & mode) === mode;
     }
     update(_triggers) {
         updateNow(this.seat);
@@ -281,7 +281,7 @@ class RxNodeImpl extends RxNode {
     configureReactronic(options) {
         if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.independentUpdate))
             throw new Error("reactronic can be configured only for elements with independent update mode and only during activation");
-        return RxSystem.getReaction(this.update).configure(options);
+        return RxSystem.getOperation(this.update).configure(options);
     }
     static get ownSeat() {
         if (!gOwnSeat)
@@ -311,7 +311,7 @@ class RxNodeImpl extends RxNode {
                 node.outer = owner;
             else
                 node.outer = owner.outer;
-            Transaction.run({ separation: true }, () => {
+            Transaction.run({ isolation: Isolation.joinAsNestedTransaction }, () => {
                 const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
@@ -449,7 +449,7 @@ function triggerUpdateViaSeat(seat) {
                 Transaction.outside(() => {
                     if (RxSystem.isLogging)
                         RxSystem.setLoggingHint(node.element, node.key);
-                    RxSystem.getReaction(node.update).configure({
+                    RxSystem.getOperation(node.update).configure({
                         order: node.level,
                     });
                 });
@@ -519,7 +519,7 @@ function triggerDeactivation(seat, isLeader, individual) {
             else
                 gFirstToDispose = gLastToDispose = seat;
             if (gFirstToDispose === seat)
-                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${seat.instance.key})` }, () => {
+                Transaction.run({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${seat.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }

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

@@ -1,6 +1,7 @@
 import { F } from "../util/Utils.js";
 import { Worker } from "../Worker.js";
 import { SnapshotOptions } from "../Options.js";
+import { ObjectHandle, ObjectVersion, Observer, FieldVersion, FieldKey } from "./Data.js";
 import { Changeset } from "./Changeset.js";
 export declare abstract class Transaction implements Worker {
     static get current(): Transaction;
@@ -20,11 +21,69 @@ export declare abstract class Transaction implements Worker {
     abstract readonly isCanceled: boolean;
     abstract readonly isFinished: boolean;
     whenFinished(): Promise<void>;
-    static create(options: SnapshotOptions | null): Transaction;
+    static create(options: SnapshotOptions | null, parent?: Transaction): Transaction;
     static run<T>(options: SnapshotOptions | null, func: F<T>, ...args: any[]): T;
-    static separate<T>(func: F<T>, ...args: any[]): T;
+    static isolate<T>(func: F<T>, ...args: any[]): T;
     static outside<T>(func: F<T>, ...args: any[]): T;
     static isFrameOver(everyN?: number, timeLimit?: number): boolean;
     static requestNextFrame(sleepTime?: number): Promise<void>;
     static get isCanceled(): boolean;
 }
+export declare class TransactionImpl extends Transaction {
+    private static readonly none;
+    private static curr;
+    private static inspection;
+    private static frameStartTime;
+    private static frameOverCounter;
+    readonly margin: number;
+    readonly parent?: TransactionImpl;
+    readonly changeset: Changeset;
+    private pending;
+    private sealed;
+    private canceled?;
+    private after?;
+    private promise?;
+    private resolve;
+    private reject;
+    constructor(options: SnapshotOptions | null, parent?: TransactionImpl);
+    static get current(): TransactionImpl;
+    get id(): number;
+    get hint(): string;
+    get options(): SnapshotOptions;
+    get timestamp(): number;
+    get error(): Error | undefined;
+    run<T>(func: F<T>, ...args: any[]): T;
+    inspect<T>(func: F<T>, ...args: any[]): T;
+    apply(): void;
+    seal(): this;
+    wrap<T>(func: F<T>, error: boolean): F<T>;
+    private static wrapperEnter;
+    private static wrapperLeave;
+    cancel(error: Error, restartAfter?: Worker | null): this;
+    get isCanceled(): boolean;
+    get isFinished(): boolean;
+    whenFinished(): Promise<void>;
+    static run<T>(options: SnapshotOptions | null, func: F<T>, ...args: any[]): T;
+    static isolate<T>(func: F<T>, ...args: any[]): T;
+    static outside<T>(func: F<T>, ...args: any[]): T;
+    static isFrameOver(everyN?: number, timeLimit?: number): boolean;
+    static requestNextFrame(sleepTime?: number): Promise<void>;
+    private static acquire;
+    private guard;
+    private wrapToRetry;
+    private wrapToWaitUntilFinish;
+    private runImpl;
+    private static seal;
+    private checkForConflicts;
+    private tryResolveConflicts;
+    private applyOrDiscard;
+    applyOrDiscardChangeset(): Array<Observer>;
+    applyObjectChanges(h: ObjectHandle, ov: ObjectVersion): void;
+    static migrateObjectChangesToAnotherTransaction(h: ObjectHandle, ov: ObjectVersion, tParent: Transaction): void;
+    static migrateFieldVersionToAnotherTransaction(h: ObjectHandle, fk: FieldKey, ov: ObjectVersion, ovParent: ObjectVersion, tParent: Transaction): void;
+    private acquirePromise;
+    private static getCurrentChangeset;
+    private static getEditableChangeset;
+    static createFieldVersion: (fv: FieldVersion, target: Transaction) => FieldVersion;
+    static _init(): void;
+}

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

@@ -9,25 +9,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { UNDEF, pause } from "../util/Utils.js";
 import { Log, misuse, error, fatal } from "../util/Dbg.js";
-import { Changeset, Dump } from "./Changeset.js";
+import { Isolation } from "../Options.js";
+import { Meta } from "./Data.js";
+import { Changeset, Dump, EMPTY_OBJECT_VERSION, UNDEFINED_REVISION } from "./Changeset.js";
 export class Transaction {
     static get current() { return TransactionImpl.current; }
     whenFinished() {
         return __awaiter(this, void 0, void 0, function* () { });
     }
-    static create(options) { return new TransactionImpl(options); }
+    static create(options, parent) { return new TransactionImpl(options, parent); }
     static run(options, func, ...args) { return TransactionImpl.run(options, func, ...args); }
-    static separate(func, ...args) { return TransactionImpl.separate(func, ...args); }
+    static isolate(func, ...args) { return TransactionImpl.isolate(func, ...args); }
     static outside(func, ...args) { return TransactionImpl.outside(func, ...args); }
     static isFrameOver(everyN = 1, timeLimit = 10) { return TransactionImpl.isFrameOver(everyN, timeLimit); }
     static requestNextFrame(sleepTime = 0) { return TransactionImpl.requestNextFrame(sleepTime); }
     static get isCanceled() { return TransactionImpl.current.isCanceled; }
 }
-class TransactionImpl extends Transaction {
-    constructor(options) {
+export class TransactionImpl extends Transaction {
+    constructor(options, parent) {
         super();
         this.margin = TransactionImpl.curr !== undefined ? TransactionImpl.curr.margin + 1 : -1;
-        this.changeset = new Changeset(options);
+        this.parent = parent;
+        this.changeset = new Changeset(options, parent === null || parent === void 0 ? void 0 : parent.changeset);
         this.pending = 0;
         this.sealed = false;
         this.canceled = undefined;
@@ -126,8 +129,8 @@ class TransactionImpl extends Transaction {
         }
         return result;
     }
-    static separate(func, ...args) {
-        return TransactionImpl.run({ separation: true }, func, ...args);
+    static isolate(func, ...args) {
+        return TransactionImpl.run({ isolation: Isolation.disjoinFromOuterTransaction }, func, ...args);
     }
     static outside(func, ...args) {
         const outer = TransactionImpl.curr;
@@ -152,11 +155,17 @@ class TransactionImpl extends Transaction {
         return pause(sleepTime);
     }
     static acquire(options) {
-        const curr = TransactionImpl.curr;
-        if ((options === null || options === void 0 ? void 0 : options.separation) || curr.isFinished || curr.options.separation === "isolated")
+        var _a;
+        const outer = TransactionImpl.curr;
+        const isolation = (_a = options === null || options === void 0 ? void 0 : options.isolation) !== null && _a !== void 0 ? _a : Isolation.joinToCurrentTransaction;
+        if (outer.isFinished || outer.options.isolation === Isolation.disjoinFromOuterAndInnerTransactions)
+            return new TransactionImpl(options);
+        else if (isolation === Isolation.joinAsNestedTransaction)
+            return new TransactionImpl(options, outer);
+        else if (isolation !== Isolation.joinToCurrentTransaction)
             return new TransactionImpl(options);
         else
-            return TransactionImpl.curr;
+            return outer;
     }
     guard() {
         if (this.sealed && TransactionImpl.curr !== this)
@@ -176,7 +185,7 @@ class TransactionImpl extends Transaction {
                         yield this.after.whenFinished();
                         const options = {
                             hint: `${this.hint} - restart after T${this.after.id}`,
-                            separation: this.options.separation === "isolated" ? "isolated" : true,
+                            isolation: this.options.isolation === Isolation.joinToCurrentTransaction ? Isolation.disjoinFromOuterTransaction : this.options.isolation,
                             logging: this.changeset.options.logging,
                             token: this.changeset.options.token,
                         };
@@ -255,11 +264,12 @@ class TransactionImpl extends Transaction {
         throw error(`T${this.id}[${this.hint}] conflicts with: ${Dump.conflicts(conflicts)}`, undefined);
     }
     applyOrDiscard() {
-        let reactive;
+        let observers;
         try {
             if (Log.isOn && Log.opt.change)
                 Log.write("╠═", "", "", undefined, "changes");
-            reactive = this.changeset.applyOrDiscard(this.canceled);
+            this.changeset.seal();
+            observers = this.applyOrDiscardChangeset();
             this.changeset.triggerGarbageCollection();
             if (this.promise) {
                 if (this.canceled && !this.after)
@@ -274,7 +284,153 @@ class TransactionImpl extends Transaction {
             fatal(e);
             throw e;
         }
-        return reactive;
+        return observers;
+    }
+    applyOrDiscardChangeset() {
+        const error = this.canceled;
+        const changeset = this.changeset;
+        changeset.items.forEach((ov, h) => {
+            changeset.sealObjectVersion(h, ov);
+            if (!error) {
+                this.applyObjectChanges(h, ov);
+                if (Changeset.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
+                    Changeset.totalObjectSnapshotCount++;
+                    if (ov.former.objectVersion === EMPTY_OBJECT_VERSION)
+                        Changeset.totalObjectHandleCount++;
+                }
+            }
+        });
+        if (Log.isOn) {
+            if (Log.opt.change && !error && !changeset.parent) {
+                changeset.items.forEach((ov, h) => {
+                    const fields = [];
+                    ov.changes.forEach((o, fk) => fields.push(fk.toString()));
+                    const s = fields.join(", ");
+                    Log.write("║", "√", `${Dump.snapshot2(h, ov.changeset)} (${s}) is ${ov.former.objectVersion === EMPTY_OBJECT_VERSION ? "constructed" : `applied over #${h.id}t${ov.former.objectVersion.changeset.id}s${ov.former.objectVersion.changeset.timestamp}`}`);
+                });
+            }
+            if (Log.opt.transaction)
+                Log.write(changeset.timestamp < UNDEFINED_REVISION ? "╚══" : "═══", `s${this.timestamp}`, `${this.hint} - ${error ? "CANCEL" : "APPLY"}(${this.changeset.items.size})${error ? ` - ${error}` : ""}`);
+        }
+        if (!error && !this.parent)
+            Changeset.propagateAllChangesThroughSubscriptions(changeset);
+        return changeset.obsolete;
+    }
+    applyObjectChanges(h, ov) {
+        const parent = this.parent;
+        if (parent)
+            TransactionImpl.migrateObjectChangesToAnotherTransaction(h, ov, parent);
+        else
+            h.applied = ov;
+    }
+    static migrateObjectChangesToAnotherTransaction(h, ov, tParent) {
+        const csParent = tParent.changeset;
+        const ovParent = csParent.getEditableObjectVersion(h, Meta.Undefined, undefined);
+        if (ov.former.objectVersion.changeset === EMPTY_OBJECT_VERSION.changeset) {
+            for (const fk in ov.data) {
+                TransactionImpl.migrateFieldVersionToAnotherTransaction(h, fk, ov, ovParent, tParent);
+            }
+        }
+        else {
+            ov.changes.forEach((o, fk) => {
+                TransactionImpl.migrateFieldVersionToAnotherTransaction(h, fk, ov, ovParent, tParent);
+            });
+        }
+    }
+    static migrateFieldVersionToAnotherTransaction(h, fk, ov, ovParent, tParent) {
+        const csParent = tParent.changeset;
+        const fv = ov.data[fk];
+        const fvParent = ovParent.data[fk];
+        if (fv.isLaunch) {
+            const migrated = TransactionImpl.createFieldVersion(fv, tParent);
+            if (ovParent.former.objectVersion.data[fk] !== fvParent) {
+                let observers = fvParent.observers;
+                if (observers) {
+                    const migratedObservers = migrated.observers = new Set();
+                    observers.forEach(o => {
+                        var _a, _b;
+                        const sub = o.observables.get(fvParent);
+                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fvParent);
+                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(migrated, sub);
+                        migratedObservers.add(o);
+                    });
+                    fvParent.observers = undefined;
+                }
+                observers = fv.observers;
+                if (observers) {
+                    let migratedObservers = migrated.observers;
+                    if (migratedObservers === undefined)
+                        migratedObservers = migrated.observers = new Set();
+                    observers.forEach(o => {
+                        var _a, _b;
+                        const sub = o.observables.get(fv);
+                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fv);
+                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(migrated, sub);
+                        migratedObservers === null || migratedObservers === void 0 ? void 0 : migratedObservers.add(o);
+                    });
+                    fv.observers = undefined;
+                }
+                const observables = fv.observables;
+                const migratedObservables = migrated.observables;
+                if (observables) {
+                    observables.forEach((s, o) => {
+                        var _a, _b;
+                        (_a = o.observers) === null || _a === void 0 ? void 0 : _a.delete(fv);
+                        (_b = o.observers) === null || _b === void 0 ? void 0 : _b.add(migrated);
+                        migratedObservables === null || migratedObservables === void 0 ? void 0 : migratedObservables.set(o, s);
+                    });
+                    observables.clear();
+                }
+                ovParent.data[fk] = migrated;
+            }
+            else {
+                const observers = fv.observers;
+                if (observers) {
+                    const migratedObservers = migrated.observers = new Set();
+                    observers.forEach(o => {
+                        var _a, _b;
+                        const sub = o.observables.get(fv);
+                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fv);
+                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(migrated, sub);
+                        migratedObservers.add(o);
+                    });
+                    fv.observers = undefined;
+                }
+                const observables = fv.observables;
+                const migratedObservables = migrated.observables;
+                if (observables) {
+                    observables.forEach((s, o) => {
+                        var _a, _b;
+                        (_a = o.observers) === null || _a === void 0 ? void 0 : _a.delete(fv);
+                        (_b = o.observers) === null || _b === void 0 ? void 0 : _b.add(migrated);
+                        migratedObservables === null || migratedObservables === void 0 ? void 0 : migratedObservables.set(o, s);
+                    });
+                    observables.clear();
+                }
+                ovParent.data[fk] = migrated;
+            }
+            csParent.bumpBy(ovParent.former.objectVersion.changeset.timestamp);
+            Changeset.markEdited(undefined, migrated, true, ovParent, fk, h);
+        }
+        else {
+            const parentContent = fvParent === null || fvParent === void 0 ? void 0 : fvParent.content;
+            if (ovParent.former.objectVersion.data[fk] !== fvParent) {
+                fvParent.content = fv.content;
+                const observers = fv.observers;
+                if (observers) {
+                    observers.forEach(o => {
+                        var _a, _b, _c;
+                        const sub = o.observables.get(fv);
+                        (_a = o.observables) === null || _a === void 0 ? void 0 : _a.delete(fv);
+                        (_b = o.observables) === null || _b === void 0 ? void 0 : _b.set(fvParent, sub);
+                        (_c = fvParent.observers) === null || _c === void 0 ? void 0 : _c.add(o);
+                    });
+                }
+            }
+            else
+                ovParent.data[fk] = fv;
+            Changeset.markEdited(parentContent, fv.content, true, ovParent, fk, h);
+        }
     }
     acquirePromise() {
         if (!this.promise) {
@@ -297,7 +453,7 @@ class TransactionImpl extends Transaction {
         Changeset.current = TransactionImpl.getCurrentChangeset;
         Changeset.edit = TransactionImpl.getEditableChangeset;
         TransactionImpl.none.sealed = true;
-        TransactionImpl.none.changeset.applyOrDiscard();
+        TransactionImpl.none.changeset.seal();
         Changeset._init();
     }
 }
@@ -306,4 +462,7 @@ TransactionImpl.curr = TransactionImpl.none;
 TransactionImpl.inspection = false;
 TransactionImpl.frameStartTime = 0;
 TransactionImpl.frameOverCounter = 0;
+TransactionImpl.createFieldVersion = function (fv, target) {
+    throw misuse("this implementation of cloneLaunch should never be called");
+};
 TransactionImpl._init();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.24.274",
+  "version": "0.24.301",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -32,13 +32,13 @@
   "homepage": "https://github.com/nezaboodka/reactronic/blob/master/README.md#readme",
   "devDependencies": {
     "@types/node": "20.11.28",
-    "@types/react": "18.2.66",
+    "@types/react": "18.3.4",
     "@typescript-eslint/eslint-plugin": "7.2.0",
     "@typescript-eslint/parser": "7.2.0",
     "ava": "6.1.2",
     "c8": "9.1.0",
     "eslint": "8.57.0",
-    "react": "18.2.0",
+    "react": "18.3.1",
     "ts-node": "10.9.2",
     "typescript": "5.3.2"
   },