fix(CORE-4563): Fix dispose infinite recursion

.github/workflows/ci.yml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main, master]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js 22
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Install Grunt CLI
+        run: npm install -g grunt-cli
+
+      - name: JSHint
+        run: grunt jshint
+
+      - name: Tests
+        run: npm test

.mise.toml

@@ -0,0 +1,2 @@
+[tools]
+node = "22.22.1"

lib/nodes/betaNode.js

@@ -26,20 +26,29 @@ Node.extend({
             }
         },
 
-        dispose: function () {
+        // visited: skip shared betas; propagateDispose: downstream joins get dispose + Memory#clear.
+        dispose: function (assertable, visited) {
+            visited = visited || {};
+            if (visited[this.__count]) {
+                return;
+            }
+            visited[this.__count] = true;
             this.leftMemory = {};
             this.rightMemory = {};
             this.leftTuples.clear();
             this.rightTuples.clear();
+            this.propagateDispose(assertable, undefined, visited);
         },
 
         disposeLeft: function (fact) {
+            // Fact-scoped retract path: clear left side only, then notify downstream.
             this.leftMemory = {};
             this.leftTuples.clear();
             this.propagateDispose(fact);
         },
 
         disposeRight: function (fact) {
+            // Mirror of disposeLeft for right-input retractions.
             this.rightMemory = {};
             this.rightTuples.clear();
             this.propagateDispose(fact);

lib/nodes/fromNode.js

@@ -41,6 +41,12 @@ JoinNode.extend({
             this.__variables = vars;
         },
 
+        // Drop from-derived fact index; super clears join tuples and walks out-edges.
+        dispose: function () {
+            this.fromMemory = {};
+            this._super(arguments);
+        },
+
         __createMatches: function (context) {
             var fh = context.factHash, o = this.from(fh);
             if (isArray(o)) {

lib/nodes/fromNotNode.js

@@ -35,6 +35,12 @@ JoinNode.extend({
 
         },
 
+        // Same as FromNode: fromMemory is outside BetaNode hash/tuples.
+        dispose: function () {
+            this.fromMemory = {};
+            this._super(arguments);
+        },
+
         retractLeft: function (context) {
             var ctx = this.removeFromLeftMemory(context);
             if (ctx) {

lib/nodes/index.js

@@ -96,10 +96,12 @@ declare({
             });
         },
 
+        // One visited map for the whole dispose walk (cycles / sharing).
         dispose: function () {
+            var visited = {};
             var typeNodes = this.typeNodes, i = typeNodes.length - 1;
             for (; i >= 0; i--) {
-                typeNodes[i].dispose();
+                typeNodes[i].dispose(visited);
             }
         },
 

lib/nodes/leftAdapterNode.js

@@ -22,10 +22,6 @@ Node.extend({
             this.__propagate("retractResolve", match);
         },
 
-        dispose: function (context) {
-            this.propagateDispose(context);
-        },
-
         toString: function () {
             return "LeftAdapterNode " + this.__count;
         }

lib/nodes/node.js

@@ -84,20 +84,27 @@ declare({
             }
         },
 
-        dispose: function (assertable) {
-            this.propagateDispose(assertable);
+        // Pass `visited` through from RootNode.dispose.
+        dispose: function (assertable, visited) {
+            visited = visited || {};
+            if (visited[this.__count]) {
+                return;
+            }
+            visited[this.__count] = true;
+            this.propagateDispose(assertable, undefined, visited);
         },
 
         retract: function (assertable) {
             this.propagateRetract(assertable);
         },
 
-        propagateDispose: function (assertable, outNodes) {
+        propagateDispose: function (assertable, outNodes, visited) {
+            visited = visited || {};
             outNodes = outNodes || this.nodes;
             var entrySet = this.__entrySet, i = entrySet.length - 1;
             for (; i >= 0; i--) {
                 var entry = entrySet[i], outNode = entry.key;
-                outNode.dispose(assertable);
+                outNode.dispose(assertable, visited);
             }
         },
 

lib/nodes/notNode.js

@@ -16,6 +16,12 @@ JoinNode.extend({
             this.notMatch = new Context(new InitialFact()).match;
         },
 
+        // BetaNode.dispose does not reset blocked-tuple map; clear before super chain.
+        dispose: function () {
+            this.leftTupleMemory = {};
+            this._super(arguments);
+        },
+
         __cloneContext: function (context) {
             return context.clone(null, null, context.match.merge(this.notMatch));
         },

lib/nodes/rightAdapterNode.js

@@ -7,10 +7,6 @@ Node.extend({
             this.__propagate("retractResolve", match);
         },
 
-        dispose: function (context) {
-            this.propagateDispose(context);
-        },
-
         propagateAssert: function (context) {
             this.__propagate("assertRight", context);
         },

lib/nodes/typeNode.js

@@ -26,11 +26,17 @@ AlphaNode.extend({
             return "TypeNode" + this.__count;
         },
 
-        dispose: function () {
+        // Root passes visited; optional otherwise.
+        dispose: function (visited) {
+            visited = visited || {};
+            if (visited[this.__count]) {
+                return;
+            }
+            visited[this.__count] = true;
             var es = this.__entrySet, i = es.length - 1;
             for (; i >= 0; i--) {
                 var e = es[i], outNode = e.key, paths = e.value;
-                outNode.dispose({paths: paths});
+                outNode.dispose({paths: paths}, visited);
             }
         },