reactronic 0.96.26004 → 0.96.26005

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

@@ -1,7 +1,6 @@
 export { all, pause, proceedSyncOrAsync } from "./util/Utils.js";
 export { Uri } from "./util/Uri.js";
-export { ReconciliationList } from "./util/ReconciliationList.js";
-export type { LinkedItem, ReconciliationListReader } from "./util/ReconciliationList.js";
+export { LinkedList, LinkedItem } from "./util/LinkedList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.js";

package/build/dist/source/api.js

@@ -1,6 +1,6 @@
 export { all, pause, proceedSyncOrAsync } from "./util/Utils.js";
 export { Uri } from "./util/Uri.js";
-export { ReconciliationList } from "./util/ReconciliationList.js";
+export { LinkedList, LinkedItem } from "./util/LinkedList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.js";

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

@@ -1,5 +1,5 @@
 import { LoggingOptions } from "../Logging.js";
-import { ReconciliationList, ReconciliationListReader, LinkedItem } from "../util/ReconciliationList.js";
+import { LinkedList, LinkedItem } from "../util/LinkedList.js";
 import { Priority, Mode } from "../Enums.js";
 import { ReactivityOptions } from "../Options.js";
 import { RxObject } from "../core/Mvcc.js";
@@ -11,7 +11,7 @@ export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, dec
 export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, bodyOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, bodyTask?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationTask?: ScriptAsync<E>, finalization?: Script<E>, signalArgs?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
 export declare function derivative<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
 export declare function launch<T>(node: ReactiveTreeNode<T>, signalArgs?: unknown): ReactiveTreeNode<T>;
-export declare abstract class ReactiveTreeNode<E = unknown> {
+export declare abstract class ReactiveTreeNode<E = unknown> extends LinkedItem<ReactiveTreeNode<E>> {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
     static frameDuration: number;
@@ -23,8 +23,7 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     abstract readonly owner: ReactiveTreeNode;
     abstract element: E;
     abstract readonly host: ReactiveTreeNode;
-    abstract readonly children: ReconciliationListReader<ReactiveTreeNode>;
-    abstract readonly slot: LinkedItem<ReactiveTreeNode<E>> | undefined;
+    abstract readonly children: LinkedList<ReactiveTreeNode>;
     abstract readonly stamp: number;
     abstract readonly outer: ReactiveTreeNode;
     abstract readonly context: ReactiveTreeNodeContext | undefined;
@@ -66,7 +65,7 @@ export type ReactiveTreeNodeDriver<E = unknown> = {
     runPreparation(node: ReactiveTreeNode<E>): void;
     runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
     runMount(node: ReactiveTreeNode<E>): void;
-    rebuildBody(node: ReactiveTreeNode<E>): void | Promise<void>;
+    runScript(node: ReactiveTreeNode<E>): void | Promise<void>;
     declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): LinkedItem<ReactiveTreeNode> | undefined;
     provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
 };
@@ -82,7 +81,7 @@ export declare abstract class BaseDriver<E = unknown> implements ReactiveTreeNod
     runPreparation(node: ReactiveTreeNode<E>): void | Promise<void>;
     runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
     runMount(node: ReactiveTreeNode<E>): void;
-    rebuildBody(node: ReactiveTreeNode<E>): void | Promise<void>;
+    runScript(node: ReactiveTreeNode<E>): void | Promise<void>;
     declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): LinkedItem<ReactiveTreeNode> | undefined;
     provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
 }
