Refactor ownership cleanup and content slot management

packages/@reflex/runtime/rollup.walkers-jit.config.ts

@@ -0,0 +1,26 @@
+import replace from "@rollup/plugin-replace";
+import resolve from "@rollup/plugin-node-resolve";
+
+export default {
+  input: "tests/walkers.jit.mjs",
+  output: {
+    file: "dist/walkers.jit.js",
+    format: "esm",
+    sourcemap: false,
+  },
+  treeshake: {
+    moduleSideEffects: false,
+    propertyReadSideEffects: false,
+  },
+  plugins: [
+    resolve({
+      extensions: [".js", ".mjs"],
+    }),
+    replace({
+      preventAssignment: true,
+      values: {
+        __DEV__: "false",
+      },
+    }),
+  ],
+};

packages/@reflex/runtime/src/reactivity/engine/tracking.ts

@@ -3,7 +3,7 @@ import type ReactiveNode from "../shape/ReactiveNode";
 import type { ReactiveEdge } from "../shape/ReactiveEdge";
 import {
   reuseOrCreateIncomingEdge,
-  unlinkEdge,
+  unlinkDetachedIncomingEdgeSequence,
 } from "../shape/methods/connect";
 
 /**
@@ -17,15 +17,36 @@ export function trackRead(source: ReactiveNode): void {
   if (!consumer) return;
 
   const prevEdge = consumer.depsTail;
-  const nextExpected = prevEdge !== null ? prevEdge.nextIn : consumer.firstIn;
-  const edge = reuseOrCreateIncomingEdge(
+  if (prevEdge !== null) {
+    if (prevEdge.from === source) return;
+
+    const nextExpected = prevEdge.nextIn;
+    if (nextExpected !== null && nextExpected.from === source) {
+      consumer.depsTail = nextExpected;
+      return;
+    }
+
+    consumer.depsTail = reuseOrCreateIncomingEdge(
+      source,
+      consumer,
+      prevEdge,
+      nextExpected,
+    );
+    return;
+  }
+
+  const firstIn = consumer.firstIn;
+  if (firstIn !== null && firstIn.from === source) {
+    consumer.depsTail = firstIn;
+    return;
+  }
+
+  consumer.depsTail = reuseOrCreateIncomingEdge(
     source,
     consumer,
-    prevEdge,
-    nextExpected,
+    null,
+    firstIn,
   );
-
-  consumer.depsTail = edge;
 }
 
 /**
@@ -34,11 +55,21 @@ export function trackRead(source: ReactiveNode): void {
  */
 export function cleanupStaleSources(node: ReactiveNode): void {
   const tail = node.depsTail;
-  let edge: ReactiveEdge | null = tail !== null ? tail.nextIn : node.firstIn;
+  let staleHead: ReactiveEdge | null;
+
+  if (tail !== null) {
+    staleHead = tail.nextIn;
+    if (staleHead === null) return;
 
-  while (edge) {
-    const next: ReactiveEdge | null = edge.nextIn;
-    unlinkEdge(edge);
-    edge = next;
+    tail.nextIn = null;
+    node.lastIn = tail;
+  } else {
+    staleHead = node.firstIn;
+    if (staleHead === null) return;
+
+    node.firstIn = null;
+    node.lastIn = null;
   }
+
+  unlinkDetachedIncomingEdgeSequence(staleHead);
 }

packages/@reflex/runtime/src/reactivity/shape/ReactiveMeta.ts

@@ -1,4 +1,4 @@
-import ReactiveNode from "./ReactiveNode";
+import type ReactiveNode from "./ReactiveNode";
 
 export enum ReactiveNodeState {
   Producer = 1 << 0,

packages/@reflex/runtime/src/reactivity/shape/methods/connect.ts

@@ -4,7 +4,7 @@ import {
   type ReactiveEdge,
 } from "../ReactiveEdge";
 import { isDisposedNode, ReactiveNodeState } from "../ReactiveMeta";
-import ReactiveNode from "../ReactiveNode";
+import type ReactiveNode from "../ReactiveNode";
 
 // ─── Internal helpers ────────────────────────────────────────────────────────
 
@@ -87,10 +87,6 @@ export function reuseOrCreateIncomingEdge(
   prev: ReactiveEdge | null,
   nextExpected: ReactiveEdge | null,
 ): ReactiveEdge {
-  // Fast path: the edge we already hold is the right one.
-  if (prev?.from === from) return prev;
-  if (nextExpected?.from === from) return nextExpected;
-
   // Scan the rest of the incoming list for a reusable edge.
   for (
     let edge = nextExpected ? nextExpected.nextIn : to.firstIn;
@@ -111,6 +107,17 @@ export function reuseOrCreateIncomingEdge(
   return linkEdge(from, to, prev);
 }
 
+export function unlinkDetachedIncomingEdgeSequence(
+  edge: ReactiveEdge | null,
+): void {
+  while (edge) {
+    const next = edge.nextIn;
+    detachOutEdge(edge.from, edge);
+    clearReactiveEdgeLinks(edge);
+    edge = next;
+  }
+}
+
 /**
  * Full incoming-edge sweep used by disposal paths.
  * Cold-path traversal that tears down every source connection.