@fluixi/reactive 1.0.0-alpha.82 → 1.0.0-alpha.84

package/dist/lib/signal/list.cjs

@@ -1 +1,549 @@
-"use strict";var E=Object.defineProperty;var H=Object.getOwnPropertyDescriptor;var Y=Object.getOwnPropertyNames;var $=Object.prototype.hasOwnProperty;var B=(e,r)=>{for(var t in r)E(e,t,{get:r[t],enumerable:!0})},J=(e,r,t,o)=>{if(r&&typeof r=="object"||typeof r=="function")for(let i of Y(r))!$.call(e,i)&&i!==t&&E(e,i,{get:()=>r[i],enumerable:!(o=H(r,i))||o.enumerable});return e};var Q=e=>J(E({},"__esModule",{value:!0}),e);var ue={};B(ue,{indexArray:()=>ie,keyArray:()=>se,mapArray:()=>oe});module.exports=Q(ue);var X="__fluixi_signal_next_state__",Z=e=>{typeof queueMicrotask=="function"?queueMicrotask(e):Promise.resolve().then(e)},s=globalThis[X]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:Z,onSuspend:null,onError:null};var R=0,U=1,T=2,S=class{constructor(){this.observers=null;this.watchers=null;this.version=0}updateIfNecessary(){}track(){if(s.untracked)return;let r=s.consumer;r&&((this.observers??=new Set).add(r),(r.sources??=new Set).add(this))}},g=class extends S{constructor(r,t){super(),this._value=r,this._equals=t?.equals===!1?()=>!1:t?.equals??Object.is}get(){return this.track(),this._value}set(r){if(!this._equals(this._value,r)){if(this._value=r,this.version++,this.observers)for(let t of[...this.observers])t.markDirty(T);C(this)}}peek(){return this._value}},k=class extends S{constructor(t,o){super();this._threw=!1;this._initialized=!1;this.state=T;this.sources=null;this._fn=t,this._equals=o?.equals===!1?()=>!1:o?.equals??Object.is}get(){if(s.consumer===this)throw new Error("Signal.Computed cannot read itself");if(this.track(),this.updateIfNecessary(),this._threw)throw this._error;return this._value}updateIfNecessary(){if(this.state===U&&this.sources){for(let t of this.sources)if(t.updateIfNecessary(),this.state===T)break}(this.state===T||!this._initialized)&&this.recompute(),this.state=R}recompute(){if(this.sources){for(let n of this.sources)n.observers?.delete(this);this.sources.clear()}let t=s.consumer,o=s.untracked;s.consumer=this,s.untracked=!1;let i,a=!1,u;try{i=this._fn()}catch(n){a=!0,u=n,i=this._value}finally{s.consumer=t,s.untracked=o}let l=!this._initialized||this._threw!==a||(a?u!==this._error:!this._equals(this._value,i));if(this._initialized=!0,this._threw=a,this._error=u,this._value=i,l){if(this.version++,this.observers)for(let n of[...this.observers])n.markDirty(T);C(this)}}markDirty(t){if(this.state>=t)return;let o=this.state===R;if(this.state=t,o){if(this.observers)for(let i of[...this.observers])i.markDirty(U);C(this)}}peek(){if(this.updateIfNecessary(),this._threw)throw this._error;return this._value}};function C(e){if(e.watchers)for(let r of[...e.watchers])r._notify(e)}function L(e){if(s.untracked)return e();s.untracked=!0;try{return e()}finally{s.untracked=!1}}function ee(e){return{cleanups:null,owned:null,parent:e,contexts:null}}function M(e){return s.onSuspend?(s.onSuspend(e,s.owner),!0):!1}function D(){return s.owner}function P(e,r){let t=s.owner;s.owner=e;try{return r()}finally{s.owner=t}}function y(e){if(s.owner){if(s.owner.disposed){e();return}(s.owner.cleanups??=[]).push(e)}}function N(e,r=!0){if(!e.disposed){if(e.owned){for(let t=e.owned.length-1;t>=0;t--)N(e.owned[t]);e.owned=null}if(e.cleanups){for(let t=e.cleanups.length-1;t>=0;t--)e.cleanups[t]();e.cleanups=null}r&&(e.disposed=!0)}}function m(e){let r=ee(s.owner);s.owner&&(s.owner.owned??=[]).push(r);let t=s.owner;s.owner=r;try{return e(()=>N(r))}finally{s.owner=t}}function W(e){s.hostSchedule=e??(r=>{Promise.resolve().then(r)})}function z(){if(s.scheduled=!1,s.flushing)return;s.flushing=!0;let e=0;try{for(;s.queue.length;){if(++e>1e5)throw new Error("[fluixi] effect flush did not settle (cycle?)");let r=s.queue;s.queue=[];for(let t of r)t.queued=!1,t.disposed||t.run()}}finally{s.flushing=!1}}function G(){s.batchDepth===0&&z()}function te(e){return!!e&&typeof e.then=="function"}W(()=>{});var j=Symbol.for("signal"),ne=Symbol.for("memo"),re=Symbol.for("signal-node");function _(e,r){let t=new g(e,{equals:r?.equals}),o=(()=>t.get()),i=(a=>{let u=typeof a=="function"?a(t.peek()):a;return t.set(u),G(),u});return Object.defineProperty(o,j,{value:!0,enumerable:!0}),Object.defineProperty(o,re,{value:{get value(){return t.peek()},get version(){return t.version}},enumerable:!1}),[o,i]}function x(e,r,t){let o=r,i=D(),a=new k(()=>P(i,()=>{try{return o=e(o)}catch(l){if(te(l))return M(l),o;throw l}}),{equals:t?.equals}),u=(()=>a.get());return Object.defineProperty(u,j,{value:!0,enumerable:!0}),Object.defineProperty(u,ne,{value:!0,enumerable:!0}),u}function O(e){return L(e)}function oe(e,r,t){let o=[];return y(()=>{for(let i of o)i.dispose();o=[]}),x(()=>{let i=e()||[];return O(()=>{if(i.length===0){for(let n of o)n.dispose();return o=[],t?.fallback?t.fallback():[]}let a=new Map;for(let n of o)a.has(n.item)||a.set(n.item,n);let u=[],l=new Set;for(let n=0;n<i.length;n++){let p=i[n],d=a.get(p);if(d&&!l.has(d))d.setIndex(n),u.push(d),l.add(d);else{let c,f,h;m(w=>{h=w;let[b,q]=_(n);f=q,c=r(p,b)});let v={item:p,rendered:c,dispose:h,setIndex:f};u.push(v),l.add(v)}}for(let n of o)l.has(n)||n.dispose();return o=u,u.map(n=>n.rendered)})})}function se(e,r,t,o){let i=[],a=[];return y(()=>{for(let u of a)u.dispose();i=[],a=[]}),x(()=>{let u=e()||[];return O(()=>{if(u.length===0){for(let c of a)c.dispose();return i=[],a=[],o?.fallback?o.fallback():[]}let l=new Map;for(let c=0;c<i.length;c++)l.set(i[c],a[c]);let n=[],p=[],d=new Set;for(let c=0;c<u.length;c++){let f=r(u[c]),h=l.get(f);if(h&&!d.has(f))h.setIndex(c),n.push(h);else{let v,w,b;m(q=>{b=q;let[I,K]=_(c);w=K;let V=x(F=>{let A=(e()||[])[I()];return A??F},u[c]);v=t(V,I)}),n.push({rendered:v,dispose:b,setIndex:w})}p.push(f),d.add(f)}for(let[c,f]of l)d.has(c)||f.dispose();return i=p,a=n,n.map(c=>c.rendered)})})}function ie(e,r,t){let o=[];return y(()=>{for(let i of o)i.dispose();o=[]}),x(()=>{let i=e()||[];return O(()=>{if(i.length===0){for(let n of o)n.dispose();return o=[],t?.fallback?t.fallback():[]}let a=o.length,u=i.length;for(let n=a;n<u;n++){let p,d,c,f=i[n];m(h=>{c=h;let[v,w]=_(f);d=w,p=r(v,n)}),o.push({rendered:p,setItem:d,dispose:c})}for(let n=u;n<a;n++)o[n].dispose();u<a&&(o=o.slice(0,u));let l=Math.min(a,u);for(let n=0;n<l;n++)o[n].setItem(i[n]);return o.map(n=>n.rendered)})})}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/signal/list.ts
+var list_exports = {};
+__export(list_exports, {
+  indexArray: () => indexArray,
+  keyArray: () => keyArray,
+  mapArray: () => mapArray
+});
+module.exports = __toCommonJS(list_exports);
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.84";
+
+// src/lib/signal/graph/state.ts
+var MAJOR = VERSION.split(".")[0];
+var KEY = `__fluixi_signal_state_v${MAJOR}__`;
+var VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
+var defaultSchedule = (run) => {
+  if (typeof queueMicrotask === "function") queueMicrotask(run);
+  else void Promise.resolve().then(run);
+};
+function defaults() {
+  return {
+    consumer: null,
+    untracked: false,
+    owner: null,
+    queue: [],
+    scheduled: false,
+    flushing: false,
+    batchDepth: 0,
+    hostSchedule: defaultSchedule,
+    onSuspend: null,
+    onError: null,
+    observer: null
+  };
+}
+var realm = globalThis;
+function backfillState(existing) {
+  const fresh = defaults();
+  const target = existing;
+  for (const field of Object.keys(fresh)) {
+    if (!(field in existing)) target[field] = fresh[field];
+  }
+  return existing;
+}
+function claim() {
+  const existing = realm[KEY];
+  return existing ? backfillState(existing) : realm[KEY] = defaults();
+}
+var G = claim();
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+
+// src/lib/signal/graph/observe.ts
+function observeReactiveNodes(next) {
+  G.observer = next;
+  return () => {
+    if (G.observer === next) G.observer = null;
+  };
+}
+var running = [];
+var origin;
+function reportReactiveNode(report) {
+  const observer = G.observer;
+  if (observer) {
+    observer.created(
+      report.parents === void 0 ? { ...report, parents: running, origin: report.origin ?? origin } : report
+    );
+  }
+}
+function enterReactiveRun(node) {
+  if (!G.observer) return false;
+  running.push(node);
+  return true;
+}
+function exitReactiveRun() {
+  running.pop();
+}
+function reportReactiveRun(node) {
+  G.observer?.ran?.(node);
+}
+function reportReactiveWrite(node, by) {
+  G.observer?.wrote?.(node, by);
+}
+function reportReactiveDispose(node) {
+  G.observer?.disposed?.(node);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+function isObserved() {
+  return G.observer != null;
+}
+
+// src/lib/signal/graph/core.ts
+var CLEAN = 0;
+var CHECK = 1;
+var DIRTY = 2;
+var Source = class {
+  constructor() {
+    /** Computeds, and watched leaves, that read this node. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.observers = null;
+    /** Watchers eagerly observing this node, which is how `runtime.ts` schedules effects. */
+    this.watchers = null;
+    /** Bumped whenever this node's value actually changes (equality-gated). */
+    this.version = 0;
+  }
+  /** Settle this node so a reader sees a current value/version. Overridden by Computed. */
+  updateIfNecessary() {
+  }
+  /** Link the current consumer (if any) as an observer of this node. */
+  track() {
+    if (G.untracked) return;
+    const consumer = G.consumer;
+    if (!consumer) return;
+    (this.observers ??= /* @__PURE__ */ new Set()).add(consumer);
+    (consumer.sources ??= /* @__PURE__ */ new Set()).add(this);
+  }
+};
+var State = class extends Source {
+  constructor(value, options) {
+    super();
+    this._value = value;
+    this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+  }
+  get() {
+    this.track();
+    return this._value;
+  }
+  set(next) {
+    if (this._equals(this._value, next)) return;
+    this._value = next;
+    this.version++;
+    reportReactiveWrite(this, G.consumer);
+    if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+    notifyWatchers(this);
+  }
+  /** Read without subscribing (peek). */
+  peek() {
+    return this._value;
+  }
+};
+var Computed = class extends Source {
+  constructor(fn, options) {
+    super();
+    this._threw = false;
+    this._initialized = false;
+    this.state = DIRTY;
+    /** Nodes this computation read on its last run. Rebuilt on every run. */
+    this.sources = null;
+    this._fn = fn;
+    this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+  }
+  get() {
+    if (G.consumer === this) {
+      throw new Error("Signal.Computed cannot read itself");
+    }
+    this.track();
+    this.updateIfNecessary();
+    if (this._threw) throw this._error;
+    return this._value;
+  }
+  /** Settle, if CHECK, verify sources; if DIRTY (or never run), recompute. */
+  updateIfNecessary() {
+    if (this.state === CHECK) {
+      if (this.sources) {
+        for (const s of this.sources) {
+          s.updateIfNecessary();
+          if (this.state === DIRTY) break;
+        }
+      }
+    }
+    if (this.state === DIRTY || !this._initialized) this.recompute();
+    this.state = CLEAN;
+  }
+  recompute() {
+    if (this.sources) {
+      for (const s of this.sources) s.observers?.delete(this);
+      this.sources.clear();
+    }
+    const prevConsumer = G.consumer;
+    const prevUntracked = G.untracked;
+    const watched = enterReactiveRun(this);
+    G.consumer = this;
+    G.untracked = false;
+    let next;
+    let threw = false;
+    let err;
+    try {
+      next = this._fn();
+    } catch (e) {
+      threw = true;
+      err = e;
+      next = this._value;
+    } finally {
+      G.consumer = prevConsumer;
+      G.untracked = prevUntracked;
+      if (watched) exitReactiveRun();
+    }
+    const changed = !this._initialized || this._threw !== threw || (threw ? err !== this._error : !this._equals(this._value, next));
+    this._initialized = true;
+    this._threw = threw;
+    this._error = err;
+    this._value = next;
+    reportReactiveRun(this);
+    if (changed) {
+      this.version++;
+      if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+      notifyWatchers(this);
+    }
+  }
+  /**
+   * Push a maybe-dirty mark. A direct observer of a changed node gets DIRTY; its
+   * own observers get CHECK (recurse), stopping where already marked, so the
+   * push is O(newly-dirtied) and never recomputes.
+   */
+  markDirty(level) {
+    if (this.state >= level) return;
+    const wasClean = this.state === CLEAN;
+    this.state = level;
+    if (wasClean) {
+      if (this.observers) for (const o of [...this.observers]) o.markDirty(CHECK);
+      notifyWatchers(this);
+    }
+  }
+  peek() {
+    this.updateIfNecessary();
+    if (this._threw) throw this._error;
+    return this._value;
+  }
+};
+function notifyWatchers(node) {
+  if (!node.watchers) return;
+  for (const w of [...node.watchers]) w._notify(node);
+}
+function untrack(fn) {
+  if (G.untracked) return fn();
+  G.untracked = true;
+  try {
+    return fn();
+  } finally {
+    G.untracked = false;
+  }
+}
+
+// src/lib/signal/graph/runtime.ts
+function makeOwner(parent) {
+  return { cleanups: null, owned: null, parent, contexts: null };
+}
+function reportSuspend(promise) {
+  if (G.onSuspend) {
+    G.onSuspend(promise, G.owner);
+    return true;
+  }
+  return false;
+}
+function getOwner() {
+  return G.owner;
+}
+function runWithOwner(owner, fn) {
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn();
+  } finally {
+    G.owner = prev;
+  }
+}
+function onCleanup(fn) {
+  if (!G.owner) return;
+  if (G.owner.disposed) {
+    fn();
+    return;
+  }
+  (G.owner.cleanups ??= []).push(fn);
+}
+function disposeOwner(owner, final = true) {
+  if (owner.disposed) return;
+  if (owner.owned) {
+    for (let i = owner.owned.length - 1; i >= 0; i--) disposeOwner(owner.owned[i]);
+    owner.owned = null;
+  }
+  if (owner.cleanups) {
+    for (let i = owner.cleanups.length - 1; i >= 0; i--) owner.cleanups[i]();
+    owner.cleanups = null;
+  }
+  if (final) owner.disposed = true;
+}
+function createRoot(fn) {
+  const owner = makeOwner(G.owner);
+  if (G.owner) (G.owner.owned ??= []).push(owner);
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn(() => disposeOwner(owner));
+  } finally {
+    G.owner = prev;
+  }
+}
+function setScheduler(fn) {
+  G.hostSchedule = fn ?? ((run) => void Promise.resolve().then(run));
+}
+function flushSync() {
+  G.scheduled = false;
+  if (G.flushing) return;
+  G.flushing = true;
+  let guard = 0;
+  try {
+    while (G.queue.length) {
+      if (++guard > 1e5) throw new Error("[fluixi] effect flush did not settle (cycle?)");
+      const batchOf = G.queue;
+      G.queue = [];
+      for (const e of batchOf) {
+        e.queued = false;
+        if (!e.disposed) e.run();
+      }
+    }
+  } finally {
+    G.flushing = false;
+  }
+}
+function afterWrite() {
+  if (G.batchDepth === 0) flushSync();
+}
+
+// src/lib/signal/graph/compat.ts
+function isThenable(v) {
+  return !!v && typeof v.then === "function";
+}
+setScheduler(() => {
+});
+var $SIGNAL = /* @__PURE__ */ Symbol.for("signal");
+var $MEMO = /* @__PURE__ */ Symbol.for("memo");
+var $NODE = /* @__PURE__ */ Symbol.for("signal-node");
+function createSignal(value, options) {
+  const state = new State(value, { equals: options?.equals });
+  const read = (() => state.get());
+  const write = ((next) => {
+    const v = typeof next === "function" ? next(state.peek()) : next;
+    state.set(v);
+    afterWrite();
+    return v;
+  });
+  Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+  Object.defineProperty(read, $NODE, {
+    value: {
+      get value() {
+        return state.peek();
+      },
+      get version() {
+        return state.version;
+      }
+    },
+    enumerable: false
+  });
+  reportReactiveNode({
+    kind: "signal",
+    node: state,
+    handle: read,
+    name: options?.name,
+    set: write
+  });
+  if (isObserved()) onCleanup(() => reportReactiveDispose(state));
+  return [read, write];
+}
+function createMemo(fn, value, options) {
+  let prev = value;
+  const owner = getOwner();
+  const c = new Computed(
+    () => runWithOwner(owner, () => {
+      try {
+        return prev = fn(prev);
+      } catch (e) {
+        if (isThenable(e)) {
+          reportSuspend(e);
+          return prev;
+        }
+        throw e;
+      }
+    }),
+    { equals: options?.equals }
+  );
+  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));
+  return read;
+}
+function untrack2(fn) {
+  return untrack(fn);
+}
+
+// src/lib/signal/list.ts
+function mapArray(list, mapFn, options) {
+  let items = [];
+  onCleanup(() => {
+    for (const e of items) e.dispose();
+    items = [];
+  });
+  return createMemo(() => {
+    const next = list() || [];
+    return untrack2(() => {
+      if (next.length === 0) {
+        for (const e of items) e.dispose();
+        items = [];
+        return options?.fallback ? options.fallback() : [];
+      }
+      const prevByItem = /* @__PURE__ */ new Map();
+      for (const e of items) if (!prevByItem.has(e.item)) prevByItem.set(e.item, e);
+      const result = [];
+      const used = /* @__PURE__ */ new Set();
+      for (let i = 0; i < next.length; i++) {
+        const value = next[i];
+        const reuse = prevByItem.get(value);
+        if (reuse && !used.has(reuse)) {
+          reuse.setIndex(i);
+          result.push(reuse);
+          used.add(reuse);
+        } else {
+          let rendered, setIndex, dispose;
+          createRoot((d) => {
+            dispose = d;
+            const [index, setIdx] = createSignal(i, { name: "row index" });
+            setIndex = setIdx;
+            rendered = mapFn(value, index);
+          });
+          const entry = { item: value, rendered, dispose, setIndex };
+          result.push(entry);
+          used.add(entry);
+        }
+      }
+      for (const e of items) if (!used.has(e)) e.dispose();
+      items = result;
+      return result.map((e) => e.rendered);
+    });
+  }, void 0, { name: "mapArray" });
+}
+function keyArray(list, keyFn, mapFn, options) {
+  let keys = [];
+  let entries = [];
+  onCleanup(() => {
+    for (const e of entries) e.dispose();
+    keys = [];
+    entries = [];
+  });
+  return createMemo(() => {
+    const next = list() || [];
+    return untrack2(() => {
+      if (next.length === 0) {
+        for (const e of entries) e.dispose();
+        keys = [];
+        entries = [];
+        return options?.fallback ? options.fallback() : [];
+      }
+      const prevByKey = /* @__PURE__ */ new Map();
+      for (let i = 0; i < keys.length; i++) prevByKey.set(keys[i], entries[i]);
+      const resultEntries = [];
+      const resultKeys = [];
+      const usedKeys = /* @__PURE__ */ new Set();
+      for (let i = 0; i < next.length; i++) {
+        const key = keyFn(next[i]);
+        const reuse = prevByKey.get(key);
+        if (reuse && !usedKeys.has(key)) {
+          reuse.setIndex(i);
+          resultEntries.push(reuse);
+        } else {
+          let rendered, setIndex, 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);
+          });
+          resultEntries.push({ rendered, dispose, setIndex });
+        }
+        resultKeys.push(key);
+        usedKeys.add(key);
+      }
+      for (const [key, e] of prevByKey) if (!usedKeys.has(key)) e.dispose();
+      keys = resultKeys;
+      entries = resultEntries;
+      return resultEntries.map((e) => e.rendered);
+    });
+  }, void 0, { name: "keyArray" });
+}
+function indexArray(list, mapFn, options) {
+  let slots = [];
+  onCleanup(() => {
+    for (const s of slots) s.dispose();
+    slots = [];
+  });
+  return createMemo(() => {
+    const next = list() || [];
+    return untrack2(() => {
+      if (next.length === 0) {
+        for (const s of slots) s.dispose();
+        slots = [];
+        return options?.fallback ? options.fallback() : [];
+      }
+      const prevLen = slots.length;
+      const nextLen = next.length;
+      for (let i = prevLen; i < nextLen; i++) {
+        let rendered, setItem, dispose;
+        const value = next[i];
+        createRoot((d) => {
+          dispose = d;
+          const [item, setVal] = createSignal(value);
+          setItem = setVal;
+          rendered = mapFn(item, i);
+        });
+        slots.push({ rendered, setItem, dispose });
+      }
+      for (let i = nextLen; i < prevLen; i++) slots[i].dispose();
+      if (nextLen < prevLen) slots = slots.slice(0, nextLen);
+      const survive = Math.min(prevLen, nextLen);
+      for (let i = 0; i < survive; i++) slots[i].setItem(next[i]);
+      return slots.map((s) => s.rendered);
+    });
+  }, void 0, { name: "indexArray" });
+}

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

