@fluixi/reactive 1.0.0-alpha.105 → 1.0.0-alpha.106

package/dist/lib/signal/index.mjs

@@ -1,7 +1,7 @@
-/*! @fluixi/reactive v1.0.0-alpha.105 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/reactive v1.0.0-alpha.106 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 
 // src/version.generated.ts
-var VERSION = "1.0.0-alpha.105";
+var VERSION = "1.0.0-alpha.106";
 
 // src/lib/signal/graph/state.ts
 var MAJOR = VERSION.split(".")[0];
@@ -197,6 +197,7 @@ var Computed = class extends Source {
     super();
     this._threw = false;
     this._initialized = false;
+    this._disposed = false;
     this.state = DIRTY;
     /** Nodes this computation read on its last run. Rebuilt on every run. */
     this.sources = null;
@@ -212,8 +213,23 @@ var Computed = class extends Source {
     if (this._threw) throw this._error;
     return this._value;
   }
+  /**
+   * Unlink from every source, for good. Without this, a source outlives the
+   * computation and keeps it (and everything its function captured) reachable
+   * through its observers set: a disposed list row stayed in memory that way.
+   * The last value stays readable; the node simply never updates again.
+   */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    if (this.sources) {
+      for (const s of this.sources) s.observers?.delete(this);
+      this.sources = null;
+    }
+  }
   /** Settle, if CHECK, verify sources; if DIRTY (or never run), recompute. */
   updateIfNecessary() {
+    if (this._disposed) return;
     if (this.state === CHECK) {
       if (this.sources) {
         for (const s of this.sources) {
@@ -257,7 +273,7 @@ var Computed = class extends Source {
     reportReactiveRun(this);
     if (changed) {
       this.version++;
-      if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+      if (this.observers) for (const o of this.observers) o.markDirty(DIRTY);
       notifyWatchers(this);
     }
   }
@@ -271,7 +287,7 @@ var Computed = class extends Source {
     const wasClean = this.state === CLEAN;
     this.state = level;
     if (wasClean) {
-      if (this.observers) for (const o of [...this.observers]) o.markDirty(CHECK);
+      if (this.observers) for (const o of this.observers) o.markDirty(CHECK);
       notifyWatchers(this);
     }
   }
@@ -310,6 +326,10 @@ var Watcher = class {
     this._pending.clear();
     return out;
   }
+  /** Drain pending without the array, for callers that only need it empty. */
+  clearPending() {
+    this._pending.clear();
+  }
   /** @internal, a watched node became non-clean. Edge-triggered: notify once. */
   _notify(node) {
     if (!this._watched.has(node) || this._pending.has(node)) return;
@@ -527,14 +547,14 @@ var EffectNode = class {
         if (typeof r === "function") (this.owner.cleanups ??= []).push(r);
       });
     });
-    reportReactiveNode({ kind: "effect", node: this.computed, handle: this, internal: !report, ...name ? { name } : {} });
+    if (isObserved()) reportReactiveNode({ kind: "effect", node: this.computed, handle: this, internal: !report, ...name ? { name } : {} });
     this.watcher = new Watcher(() => enqueue(this));
     this.run();
     this.watcher.watch(this.computed);
   }
   run() {
     if (this.disposed) return;
-    this.watcher.getPending();
+    this.watcher.clearPending();
     try {
       this.computed.get();
     } catch (e) {
@@ -551,6 +571,7 @@ var EffectNode = class {
     this.disposed = true;
     reportReactiveDispose(this.computed);
     this.watcher.unwatch(this.computed);
+    this.computed.dispose();
     disposeOwner(this.owner);
   }
 };
@@ -589,13 +610,15 @@ function createSignal(value, options) {
     },
     enumerable: false
   });
-  reportReactiveNode({
-    kind: "signal",
-    node: state,
-    handle: read,
-    name: options?.name,
-    set: write
-  });
+  if (isObserved()) {
+    reportReactiveNode({
+      kind: "signal",
+      node: state,
+      handle: read,
+      name: options?.name,
+      set: write
+    });
+  }
   if (isObserved()) onCleanup(() => reportReactiveDispose(state));
   return [read, write];
 }