@@ -111,9 +110,8 @@ declare class ReactiveTreeNode$<E = unknown> extends ReactiveTreeNode<E> {
     readonly level: number;
     readonly owner: ReactiveTreeNode$;
     readonly element: E;
-    host: ReactiveTreeNode$;
-    readonly children: ReconciliationList<ReactiveTreeNode$>;
-    slot: LinkedItem<ReactiveTreeNode$<E>> | undefined;
+    host: ReactiveTreeNode;
+    readonly children: LinkedList<ReactiveTreeNode>;
     stamp: number;
     outer: ReactiveTreeNode$;
     context: ReactiveTreeNodeContext$<any> | undefined;
@@ -128,7 +126,7 @@ declare class ReactiveTreeNode$<E = unknown> extends ReactiveTreeNode<E> {
     has(mode: Mode): boolean;
     body(_signalArgs: unknown): void;
     configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
-    static get nodeSlot(): LinkedItem<ReactiveTreeNode$>;
+    static get node(): ReactiveTreeNode$;
     static tryUseTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T | undefined;
     static useTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T;
     static setTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>, value: T | undefined): void;

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

@@ -18,7 +18,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { misuse } from "../util/Dbg.js";
 import { Uri } from "../util/Uri.js";
-import { ReconciliationList } from "../util/ReconciliationList.js";
+import { LinkedList, LinkedItem, Mark, LinkedSubList } from "../util/LinkedList.js";
 import { emitLetters, flags, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js";
 import { Priority, Mode, Isolation, Reentrance } from "../Enums.js";
 import { RxObject } from "../core/Mvcc.js";
@@ -36,13 +36,13 @@ export function declare(driver, bodyOrDeclaration, bodyTask, key, mode, preparat
     else
         declaration = bodyOrDeclaration !== null && bodyOrDeclaration !== void 0 ? bodyOrDeclaration : {};
     let effectiveKey = declaration.key;
-    const owner = gNodeSlot === null || gNodeSlot === void 0 ? void 0 : gNodeSlot.instance;
+    const owner = gCurrentNode;
     if (owner) {
         let existing = owner.driver.declareChild(owner, driver, declaration, declaration.basis);
-        const children = owner.children;
-        existing !== null && existing !== void 0 ? existing : (existing = children.tryReuse(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside 'body' only"));
+        const renovation = owner.children.renovation;
+        existing !== null && existing !== void 0 ? existing : (existing = renovation.tryReaffirm(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside 'body' only"));
         if (existing) {
-            result = existing.instance;
+            result = existing;
             if (result.driver !== driver && driver !== undefined)
                 throw misuse(`changing element driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
             const exSignalArgs = result.declaration.signalArgs;
@@ -52,12 +52,11 @@ export function declare(driver, bodyOrDeclaration, bodyTask, key, mode, preparat
         }
         else {
             result = new ReactiveTreeNode$(effectiveKey || generateKey(owner), driver, declaration, owner);
-            result.slot = children.add(result);
+            renovation.thisIsAdded(result);
         }
     }
     else {
         result = new ReactiveTreeNode$(effectiveKey || generateKey(owner), driver, declaration, owner);
-        result.slot = ReconciliationList.createItem(result);
     }
     return result;
 }
@@ -72,9 +71,9 @@ export function launch(node, signalArgs) {
     ReactiveTreeNode.rebuildBody(node, signalArgs);
     return node;
 }
-export class ReactiveTreeNode {
+export class ReactiveTreeNode extends LinkedItem {
     static get current() {
-        return ReactiveTreeNode$.nodeSlot.instance;
+        return ReactiveTreeNode$.node;
     }
     static get isFirstBodyBuild() {
         return ReactiveTreeNode.current.stamp === 1;
@@ -84,15 +83,15 @@ export class ReactiveTreeNode {
         const declaration = impl.declaration;
         if (node.stamp >= Number.MAX_SAFE_INTEGER || !signalsAreEqual(signalArgs, declaration.signalArgs)) {
             declaration.signalArgs = signalArgs;
-            rebuildBodyViaSlot(impl.slot);
+            rebuildBodyImpl(impl);
         }
     }
     static launchFinalization(node) {
         const impl = node;
-        launchFinalizationViaSlot(impl.slot, true, true);
+        launchFinalizationImpl(impl, true, true);
     }
     static launchNestedNodesThenDo(action) {
-        launchNestedNodesThenDoImpl(ReactiveTreeNode$.nodeSlot, undefined, action);
+        launchNestedNodesThenDoImpl(ReactiveTreeNode$.node, undefined, action);
     }
     static markAsMounted(node, yes) {
         const n = node;
@@ -103,14 +102,13 @@ export class ReactiveTreeNode {
         n.stamp = yes ? 0 : Number.MAX_SAFE_INTEGER - 1;
     }
     lookupTreeNodeByUri(uri) {
-        var _a;
         const t = Uri.parse(uri);
         if (t.authority !== this.key)
             throw misuse(`authority '${t.authority}' doesn't match root node key '${this.key}'`);
         const segments = t.path.split("/");
         let result = this;
         for (let i = 1; i < segments.length && result !== undefined; i++)
-            result = (_a = result.children.lookup(segments[i])) === null || _a === void 0 ? void 0 : _a.instance;
+            result = result.children.lookup(segments[i]);
         return result;
     }
     static findMatchingHost(node, match) {
@@ -120,15 +118,15 @@ export class ReactiveTreeNode {
         return p;
     }
     static findMatchingPrevSibling(node, match) {
-        let p = node.slot.prev;
-        while (p && !match(p.instance))
+        let p = node.prev;
+        while (p && !match(p))
             p = p.prev;
-        return p === null || p === void 0 ? void 0 : p.instance;
+        return p;
     }
     static forEachChildRecursively(node, action) {
         action(node);
         for (const child of node.children.items())
-            ReactiveTreeNode.forEachChildRecursively(child.instance, action);
+            ReactiveTreeNode.forEachChildRecursively(child, action);
     }
     static getDefaultLoggingOptions() {
         return ReactiveTreeNode$.logging;
@@ -158,8 +156,8 @@ export class BaseDriver {
     }
     runMount(node) {
     }
-    rebuildBody(node) {
-        return invokeRebuildBodyUsingBasisChain(node.element, node.declaration);
+    runScript(node) {
+        return invokeScriptUsingBasisChain(node.element, node.declaration);
     }
     declareChild(ownerNode, childDriver, childDeclaration, childBasis) {
         return undefined;
@@ -196,7 +194,7 @@ export 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.basis) ? getModeUsingBasisChain(declaration === null || declaration === void 0 ? void 0 : declaration.basis) : Mode.default);
 }
-function invokeRebuildBodyUsingBasisChain(element, declaration) {
+function invokeScriptUsingBasisChain(element, declaration) {
     let result = undefined;
     const basis = declaration.basis;
     const body = declaration.body;
@@ -204,11 +202,11 @@ function invokeRebuildBodyUsingBasisChain(element, declaration) {
     if (body && bodyTask)
         throw misuse("'body' and 'bodyTask' cannot be defined together");
     if (body)
-        result = body.call(element, element, basis ? () => invokeRebuildBodyUsingBasisChain(element, basis) : NOP);
+        result = body.call(element, element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP);
     else if (bodyTask)
-        result = bodyTask.call(element, element, basis ? () => invokeRebuildBodyUsingBasisChain(element, basis) : NOP_ASYNC);
+        result = bodyTask.call(element, element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP_ASYNC);
     else if (basis)
-        result = invokeRebuildBodyUsingBasisChain(element, basis);
+        result = invokeScriptUsingBasisChain(element, basis);
     return result;
 }
 function invokePreparationUsingBasisChain(element, declaration) {
@@ -270,8 +268,7 @@ class ReactiveTreeNode$ extends ReactiveTreeNode {
         }
         this.element = driver.create(this);
         this.host = thisAsUnknown;
-        this.children = new ReconciliationList(getNodeKey, true);
-        this.slot = undefined;
+        this.children = new LinkedList(getNodeKey, true);
         this.stamp = Number.MAX_SAFE_INTEGER;
         this.context = undefined;
         this.numerator = 0;
@@ -292,35 +289,35 @@ class ReactiveTreeNode$ extends ReactiveTreeNode {
         return result.toString();
     }
     get strictOrder() {
-        return this.children.isStrict;
+        return this.children.isStrictOrder;
     }
     set strictOrder(value) {
-        this.children.isStrict = value;
+        this.children.isStrictOrder = value;
     }
     get isMoved() {
-        return this.owner.children.isMoved(this.slot);
+        return this.mark === Mark.modified;
     }
     has(mode) {
         return flags(getModeUsingBasisChain(this.declaration), mode);
     }
     body(_signalArgs) {
-        rebuildBodyNow(this.slot);
+        runScriptNow(this);
     }
     configureReactivity(options) {
         if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.autonomous))
             throw misuse("reactronic can be configured only for elements with autonomous mode and only during preparation");
         return manageReaction(this.body).configure(options);
     }
-    static get nodeSlot() {
-        if (!gNodeSlot)
-            throw misuse("current element is undefined");
-        return gNodeSlot;
+    static get node() {
+        if (!gCurrentNode)
+            throw misuse("current node is undefined");
+        return gCurrentNode;
     }
     static tryUseTreeVariableValue(variable) {
         var _a, _b;
-        let node = ReactiveTreeNode$.nodeSlot.instance;
-        while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && node.owner !== node)
-            node = node.outer.slot.instance;
+        let node = ReactiveTreeNode.current;
+        while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.value) !== variable && node.owner !== node)
+            node = node.outer;
         return (_b = node.context) === null || _b === void 0 ? void 0 : _b.value;
     }
     static useTreeVariableValue(variable) {
@@ -331,7 +328,7 @@ class ReactiveTreeNode$ extends ReactiveTreeNode {
         return result;
     }
     static setTreeVariableValue(variable, value) {
-        const node = ReactiveTreeNode$.nodeSlot.instance;
+        const node = ReactiveTreeNode$.node;
         const owner = node.owner;
         const hostCtx = runNonReactive(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
@@ -383,42 +380,42 @@ function gatherAuthorityAndPath(node, path, relativeTo) {
 function getNodeKey(node) {
     return node.stamp >= 0 ? node.key : undefined;
 }
-function launchNestedNodesThenDoImpl(nodeSlot, error, action) {
-    runInsideContextOfNode(nodeSlot, () => {
+function launchNestedNodesThenDoImpl(node, error, action) {
+    runInsideContextOfNode(node, () => {
         var _a;
-        const owner = nodeSlot.instance;
+        const owner = node;
         const children = owner.children;
-        if (children.isReconciliationInProgress) {
+        if (children.isRenovationInProgress) {
             let promised = undefined;
             try {
-                children.endReconciliation(error);
-                for (const child of children.itemsRemoved(true))
-                    launchFinalizationViaSlot(child, true, true);
+                const renovation = children.endRenovation(error);
+                for (const child of renovation.lostItems())
+                    launchFinalizationImpl(child, true, true);
                 if (!error) {
-                    const sequential = children.isStrict;
+                    const sequential = children.isStrictOrder;
                     let p1 = undefined;
                     let p2 = undefined;
                     let mounting = false;
                     let partition = owner;
-                    for (const child of children.items()) {
+                    for (const c of children.items()) {
                         if (Transaction.isCanceled)
                             break;
-                        const childNode = child.instance;
-                        const isPart = childNode.driver.isPartition;
+                        const child = c;
+                        const isPart = child.driver.isPartition;
                         const host = isPart ? owner : partition;
                         mounting = markToMountIfNecessary(mounting, host, child, children, sequential);
-                        const p = (_a = childNode.priority) !== null && _a !== void 0 ? _a : Priority.realtime;
+                        const p = (_a = child.priority) !== null && _a !== void 0 ? _a : Priority.realtime;
                         if (p === Priority.realtime)
-                            rebuildBodyViaSlot(child);
+                            rebuildBodyImpl(child);
                         else if (p === Priority.normal)
                             p1 = push(child, p1);
                         else
                             p2 = push(child, p2);
                         if (isPart)
-                            partition = childNode;
+                            partition = child;
                     }
                     if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
-                        promised = startIncrementalNestedBodyBuild(nodeSlot, children, p1, p2).then(() => action(error), e => action(e));
+                        promised = startIncrementalNestedScriptsRun(node, children, p1, p2).then(() => action(error), e => action(e));
                 }
             }
             finally {
@@ -428,32 +425,31 @@ function launchNestedNodesThenDoImpl(nodeSlot, error, action) {
         }
     });
 }
-function markToMountIfNecessary(mounting, host, nodeSlot, children, sequential) {
-    const node = nodeSlot.instance;
+function markToMountIfNecessary(mounting, host, node, children, sequential) {
     if (node.element.native && !node.has(Mode.external)) {
         if (mounting || node.host !== host) {
-            children.markAsMoved(nodeSlot);
+            LinkedItem.setStatus$(node, Mark.modified, node.rank);
             mounting = false;
         }
     }
-    else if (sequential && children.isMoved(nodeSlot))
+    else if (sequential && node.mark === Mark.modified)
         mounting = true;
     node.host = host;
     return mounting;
 }
-function startIncrementalNestedBodyBuild(ownerSlot, allChildren, priority1, priority2) {
+function startIncrementalNestedScriptsRun(ownerNode, allChildren, priority1, priority2) {
     return __awaiter(this, void 0, void 0, function* () {
-        const stamp = ownerSlot.instance.stamp;
+        const stamp = ownerNode.stamp;
         if (priority1)
-            yield runNestedBodyBuildIncrementally(ownerSlot, stamp, allChildren, priority1, Priority.normal);
+            yield runNestedScriptsIncrementally(ownerNode, stamp, allChildren, priority1, Priority.normal);
         if (priority2)
-            yield runNestedBodyBuildIncrementally(ownerSlot, stamp, allChildren, priority2, Priority.background);
+            yield runNestedScriptsIncrementally(ownerNode, stamp, allChildren, priority2, Priority.background);
     });
 }
-function runNestedBodyBuildIncrementally(owner, stamp, allChildren, items, priority) {
+function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priority) {
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
-        const node = owner.instance;
+        const node = owner;
         if (!Transaction.isCanceled || !Transaction.isFrameOver(1, ReactiveTreeNode$.shortFrameDuration / 3)) {
             let outerPriority = ReactiveTreeNode$.currentBodyPriority;
             ReactiveTreeNode$.currentBodyPriority = priority;
@@ -463,7 +459,7 @@ function runNestedBodyBuildIncrementally(owner, stamp, allChildren, items, prior
                 const frameDurationLimit = priority === Priority.background ? ReactiveTreeNode.shortFrameDuration : Infinity;
                 let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveTreeNode.frameDuration / 4, ReactiveTreeNode.shortFrameDuration));
                 for (const child of items) {
-                    rebuildBodyViaSlot(child);
+                    rebuildBodyImpl(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
                         ReactiveTreeNode$.currentBodyPriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
@@ -481,8 +477,7 @@ function runNestedBodyBuildIncrementally(owner, stamp, allChildren, items, prior
         }
     });
 }
-function rebuildBodyViaSlot(nodeSlot) {
-    const node = nodeSlot.instance;
+function rebuildBodyImpl(node) {
     if (node.stamp >= 0) {
         if (node.has(Mode.autonomous)) {
             if (node.stamp === Number.MAX_SAFE_INTEGER) {
@@ -497,9 +492,9 @@ function rebuildBodyViaSlot(nodeSlot) {
             runNonReactive(node.body, node.declaration.signalArgs);
         }
         else if (node.owner !== node)
-            rebuildBodyNow(nodeSlot);
+            runScriptNow(node);
         else
-            runTransactional(() => rebuildBodyNow(nodeSlot));
+            runTransactional(() => runScriptNow(node));
     }
 }
 function mountOrRemountIfNecessary(node) {
@@ -518,32 +513,30 @@ function mountOrRemountIfNecessary(node) {
     else if (node.isMoved && !node.has(Mode.external) && node.host !== node)
         runNonReactive(() => driver.runMount(node));
 }
-function rebuildBodyNow(nodeSlot) {
-    const node = nodeSlot.instance;
+function runScriptNow(node) {
     if (node.stamp >= 0) {
         let result = undefined;
-        runInsideContextOfNode(nodeSlot, () => {
+        runInsideContextOfNode(node, () => {
             mountOrRemountIfNecessary(node);
             if (node.stamp < Number.MAX_SAFE_INTEGER - 1) {
                 try {
                     node.stamp++;
                     node.numerator = 0;
-                    node.children.beginReconciliation();
+                    node.children.beginRenovation();
                     const driver = node.driver;
-                    result = driver.rebuildBody(node);
-                    result = proceedSyncOrAsync(result, v => { launchNestedNodesThenDoImpl(nodeSlot, undefined, NOP); return v; }, e => { console.log(e); launchNestedNodesThenDoImpl(nodeSlot, e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
+                    result = driver.runScript(node);
+                    result = proceedSyncOrAsync(result, v => { launchNestedNodesThenDoImpl(node, undefined, NOP); return v; }, e => { console.log(e); launchNestedNodesThenDoImpl(node, e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
                 }
                 catch (e) {
-                    launchNestedNodesThenDoImpl(nodeSlot, e, NOP);
-                    console.log(`Reactive node body build failed: ${node.key}`);
+                    launchNestedNodesThenDoImpl(node, e, NOP);
+                    console.log(`Reactive node body failed: ${node.key}`);
                     console.log(`${e}`);
                 }
             }
         });
     }
 }
-function launchFinalizationViaSlot(nodeSlot, isLeader, individual) {
-    const node = nodeSlot.instance;
+function launchFinalizationImpl(node, isLeader, individual) {
     if (node.stamp >= 0) {
         const driver = node.driver;
         if (individual && node.key !== node.declaration.key && !driver.isPartition)
@@ -551,39 +544,34 @@ function launchFinalizationViaSlot(nodeSlot, isLeader, individual) {
         node.stamp = ~node.stamp;
         const childrenAreLeaders = runNonReactive(() => driver.runFinalization(node, isLeader));
         if (node.has(Mode.autonomous)) {
-            nodeSlot.aux = undefined;
-            const last = gLastToDispose;
-            if (last)
-                gLastToDispose = last.aux = nodeSlot;
-            else
-                gFirstToDispose = gLastToDispose = nodeSlot;
-            if (gFirstToDispose === nodeSlot)
-                runTransactional({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${nodeSlot.instance.key})` }, () => {
+            LinkedItem.link$(gDisposeList, node, undefined);
+            if (gDisposeList.first === node)
+                runTransactional({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${node.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }
         for (const child of node.children.items())
-            launchFinalizationViaSlot(child, childrenAreLeaders, false);
+            launchFinalizationImpl(child, childrenAreLeaders, false);
         ReactiveTreeNode$.grandNodeCount--;
     }
 }
 function runDisposalLoop() {
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
-        let slot = gFirstToDispose;
-        while (slot !== undefined) {
+        let node = gDisposeList.first;
+        while (node !== undefined) {
             if (Transaction.isFrameOver(500, 5))
                 yield Transaction.requestNextFrame();
-            disposeRxObject(slot.instance);
-            slot = slot.aux;
+            disposeRxObject(node);
+            LinkedItem.link$(undefined, node, undefined);
+            node = gDisposeList.first;
             ReactiveTreeNode$.disposableNodeCount--;
         }
-        gFirstToDispose = gLastToDispose = undefined;
     });
 }
 function wrapToRunInside(func) {
     let wrappedToRunInside;
-    const outer = gNodeSlot;
+    const outer = gCurrentNode;
     if (outer)
         wrappedToRunInside = (...args) => {
             return runInsideContextOfNode(outer, func, ...args);
@@ -592,14 +580,14 @@ function wrapToRunInside(func) {
         wrappedToRunInside = func;
     return wrappedToRunInside;
 }
-function runInsideContextOfNode(nodeSlot, func, ...args) {
-    const outer = gNodeSlot;
+function runInsideContextOfNode(node, func, ...args) {
+    const outer = gCurrentNode;
     try {
-        gNodeSlot = nodeSlot;
+        gCurrentNode = node;
         return func(...args);
     }
     finally {
-        gNodeSlot = outer;
+        gCurrentNode = outer;
     }
 }
 export function signalsAreEqual(a1, a2) {
@@ -653,6 +641,5 @@ function defaultReject(error) {
 Promise.prototype.then = reactronicDomHookedThen;
 const NOP = (...args) => { };
 const NOP_ASYNC = (...args) => __awaiter(void 0, void 0, void 0, function* () { });
-let gNodeSlot = undefined;
-let gFirstToDispose = undefined;
-let gLastToDispose = undefined;
+let gCurrentNode = undefined;
+const gDisposeList = new LinkedSubList();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.96.26004",
+  "version": "0.96.26005",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",