@@ -1,10 +1,10 @@
 /**
- * Keyed list reconciliation primitives — the reactive foundation for `<For>`,
+ * Keyed list reconciliation primitives, the reactive foundation for `<For>`,
  * `<For by>` and `<Index>` (mirrors SolidJS `mapArray`/`keyArray`/`indexArray`).
  *
  * Each maps a reactive array to an array of mapped values and reuses per-item
  * reactive scopes across updates so only changed items re-run their map fn. Every
- * mapped item lives in its own `createRoot`, so it has a disposable owner scope —
+ * mapped item lives in its own `createRoot`, so it has a disposable owner scope
  * this is what keeps list items owner-stable (the thing ad-hoc array handling gets
  * wrong).
  */
@@ -25,13 +25,13 @@ export declare function mapArray<T, U>(list: ListSource<T>, mapFn: (item: T, ind
  * 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={…}>`.
+ * propagate). 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[]>;
 /**
- * Index-keyed map. Reuse is keyed by *position*: growing adds slots, shrinking
+ * Index-keyed map. Reuse is keyed by *position*, growing adds slots, shrinking
  * disposes trailing slots, and when the value at a position changes only that
- * slot's item signal updates (the map fn is NOT re-run). The map fn receives a
+ * slot's item signal updates (the map fn is not re-run). The map fn receives a
  * live item accessor and a plain (stable) index. Backs `<Index>`.
  */
 export declare function indexArray<T, U>(list: ListSource<T>, mapFn: (item: Accessor<T>, index: number) => U, options?: ListOptions): Accessor<U[]>;

package/dist/lib/signal/list.js

@@ -1,10 +1,10 @@
 /**
- * Keyed list reconciliation primitives — the reactive foundation for `<For>`,
+ * Keyed list reconciliation primitives, the reactive foundation for `<For>`,
  * `<For by>` and `<Index>` (mirrors SolidJS `mapArray`/`keyArray`/`indexArray`).
  *
  * Each maps a reactive array to an array of mapped values and reuses per-item
  * reactive scopes across updates so only changed items re-run their map fn. Every
- * mapped item lives in its own `createRoot`, so it has a disposable owner scope —
+ * mapped item lives in its own `createRoot`, so it has a disposable owner scope
  * this is what keeps list items owner-stable (the thing ad-hoc array handling gets
  * wrong).
  */
@@ -46,7 +46,7 @@ export function mapArray(list, mapFn, options) {
                     let rendered, setIndex, dispose;
                     createRoot((d) => {
                         dispose = d;
-                        const [index, setIdx] = createSignal(i);
+                        const [index, setIdx] = createSignal(i, { name: 'row index' });
                         setIndex = setIdx;
                         rendered = mapFn(value, index);
                     });
@@ -61,13 +61,13 @@ export function mapArray(list, mapFn, options) {
             items = result;
             return result.map((e) => e.rendered);
         });
-    });
+    }, undefined, { name: 'mapArray' });
 }
 /**
  * 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={…}>`.
+ * propagate). Backs `<For by={...}>`.
  */
 export function keyArray(list, keyFn, mapFn, options) {
     let keys = [];
@@ -101,7 +101,7 @@ export function keyArray(list, keyFn, mapFn, options) {
                     let rendered, setIndex, dispose;
                     createRoot((d) => {
                         dispose = d;
-                        const [index, setIdx] = createSignal(i);
+                        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)
@@ -125,12 +125,12 @@ export function keyArray(list, keyFn, mapFn, options) {
             entries = resultEntries;
             return resultEntries.map((e) => e.rendered);
         });
-    });
+    }, undefined, { name: 'keyArray' });
 }
 /**
- * Index-keyed map. Reuse is keyed by *position*: growing adds slots, shrinking
+ * Index-keyed map. Reuse is keyed by *position*, growing adds slots, shrinking
  * disposes trailing slots, and when the value at a position changes only that
- * slot's item signal updates (the map fn is NOT re-run). The map fn receives a
+ * slot's item signal updates (the map fn is not re-run). The map fn receives a
  * live item accessor and a plain (stable) index. Backs `<Index>`.
  */
 export function indexArray(list, mapFn, options) {
@@ -168,5 +168,5 @@ export function indexArray(list, mapFn, options) {
                 slots[i].setItem(next[i]);
             return slots.map((s) => s.rendered);
         });
-    });
+    }, undefined, { name: 'indexArray' });
 }