@@ -619,8 +642,11 @@ function createMemo(fn, value, options) {
   const read = (() => c.get());
   Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
   Object.defineProperty(read, $MEMO, { value: true, enumerable: true });
-  reportReactiveNode({ kind: "memo", node: c, handle: read, name: options?.name });
-  if (isObserved()) onCleanup(() => reportReactiveDispose(c));
+  if (isObserved()) reportReactiveNode({ kind: "memo", node: c, handle: read, name: options?.name });
+  onCleanup(() => {
+    c.dispose();
+    if (isObserved()) reportReactiveDispose(c);
+  });
   return read;
 }
 function createEffect(fn, value, options) {
@@ -677,6 +703,20 @@ function on(deps, fn, options) {
 }
 
 // src/lib/signal/list.ts
+function lazyIndex(initial) {
+  let current = initial;
+  let state = null;
+  return {
+    index: () => {
+      if (!state) state = createSignal(current, { name: "row index" });
+      return state[0]();
+    },
+    set: (n) => {
+      current = n;
+      if (state) state[1](n);
+    }
+  };
+}
 function mapArray(list, mapFn, options) {
   let items = [];
   onCleanup(() => {
@@ -706,9 +746,9 @@ function mapArray(list, mapFn, options) {
           let rendered, setIndex, dispose;
           createRoot((d) => {
             dispose = d;
-            const [index, setIdx] = createSignal(i, { name: "row index" });
-            setIndex = setIdx;
-            rendered = mapFn(value, index);
+            const idx = lazyIndex(i);
+            setIndex = idx.set;
+            rendered = mapFn(value, idx.index);
           });
           const entry = { item: value, rendered, dispose, setIndex };
           result.push(entry);
@@ -748,21 +788,19 @@ function keyArray(list, keyFn, mapFn, options) {
         const reuse = prevByKey.get(key);
         if (reuse && !usedKeys.has(key)) {
           reuse.setIndex(i);
+          reuse.setItem(next[i]);
           resultEntries.push(reuse);
         } else {
-          let rendered, setIndex, dispose;
+          let rendered, setIndex, setItem, dispose;
           createRoot((d) => {
             dispose = d;
-            const [index, setIdx] = createSignal(i, { name: "row index" });
-            setIndex = setIdx;
-            const item = createMemo((prev) => {
-              const cur = list() || [];
-              const v = cur[index()];
-              return v !== void 0 && v !== null ? v : prev;
-            }, next[i]);
-            rendered = mapFn(item, index);
+            const idx = lazyIndex(i);
+            setIndex = idx.set;
+            const [item, writeItem] = createSignal(next[i]);
+            setItem = (v) => writeItem(() => v);
+            rendered = mapFn(item, idx.index);
           });
-          resultEntries.push({ rendered, dispose, setIndex });
+          resultEntries.push({ rendered, dispose, setIndex, setItem });
         }
         resultKeys.push(key);
         usedKeys.add(key);
@@ -812,7 +850,7 @@ function indexArray(list, mapFn, options) {
 
 // src/lib/signal/graph/detect.ts
 var __BROWSER_PROD__ = typeof window === "undefined" ? false : window.__FLUIXI_PROD__ === true;
-var __DEV__ = typeof process === "undefined" ? __BROWSER_PROD__ : false;
+var __DEV__ = typeof process === "undefined" ? __BROWSER_PROD__ : process.env.NODE_ENV !== "production";
 var $SIGNAL2 = /* @__PURE__ */ Symbol.for("signal");
 var $MEMO2 = /* @__PURE__ */ Symbol.for("memo");
 var $RESOURCE = /* @__PURE__ */ Symbol.for("resource");

package/dist/lib/signal/list.cjs

@@ -27,7 +27,7 @@ __export(list_exports, {
 module.exports = __toCommonJS(list_exports);
 
 // src/version.generated.ts
-var VERSION = "1.0.0-alpha.105";
+var VERSION = "1.0.0-alpha.106";
 
 // src/lib/signal/graph/state.ts
 var MAJOR = VERSION.split(".")[0];
@@ -169,6 +169,7 @@ var Computed = class extends Source {
     super();
     this._threw = false;
     this._initialized = false;
+    this._disposed = false;
     this.state = DIRTY;
     /** Nodes this computation read on its last run. Rebuilt on every run. */
     this.sources = null;
@@ -184,8 +185,23 @@ var Computed = class extends Source {
     if (this._threw) throw this._error;
     return this._value;
   }
+  /**
+   * Unlink from every source, for good. Without this, a source outlives the
+   * computation and keeps it (and everything its function captured) reachable
+   * through its observers set: a disposed list row stayed in memory that way.
+   * The last value stays readable; the node simply never updates again.
+   */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    if (this.sources) {
+      for (const s of this.sources) s.observers?.delete(this);
+      this.sources = null;
+    }
+  }
   /** Settle, if CHECK, verify sources; if DIRTY (or never run), recompute. */
   updateIfNecessary() {
+    if (this._disposed) return;
     if (this.state === CHECK) {
       if (this.sources) {
         for (const s of this.sources) {
@@ -229,7 +245,7 @@ var Computed = class extends Source {
     reportReactiveRun(this);
     if (changed) {
       this.version++;
-      if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+      if (this.observers) for (const o of this.observers) o.markDirty(DIRTY);
       notifyWatchers(this);
     }
   }
@@ -243,7 +259,7 @@ var Computed = class extends Source {
     const wasClean = this.state === CLEAN;
     this.state = level;
     if (wasClean) {
-      if (this.observers) for (const o of [...this.observers]) o.markDirty(CHECK);
+      if (this.observers) for (const o of this.observers) o.markDirty(CHECK);
       notifyWatchers(this);
     }
   }
@@ -388,13 +404,15 @@ function createSignal(value, options) {
     },
     enumerable: false
   });
-  reportReactiveNode({
-    kind: "signal",
-    node: state,
-    handle: read,
-    name: options?.name,
-    set: write
-  });
+  if (isObserved()) {
+    reportReactiveNode({
+      kind: "signal",
+      node: state,
+      handle: read,
+      name: options?.name,
+      set: write
+    });
+  }
   if (isObserved()) onCleanup(() => reportReactiveDispose(state));
   return [read, write];
 }
@@ -418,8 +436,11 @@ function createMemo(fn, value, options) {
   const read = (() => c.get());
   Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
   Object.defineProperty(read, $MEMO, { value: true, enumerable: true });
-  reportReactiveNode({ kind: "memo", node: c, handle: read, name: options?.name });
-  if (isObserved()) onCleanup(() => reportReactiveDispose(c));
+  if (isObserved()) reportReactiveNode({ kind: "memo", node: c, handle: read, name: options?.name });
+  onCleanup(() => {
+    c.dispose();
+    if (isObserved()) reportReactiveDispose(c);
+  });
   return read;
 }
 function untrack2(fn) {
@@ -427,6 +448,20 @@ function untrack2(fn) {
 }
 
 // src/lib/signal/list.ts
+function lazyIndex(initial) {
+  let current = initial;
+  let state = null;
+  return {
+    index: () => {
+      if (!state) state = createSignal(current, { name: "row index" });
+      return state[0]();
+    },
+    set: (n) => {
+      current = n;
+      if (state) state[1](n);
+    }
+  };
+}
 function mapArray(list, mapFn, options) {
   let items = [];
   onCleanup(() => {
@@ -456,9 +491,9 @@ function mapArray(list, mapFn, options) {
           let rendered, setIndex, dispose;
           createRoot((d) => {
             dispose = d;
-            const [index, setIdx] = createSignal(i, { name: "row index" });
-            setIndex = setIdx;
-            rendered = mapFn(value, index);
+            const idx = lazyIndex(i);
+            setIndex = idx.set;
+            rendered = mapFn(value, idx.index);
           });
           const entry = { item: value, rendered, dispose, setIndex };
           result.push(entry);
@@ -498,21 +533,19 @@ function keyArray(list, keyFn, mapFn, options) {
         const reuse = prevByKey.get(key);
         if (reuse && !usedKeys.has(key)) {
           reuse.setIndex(i);
+          reuse.setItem(next[i]);
           resultEntries.push(reuse);
         } else {
-          let rendered, setIndex, dispose;
+          let rendered, setIndex, setItem, dispose;
           createRoot((d) => {
             dispose = d;
-            const [index, setIdx] = createSignal(i, { name: "row index" });
-            setIndex = setIdx;
-            const item = createMemo((prev) => {
-              const cur = list() || [];
-              const v = cur[index()];
-              return v !== void 0 && v !== null ? v : prev;
-            }, next[i]);
-            rendered = mapFn(item, index);
+            const idx = lazyIndex(i);
+            setIndex = idx.set;
+            const [item, writeItem] = createSignal(next[i]);
+            setItem = (v) => writeItem(() => v);
+            rendered = mapFn(item, idx.index);
           });
-          resultEntries.push({ rendered, dispose, setIndex });
+          resultEntries.push({ rendered, dispose, setIndex, setItem });
         }
         resultKeys.push(key);
         usedKeys.add(key);

package/dist/lib/signal/list.d.ts

@@ -14,18 +14,13 @@ interface ListOptions {
     /** Returned (as-is, not wrapped) when the list is empty/nullish. */
     fallback?: () => any;
 }
-/**
- * Reference-keyed map. Reuses an item's mapped value while the same value (by
- * `===`) stays in the list; new values get a fresh root + index signal; removed
- * values are disposed. The map fn receives the plain value (a snapshot) and a
- * reactive index accessor. Backs `<For>`.
- */
 export declare function mapArray<T, U>(list: ListSource<T>, mapFn: (item: T, index: Accessor<number>) => U, options?: ListOptions): Accessor<U[]>;
 /**
  * Key-function map. Like `mapArray` but reuse is keyed by `keyFn(item)` (so the
  * same key survives object recreation), and the map fn receives a *live* item
- * accessor (reads through to the current list value, so sub-property updates
- * propagate). Backs `<For by={...}>`.
+ * accessor: a per-entry signal the reconciliation sets, so a new object under
+ * the same key propagates without the whole list being re-read per row.
+ * Backs `<For by={...}>`.
  */
 export declare function keyArray<T, U>(list: ListSource<T>, keyFn: (item: T) => any, mapFn: (item: Accessor<T>, index: Accessor<number>) => U, options?: ListOptions): Accessor<U[]>;
 /**

package/dist/lib/signal/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/lib/signal/list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,KAAK,QAAQ,EAA4D,MAAM,mBAAmB,CAAC;AAE5G,KAAK,UAAU,CAAC,CAAC,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,CAAC;AAEvE,UAAU,WAAW;IACnB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,GAAG,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EAC9C,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,CAAC,EAAE,CAAC,CA6Cf;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,EACvB,KAAK,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EACxD,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,CAAC,EAAE,CAAC,CAuDf;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAC9C,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,CAAC,EAAE,CAAC,CAuCf"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/lib/signal/list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,KAAK,QAAQ,EAAyE,MAAM,mBAAmB,CAAC;AAEzH,KAAK,UAAU,CAAC,CAAC,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,CAAC;AAEvE,UAAU,WAAW;IACnB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,GAAG,CAAC;CACtB;AA4BD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EAC9C,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,CAAC,EAAE,CAAC,CA6Cf;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,EACvB,KAAK,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EACxD,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,CAAC,EAAE,CAAC,CAuDf;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAC9C,OAAO,CAAC,EAAE,WAAW,GACpB,QAAQ,CAAC,CAAC,EAAE,CAAC,CAuCf"}

package/dist/lib/signal/list.js

@@ -15,6 +15,27 @@ import { createMemo, createRoot, createSignal, onCleanup, untrack } from './grap
  * values are disposed. The map fn receives the plain value (a snapshot) and a
  * reactive index accessor. Backs `<For>`.
  */
+/**
+ * A row index that builds its signal on first read. Most rows never read
+ * their index, and an unread index signal is a State plus its closure per row.
+ * `set` keeps the plain number current until (and unless) that read happens.
+ */
+function lazyIndex(initial) {
+    let current = initial;
+    let state = null;
+    return {
+        index: () => {
+            if (!state)
+                state = createSignal(current, { name: 'row index' });
+            return state[0]();
+        },
+        set: (n) => {
+            current = n;
+            if (state)
+                state[1](n);
+        },
+    };
+}
 export function mapArray(list, mapFn, options) {
     let items = [];
     onCleanup(() => { for (const e of items)
@@ -46,9 +67,9 @@ export function mapArray(list, mapFn, options) {
                     let rendered, setIndex, dispose;
                     createRoot((d) => {
                         dispose = d;
-                        const [index, setIdx] = createSignal(i, { name: 'row index' });
-                        setIndex = setIdx;
-                        rendered = mapFn(value, index);
+                        const idx = lazyIndex(i);
+                        setIndex = idx.set;
+                        rendered = mapFn(value, idx.index);
                     });
                     const entry = { item: value, rendered, dispose, setIndex };
                     result.push(entry);
@@ -66,8 +87,9 @@ export function mapArray(list, mapFn, options) {
 /**
  * Key-function map. Like `mapArray` but reuse is keyed by `keyFn(item)` (so the
  * same key survives object recreation), and the map fn receives a *live* item
- * accessor (reads through to the current list value, so sub-property updates
- * propagate). Backs `<For by={...}>`.
+ * accessor: a per-entry signal the reconciliation sets, so a new object under
+ * the same key propagates without the whole list being re-read per row.
+ * Backs `<For by={...}>`.
  */
 export function keyArray(list, keyFn, mapFn, options) {
     let keys = [];
@@ -95,25 +117,25 @@ export function keyArray(list, keyFn, mapFn, options) {
                 const reuse = prevByKey.get(key);
                 if (reuse && !usedKeys.has(key)) {
                     reuse.setIndex(i);
+                    reuse.setItem(next[i]);
                     resultEntries.push(reuse);
                 }
                 else {
-                    let rendered, setIndex, dispose;
+                    let rendered, setIndex, setItem, dispose;
                     createRoot((d) => {
                         dispose = d;
-                        const [index, setIdx] = createSignal(i, { name: 'row index' });
-                        setIndex = setIdx;
-                        // Live accessor: reads the current list at this index. Falls back to the
-                        // last known value while the array is mid-shrink (idx out of bounds)
-                        // so render fns don't read undefined before disposal completes.
-                        const item = createMemo((prev) => {
-                            const cur = (list() || []);
-                            const v = cur[index()];
-                            return v !== undefined && v !== null ? v : prev;
-                        }, next[i]);
-                        rendered = mapFn(item, index);
+                        const idx = lazyIndex(i);
+                        setIndex = idx.set;
+                        // The entry's own signal, set during reconciliation. A memo that
+                        // read the whole list made every list write recompute every row;
+                        // this way only a row whose item actually changed is notified.
+                        // The signal also holds the last value while the array is
+                        // mid-shrink, so render fns don't read undefined before disposal.
+                        const [item, writeItem] = createSignal(next[i]);
+                        setItem = (v) => writeItem(() => v);
+                        rendered = mapFn(item, idx.index);
                     });
-                    resultEntries.push({ rendered, dispose, setIndex });
+                    resultEntries.push({ rendered, dispose, setIndex, setItem });
                 }
                 resultKeys.push(key);
                 usedKeys.add(key);

package/dist/lib/signal/list.mjs

@@ -1,5 +1,5 @@
 // src/version.generated.ts
-var VERSION = "1.0.0-alpha.105";
+var VERSION = "1.0.0-alpha.106";
 
 // src/lib/signal/graph/state.ts
 var MAJOR = VERSION.split(".")[0];
@@ -141,6 +141,7 @@ var Computed = class extends Source {
     super();
     this._threw = false;
     this._initialized = false;
+    this._disposed = false;
     this.state = DIRTY;
     /** Nodes this computation read on its last run. Rebuilt on every run. */
     this.sources = null;
@@ -156,8 +157,23 @@ var Computed = class extends Source {
     if (this._threw) throw this._error;
     return this._value;
   }
+  /**
+   * Unlink from every source, for good. Without this, a source outlives the
+   * computation and keeps it (and everything its function captured) reachable
+   * through its observers set: a disposed list row stayed in memory that way.
+   * The last value stays readable; the node simply never updates again.
+   */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    if (this.sources) {
+      for (const s of this.sources) s.observers?.delete(this);
+      this.sources = null;
+    }
+  }
   /** Settle, if CHECK, verify sources; if DIRTY (or never run), recompute. */
   updateIfNecessary() {
+    if (this._disposed) return;
     if (this.state === CHECK) {
       if (this.sources) {
         for (const s of this.sources) {
@@ -201,7 +217,7 @@ var Computed = class extends Source {
     reportReactiveRun(this);
     if (changed) {
       this.version++;
-      if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+      if (this.observers) for (const o of this.observers) o.markDirty(DIRTY);
       notifyWatchers(this);
     }
   }
@@ -215,7 +231,7 @@ var Computed = class extends Source {
     const wasClean = this.state === CLEAN;
     this.state = level;
     if (wasClean) {
-      if (this.observers) for (const o of [...this.observers]) o.markDirty(CHECK);
+      if (this.observers) for (const o of this.observers) o.markDirty(CHECK);
       notifyWatchers(this);
     }
   }
@@ -360,13 +376,15 @@ function createSignal(value, options) {
     },
     enumerable: false
   });
-  reportReactiveNode({
-    kind: "signal",
-    node: state,
-    handle: read,
-    name: options?.name,
-    set: write
-  });
+  if (isObserved()) {
+    reportReactiveNode({
+      kind: "signal",
+      node: state,
+      handle: read,
+      name: options?.name,
+      set: write
+    });
+  }
   if (isObserved()) onCleanup(() => reportReactiveDispose(state));
   return [read, write];
 }
@@ -390,8 +408,11 @@ function createMemo(fn, value, options) {
   const read = (() => c.get());
   Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
   Object.defineProperty(read, $MEMO, { value: true, enumerable: true });
-  reportReactiveNode({ kind: "memo", node: c, handle: read, name: options?.name });
-  if (isObserved()) onCleanup(() => reportReactiveDispose(c));
+  if (isObserved()) reportReactiveNode({ kind: "memo", node: c, handle: read, name: options?.name });
+  onCleanup(() => {
+    c.dispose();
+    if (isObserved()) reportReactiveDispose(c);
+  });
   return read;
 }
 function untrack2(fn) {
@@ -399,6 +420,20 @@ function untrack2(fn) {
 }
 
 // src/lib/signal/list.ts
+function lazyIndex(initial) {
+  let current = initial;
+  let state = null;
+  return {
+    index: () => {
+      if (!state) state = createSignal(current, { name: "row index" });
+      return state[0]();
+    },
+    set: (n) => {
+      current = n;
+      if (state) state[1](n);
+    }
+  };
+}
 function mapArray(list, mapFn, options) {
   let items = [];
   onCleanup(() => {
@@ -428,9 +463,9 @@ function mapArray(list, mapFn, options) {
           let rendered, setIndex, dispose;
           createRoot((d) => {
             dispose = d;
-            const [index, setIdx] = createSignal(i, { name: "row index" });
-            setIndex = setIdx;
-            rendered = mapFn(value, index);
+            const idx = lazyIndex(i);
+            setIndex = idx.set;
+            rendered = mapFn(value, idx.index);
           });
           const entry = { item: value, rendered, dispose, setIndex };
           result.push(entry);
@@ -470,21 +505,19 @@ function keyArray(list, keyFn, mapFn, options) {
         const reuse = prevByKey.get(key);
         if (reuse && !usedKeys.has(key)) {
           reuse.setIndex(i);
+          reuse.setItem(next[i]);
           resultEntries.push(reuse);
         } else {
-          let rendered, setIndex, dispose;
+          let rendered, setIndex, setItem, dispose;
           createRoot((d) => {
             dispose = d;
-            const [index, setIdx] = createSignal(i, { name: "row index" });
-            setIndex = setIdx;
-            const item = createMemo((prev) => {
-              const cur = list() || [];
-              const v = cur[index()];
-              return v !== void 0 && v !== null ? v : prev;
-            }, next[i]);
-            rendered = mapFn(item, index);
+            const idx = lazyIndex(i);
+            setIndex = idx.set;
+            const [item, writeItem] = createSignal(next[i]);
+            setItem = (v) => writeItem(() => v);
+            rendered = mapFn(item, idx.index);
           });
-          resultEntries.push({ rendered, dispose, setIndex });
+          resultEntries.push({ rendered, dispose, setIndex, setItem });
         }
         resultKeys.push(key);
         usedKeys.add(key);