reactronic 0.24.275 → 0.24.302

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

@@ -1,9 +1,9 @@
 import { LoggingOptions } from "../Logging.js";
 import { MergeListReader, MergedItem } from "../util/MergeList.js";
 import { MemberOptions } from "../Options.js";
-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 type Script<E> = (el: E, basis: () => void) => void;
+export type ScriptAsync<E> = (el: E, basis: () => Promise<void>) => Promise<void>;
+export type Handler<E = unknown, R = void> = (el: E) => R;
 export declare enum Mode {
     default = 0,
     independentUpdate = 1,
@@ -56,11 +56,13 @@ export declare abstract class RxNode<E = unknown> {
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
 export type RxNodeDecl<E = unknown> = {
+    isAsync?: boolean;
     script?: Script<E>;
     scriptAsync?: ScriptAsync<E>;
     key?: string;
     mode?: Mode;
     creation?: Script<E>;
+    creationAsync?: ScriptAsync<E>;
     destruction?: Script<E>;
     triggers?: unknown;
     basis?: RxNodeDecl<E>;
@@ -83,10 +85,10 @@ export type RxNodeContext<T extends Object = Object> = {
 export declare abstract class BaseDriver<E = unknown> implements RxNodeDriver<E> {
     readonly name: string;
     readonly isPartition: boolean;
-    readonly initialize?: Handler<E, void> | undefined;
-    constructor(name: string, isPartition: boolean, initialize?: Handler<E, void> | undefined);
+    readonly initialize?: Handler<E> | undefined;
+    constructor(name: string, isPartition: boolean, initialize?: Handler<E> | undefined);
     abstract allocate(node: RxNode<E>): E;
-    create(node: RxNode<E>): void;
+    create(node: RxNode<E>): void | Promise<void>;
     destroy(node: RxNode<E>, isLeader: boolean): boolean;
     mount(node: RxNode<E>): void;
     update(node: RxNode<E>): void | Promise<void>;

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

@@ -16,9 +16,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { misuse } from "../util/Dbg.js";
 import { MergeList } from "../util/MergeList.js";
-import { emitLetters, getCallerInfo } from "../util/Utils.js";
-import { Reentrance } from "../Options.js";
+import { emitLetters, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.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";
@@ -152,7 +153,7 @@ export class BaseDriver {
     create(node) {
         var _a;
         (_a = this.initialize) === null || _a === void 0 ? void 0 : _a.call(this, node.element);
-        invokeCreationUsingBasisChain(node.element, node.declaration);
+        return invokeCreationUsingBasisChain(node.element, node.declaration);
     }
     destroy(node, isLeader) {
         invokeDestructionUsingBasisChain(node.element, node.declaration);
@@ -161,7 +162,7 @@ export class BaseDriver {
     mount(node) {
     }
     update(node) {
-        invokeScriptUsingBasisChain(node.element, node.declaration);
+        return invokeScriptUsingBasisChain(node.element, node.declaration);
     }
     child(ownerNode, childDriver, childDeclaration, childBasis) {
         return undefined;
@@ -199,20 +200,40 @@ function getModeUsingBasisChain(declaration) {
     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 invokeScriptUsingBasisChain(element, declaration) {
+    let result = undefined;
     const basis = declaration.basis;
     const script = declaration.script;
-    if (script)
-        script(element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP);
+    const scriptAsync = declaration.scriptAsync;
+    if (script && scriptAsync) {
+        throw misuse("'script' and 'scriptAsync' cannot be defined together");
+    }
+    if (script) {
+        result = script(element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP);
+    }
+    else if (scriptAsync) {
+        result = scriptAsync(element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP_ASYNC);
+    }
     else if (basis)
-        invokeScriptUsingBasisChain(element, basis);
+        result = invokeScriptUsingBasisChain(element, basis);
+    return result;
 }
 function invokeCreationUsingBasisChain(element, declaration) {
+    let result = undefined;
     const basis = declaration.basis;
     const creation = declaration.creation;
-    if (creation)
-        creation(element, basis ? () => invokeCreationUsingBasisChain(element, basis) : NOP);
+    const creationAsync = declaration.creationAsync;
+    if (creation && creationAsync) {
+        throw misuse("'creation' and 'creationAsync' cannot be defined together");
+    }
+    if (creation) {
+        result = creation(element, basis ? () => invokeCreationUsingBasisChain(element, basis) : NOP);
+    }
+    else if (creationAsync) {
+        result = creationAsync(element, basis ? () => invokeCreationUsingBasisChain(element, basis) : NOP_ASYNC);
+    }
     else if (basis)
-        invokeCreationUsingBasisChain(element, basis);
+        result = invokeCreationUsingBasisChain(element, basis);
+    return result;
 }
 function invokeDestructionUsingBasisChain(element, declaration) {
     const basis = declaration.basis;
@@ -281,7 +302,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 +332,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 +470,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,
                     });
                 });
@@ -489,10 +510,7 @@ function updateNow(seat) {
                     node.children.beginMerge();
                     const driver = node.driver;
                     result = driver.update(node);
-                    if (result instanceof Promise)
-                        result.then(v => { runUpdateNestedNodesThenDo(undefined, NOP); return v; }, e => { console.log(e); runUpdateNestedNodesThenDo(e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
-                    else
-                        runUpdateNestedNodesThenDo(undefined, NOP);
+                    result = proceedSyncOrAsync(result, v => { runUpdateNestedNodesThenDo(undefined, NOP); return v; }, e => { console.log(e); runUpdateNestedNodesThenDo(e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
                 }
                 catch (e) {
                     runUpdateNestedNodesThenDo(e, NOP);
@@ -519,7 +537,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));
                 });
         }
@@ -613,6 +631,7 @@ function defaultReject(error) {
 }
 Promise.prototype.then = reactronicDomHookedThen;
 const NOP = (...args) => { };
+const NOP_ASYNC = (...args) => __awaiter(void 0, void 0, void 0, function* () { });
 let gOwnSeat = undefined;
 let gFirstToDispose = undefined;
 let gLastToDispose = undefined;

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 migrateFieldVersion: (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,159 @@ 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) {
+                if (fk === Meta.Revision) {
+                    console.log("(!)");
+                }
+                TransactionImpl.migrateFieldVersionToAnotherTransaction(h, fk, ov, ovParent, tParent);
+            }
+        }
+        else {
+            ov.changes.forEach((o, fk) => {
+                if (fk === Meta.Revision) {
+                    console.log("(!)");
+                }
+                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.migrateFieldVersion(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 +459,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 +468,7 @@ TransactionImpl.curr = TransactionImpl.none;
 TransactionImpl.inspection = false;
 TransactionImpl.frameStartTime = 0;
 TransactionImpl.frameOverCounter = 0;
+TransactionImpl.migrateFieldVersion = function (fv, target) {
+    throw misuse("this implementation of cloneLaunch should never be called");
+};
 TransactionImpl._init();

package/build/dist/source/util/Utils.d.ts

@@ -7,6 +7,7 @@ export declare class Utils {
 export declare function UNDEF(...args: any[]): never;
 export declare function all(promises: Array<Promise<any>>): Promise<any[]>;
 export declare function pause<T>(timeout: number): Promise<T>;
+export declare function proceedSyncOrAsync<T>(result: T | Promise<T>, success: (v: any) => T, failure: (e: any) => T): T | Promise<T>;
 export declare function emitLetters(n: number): string;
 export declare function objectHasMember<T>(obj: any, member: string): obj is T;
 export declare function getCallerInfo(prefix: string): string;

package/build/dist/source/util/Utils.js

@@ -53,6 +53,14 @@ export function pause(timeout) {
         setTimeout(resolve.bind(null, () => resolve), timeout);
     });
 }
+export function proceedSyncOrAsync(result, success, failure) {
+    let r;
+    if (result instanceof Promise)
+        r = result.then(v => success(v), e => failure(e));
+    else
+        r = success(result);
+    return r;
+}
 export function emitLetters(n) {
     if (n < 0)
         throw new Error(`emitLetters: argument (${n}) should not be negative or zero`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.24.275",
+  "version": "0.24.302",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -32,15 +32,15 @@
   "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"
+    "typescript": "5.5.4"
   },
   "scripts": {
     "build": "eslint source/**.ts test/**.test.ts react/**.tsx && tsc",