@solidjs/signals 0.8.2 → 0.8.3

package/dist/prod.js

@@ -24,13 +24,13 @@ var SUPPORTS_PROXY = typeof Proxy === "function";
 
 // src/core/heap.ts
 function actualInsertIntoHeap(n, heap) {
-  const parentHeight = (n.w?._ ? n.w.$?.c : n.w?.c) ?? -1;
+  const parentHeight = (n.w?.$ ? n.w.aa?.c : n.w?.c) ?? -1;
   if (parentHeight >= n.c)
     n.c = parentHeight + 1;
   const height = n.c;
-  const heapAtHeight = heap.r[height];
+  const heapAtHeight = heap.s[height];
   if (heapAtHeight === void 0) {
-    heap.r[height] = n;
+    heap.s[height] = n;
   } else {
     const tail = heapAtHeight.z;
     tail.Q = n;
@@ -67,13 +67,13 @@ function deleteFromHeap(n, heap) {
   n.b = flags & ~(8 /* InHeap */ | 16 /* InHeapHeight */);
   const height = n.c;
   if (n.z === n) {
-    heap.r[height] = void 0;
+    heap.s[height] = void 0;
   } else {
     const next = n.Q;
-    const dhh = heap.r[height];
+    const dhh = heap.s[height];
     const end = next ?? dhh;
     if (n === dhh) {
-      heap.r[height] = next;
+      heap.s[height] = next;
     } else {
       n.z.Q = next;
     }
@@ -83,11 +83,11 @@ function deleteFromHeap(n, heap) {
   n.Q = void 0;
 }
 function markHeap(heap) {
-  if (heap.aa)
+  if (heap.ba)
     return;
-  heap.aa = true;
+  heap.ba = true;
   for (let i = 0; i <= heap.L; i++) {
-    for (let el = heap.r[i]; el !== void 0; el = el.Q) {
+    for (let el = heap.s[i]; el !== void 0; el = el.Q) {
       if (el.b & 8 /* InHeap */)
         markNode(el);
     }
@@ -98,28 +98,28 @@ function markNode(el, newState = 2 /* Dirty */) {
   if ((flags & (1 /* Check */ | 2 /* Dirty */)) >= newState)
     return;
   el.b = flags & ~(1 /* Check */ | 2 /* Dirty */) | newState;
-  for (let link2 = el.s; link2 !== null; link2 = link2.A) {
+  for (let link2 = el.x; link2 !== null; link2 = link2.A) {
     markNode(link2.j, 1 /* Check */);
   }
-  if (el.ba !== null) {
-    for (let child = el.ba; child !== null; child = child.ra) {
-      for (let link2 = child.s; link2 !== null; link2 = link2.A) {
+  if (el.ca !== null) {
+    for (let child = el.ca; child !== null; child = child.sa) {
+      for (let link2 = child.x; link2 !== null; link2 = link2.A) {
         markNode(link2.j, 1 /* Check */);
       }
     }
   }
 }
 function runHeap(heap, recompute2) {
-  heap.aa = false;
-  for (heap.p = 0; heap.p <= heap.L; heap.p++) {
-    let el = heap.r[heap.p];
+  heap.ba = false;
+  for (heap.q = 0; heap.q <= heap.L; heap.q++) {
+    let el = heap.s[heap.q];
     while (el !== void 0) {
       if (el.b & 8 /* InHeap */)
         recompute2(el);
       else {
         adjustHeight(el, heap);
       }
-      el = heap.r[heap.p];
+      el = heap.s[heap.q];
     }
   }
   heap.L = 0;
@@ -127,10 +127,10 @@ function runHeap(heap, recompute2) {
 function adjustHeight(el, heap) {
   deleteFromHeap(el, heap);
   let newHeight = el.c;
-  for (let d = el.x; d; d = d.F) {
+  for (let d = el.l; d; d = d.E) {
     const dep1 = d.R;
-    const dep = "_owner" in dep1 ? dep1.B : dep1;
-    if ("_fn" in dep) {
+    const dep = dep1.ia || dep1;
+    if (dep.H) {
       if (dep.c >= newHeight) {
         newHeight = dep.c + 1;
       }
@@ -138,7 +138,7 @@ function adjustHeight(el, heap) {
   }
   if (el.c !== newHeight) {
     el.c = newHeight;
-    for (let s = el.s; s !== null; s = s.A) {
+    for (let s = el.x; s !== null; s = s.A) {
       insertIntoHeapHeight(s.j, heap);
     }
   }
@@ -147,41 +147,40 @@ function adjustHeight(el, heap) {
 // src/core/scheduler.ts
 var clock = 0;
 var activeTransition = null;
-var unobserved = [];
 var transitions = /* @__PURE__ */ new Set();
 var scheduled = false;
 function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.ca)
+  if (!globalQueue.da)
     queueMicrotask(flush);
 }
 var dirtyQueue = {
-  r: new Array(2e3).fill(void 0),
-  aa: false,
-  p: 0,
+  s: new Array(2e3).fill(void 0),
+  ba: false,
+  q: 0,
   L: 0
 };
 var zombieQueue = {
-  r: new Array(2e3).fill(void 0),
-  aa: false,
-  p: 0,
+  s: new Array(2e3).fill(void 0),
+  ba: false,
+  q: 0,
   L: 0
 };
 var Queue = class {
   w = null;
   k = [[], []];
-  l = [];
+  m = [];
   created = clock;
   addChild(child) {
-    this.l.push(child);
+    this.m.push(child);
     child.w = this;
   }
   removeChild(child) {
-    const index = this.l.indexOf(child);
+    const index = this.m.indexOf(child);
     if (index >= 0) {
-      this.l.splice(index, 1);
+      this.m.splice(index, 1);
       child.w = null;
     }
   }
@@ -196,8 +195,8 @@ var Queue = class {
       this.k[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.l.length; i++) {
-      this.l[i].run(type);
+    for (let i = 0; i < this.m.length; i++) {
+      this.m[i].run(type);
     }
   }
   enqueue(type, fn) {
@@ -209,12 +208,12 @@ var Queue = class {
     stub.k[0].push(...this.k[0]);
     stub.k[1].push(...this.k[1]);
     this.k = [[], []];
-    for (let i = 0; i < this.l.length; i++) {
-      let child = this.l[i];
-      let childStub = stub.l[i];
+    for (let i = 0; i < this.m.length; i++) {
+      let child = this.m[i];
+      let childStub = stub.m[i];
       if (!childStub) {
-        childStub = { k: [[], []], l: [] };
-        stub.l[i] = childStub;
+        childStub = { k: [[], []], m: [] };
+        stub.m[i] = childStub;
       }
       child.stashQueues(childStub);
     }
@@ -222,23 +221,23 @@ var Queue = class {
   restoreQueues(stub) {
     this.k[0].push(...stub.k[0]);
     this.k[1].push(...stub.k[1]);
-    for (let i = 0; i < stub.l.length; i++) {
-      const childStub = stub.l[i];
-      let child = this.l[i];
+    for (let i = 0; i < stub.m.length; i++) {
+      const childStub = stub.m[i];
+      let child = this.m[i];
       if (child)
         child.restoreQueues(childStub);
     }
   }
 };
 var GlobalQueue = class _GlobalQueue extends Queue {
-  ca = false;
+  da = false;
   h = [];
   static S;
-  static ka;
+  static la;
   flush() {
-    if (this.ca)
+    if (this.da)
       return;
-    this.ca = true;
+    this.da = true;
     try {
       runHeap(dirtyQueue, _GlobalQueue.S);
       if (activeTransition) {
@@ -266,8 +265,8 @@ var GlobalQueue = class _GlobalQueue extends Queue {
           n.g = n.e;
           n.e = NOT_PENDING;
         }
-        if (n.ha)
-          _GlobalQueue.ka(n, false, true);
+        if (n.H)
+          _GlobalQueue.la(n, false, true);
       }
       globalQueue.h.length = 0;
       clock++;
@@ -275,15 +274,14 @@ var GlobalQueue = class _GlobalQueue extends Queue {
       this.run(1 /* Render */);
       this.run(2 /* User */);
     } finally {
-      this.ca = false;
-      unobserved.length && notifyUnobserved();
+      this.da = false;
     }
   }
   notify(node, mask, flags) {
     if (mask & 1 /* Pending */) {
       if (flags & 1 /* Pending */) {
-        if (activeTransition && !activeTransition.asyncNodes.includes(node.C.cause))
-          activeTransition.asyncNodes.push(node.C.cause);
+        if (activeTransition && !activeTransition.asyncNodes.includes(node.B.cause))
+          activeTransition.asyncNodes.push(node.B.cause);
       }
       return true;
     }
@@ -297,7 +295,7 @@ var GlobalQueue = class _GlobalQueue extends Queue {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
-        queueStash: { k: [[], []], l: [] }
+        queueStash: { k: [[], []], m: [] }
       };
     }
     transitions.add(activeTransition);
@@ -316,8 +314,8 @@ function runPending(pendingNodes, value) {
   for (let i = 0; i < p.length; i++) {
     const n = p[i];
     n.T = activeTransition;
-    if (n.H) {
-      n.H.da(value);
+    if (n.I) {
+      n.I.ea(value);
       needsReset = true;
     }
   }
@@ -343,18 +341,10 @@ function transitionComplete(transition) {
   }
   return done;
 }
-function notifyUnobserved() {
-  for (let i = 0; i < unobserved.length; i++) {
-    const source = unobserved[i];
-    if (!source.s)
-      unobserved[i].sa?.();
-  }
-  unobserved = [];
-}
 
 // src/core/core.ts
 GlobalQueue.S = recompute;
-GlobalQueue.ka = disposeChildren;
+GlobalQueue.la = disposeChildren;
 var tracking = false;
 var stale = false;
 var pendingValueCheck = false;
@@ -362,10 +352,10 @@ var pendingCheck = null;
 var context = null;
 var defaultContext = {};
 function notifySubs(node) {
-  for (let s = node.s; s !== null; s = s.A) {
+  for (let s = node.x; s !== null; s = s.A) {
     const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-    if (queue.p > s.j.c)
-      queue.p = s.j.c;
+    if (queue.q > s.j.c)
+      queue.q = s.j.c;
     insertIntoHeap(s.j, queue);
   }
 }
@@ -377,24 +367,24 @@ function recompute(el, create = false) {
     markDisposal(el);
     globalQueue.h.push(el);
     el.V = el.t;
-    el.U = el.q;
+    el.U = el.r;
     el.t = null;
-    el.q = null;
+    el.r = null;
   }
   const oldcontext = context;
   context = el;
-  el.I = null;
+  el.F = null;
   el.b = 4 /* RecomputingDeps */;
   el.J = clock;
   let value = el.e === NOT_PENDING ? el.g : el.e;
   let oldHeight = el.c;
   let prevStatusFlags = el.f;
-  let prevError = el.C;
+  let prevError = el.B;
   let prevTracking = tracking;
   clearStatusFlags(el);
   tracking = true;
   try {
-    value = el.ha(value);
+    value = el.H(value);
   } catch (e) {
     if (e instanceof NotReadyError) {
       if (e.cause !== el)
@@ -408,51 +398,51 @@ function recompute(el, create = false) {
   }
   el.b = 0 /* None */;
   context = oldcontext;
-  const depsTail = el.I;
-  let toRemove = depsTail !== null ? depsTail.F : el.x;
+  const depsTail = el.F;
+  let toRemove = depsTail !== null ? depsTail.E : el.l;
   if (toRemove !== null) {
     do {
       toRemove = unlinkSubs(toRemove);
     } while (toRemove !== null);
     if (depsTail !== null) {
-      depsTail.F = null;
+      depsTail.E = null;
     } else {
-      el.x = null;
+      el.l = null;
     }
   }
-  const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, value);
-  const statusFlagsChanged = el.f !== prevStatusFlags || el.C !== prevError;
-  el.la?.(statusFlagsChanged, prevStatusFlags);
+  const valueChanged = !el.fa || !el.fa(el.e === NOT_PENDING ? el.g : el.e, value);
+  const statusFlagsChanged = el.f !== prevStatusFlags || el.B !== prevError;
+  el.ma?.(statusFlagsChanged, prevStatusFlags);
   if (valueChanged || statusFlagsChanged) {
     if (valueChanged) {
-      if (create || el.ia || el.K)
+      if (create || el.ja || el.K)
         el.g = value;
       else {
         if (el.e === NOT_PENDING)
           globalQueue.h.push(el);
         el.e = value;
       }
-      if (el.D)
-        el.D.da(value);
+      if (el.C)
+        el.C.ea(value);
     }
-    for (let s = el.s; s !== null; s = s.A) {
+    for (let s = el.x; s !== null; s = s.A) {
       const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
-      if (s.j.c < el.c && queue.p > s.j.c)
-        queue.p = s.j.c;
+      if (s.j.c < el.c && queue.q > s.j.c)
+        queue.q = s.j.c;
       insertIntoHeap(s.j, queue);
     }
   } else if (el.c != oldHeight) {
-    for (let s = el.s; s !== null; s = s.A) {
+    for (let s = el.x; s !== null; s = s.A) {
       insertIntoHeapHeight(s.j, s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
     }
   }
 }
 function updateIfNecessary(el) {
   if (el.b & 1 /* Check */) {
-    for (let d = el.x; d; d = d.F) {
+    for (let d = el.l; d; d = d.E) {
       const dep1 = d.R;
-      const dep = "_owner" in dep1 ? dep1.B : dep1;
-      if ("_fn" in dep) {
+      const dep = dep1.ia || dep1;
+      if (dep.H) {
         updateIfNecessary(dep);
       }
       if (el.b & 2 /* Dirty */) {
@@ -467,32 +457,45 @@ function updateIfNecessary(el) {
 }
 function unlinkSubs(link2) {
   const dep = link2.R;
-  const nextDep = link2.F;
+  const nextDep = link2.E;
   const nextSub = link2.A;
-  const prevSub = link2.ma;
+  const prevSub = link2.na;
   if (nextSub !== null) {
-    nextSub.ma = prevSub;
+    nextSub.na = prevSub;
   } else {
     dep.W = prevSub;
   }
   if (prevSub !== null) {
     prevSub.A = nextSub;
   } else {
-    dep.s = nextSub;
+    dep.x = nextSub;
+    if (nextSub === null) {
+      dep.ta?.();
+      dep.H && unobserved(dep);
+    }
   }
   return nextDep;
 }
+function unobserved(el) {
+  deleteFromHeap(el, el.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  let dep = el.l;
+  while (dep !== null) {
+    dep = unlinkSubs(dep);
+  }
+  el.l = null;
+  runDisposal(el);
+}
 function link(dep, sub) {
-  const prevDep = sub.I;
+  const prevDep = sub.F;
   if (prevDep !== null && prevDep.R === dep) {
     return;
   }
   let nextDep = null;
   const isRecomputing = sub.b & 4 /* RecomputingDeps */;
   if (isRecomputing) {
-    nextDep = prevDep !== null ? prevDep.F : sub.x;
+    nextDep = prevDep !== null ? prevDep.E : sub.l;
     if (nextDep !== null && nextDep.R === dep) {
-      sub.I = nextDep;
+      sub.F = nextDep;
       return;
     }
   }
@@ -500,28 +503,28 @@ function link(dep, sub) {
   if (prevSub !== null && prevSub.j === sub && (!isRecomputing || isValidLink(prevSub, sub))) {
     return;
   }
-  const newLink = sub.I = dep.W = {
+  const newLink = sub.F = dep.W = {
     R: dep,
     j: sub,
-    F: nextDep,
-    ma: prevSub,
+    E: nextDep,
+    na: prevSub,
     A: null
   };
   if (prevDep !== null) {
-    prevDep.F = newLink;
+    prevDep.E = newLink;
   } else {
-    sub.x = newLink;
+    sub.l = newLink;
   }
   if (prevSub !== null) {
     prevSub.A = newLink;
   } else {
-    dep.s = newLink;
+    dep.x = newLink;
   }
 }
 function isValidLink(checkLink, sub) {
-  const depsTail = sub.I;
+  const depsTail = sub.F;
   if (depsTail !== null) {
-    let link2 = sub.x;
+    let link2 = sub.l;
     do {
       if (link2 === checkLink) {
         return true;
@@ -529,14 +532,14 @@ function isValidLink(checkLink, sub) {
       if (link2 === depsTail) {
         break;
       }
-      link2 = link2.F;
+      link2 = link2.E;
     } while (link2 !== null);
   }
   return false;
 }
 function setStatusFlags(signal2, flags, error = null) {
   signal2.f = flags;
-  signal2.C = error;
+  signal2.B = error;
 }
 function setError(signal2, error) {
   setStatusFlags(signal2, 2 /* Error */, error);
@@ -545,7 +548,7 @@ function clearStatusFlags(signal2) {
   setStatusFlags(signal2, 0 /* None */);
 }
 function markDisposal(el) {
-  let child = el.q;
+  let child = el.r;
   while (child) {
     child.b |= 32 /* Zombie */;
     const inHeap = child.b & 8 /* InHeap */;
@@ -557,23 +560,32 @@ function markDisposal(el) {
     child = child.M;
   }
 }
+function dispose(node) {
+  let toRemove = node.l || null;
+  do {
+    toRemove = unlinkSubs(toRemove);
+  } while (toRemove !== null);
+  node.l = null;
+  node.F = null;
+  disposeChildren(node, true);
+}
 function disposeChildren(node, self = false, zombie) {
   if (node.b & 64 /* Disposed */)
     return;
   if (self)
     node.b = 64 /* Disposed */;
-  let child = zombie ? node.U : node.q;
+  let child = zombie ? node.U : node.r;
   while (child) {
     const nextChild = child.M;
-    if (child.x) {
+    if (child.l) {
       const n = child;
       deleteFromHeap(n, n.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
-      let toRemove = n.x;
+      let toRemove = n.l;
       do {
         toRemove = unlinkSubs(toRemove);
       } while (toRemove !== null);
-      n.x = null;
-      n.I = null;
+      n.l = null;
+      n.F = null;
     }
     disposeChildren(child, true);
     child = nextChild;
@@ -581,7 +593,7 @@ function disposeChildren(node, self = false, zombie) {
   if (zombie) {
     node.U = null;
   } else {
-    node.q = null;
+    node.r = null;
     node.M = null;
   }
   runDisposal(node, zombie);
@@ -602,16 +614,16 @@ function runDisposal(node, zombie) {
 }
 function withOptions(obj, options) {
   obj.id = options?.id ?? (context?.id != null ? getNextChildId(context) : void 0);
-  obj.ea = options?.equals != null ? options.equals : isEqual;
-  obj.ya = !!options?.pureWrite;
-  obj.sa = options?.unobserved;
-  if (options?.ja)
-    Object.assign(obj, options.ja);
+  obj.fa = options?.equals != null ? options.equals : isEqual;
+  obj.za = !!options?.pureWrite;
+  obj.ta = options?.unobserved;
+  if (options?.ka)
+    Object.assign(obj, options.ka);
   return obj;
 }
 function getNextChildId(owner) {
   if (owner.id != null)
-    return formatId(owner.id, owner.na++);
+    return formatId(owner.id, owner.oa++);
   throw new Error("Cannot get child id from owner without an id");
 }
 function formatId(prefix, id) {
@@ -623,21 +635,21 @@ function computed(fn, initialValue, options) {
     {
       t: null,
       i: globalQueue,
-      E: defaultContext,
-      na: 0,
-      ha: fn,
+      D: defaultContext,
+      oa: 0,
+      H: fn,
       g: initialValue,
       c: 0,
-      ba: null,
+      ca: null,
       Q: void 0,
       z: null,
+      l: null,
+      F: null,
       x: null,
-      I: null,
-      s: null,
       W: null,
       w: context,
       M: null,
-      q: null,
+      r: null,
       b: 0 /* None */,
       f: 4 /* Uninitialized */,
       J: clock,
@@ -648,16 +660,16 @@ function computed(fn, initialValue, options) {
     options
   );
   self.z = self;
-  const parent = context?._ ? context.$ : context;
+  const parent = context?.$ ? context.aa : context;
   if (context) {
     context.i && (self.i = context.i);
-    context.E && (self.E = context.E);
-    const lastChild = context.q;
+    context.D && (self.D = context.D);
+    const lastChild = context.r;
     if (lastChild === null) {
-      context.q = self;
+      context.r = self;
     } else {
       self.M = lastChild;
-      context.q = self;
+      context.r = self;
     }
   }
   if (parent)
@@ -720,7 +732,7 @@ function asyncComputed(asyncFn, initialValue, options) {
     throw new NotReadyError(context);
   };
   const self = computed(fn, initialValue, options);
-  self.ta = () => {
+  self.ua = () => {
     refreshing = true;
     recompute(self);
     flush();
@@ -729,13 +741,13 @@ function asyncComputed(asyncFn, initialValue, options) {
 }
 function signal(v, options, firewall = null) {
   if (firewall !== null) {
-    return firewall.ba = withOptions(
+    return firewall.ca = withOptions(
       {
         g: v,
-        s: null,
+        x: null,
         W: null,
-        B: firewall,
-        ra: firewall.ba,
+        ia: firewall,
+        sa: firewall.ca,
         f: 0 /* None */,
         J: clock,
         e: NOT_PENDING
@@ -746,7 +758,7 @@ function signal(v, options, firewall = null) {
     return withOptions(
       {
         g: v,
-        s: null,
+        x: null,
         W: null,
         f: 0 /* None */,
         J: clock,
@@ -771,14 +783,14 @@ function untrack(fn) {
 }
 function read(el) {
   let c = context;
-  if (c?._)
-    c = c.$;
+  if (c?.$)
+    c = c.aa;
   if (c && tracking) {
     link(el, c);
-    const owner = "_owner" in el ? el.B : el;
-    if ("_fn" in owner) {
+    const owner = el.ia || el;
+    if (owner.H) {
       const isZombie = el.b & 32 /* Zombie */;
-      if (owner.c >= (isZombie ? zombieQueue.p : dirtyQueue.p)) {
+      if (owner.c >= (isZombie ? zombieQueue.q : dirtyQueue.q)) {
         markNode(c);
         markHeap(isZombie ? zombieQueue : dirtyQueue);
         updateIfNecessary(owner);
@@ -791,40 +803,40 @@ function read(el) {
   }
   if (pendingCheck) {
     const pendingResult = (el.f & 1 /* Pending */) !== 0 || !!el.T || false;
-    if (!el.H) {
-      el.H = signal(pendingResult);
-      el.H.ia = true;
-      el.H.da = (v) => setSignal(el.H, v);
+    if (!el.I) {
+      el.I = signal(pendingResult);
+      el.I.ja = true;
+      el.I.ea = (v) => setSignal(el.I, v);
     }
     const prev = pendingCheck;
     pendingCheck = null;
-    read(el.H);
+    read(el.I);
     pendingCheck = prev;
     prev.g = pendingResult || prev.g;
   }
   if (pendingValueCheck) {
-    if (!el.D) {
-      el.D = signal(
+    if (!el.C) {
+      el.C = signal(
         el.e === NOT_PENDING ? el.g : el.e
       );
-      el.D.ia = true;
-      el.D.da = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.D, v)));
+      el.C.ja = true;
+      el.C.ea = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.C, v)));
     }
     pendingValueCheck = false;
     try {
-      return read(el.D);
+      return read(el.C);
     } finally {
       pendingValueCheck = true;
     }
   }
   if (el.f & 1 /* Pending */) {
     if (c && !stale || el.f & 4 /* Uninitialized */)
-      throw el.C;
+      throw el.B;
     else if (c && stale && !pendingCheck) {
       setStatusFlags(
         c,
         c.f | 1,
-        el.C
+        el.B
       );
     }
   }
@@ -833,7 +845,7 @@ function read(el) {
       recompute(el, true);
       return read(el);
     } else {
-      throw el.C;
+      throw el.B;
     }
   }
   return !c || el.e === NOT_PENDING || stale && !pendingCheck && el.T && activeTransition !== el.T ? el.g : el.e;
@@ -844,19 +856,19 @@ function setSignal(el, v) {
       el.e === NOT_PENDING ? el.g : el.e
     );
   }
-  const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, v);
+  const valueChanged = !el.fa || !el.fa(el.e === NOT_PENDING ? el.g : el.e, v);
   if (!valueChanged && !el.f)
     return v;
   if (valueChanged) {
-    if (el.ia)
+    if (el.ja)
       el.g = v;
     else {
       if (el.e === NOT_PENDING)
         globalQueue.h.push(el);
       el.e = v;
     }
-    if (el.D)
-      el.D.da(v);
+    if (el.C)
+      el.C.ea(v);
   }
   clearStatusFlags(el);
   el.J = clock;
@@ -886,15 +898,15 @@ function onCleanup(fn) {
 function createOwner(options) {
   const parent = context;
   const owner = {
-    _: true,
-    $: parent?._ ? parent.$ : parent,
-    q: null,
+    $: true,
+    aa: parent?.$ ? parent.aa : parent,
+    r: null,
     M: null,
     t: null,
     id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : void 0),
     i: parent?.i ?? globalQueue,
-    E: parent?.E || defaultContext,
-    na: 0,
+    D: parent?.D || defaultContext,
+    oa: 0,
     V: null,
     U: null,
     w: parent,
@@ -903,12 +915,12 @@ function createOwner(options) {
     }
   };
   if (parent) {
-    const lastChild = parent.q;
+    const lastChild = parent.r;
     if (lastChild === null) {
-      parent.q = owner;
+      parent.r = owner;
     } else {
       owner.M = lastChild;
-      parent.q = owner;
+      parent.r = owner;
     }
   }
   return owner;
@@ -969,7 +981,7 @@ function getContext(context2, owner = getOwner()) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context2, owner) ? owner.E[context2.id] : context2.defaultValue;
+  const value = hasContext(context2, owner) ? owner.D[context2.id] : context2.defaultValue;
   if (isUndefined(value)) {
     throw new ContextNotFoundError();
   }
@@ -979,13 +991,13 @@ function setContext(context2, value, owner = getOwner()) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  owner.E = {
-    ...owner.E,
+  owner.D = {
+    ...owner.D,
     [context2.id]: isUndefined(value) ? context2.defaultValue : value
   };
 }
 function hasContext(context2, owner) {
-  return !isUndefined(owner?.E[context2.id]);
+  return !isUndefined(owner?.D[context2.id]);
 }
 function isUndefined(value) {
   return typeof value === "undefined";
@@ -996,27 +1008,27 @@ function effect(compute, effect2, error, initialValue, options) {
   let initialized = false;
   const node = computed(compute, initialValue, {
     ...options,
-    ja: {
-      fa: true,
-      oa: initialValue,
-      ua: effect2,
-      pa: error,
+    ka: {
+      ga: true,
+      pa: initialValue,
+      va: effect2,
+      qa: error,
       N: void 0,
       i: getOwner()?.i ?? globalQueue,
       K: options?.render ? 1 /* Render */ : 2 /* User */,
-      la(statusFlagsChanged, prevStatusFlags) {
+      ma(statusFlagsChanged, prevStatusFlags) {
         if (initialized) {
           const errorChanged = this.f && this.f === prevStatusFlags && statusFlagsChanged;
-          this.fa = !(this.f & 2 /* Error */) && !(this.f & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
-          if (this.fa)
+          this.ga = !(this.f & 2 /* Error */) && !(this.f & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
+          if (this.ga)
             this.i.enqueue(this.K, runEffect.bind(this));
         }
         if (this.f & 2 /* Error */) {
-          let error2 = this.C;
+          let error2 = this.B;
           this.i.notify(this, 1 /* Pending */, 0);
           if (this.K === 2 /* User */) {
             try {
-              return this.pa ? this.pa(error2, () => {
+              return this.qa ? this.qa(error2, () => {
                 this.N?.();
                 this.N = void 0;
               }) : console.error(error2);
@@ -1038,23 +1050,23 @@ function effect(compute, effect2, error, initialValue, options) {
   });
   initialized = true;
   if (node.K === 1 /* Render */)
-    node.ha = (p) => staleValues(() => compute(p));
+    node.H = (p) => staleValues(() => compute(p));
   !options?.defer && !(node.f & (2 /* Error */ | 1 /* Pending */)) && (node.K === 2 /* User */ ? node.i.enqueue(node.K, runEffect.bind(node)) : runEffect.call(node));
   onCleanup(() => node.N?.());
 }
 function runEffect() {
-  if (!this.fa || this.b & 64 /* Disposed */)
+  if (!this.ga || this.b & 64 /* Disposed */)
     return;
   this.N?.();
   this.N = void 0;
   try {
-    this.N = this.ua(this.g, this.oa);
+    this.N = this.va(this.g, this.pa);
   } catch (error) {
     if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
       throw error;
   } finally {
-    this.oa = this.g;
-    this.fa = false;
+    this.pa = this.g;
+    this.ga = false;
   }
 }
 
@@ -1085,7 +1097,7 @@ function createMemo(compute, value, options) {
 function createAsync(compute, value, options) {
   const node = asyncComputed(compute, value, options);
   const ret = read.bind(null, node);
-  ret.refresh = node.ta;
+  ret.refresh = node.ua;
   return ret;
 }
 function createEffect(compute, effectFn, value, options) {
@@ -1105,11 +1117,29 @@ function createRenderEffect(compute, effectFn, value, options) {
 }
 function createTrackedEffect(compute, options) {
 }
-function createReaction(effect2, options) {
+function createReaction(effectFn, options) {
+  let cleanup = void 0;
+  onCleanup(() => cleanup?.());
+  return (tracking2) => {
+    effect(
+      () => (tracking2(), getOwner()),
+      (node) => {
+        cleanup?.();
+        cleanup = (effectFn.effect || effectFn)?.();
+        dispose(node);
+      },
+      effectFn.error,
+      void 0,
+      {
+        defer: true,
+        ...options
+      }
+    );
+  };
 }
 function resolve(fn) {
   return new Promise((res, rej) => {
-    createRoot((dispose) => {
+    createRoot((dispose2) => {
       computed(() => {
         try {
           res(fn());
@@ -1118,7 +1148,7 @@ function resolve(fn) {
             throw err;
           rej(err);
         }
-        dispose();
+        dispose2();
       });
     });
   });
@@ -1127,6 +1157,14 @@ function createOptimistic(first, second, third) {
   return {};
 }
 function onSettled(callback) {
+  let cleanup;
+  const o = getOwner();
+  if (o)
+    onCleanup(() => cleanup?.());
+  globalQueue.enqueue(2 /* User */, () => {
+    cleanup = callback();
+    !o && cleanup?.();
+  });
 }
 
 // src/store/reconcile.ts
@@ -1262,23 +1300,17 @@ function reconcile(value, key, all = false) {
 function createProjectionInternal(fn, initialValue = {}, options) {
   let node;
   const wrappedMap = /* @__PURE__ */ new WeakMap();
-  const traps = {
-    ...storeTraps,
-    get(target, property, receiver) {
-      const o = getOwner();
-      const n = node;
-      (!o || o !== n) && n && read(n);
-      return storeTraps.get(target, property, receiver);
-    }
-  };
   const wrapProjection = (source) => {
     if (wrappedMap.has(source))
       return wrappedMap.get(source);
     if (source[$TARGET]?.[STORE_WRAP] === wrapProjection)
       return source;
-    const wrapped = createStoreProxy(source, traps, {
+    const wrapped = createStoreProxy(source, storeTraps, {
       [STORE_WRAP]: wrapProjection,
-      [STORE_LOOKUP]: wrappedMap
+      [STORE_LOOKUP]: wrappedMap,
+      [STORE_FIREWALL]() {
+        return node;
+      }
     });
     wrappedMap.set(source, wrapped);
     return wrapped;
@@ -1311,6 +1343,7 @@ var STORE_NODE = "n";
 var STORE_HAS = "h";
 var STORE_WRAP = "w";
 var STORE_LOOKUP = "l";
+var STORE_FIREWALL = "f";
 function createStoreProxy(value, traps = storeTraps, extend) {
   let newTarget;
   if (Array.isArray(value)) {
@@ -1339,18 +1372,24 @@ function getNodes(target, type) {
     target[type] = nodes = /* @__PURE__ */ Object.create(null);
   return nodes;
 }
-function getNode(nodes, property, value, equals = isEqual) {
+function getNode(nodes, property, value, firewall, equals = isEqual) {
   if (nodes[property])
     return nodes[property];
-  return nodes[property] = signal(value, {
-    equals,
-    unobserved() {
-      delete nodes[property];
-    }
-  });
+  return nodes[property] = signal(
+    value,
+    {
+      equals,
+      unobserved() {
+        delete nodes[property];
+      }
+    },
+    firewall
+  );
 }
 function trackSelf(target, symbol = $TRACK) {
-  getObserver() && read(getNode(getNodes(target, STORE_NODE), symbol, void 0, false));
+  getObserver() && read(
+    getNode(getNodes(target, STORE_NODE), symbol, void 0, target[STORE_FIREWALL]?.(), false)
+  );
 }
 function getKeys(source, override, enumerable = true) {
   const baseKeys = untrack(() => enumerable ? Object.keys(source) : Reflect.ownKeys(source));
@@ -1413,7 +1452,14 @@ var storeTraps = {
         let proto;
         return !Array.isArray(target[STORE_VALUE]) && (proto = Object.getPrototypeOf(target[STORE_VALUE])) && proto !== Object.prototype ? value.bind(storeValue) : value;
       } else if (getObserver()) {
-        return read(getNode(nodes, property, isWrappable(value) ? wrap(value, target) : value));
+        return read(
+          getNode(
+            nodes,
+            property,
+            isWrappable(value) ? wrap(value, target) : value,
+            target[STORE_FIREWALL]?.()
+          )
+        );
       }
     }
     return isWrappable(value) ? wrap(value, target) : value;
@@ -1422,7 +1468,7 @@ var storeTraps = {
     if (property === $PROXY || property === $TRACK || property === "__proto__")
       return true;
     const has = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] !== $DELETED : property in target[STORE_VALUE];
-    getObserver() && read(getNode(getNodes(target, STORE_HAS), property, has));
+    getObserver() && read(getNode(getNodes(target, STORE_HAS), property, has, target[STORE_FIREWALL]?.()));
     return has;
   },
   set(target, property, rawValue) {
@@ -1797,60 +1843,60 @@ function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
   return createMemo(
     updateKeyedMap.bind({
-      B: createOwner(),
-      m: 0,
-      va: list,
+      X: createOwner(),
+      n: 0,
+      wa: list,
       G: [],
       O: map,
       d: [],
       a: [],
       P: keyFn,
-      n: keyFn || options?.keyed === false ? [] : void 0,
-      o: map.length > 1 ? [] : void 0,
-      X: options?.fallback
+      o: keyFn || options?.keyed === false ? [] : void 0,
+      p: map.length > 1 ? [] : void 0,
+      Y: options?.fallback
     })
   );
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this.va() || [], newLen = newItems.length;
+  const newItems = this.wa() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.B, () => {
-    let i, j, mapper = this.n ? () => {
-      this.n[j] = signal(newItems[j], pureOptions);
-      this.o && (this.o[j] = signal(j, pureOptions));
+  runWithOwner(this.X, () => {
+    let i, j, mapper = this.o ? () => {
+      this.o[j] = signal(newItems[j], pureOptions);
+      this.p && (this.p[j] = signal(j, pureOptions));
       return this.O(
-        read.bind(null, this.n[j]),
-        this.o ? read.bind(null, this.o[j]) : void 0
+        read.bind(null, this.o[j]),
+        this.p ? read.bind(null, this.p[j]) : void 0
       );
-    } : this.o ? () => {
+    } : this.p ? () => {
       const item = newItems[j];
-      this.o[j] = signal(j, pureOptions);
+      this.p[j] = signal(j, pureOptions);
       return this.O(
         () => item,
-        read.bind(null, this.o[j])
+        read.bind(null, this.p[j])
       );
     } : () => {
       const item = newItems[j];
       return this.O(() => item);
     };
     if (newLen === 0) {
-      if (this.m !== 0) {
-        this.B.dispose(false);
+      if (this.n !== 0) {
+        this.X.dispose(false);
         this.a = [];
         this.G = [];
         this.d = [];
-        this.m = 0;
-        this.n && (this.n = []);
+        this.n = 0;
         this.o && (this.o = []);
+        this.p && (this.p = []);
       }
-      if (this.X && !this.d[0]) {
+      if (this.Y && !this.d[0]) {
         this.d[0] = runWithOwner(
           this.a[0] = createOwner(),
-          this.X
+          this.Y
         );
       }
-    } else if (this.m === 0) {
+    } else if (this.n === 0) {
       if (this.a[0])
         this.a[0].dispose();
       this.d = new Array(newLen);
@@ -1858,18 +1904,18 @@ function updateKeyedMap() {
         this.G[j] = newItems[j];
         this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
       }
-      this.m = newLen;
+      this.n = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.n ? new Array(newLen) : void 0, tempIndexes = this.o ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.m, newLen); start < end && (this.G[start] === newItems[start] || this.n && compare(this.P, this.G[start], newItems[start])); start++) {
-        if (this.n)
-          setSignal(this.n[start], newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.o ? new Array(newLen) : void 0, tempIndexes = this.p ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.n, newLen); start < end && (this.G[start] === newItems[start] || this.o && compare(this.P, this.G[start], newItems[start])); start++) {
+        if (this.o)
+          setSignal(this.o[start], newItems[start]);
       }
-      for (end = this.m - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.G[end] === newItems[newEnd] || this.n && compare(this.P, this.G[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.n - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.G[end] === newItems[newEnd] || this.o && compare(this.P, this.G[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.d[end];
         tempNodes[newEnd] = this.a[end];
-        tempRows && (tempRows[newEnd] = this.n[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.o[end]);
+        tempRows && (tempRows[newEnd] = this.o[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.p[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
@@ -1887,8 +1933,8 @@ function updateKeyedMap() {
         if (j !== void 0 && j !== -1) {
           temp[j] = this.d[i];
           tempNodes[j] = this.a[i];
-          tempRows && (tempRows[j] = this.n[i]);
-          tempIndexes && (tempIndexes[j] = this.o[i]);
+          tempRows && (tempRows[j] = this.o[i]);
+          tempIndexes && (tempIndexes[j] = this.p[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
@@ -1899,18 +1945,18 @@ function updateKeyedMap() {
           this.d[j] = temp[j];
           this.a[j] = tempNodes[j];
           if (tempRows) {
-            this.n[j] = tempRows[j];
-            setSignal(this.n[j], newItems[j]);
+            this.o[j] = tempRows[j];
+            setSignal(this.o[j], newItems[j]);
           }
           if (tempIndexes) {
-            this.o[j] = tempIndexes[j];
-            setSignal(this.o[j], j);
+            this.p[j] = tempIndexes[j];
+            setSignal(this.p[j], j);
           }
         } else {
           this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
         }
       }
-      this.d = this.d.slice(0, this.m = newLen);
+      this.d = this.d.slice(0, this.n = newLen);
       this.G = newItems.slice(0);
     }
   });
@@ -1918,45 +1964,45 @@ function updateKeyedMap() {
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    B: createOwner(),
-    m: 0,
+    X: createOwner(),
+    n: 0,
     y: 0,
-    wa: count,
+    xa: count,
     O: map,
     a: [],
     d: [],
-    xa: options?.from,
-    X: options?.fallback
+    ya: options?.from,
+    Y: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.wa();
-  const from = this.xa?.() || 0;
-  runWithOwner(this.B, () => {
+  const newLen = this.xa();
+  const from = this.ya?.() || 0;
+  runWithOwner(this.X, () => {
     if (newLen === 0) {
-      if (this.m !== 0) {
-        this.B.dispose(false);
+      if (this.n !== 0) {
+        this.X.dispose(false);
         this.a = [];
         this.d = [];
-        this.m = 0;
+        this.n = 0;
       }
-      if (this.X && !this.d[0]) {
+      if (this.Y && !this.d[0]) {
         this.d[0] = runWithOwner(
           this.a[0] = createOwner(),
-          this.X
+          this.Y
         );
       }
       return;
     }
     const to = from + newLen;
-    const prevTo = this.y + this.m;
-    if (this.m === 0 && this.a[0])
+    const prevTo = this.y + this.n;
+    if (this.n === 0 && this.a[0])
       this.a[0].dispose();
     for (let i = to; i < prevTo; i++)
       this.a[i - this.y].dispose();
     if (this.y < from) {
       let i = this.y;
-      while (i < from && i < this.m)
+      while (i < from && i < this.n)
         this.a[i++].dispose();
       this.a.splice(0, from - this.y);
       this.d.splice(0, from - this.y);
@@ -1984,7 +2030,7 @@ function updateRepeat() {
     }
     this.d = this.d.slice(0, newLen);
     this.y = from;
-    this.m = newLen;
+    this.n = newLen;
   });
   return this.d;
 }
@@ -1995,19 +2041,19 @@ function compare(key, a, b) {
 // src/boundaries.ts
 function boundaryComputed(fn, propagationMask) {
   const node = computed(fn, void 0, {
-    ja: {
-      la() {
+    ka: {
+      ma() {
         let flags = this.f;
-        this.f &= ~this.Y;
-        if (this.Y & 1 /* Pending */ && !(this.f & 4 /* Uninitialized */)) {
+        this.f &= ~this.Z;
+        if (this.Z & 1 /* Pending */ && !(this.f & 4 /* Uninitialized */)) {
           flags &= ~1 /* Pending */;
         }
-        this.i.notify(this, this.Y, flags);
+        this.i.notify(this, this.Z, flags);
       },
-      Y: propagationMask
+      Z: propagationMask
     }
   });
-  node.Y = propagationMask;
+  node.Z = propagationMask;
   return node;
 }
 function createBoundChildren(owner, fn, queue, mask) {
@@ -2021,7 +2067,7 @@ function createBoundChildren(owner, fn, queue, mask) {
 }
 var ConditionalQueue = class extends Queue {
   u;
-  ga = /* @__PURE__ */ new Set();
+  ha = /* @__PURE__ */ new Set();
   h = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
@@ -2043,9 +2089,9 @@ var ConditionalQueue = class extends Queue {
       }
       if (type & 2 /* Error */) {
         if (flags & 2 /* Error */) {
-          this.ga.add(node);
+          this.ha.add(node);
           type &= ~2 /* Error */;
-        } else if (this.ga.delete(node))
+        } else if (this.ha.delete(node))
           type &= ~2 /* Error */;
       }
     }
@@ -2053,13 +2099,13 @@ var ConditionalQueue = class extends Queue {
   }
 };
 var CollectionQueue = class extends Queue {
-  Z;
+  _;
   a = /* @__PURE__ */ new Set();
   u = signal(false, { pureWrite: true });
-  qa = false;
+  ra = false;
   constructor(type) {
     super();
-    this.Z = type;
+    this._ = type;
   }
   run(type) {
     if (!type || read(this.u))
@@ -2067,9 +2113,9 @@ var CollectionQueue = class extends Queue {
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (!(type & this.Z) || this.Z & 1 /* Pending */ && this.qa)
+    if (!(type & this._) || this._ & 1 /* Pending */ && this.ra)
       return super.notify(node, type, flags);
-    if (flags & this.Z) {
+    if (flags & this._) {
       this.a.add(node);
       if (this.a.size === 1)
         setSignal(this.u, true);
@@ -2078,7 +2124,7 @@ var CollectionQueue = class extends Queue {
       if (this.a.size === 0)
         setSignal(this.u, false);
     }
-    type &= ~this.Z;
+    type &= ~this._;
     return type ? super.notify(node, type, flags) : true;
   }
 };
@@ -2088,14 +2134,14 @@ function createBoundary(fn, condition) {
   const tree = createBoundChildren(owner, fn, queue, 0);
   computed(() => {
     const disabled = read(queue.u);
-    tree.Y = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
+    tree.Z = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
     if (!disabled) {
       queue.h.forEach(
         (node) => queue.notify(node, 1 /* Pending */, 1 /* Pending */)
       );
-      queue.ga.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
+      queue.ha.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
       queue.h.clear();
-      queue.ga.clear();
+      queue.ha.clear();
     }
   });
   return () => read(queue.u) ? void 0 : read(tree);
@@ -2108,7 +2154,7 @@ function createCollectionBoundary(type, fn, fallback) {
     if (!read(queue.u)) {
       const resolved = read(tree);
       if (!untrack(() => read(queue.u)))
-        queue.qa = true;
+        queue.ra = true;
       return resolved;
     }
     return fallback(queue);
@@ -2121,7 +2167,7 @@ function createLoadBoundary(fn, fallback) {
 function createErrorBoundary(fn, fallback) {
   return createCollectionBoundary(2 /* Error */, fn, (queue) => {
     let node = queue.a.values().next().value;
-    return fallback(node.C, () => {
+    return fallback(node.B, () => {
       for (let node2 of queue.a) {
         recompute(node2, true);
       }