@solidjs/signals 0.7.5 → 0.8.1

package/dist/prod.js

@@ -1,8 +1,8 @@
 // src/core/error.ts
 var NotReadyError = class extends Error {
-  constructor(node) {
+  constructor(cause) {
     super();
-    this.cause = node;
+    this.cause = cause;
   }
 };
 var NoOwnerError = class extends Error {
@@ -19,944 +19,907 @@ var ContextNotFoundError = class extends Error {
 };
 
 // src/core/constants.ts
-var STATE_CLEAN = 0;
-var STATE_CHECK = 1;
-var STATE_DIRTY = 2;
-var STATE_DISPOSED = 3;
-var EFFECT_PURE = 0;
-var EFFECT_RENDER = 1;
-var EFFECT_USER = 2;
+var NOT_PENDING = {};
 var SUPPORTS_PROXY = typeof Proxy === "function";
 
-// src/core/flags.ts
-var ERROR_OFFSET = 0;
-var ERROR_BIT = 1 << ERROR_OFFSET;
-var LOADING_OFFSET = 1;
-var LOADING_BIT = 1 << LOADING_OFFSET;
-var UNINITIALIZED_OFFSET = 2;
-var UNINITIALIZED_BIT = 1 << UNINITIALIZED_OFFSET;
-var DEFAULT_FLAGS = ERROR_BIT;
+// src/core/heap.ts
+function actualInsertIntoHeap(n, heap) {
+  const parentHeight = (n.q?._ ? n.q.$?.c : n.q?.c) ?? -1;
+  if (parentHeight >= n.c)
+    n.c = parentHeight + 1;
+  const height = n.c;
+  const heapAtHeight = heap.p[height];
+  if (heapAtHeight === void 0) {
+    heap.p[height] = n;
+  } else {
+    const tail = heapAtHeight.x;
+    tail.P = n;
+    n.x = tail;
+    heapAtHeight.x = n;
+  }
+  if (height > heap.J) {
+    heap.J = height;
+  }
+}
+function insertIntoHeap(n, heap) {
+  let flags = n.b;
+  if (flags & (8 /* InHeap */ | 4 /* RecomputingDeps */))
+    return;
+  if (flags & 1 /* Check */) {
+    n.b = flags & ~(1 /* Check */ | 2 /* Dirty */) | 2 /* Dirty */ | 8 /* InHeap */;
+  } else
+    n.b = flags | 8 /* InHeap */;
+  if (!(flags & 16 /* InHeapHeight */)) {
+    actualInsertIntoHeap(n, heap);
+  }
+}
+function insertIntoHeapHeight(n, heap) {
+  let flags = n.b;
+  if (flags & (8 /* InHeap */ | 4 /* RecomputingDeps */ | 16 /* InHeapHeight */))
+    return;
+  n.b = flags | 16 /* InHeapHeight */;
+  actualInsertIntoHeap(n, heap);
+}
+function deleteFromHeap(n, heap) {
+  const flags = n.b;
+  if (!(flags & (8 /* InHeap */ | 16 /* InHeapHeight */)))
+    return;
+  n.b = flags & ~(8 /* InHeap */ | 16 /* InHeapHeight */);
+  const height = n.c;
+  if (n.x === n) {
+    heap.p[height] = void 0;
+  } else {
+    const next = n.P;
+    const dhh = heap.p[height];
+    const end = next ?? dhh;
+    if (n === dhh) {
+      heap.p[height] = next;
+    } else {
+      n.x.P = next;
+    }
+    end.x = n.x;
+  }
+  n.x = n;
+  n.P = void 0;
+}
+function markHeap(heap) {
+  if (heap.aa)
+    return;
+  heap.aa = true;
+  for (let i = 0; i <= heap.J; i++) {
+    for (let el = heap.p[i]; el !== void 0; el = el.P) {
+      if (el.b & 8 /* InHeap */)
+        markNode(el);
+    }
+  }
+}
+function markNode(el, newState = 2 /* Dirty */) {
+  const flags = el.b;
+  if ((flags & (1 /* Check */ | 2 /* Dirty */)) >= newState)
+    return;
+  el.b = flags & ~(1 /* Check */ | 2 /* Dirty */) | newState;
+  for (let link2 = el.r; link2 !== null; link2 = link2.y) {
+    markNode(link2.j, 1 /* Check */);
+  }
+  if (el.ba !== null) {
+    for (let child = el.ba; child !== null; child = child.ra) {
+      for (let link2 = child.r; link2 !== null; link2 = link2.y) {
+        markNode(link2.j, 1 /* Check */);
+      }
+    }
+  }
+}
+function runHeap(heap, recompute2) {
+  heap.aa = false;
+  for (heap.n = 0; heap.n <= heap.J; heap.n++) {
+    let el = heap.p[heap.n];
+    while (el !== void 0) {
+      if (el.b & 8 /* InHeap */)
+        recompute2(el);
+      else {
+        adjustHeight(el, heap);
+      }
+      el = heap.p[heap.n];
+    }
+  }
+  heap.J = 0;
+}
+function adjustHeight(el, heap) {
+  deleteFromHeap(el, heap);
+  let newHeight = el.c;
+  for (let d = el.u; d; d = d.E) {
+    const dep1 = d.Q;
+    const dep = "_owner" in dep1 ? dep1.z : dep1;
+    if ("_fn" in dep) {
+      if (dep.c >= newHeight) {
+        newHeight = dep.c + 1;
+      }
+    }
+  }
+  if (el.c !== newHeight) {
+    el.c = newHeight;
+    for (let s = el.r; s !== null; s = s.y) {
+      insertIntoHeapHeight(s.j, heap);
+    }
+  }
+}
 
 // src/core/scheduler.ts
 var clock = 0;
-function incrementClock() {
-  clock++;
-}
-var ActiveTransition = null;
-var Unobserved = [];
+var activeTransition = null;
+var unobserved = [];
+var transitions = /* @__PURE__ */ new Set();
 var scheduled = false;
 function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  if (!globalQueue.C)
+  if (!globalQueue.ca)
     queueMicrotask(flush);
 }
-function notifyUnobserved() {
-  for (let i = 0; i < Unobserved.length; i++) {
-    const source = Unobserved[i];
-    if (!source.c || !source.c.length)
-      Unobserved[i].fa?.();
-  }
-  Unobserved = [];
-}
-var pureQueue = [];
+var dirtyQueue = {
+  p: new Array(2e3).fill(void 0),
+  aa: false,
+  n: 0,
+  J: 0
+};
+var zombieQueue = {
+  p: new Array(2e3).fill(void 0),
+  aa: false,
+  n: 0,
+  J: 0
+};
 var Queue = class {
-  l = null;
-  C = false;
-  h = [[], []];
-  i = [];
+  q = null;
+  A = [[], []];
+  R = [];
   created = clock;
-  enqueue(type, fn) {
-    pureQueue.push(fn);
-    if (type)
-      this.h[type - 1].push(fn);
-    schedule();
+  addChild(child) {
+    this.R.push(child);
+    child.q = this;
+  }
+  removeChild(child) {
+    const index = this.R.indexOf(child);
+    if (index >= 0) {
+      this.R.splice(index, 1);
+      child.q = null;
+    }
+  }
+  notify(node, mask, flags) {
+    if (this.q)
+      return this.q.notify(node, mask, flags);
+    return false;
   }
   run(type) {
-    if (type === EFFECT_PURE) {
-      pureQueue.length && runQueue(pureQueue, type);
-      pureQueue = [];
-      return;
-    } else if (this.h[type - 1].length) {
-      const effects = this.h[type - 1];
-      this.h[type - 1] = [];
+    if (this.A[type - 1].length) {
+      const effects = this.A[type - 1];
+      this.A[type - 1] = [];
       runQueue(effects, type);
     }
-    for (let i = 0; i < this.i.length; i++) {
-      this.i[i].run(type);
+    for (let i = 0; i < this.R.length; i++) {
+      this.R[i].run(type);
     }
   }
+  enqueue(type, fn) {
+    if (type)
+      this.A[type - 1].push(fn);
+    schedule();
+  }
+};
+var GlobalQueue = class _GlobalQueue extends Queue {
+  ca = false;
+  h = [];
+  static S;
+  static la;
   flush() {
-    if (this.C)
+    if (this.ca)
       return;
-    this.C = true;
+    this.ca = true;
     try {
-      this.run(EFFECT_PURE);
-      incrementClock();
+      runHeap(dirtyQueue, _GlobalQueue.S);
+      if (activeTransition) {
+        if (!transitionComplete(activeTransition)) {
+          runHeap(zombieQueue, _GlobalQueue.S);
+          globalQueue.h = [];
+          activeTransition.queues[0].push(...globalQueue.A[0]);
+          activeTransition.queues[1].push(...globalQueue.A[1]);
+          globalQueue.A = [[], []];
+          clock++;
+          scheduled = false;
+          runPending(activeTransition.pendingNodes, true);
+          activeTransition = null;
+          return;
+        }
+        globalQueue.h.push(...activeTransition.pendingNodes);
+        globalQueue.A[0].push(...activeTransition.queues[0]);
+        globalQueue.A[1].push(...activeTransition.queues[1]);
+        transitions.delete(activeTransition);
+        activeTransition = null;
+        if (runPending(globalQueue.h, false))
+          runHeap(dirtyQueue, _GlobalQueue.S);
+      } else if (transitions.size)
+        runHeap(zombieQueue, _GlobalQueue.S);
+      for (let i = 0; i < globalQueue.h.length; i++) {
+        const n = globalQueue.h[i];
+        if (n.e !== NOT_PENDING) {
+          n.g = n.e;
+          n.e = NOT_PENDING;
+        }
+        if (n.ha)
+          _GlobalQueue.la(n, false, true);
+      }
+      globalQueue.h.length = 0;
+      clock++;
       scheduled = false;
-      this.run(EFFECT_RENDER);
-      this.run(EFFECT_USER);
+      this.run(1 /* Render */);
+      this.run(2 /* User */);
     } finally {
-      this.C = false;
-      Unobserved.length && notifyUnobserved();
+      this.ca = false;
+      unobserved.length && notifyUnobserved();
     }
   }
-  addChild(child) {
-    if (ActiveTransition && ActiveTransition.J.has(this))
-      return ActiveTransition.J.get(this).addChild(child);
-    this.i.push(child);
-    child.l = this;
-  }
-  removeChild(child) {
-    if (ActiveTransition && ActiveTransition.J.has(this))
-      return ActiveTransition.J.get(this).removeChild(child);
-    const index = this.i.indexOf(child);
-    if (index >= 0) {
-      this.i.splice(index, 1);
-      child.l = null;
+  notify(node, mask, flags) {
+    if (mask & 1 /* Pending */) {
+      if (flags & 1 /* Pending */) {
+        if (activeTransition && !activeTransition.asyncNodes.includes(node.B.cause))
+          activeTransition.asyncNodes.push(node.B.cause);
+      }
+      return true;
     }
-  }
-  notify(...args) {
-    if (this.l)
-      return this.l.notify(...args);
     return false;
   }
-  merge(queue) {
-    this.h[0].push.apply(this.h[0], queue.h[0]);
-    this.h[1].push.apply(this.h[1], queue.h[1]);
-    for (let i = 0; i < queue.i.length; i++) {
-      const og = this.i.find((c) => c.d === queue.i[i].d);
-      if (og)
-        og.merge(queue.i[i]);
-      else
-        this.addChild(queue.i[i]);
+  initTransition(node) {
+    if (activeTransition && activeTransition.time === clock)
+      return;
+    if (!activeTransition) {
+      activeTransition = node.T ?? {
+        time: clock,
+        pendingNodes: [],
+        asyncNodes: [],
+        queues: [[], []]
+      };
+    }
+    transitions.add(activeTransition);
+    activeTransition.time = clock;
+    for (let i = 0; i < globalQueue.h.length; i++) {
+      const n = globalQueue.h[i];
+      n.T = activeTransition;
+      activeTransition.pendingNodes.push(n);
     }
+    globalQueue.h = activeTransition.pendingNodes;
   }
 };
-var globalQueue = new Queue();
+function runPending(pendingNodes, value) {
+  let needsReset = false;
+  const p = pendingNodes.slice();
+  for (let i = 0; i < p.length; i++) {
+    const n = p[i];
+    n.T = activeTransition;
+    if (n.G) {
+      n.G.da(value);
+      needsReset = true;
+    }
+  }
+  return needsReset;
+}
+var globalQueue = new GlobalQueue();
 function flush() {
   while (scheduled) {
     globalQueue.flush();
   }
 }
-function removeSourceObservers(node, index) {
-  let source;
-  let swap;
-  for (let i = index; i < node.b.length; i++) {
-    source = getTransitionSource(node.b[i]);
-    if (source.c) {
-      if ((swap = source.c.indexOf(node)) !== -1) {
-        source.c[swap] = source.c[source.c.length - 1];
-        source.c.pop();
-      }
-      if (!source.c.length)
-        Unobserved.push(source);
-    }
-  }
-}
 function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++)
     queue[i](type);
 }
-var Transition = class _Transition {
-  b = /* @__PURE__ */ new Map();
-  t = /* @__PURE__ */ new Set();
-  K = /* @__PURE__ */ new Set();
-  j = /* @__PURE__ */ new Set();
-  D = false;
-  h = [[], []];
-  J = /* @__PURE__ */ new Map();
-  G = [];
-  i = [];
-  l = null;
-  C = false;
-  Y = false;
-  d = globalQueue;
-  aa;
-  created = clock;
-  constructor(signal) {
-    this.aa = signal;
-    this.J.set(globalQueue, this);
-    for (const child of globalQueue.i) {
-      cloneQueue(child, this, this);
+function transitionComplete(transition) {
+  let done = true;
+  for (let i = 0; i < transition.asyncNodes.length; i++) {
+    if (transition.asyncNodes[i].f & 1 /* Pending */) {
+      done = false;
+      break;
     }
   }
-  enqueue(type, fn) {
-    this.G.push(fn);
-    if (type)
-      this.h[type - 1].push(fn);
-    this.schedule();
-  }
-  run(type) {
-    if (type === EFFECT_PURE) {
-      this.G.length && runQueue(this.G, type);
-      this.G = [];
-      return;
-    } else if (this.h[type - 1].length) {
-      const effects = this.h[type - 1];
-      this.h[type - 1] = [];
-      runQueue(effects, type);
-    }
-    for (let i = 0; i < this.i.length; i++) {
-      this.i[i].run(type);
-    }
+  return done;
+}
+function notifyUnobserved() {
+  for (let i = 0; i < unobserved.length; i++) {
+    const source = unobserved[i];
+    if (!source.r)
+      unobserved[i].sa?.();
   }
-  flush() {
-    if (this.C || this.D)
-      return;
-    globalQueue.flush();
-    this.C = true;
-    let currentTransition = ActiveTransition;
-    ActiveTransition = this;
-    try {
-      this.run(EFFECT_PURE);
-      incrementClock();
-      this.Y = false;
-      ActiveTransition = currentTransition;
-      finishTransition(this);
-    } finally {
-      this.C = false;
-      ActiveTransition = currentTransition;
+  unobserved = [];
+}
+
+// src/core/core.ts
+GlobalQueue.S = recompute;
+GlobalQueue.la = disposeChildren;
+var tracking = false;
+var stale = false;
+var pendingValueCheck = false;
+var pendingCheck = null;
+var context = null;
+var defaultContext = {};
+function recompute(el, create = false) {
+  deleteFromHeap(el, el.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  if (el.e !== NOT_PENDING || el.U || el.V)
+    disposeChildren(el);
+  else {
+    markDisposal(el);
+    globalQueue.h.push(el);
+    el.V = el.s;
+    el.U = el.o;
+    el.s = null;
+    el.o = null;
+  }
+  const oldcontext = context;
+  context = el;
+  el.H = null;
+  el.b = 4 /* RecomputingDeps */;
+  el.W = clock;
+  let value = el.e === NOT_PENDING ? el.g : el.e;
+  let oldHeight = el.c;
+  let prevStatusFlags = el.f;
+  let prevError = el.B;
+  let prevTracking = tracking;
+  clearStatusFlags(el);
+  tracking = true;
+  try {
+    value = el.ha(value);
+  } catch (e) {
+    if (e instanceof NotReadyError) {
+      if (e.cause !== el)
+        link(e.cause, el);
+      setStatusFlags(el, prevStatusFlags & ~2 /* Error */ | 1 /* Pending */, e);
+    } else {
+      setError(el, e);
     }
+  } finally {
+    tracking = prevTracking;
   }
-  addChild(child) {
-    this.i.push(child);
-    child.l = this;
-  }
-  removeChild(child) {
-    const index = this.i.indexOf(child);
-    if (index >= 0)
-      this.i.splice(index, 1);
-  }
-  notify(node, type, flags) {
-    if (!(type & LOADING_BIT))
-      return false;
-    if (flags & LOADING_BIT) {
-      this.t.add(node);
+  el.b = 0 /* None */;
+  context = oldcontext;
+  const depsTail = el.H;
+  let toRemove = depsTail !== null ? depsTail.E : el.u;
+  if (toRemove !== null) {
+    do {
+      toRemove = unlinkSubs(toRemove);
+    } while (toRemove !== null);
+    if (depsTail !== null) {
+      depsTail.E = null;
     } else {
-      this.t.delete(node);
+      el.u = null;
     }
-    return true;
   }
-  merge(queue) {
-    this.h[0].push.apply(this.h[0], queue.h[0]);
-    this.h[1].push.apply(this.h[1], queue.h[1]);
-    this.G.push.apply(this.G, queue.G);
-    queue.h[0].length = 0;
-    queue.h[1].length = 0;
-    queue.G.length = 0;
-    for (let i = 0; i < queue.i.length; i++) {
-      const og = this.i.find((c) => c.d === queue.i[i].d);
-      if (og)
-        og.merge(queue.i[i]);
-      else
-        this.addChild(queue.i[i]);
-    }
-  }
-  schedule() {
-    if (this.Y)
-      return;
-    this.Y = true;
-    if (!this.C)
-      queueMicrotask(() => this.flush());
-  }
-  runTransition(fn, force = false) {
-    if (this.D) {
-      if (this.D instanceof _Transition)
-        return this.D.runTransition(fn, force);
-      if (!force)
-        throw new Error("Transition already completed");
-      fn();
-      return;
-    }
-    ActiveTransition = this;
-    try {
-      let result = fn();
-      let transition2 = ActiveTransition;
-      if (result?.next) {
-        (async function() {
-          let temp, value;
-          while (!(temp = result.next(value)).done) {
-            transition2 = ActiveTransition;
-            if (temp.value instanceof Promise) {
-              transition2.K.add(temp.value);
-              try {
-                value = await temp.value;
-              } finally {
-                transition2 = latestTransition(transition2);
-                transition2.K.delete(temp.value);
-              }
-              ActiveTransition = transition2;
-            } else
-              value = temp.value;
-          }
-          ActiveTransition = null;
-          finishTransition(transition2);
-        })();
-      }
-      if (result instanceof Promise) {
-        transition2.K.add(result);
-        result.finally(() => {
-          transition2 = latestTransition(transition2);
-          transition2.K.delete(result);
-          ActiveTransition = null;
-          finishTransition(transition2);
-        });
+  const valueChanged = !el.ea || !el.ea(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.I)
+        el.g = value;
+      else {
+        if (el.e === NOT_PENDING)
+          globalQueue.h.push(el);
+        el.e = value;
       }
-    } finally {
-      const transition2 = ActiveTransition;
-      ActiveTransition = null;
-      finishTransition(transition2);
-    }
-  }
-  addOptimistic(fn) {
-    if (fn.f && fn.f !== this) {
-      mergeTransitions(fn.f, this);
-      ActiveTransition = fn.f;
-      return;
+      if (el.C)
+        el.C.da(value);
     }
-    fn.f = this;
-    this.j.add(fn);
-  }
-};
-function cloneGraph(node) {
-  if (node.j) {
-    if (node.a !== STATE_DISPOSED) {
-      !node.f && node.j.ia?.();
-      ActiveTransition.addOptimistic(node.j);
+    for (let s = el.r; s !== null; s = s.y) {
+      const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+      if (s.j.c < el.c && queue.n > s.j.c)
+        queue.n = s.j.c;
+      insertIntoHeap(s.j, queue);
     }
-    return node;
-  }
-  if (node.f) {
-    if (node.f !== ActiveTransition) {
-      mergeTransitions(node.f, ActiveTransition);
-      ActiveTransition = node.f;
+  } else if (el.c != oldHeight) {
+    for (let s = el.r; s !== null; s = s.y) {
+      insertIntoHeapHeight(s.j, s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
     }
-    return node.f.b.get(node);
   }
-  const clone = Object.create(Object.getPrototypeOf(node));
-  Object.assign(clone, node, {
-    o: null,
-    n: null,
-    c: null,
-    b: node.b ? [...node.b] : null,
-    d: node
-  });
-  delete clone.T;
-  ActiveTransition.b.set(node, clone);
-  node.f = ActiveTransition;
-  if (node.b) {
-    for (let i = 0; i < node.b.length; i++)
-      node.b[i].c.push(clone);
-  }
-  if (node.c) {
-    clone.c = [];
-    for (let i = 0, length = node.c.length; i < length; i++) {
-      !node.c[i].d && clone.c.push(cloneGraph(node.c[i]));
-    }
-  }
-  return clone;
-}
-function latestTransition(t) {
-  while (t.D instanceof Transition)
-    t = t.D;
-  return t;
-}
-function replaceSourceObservers(node, transition2) {
-  let source;
-  let transitionSource;
-  let swap;
-  for (let i = 0; i < node.b.length; i++) {
-    transitionSource = transition2.b.get(node.b[i]);
-    source = transitionSource || node.b[i];
-    if (source.c && (swap = source.c.indexOf(node)) !== -1) {
-      source.c[swap] = transitionSource ? node.d : source.c[source.c.length - 1];
-      !transitionSource && source.c.pop();
-    }
-  }
-}
-function cloneQueue(queue, parent, transition2) {
-  const clone = Object.create(Object.getPrototypeOf(queue));
-  Object.assign(clone, queue, {
-    d: queue,
-    l: parent,
-    i: [],
-    enqueue(type, fn) {
-      transition2 = latestTransition(transition2);
-      transition2.enqueue(type, fn);
-    },
-    notify(node, type, flags) {
-      node = node.d || node;
-      if (!clone.L || type & LOADING_BIT) {
-        type &= ~LOADING_BIT;
-        transition2 = latestTransition(transition2);
-        transition2.notify(node, LOADING_BIT, flags);
-        if (!type)
-          return true;
+}
+function updateIfNecessary(el) {
+  if (el.b & 1 /* Check */) {
+    for (let d = el.u; d; d = d.E) {
+      const dep1 = d.Q;
+      const dep = "_owner" in dep1 ? dep1.z : dep1;
+      if ("_fn" in dep) {
+        updateIfNecessary(dep);
+      }
+      if (el.b & 2 /* Dirty */) {
+        break;
       }
-      return queue.notify.call(this, node, type, flags);
-    }
-  });
-  parent.i.push(clone);
-  transition2.J.set(queue, clone);
-  for (const child of queue.i) {
-    cloneQueue(child, clone, transition2);
-  }
-}
-function resolveQueues(children) {
-  for (const child of children) {
-    const og = child.d;
-    if (og) {
-      const clonedChildren = child.i;
-      delete child.enqueue;
-      delete child.notify;
-      delete child.l;
-      delete child.i;
-      Object.assign(og, child);
-      delete og.d;
-      resolveQueues(clonedChildren);
-    } else if (child.l.d) {
-      child.l.d.addChild(child);
-    }
-  }
-}
-function mergeTransitions(t1, t2) {
-  t2.b.forEach((value, key) => {
-    key.f = t1;
-    t1.b.set(key, value);
-  });
-  t2.j.forEach((c) => {
-    c.f = t1;
-    t1.j.add(c);
-  });
-  t2.K.forEach((p) => t1.K.add(p));
-  t2.t.forEach((n) => t1.t.add(n));
-  t1.merge(t2);
-  t2.D = t1;
-}
-function getTransitionSource(input) {
-  return ActiveTransition && ActiveTransition.b.get(input) || input;
-}
-function getQueue(node) {
-  const transition2 = ActiveTransition || node.d?.f;
-  return transition2 && transition2.J.get(node.E) || node.E;
-}
-function initialDispose(node) {
-  let current = node.n;
-  while (current !== null && current.l === node) {
-    initialDispose(current);
-    const clone = ActiveTransition.b.get(current);
-    if (clone && !clone.Z)
-      clone.dispose(true);
-    current = current.n;
-  }
-}
-function finishTransition(transition2) {
-  if (transition2.D || transition2.Y || transition2.K.size || transition2.t.size)
-    return;
-  globalQueue.h[0].push.apply(globalQueue.h[0], transition2.h[0]);
-  globalQueue.h[1].push.apply(globalQueue.h[1], transition2.h[1]);
-  resolveQueues(transition2.i);
-  for (const [source, clone] of transition2.b) {
-    if (source === clone || source.f !== transition2) {
-      delete source.f;
-      continue;
-    }
-    if (clone.b)
-      replaceSourceObservers(clone, transition2);
-    if (clone.Z || clone.a === STATE_DISPOSED) {
-      source.dispose(clone.a === STATE_DISPOSED);
-      source.emptyDisposal();
-      delete clone.Z;
-    } else {
-      delete clone.n;
-      delete clone.o;
-    }
-    Object.assign(source, clone);
-    delete source.d;
-    let current = clone.n;
-    if (current?.z === clone)
-      current.z = source;
-    while (current?.l === clone) {
-      current.l = source;
-      current = current.n;
     }
-    delete source.f;
   }
-  transition2.D = true;
-  for (const reset of transition2.j) {
-    delete reset.f;
-    reset();
+  if (el.b & 2 /* Dirty */) {
+    recompute(el);
   }
-  transition2.aa.write(true);
-  globalQueue.flush();
+  el.b = 0 /* None */;
 }
-
-// src/core/owner.ts
-var currentOwner = null;
-var defaultContext = {};
-function getOwner() {
-  return currentOwner;
-}
-function setOwner(owner) {
-  const out = currentOwner;
-  currentOwner = owner;
-  return out;
-}
-var Owner = class {
-  // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
-  // However, the children are actually added in reverse creation order
-  // See comment at the top of the file for an example of the _nextSibling traversal
-  l = null;
-  n = null;
-  z = null;
-  a = STATE_CLEAN;
-  o = null;
-  A = defaultContext;
-  E = globalQueue;
-  ga = 0;
-  id = null;
-  constructor(id = null, skipAppend = false) {
-    this.id = id;
-    if (currentOwner) {
-      !skipAppend && currentOwner.append(this);
-    }
-  }
-  append(child) {
-    child.l = this;
-    child.z = this;
-    if (this.n)
-      this.n.z = child;
-    child.n = this.n;
-    this.n = child;
-    if (this.id != null && child.id == null)
-      child.id = this.getNextChildId();
-    if (child.A !== this.A) {
-      child.A = { ...this.A, ...child.A };
-    }
-    if (this.E)
-      child.E = this.E;
-  }
-  dispose(self = true) {
-    if (this.a === STATE_DISPOSED)
-      return;
-    let head = self ? this.z || this.l : this, current = this.n, next = null;
-    while (current && current.l === this) {
-      current.dispose(true);
-      next = current.n;
-      current.n = null;
-      current = next;
-    }
-    this.ga = 0;
-    if (self)
-      this.M();
-    if (current)
-      current.z = !self ? this : this.z;
-    if (head)
-      head.n = current;
-  }
-  M() {
-    if (this.z)
-      this.z.n = null;
-    this.l = null;
-    this.z = null;
-    this.A = defaultContext;
-    this.a = STATE_DISPOSED;
-    this.emptyDisposal();
-  }
-  emptyDisposal() {
-    if (!this.o)
+function unlinkSubs(link2) {
+  const dep = link2.Q;
+  const nextDep = link2.E;
+  const nextSub = link2.y;
+  const prevSub = link2.na;
+  if (nextSub !== null) {
+    nextSub.na = prevSub;
+  } else {
+    dep.X = prevSub;
+  }
+  if (prevSub !== null) {
+    prevSub.y = nextSub;
+  } else {
+    dep.r = nextSub;
+  }
+  return nextDep;
+}
+function link(dep, sub) {
+  const prevDep = sub.H;
+  if (prevDep !== null && prevDep.Q === dep) {
+    return;
+  }
+  let nextDep = null;
+  const isRecomputing = sub.b & 4 /* RecomputingDeps */;
+  if (isRecomputing) {
+    nextDep = prevDep !== null ? prevDep.E : sub.u;
+    if (nextDep !== null && nextDep.Q === dep) {
+      sub.H = nextDep;
       return;
-    if (Array.isArray(this.o)) {
-      for (let i = 0; i < this.o.length; i++) {
-        const callable = this.o[i];
-        callable.call(callable);
-      }
-    } else {
-      this.o.call(this.o);
     }
-    this.o = null;
   }
-  getNextChildId() {
-    if (this.id != null)
-      return formatId(this.id, this.ga++);
-    throw new Error("Cannot get child id from owner without an id");
+  const prevSub = dep.X;
+  if (prevSub !== null && prevSub.j === sub && (!isRecomputing || isValidLink(prevSub, sub))) {
+    return;
   }
-};
-function createContext(defaultValue, description) {
-  return { id: Symbol(description), defaultValue };
-}
-function getContext(context, owner = currentOwner) {
-  if (!owner) {
-    throw new NoOwnerError();
+  const newLink = sub.H = dep.X = {
+    Q: dep,
+    j: sub,
+    E: nextDep,
+    na: prevSub,
+    y: null
+  };
+  if (prevDep !== null) {
+    prevDep.E = newLink;
+  } else {
+    sub.u = newLink;
   }
-  const value = hasContext(context, owner) ? owner.A[context.id] : context.defaultValue;
-  if (isUndefined(value)) {
-    throw new ContextNotFoundError();
+  if (prevSub !== null) {
+    prevSub.y = newLink;
+  } else {
+    dep.r = newLink;
   }
-  return value;
 }
-function setContext(context, value, owner = currentOwner) {
-  if (!owner) {
-    throw new NoOwnerError();
+function isValidLink(checkLink, sub) {
+  const depsTail = sub.H;
+  if (depsTail !== null) {
+    let link2 = sub.u;
+    do {
+      if (link2 === checkLink) {
+        return true;
+      }
+      if (link2 === depsTail) {
+        break;
+      }
+      link2 = link2.E;
+    } while (link2 !== null);
   }
-  owner.A = {
-    ...owner.A,
-    [context.id]: isUndefined(value) ? context.defaultValue : value
-  };
+  return false;
 }
-function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?.A[context.id]);
+function setStatusFlags(signal2, flags, error = null) {
+  signal2.f = flags;
+  signal2.B = error;
 }
-function onCleanup(fn) {
-  if (!currentOwner)
-    return fn;
-  const node = currentOwner;
-  if (!node.o) {
-    node.o = fn;
-  } else if (Array.isArray(node.o)) {
-    node.o.push(fn);
+function setError(signal2, error) {
+  setStatusFlags(signal2, 2 /* Error */ | 4 /* Uninitialized */, error);
+}
+function clearStatusFlags(signal2) {
+  setStatusFlags(signal2, 0 /* None */);
+}
+function markDisposal(el) {
+  let child = el.o;
+  while (child) {
+    child.b |= 32 /* Zombie */;
+    const inHeap = child.b & 8 /* InHeap */;
+    if (inHeap) {
+      deleteFromHeap(child, dirtyQueue);
+      insertIntoHeap(child, zombieQueue);
+    }
+    markDisposal(child);
+    child = child.K;
+  }
+}
+function disposeChildren(node, self = false, zombie) {
+  if (node.b & 64 /* Disposed */)
+    return;
+  if (self)
+    node.b = 64 /* Disposed */;
+  let child = zombie ? node.U : node.o;
+  while (child) {
+    const nextChild = child.K;
+    if (child.u) {
+      const n = child;
+      deleteFromHeap(n, n.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+      let toRemove = n.u;
+      do {
+        toRemove = unlinkSubs(toRemove);
+      } while (toRemove !== null);
+      n.u = null;
+      n.H = null;
+    }
+    disposeChildren(child, true);
+    child = nextChild;
+  }
+  if (zombie) {
+    node.U = null;
   } else {
-    node.o = [node.o, fn];
+    node.o = null;
+    node.K = null;
   }
-  return fn;
+  runDisposal(node, zombie);
+}
+function runDisposal(node, zombie) {
+  let disposal = zombie ? node.V : node.s;
+  if (!disposal)
+    return;
+  if (Array.isArray(disposal)) {
+    for (let i = 0; i < disposal.length; i++) {
+      const callable = disposal[i];
+      callable.call(callable);
+    }
+  } else {
+    disposal.call(disposal);
+  }
+  zombie ? node.V = null : node.s = null;
+}
+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);
+  return obj;
+}
+function getNextChildId(owner) {
+  if (owner.id != null)
+    return formatId(owner.id, owner.oa++);
+  throw new Error("Cannot get child id from owner without an id");
 }
 function formatId(prefix, id) {
   const num = id.toString(36), len = num.length - 1;
   return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
 }
-function isUndefined(value) {
-  return typeof value === "undefined";
-}
-
-// src/core/core.ts
-var currentObserver = null;
-var currentMask = DEFAULT_FLAGS;
-var newSources = null;
-var newSourcesIndex = 0;
-var newFlags = 0;
-var notStale = false;
-var updateCheck = null;
-var staleCheck = null;
-function getObserver() {
-  return currentObserver;
+function computed(fn, initialValue, options) {
+  const self = withOptions(
+    {
+      s: null,
+      i: globalQueue,
+      D: defaultContext,
+      oa: 0,
+      ha: fn,
+      g: initialValue,
+      c: 0,
+      ba: null,
+      P: void 0,
+      x: null,
+      u: null,
+      H: null,
+      r: null,
+      X: null,
+      q: context,
+      K: null,
+      o: null,
+      b: 0 /* None */,
+      f: 4 /* Uninitialized */,
+      W: clock,
+      e: NOT_PENDING,
+      V: null,
+      U: null
+    },
+    options
+  );
+  self.x = self;
+  const parent = context?._ ? context.$ : context;
+  if (context) {
+    context.i && (self.i = context.i);
+    context.D && (self.D = context.D);
+    const lastChild = context.o;
+    if (lastChild === null) {
+      context.o = self;
+    } else {
+      self.K = lastChild;
+      context.o = self;
+    }
+  }
+  if (parent)
+    self.c = parent.c + 1;
+  recompute(self, true);
+  return self;
 }
-var UNCHANGED = Symbol(0);
-var Computation = class extends Owner {
-  b = null;
-  c = null;
-  m;
-  O;
-  P;
-  // Used in __DEV__ mode, hopefully removed in production
-  na;
-  // Using false is an optimization as an alternative to _equals: () => false
-  // which could enable more efficient DIRTY notification
-  ba = isEqual;
-  fa;
-  ja = false;
-  /** Whether the computation is an error or has ancestors that are unresolved */
-  g = 0;
-  /** Which flags raised by sources are handled, vs. being passed through. */
-  ca = DEFAULT_FLAGS;
-  Q = -1;
-  H = false;
-  f;
-  d;
-  j;
-  constructor(initialValue, compute2, options) {
-    super(options?.id, compute2 === null);
-    this.P = compute2;
-    this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this.g = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
-    this.m = initialValue;
-    if (options?.equals !== void 0)
-      this.ba = options.equals;
-    this.ja = !!options?.pureWrite;
-    this.fa = options?.unobserved;
-    if (ActiveTransition) {
-      this.f = ActiveTransition;
-      ActiveTransition.b.set(this, this);
-    }
-  }
-  ha() {
-    if (staleCheck && (this.g & LOADING_BIT || this.f)) {
-      staleCheck.m = true;
-      this.f?.aa.read();
-    }
-    track(this);
-    newFlags |= this.g & ~currentMask;
-    if (this.g & ERROR_BIT) {
-      throw this.O;
+function asyncComputed(asyncFn, initialValue, options) {
+  let lastResult = void 0;
+  let refreshing = false;
+  const fn = (prev) => {
+    const result = asyncFn(prev, refreshing);
+    refreshing = false;
+    lastResult = result;
+    const isPromise = result instanceof Promise;
+    const iterator = result[Symbol.asyncIterator];
+    if (!isPromise && !iterator) {
+      return result;
+    }
+    if (isPromise) {
+      result.then((v) => {
+        if (lastResult !== result)
+          return;
+        globalQueue.initTransition(self);
+        setSignal(self, () => v);
+        flush();
+      }).catch((e) => {
+        if (lastResult !== result)
+          return;
+        globalQueue.initTransition(self);
+        setError(self, e);
+        flush();
+      });
     } else {
-      return this.m;
-    }
-  }
-  /**
-   * Return the current value of this computation
-   * Automatically re-executes the surrounding computation when the value changes
-   */
-  read() {
-    if (ActiveTransition && (ActiveTransition.b.has(this) || !this.d && this.g & (UNINITIALIZED_BIT | ERROR_BIT))) {
-      const clone = ActiveTransition.b.get(this) || cloneGraph(this);
-      if (clone !== this)
-        return clone.read();
-    }
-    if (this.P) {
-      if (this.g & ERROR_BIT && this.Q <= clock)
-        update(this);
-      else
-        this.F();
-    }
-    return this.ha();
-  }
-  /**
-   * Return the current value of this computation
-   * Automatically re-executes the surrounding computation when the value changes
-   *
-   * If the computation has any unresolved ancestors, this function waits for the value to resolve
-   * before continuing
-   */
-  wait() {
-    if (ActiveTransition && (ActiveTransition.b.has(this) || !this.d && this.g & (UNINITIALIZED_BIT | ERROR_BIT))) {
-      const clone = ActiveTransition.b.get(this) || cloneGraph(this);
-      if (clone !== this)
-        return clone.wait();
-    }
-    if (this.P) {
-      if (this.g & ERROR_BIT && this.Q <= clock)
-        update(this);
-      else
-        this.F();
-    }
-    if ((notStale || this.g & UNINITIALIZED_BIT) && this.g & LOADING_BIT) {
-      throw new NotReadyError(this);
-    }
-    return this.ha();
-  }
-  /** Update the computation with a new value. */
-  write(value, flags = 0, raw = false) {
-    if (ActiveTransition && !this.d) {
-      const clone = cloneGraph(this);
-      if (clone !== this)
-        return clone.write(value, flags, raw);
-    }
-    const newValue = !raw && typeof value === "function" ? value(this.m) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this.g & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
-    this.ba === false || !this.ba(this.m, newValue));
-    if (valueChanged) {
-      this.m = newValue;
-      this.O = void 0;
-    }
-    const changedFlagsMask = this.g ^ flags, changedFlags = changedFlagsMask & flags;
-    this.g = flags;
-    this.Q = clock + 1;
-    if (this.c && !(this.j && ActiveTransition)) {
-      for (let i = 0; i < this.c.length; i++) {
-        if (valueChanged) {
-          this.c[i].u(STATE_DIRTY);
-        } else if (changedFlagsMask) {
-          this.c[i]._(changedFlagsMask, changedFlags);
+      (async () => {
+        try {
+          for await (let value of result) {
+            if (lastResult !== result)
+              return;
+            globalQueue.initTransition(self);
+            setSignal(self, () => value);
+            flush();
+          }
+        } catch (error) {
+          if (lastResult !== result)
+            return;
+          globalQueue.initTransition(self);
+          setError(self, error);
+          flush();
         }
-      }
+      })();
     }
-    return this.m;
+    globalQueue.initTransition(context);
+    throw new NotReadyError(context);
+  };
+  const self = computed(fn, initialValue, options);
+  self.ta = () => {
+    refreshing = true;
+    recompute(self);
+    flush();
+  };
+  return self;
+}
+function signal(v, options, firewall = null) {
+  if (firewall !== null) {
+    return firewall.ba = withOptions(
+      {
+        g: v,
+        r: null,
+        X: null,
+        z: firewall,
+        ra: firewall.ba,
+        f: 0 /* None */,
+        W: clock,
+        e: NOT_PENDING
+      },
+      options
+    );
+  } else {
+    return withOptions(
+      {
+        g: v,
+        r: null,
+        X: null,
+        f: 0 /* None */,
+        W: clock,
+        e: NOT_PENDING
+      },
+      options
+    );
   }
-  /**
-   * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
-   */
-  u(state, skipQueue) {
-    if (this.a >= state && !this.H)
-      return;
-    this.H = !!skipQueue;
-    this.a = state;
-    if (this.c && !(this.j && ActiveTransition)) {
-      for (let i = 0; i < this.c.length; i++) {
-        this.c[i].u(STATE_CHECK, skipQueue);
+}
+function isEqual(a, b) {
+  return a === b;
+}
+function untrack(fn) {
+  if (!tracking)
+    return fn();
+  tracking = false;
+  try {
+    return fn();
+  } finally {
+    tracking = true;
+  }
+}
+function read(el) {
+  let c = context;
+  if (c?._)
+    c = c.$;
+  if (c && tracking) {
+    link(el, c);
+    const owner = "_owner" in el ? el.z : el;
+    if ("_fn" in owner) {
+      const isZombie = el.b & 32 /* Zombie */;
+      if (owner.c >= (isZombie ? zombieQueue.n : dirtyQueue.n)) {
+        markNode(c);
+        markHeap(isZombie ? zombieQueue : dirtyQueue);
+        updateIfNecessary(owner);
       }
-    }
-  }
-  /**
-   * Notify the computation that one of its sources has changed flags.
-   *
-   * @param mask A bitmask for which flag(s) were changed.
-   * @param newFlags The source's new flags, masked to just the changed ones.
-   */
-  _(mask, newFlags2) {
-    if (this.a >= STATE_DIRTY)
-      return;
-    if (mask & this.ca || this.j && ActiveTransition) {
-      this.u(STATE_DIRTY);
-      return;
-    }
-    if (this.a >= STATE_CHECK && !this.H)
-      return;
-    const prevFlags = this.g & mask;
-    const deltaFlags = prevFlags ^ newFlags2;
-    if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this.u(STATE_CHECK);
-    } else {
-      this.g ^= deltaFlags;
-      if (this.c) {
-        for (let i = 0; i < this.c.length; i++) {
-          this.c[i]._(mask, newFlags2);
-        }
+      const height = owner.c;
+      if (height >= c.c && el.q !== c) {
+        c.c = height + 1;
       }
     }
   }
-  N(error) {
-    if (ActiveTransition && !this.d) {
-      const clone = cloneGraph(this);
-      if (clone !== this)
-        return clone.N(error);
-    }
-    this.O = error;
-    this.write(UNCHANGED, this.g & ~LOADING_BIT | ERROR_BIT | UNINITIALIZED_BIT);
-  }
-  /**
-   * This is the core part of the reactivity system, which makes sure that the values are updated
-   * before they are read. We've also adapted it to return the loading state of the computation,
-   * so that we can propagate that to the computation's observers.
-   *
-   * This function will ensure that the value and states we read from the computation are up to date
-   */
-  F() {
-    if (!this.P) {
-      return;
+  if (pendingCheck) {
+    const pendingResult = (el.f & 1 /* Pending */) !== 0 || !!el.T || false;
+    if (!el.G) {
+      el.G = signal(pendingResult);
+      el.G.ia = true;
+      el.G.da = (v) => setSignal(el.G, v);
     }
-    if (this.a === STATE_DISPOSED) {
-      return;
+    const prev = pendingCheck;
+    pendingCheck = null;
+    read(el.G);
+    pendingCheck = prev;
+    prev.g = pendingResult || prev.g;
+  }
+  if (pendingValueCheck) {
+    if (!el.C) {
+      el.C = signal(
+        el.e === NOT_PENDING ? el.g : el.e
+      );
+      el.C.ia = true;
+      el.C.da = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el.C, v)));
     }
-    if (this.a === STATE_CLEAN) {
-      return;
+    pendingValueCheck = false;
+    try {
+      return read(el.C);
+    } finally {
+      pendingValueCheck = true;
     }
-    let observerFlags = 0;
-    if (this.a === STATE_CHECK) {
-      for (let i = 0; i < this.b.length; i++) {
-        const source = getTransitionSource(this.b[i]);
-        source.F();
-        observerFlags |= source.g & ~UNINITIALIZED_BIT;
-        if (this.a === STATE_DIRTY) {
-          break;
-        }
-      }
+  }
+  if (el.f & 1 /* Pending */) {
+    if (c && !stale || el.f & 4 /* Uninitialized */)
+      throw el.B;
+    else if (c && stale && !pendingCheck) {
+      setStatusFlags(
+        c,
+        c.f | 1,
+        el.B
+      );
     }
-    if (this.a === STATE_DIRTY) {
-      update(this);
+  }
+  if (el.f & 2 /* Error */) {
+    if (el.W < clock) {
+      recompute(el, true);
+      return read(el);
     } else {
-      this.write(UNCHANGED, observerFlags);
-      this.a = STATE_CLEAN;
+      throw el.B;
     }
   }
-  /**
-   * Remove ourselves from the owner graph and the computation graph
-   */
-  M() {
-    if (this.a === STATE_DISPOSED)
-      return;
-    if (this.b)
-      removeSourceObservers(this, 0);
-    super.M();
+  return !c || el.e === NOT_PENDING || stale && !pendingCheck && el.T && activeTransition !== el.T ? el.g : el.e;
+}
+function setSignal(el, v) {
+  if (typeof v === "function") {
+    v = v(
+      el.e === NOT_PENDING ? el.g : el.e
+    );
   }
-};
-function track(computation) {
-  if (ActiveTransition && computation.d)
-    computation = computation.d;
-  if (currentObserver) {
-    if (!newSources && currentObserver.b && currentObserver.b[newSourcesIndex] === computation) {
-      newSourcesIndex++;
-    } else if (!newSources)
-      newSources = [computation];
-    else if (computation !== newSources[newSources.length - 1]) {
-      newSources.push(computation);
-    }
-    if (updateCheck) {
-      updateCheck.m = computation.Q > currentObserver.Q;
-    }
-  }
-}
-function update(node) {
-  const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
-  newSources = null;
-  newSourcesIndex = 0;
-  newFlags = 0;
-  try {
-    if (ActiveTransition && node.d && !node.Z) {
-      initialDispose(node.d);
-      node.Z = true;
-    }
-    node.dispose(false);
-    node.emptyDisposal();
-    const result = compute(node, node.P, node);
-    node.write(result, newFlags, true);
-  } catch (error) {
-    if (error instanceof NotReadyError) {
-      if (error.cause !== node)
-        compute(
-          node,
-          () => track(error.cause),
-          node
-        );
-      node.write(UNCHANGED, newFlags | LOADING_BIT | node.g & UNINITIALIZED_BIT);
-    } else {
-      node.N(error);
+  const valueChanged = !el.ea || !el.ea(el.e === NOT_PENDING ? el.g : el.e, v);
+  if (!valueChanged && !el.f)
+    return v;
+  if (valueChanged) {
+    if (el.ia)
+      el.g = v;
+    else {
+      if (el.e === NOT_PENDING)
+        globalQueue.h.push(el);
+      el.e = v;
+    }
+    if (el.C)
+      el.C.da(v);
+  }
+  clearStatusFlags(el);
+  el.W = clock;
+  for (let s = el.r; s !== null; s = s.y) {
+    const queue = s.j.b & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+    if (queue.n > s.j.c)
+      queue.n = s.j.c;
+    insertIntoHeap(s.j, queue);
+  }
+  schedule();
+  return v;
+}
+function getObserver() {
+  return tracking ? context : null;
+}
+function getOwner() {
+  return context;
+}
+function onCleanup(fn) {
+  if (!context)
+    return fn;
+  const node = context;
+  if (!node.s) {
+    node.s = fn;
+  } else if (Array.isArray(node.s)) {
+    node.s.push(fn);
+  } else {
+    node.s = [node.s, fn];
+  }
+  return fn;
+}
+function createOwner(options) {
+  const parent = context;
+  const owner = {
+    _: true,
+    $: parent?._ ? parent.$ : parent,
+    o: null,
+    K: null,
+    s: null,
+    id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : void 0),
+    i: parent?.i ?? globalQueue,
+    D: parent?.D || defaultContext,
+    oa: 0,
+    V: null,
+    U: null,
+    q: parent,
+    dispose(self = true) {
+      disposeChildren(owner, self);
     }
-  } finally {
-    if (newSources) {
-      if (node.b)
-        removeSourceObservers(node, newSourcesIndex);
-      if (node.b && newSourcesIndex > 0) {
-        node.b.length = newSourcesIndex + newSources.length;
-        for (let i = 0; i < newSources.length; i++) {
-          node.b[newSourcesIndex + i] = newSources[i];
-        }
-      } else {
-        node.b = newSources;
-      }
-      let source;
-      for (let i = newSourcesIndex; i < node.b.length; i++) {
-        source = getTransitionSource(node.b[i]);
-        if (!source.c)
-          source.c = [node];
-        else
-          source.c.push(node);
-      }
-    } else if (node.b && newSourcesIndex < node.b.length) {
-      removeSourceObservers(node, newSourcesIndex);
-      node.b.length = newSourcesIndex;
+  };
+  if (parent) {
+    const lastChild = parent.o;
+    if (lastChild === null) {
+      parent.o = owner;
+    } else {
+      owner.K = lastChild;
+      parent.o = owner;
     }
-    newSources = prevSources;
-    newSourcesIndex = prevSourcesIndex;
-    newFlags = prevFlags;
-    node.Q = clock + 1;
-    node.a = STATE_CLEAN;
   }
+  return owner;
 }
-function isEqual(a, b) {
-  return a === b;
+function createRoot(init, options) {
+  const owner = createOwner(options);
+  return runWithOwner(owner, () => init(owner.dispose));
 }
-function untrack(fn) {
-  if (currentObserver === null)
+function runWithOwner(owner, fn) {
+  const oldContext = context;
+  context = owner;
+  try {
+    return fn();
+  } finally {
+    context = oldContext;
+  }
+}
+function staleValues(fn, set = true) {
+  const prevStale = stale;
+  stale = set;
+  try {
     return fn();
-  return compute(getOwner(), fn, null);
+  } finally {
+    stale = prevStale;
+  }
 }
-function hasUpdated(fn) {
-  const current = updateCheck;
-  updateCheck = { m: false };
+function pending(fn) {
+  const prevLatest = pendingValueCheck;
+  pendingValueCheck = true;
   try {
-    fn();
-    return updateCheck.m;
+    return staleValues(fn, false);
   } finally {
-    updateCheck = current;
+    pendingValueCheck = prevLatest;
   }
 }
-function pendingCheck(fn, loadingValue) {
-  const current = staleCheck;
-  staleCheck = { m: false };
+function isPending(fn, loadingValue) {
+  const current = pendingCheck;
+  pendingCheck = { g: false };
   try {
-    latest(fn);
-    return staleCheck.m;
+    staleValues(fn);
+    return pendingCheck.g;
   } catch (err) {
     if (!(err instanceof NotReadyError))
       return false;
@@ -964,413 +927,161 @@ function pendingCheck(fn, loadingValue) {
       return loadingValue;
     throw err;
   } finally {
-    staleCheck = current;
+    pendingCheck = current;
   }
 }
-function isPending(fn, loadingValue) {
-  if (!currentObserver)
-    return pendingCheck(fn, loadingValue);
-  const c = new Computation(void 0, () => pendingCheck(fn, loadingValue));
-  c.j = () => c.write(false);
-  c.j.ia = () => globalQueue.enqueue(0, () => c.j.f && c.write(true));
-  c.ca |= LOADING_BIT;
-  const res = c.wait();
-  c.o = () => {
-    if (c.j.f) {
-      c.j.f.j.delete(c.j);
-      delete c.j.f;
-    }
-  };
-  return res;
+
+// src/core/context.ts
+function createContext(defaultValue, description) {
+  return { id: Symbol(description), defaultValue };
 }
-function latest(fn, fallback) {
-  const argLength = arguments.length;
-  const prevFlags = newFlags;
-  const prevNotStale = notStale;
-  notStale = false;
-  try {
-    return fn();
-  } catch (err) {
-    if (argLength > 1 && err instanceof NotReadyError)
-      return fallback;
-    throw err;
-  } finally {
-    newFlags = prevFlags;
-    notStale = prevNotStale;
+function getContext(context2, owner = getOwner()) {
+  if (!owner) {
+    throw new NoOwnerError();
   }
+  const value = hasContext(context2, owner) ? owner.D[context2.id] : context2.defaultValue;
+  if (isUndefined(value)) {
+    throw new ContextNotFoundError();
+  }
+  return value;
 }
-function compute(owner, fn, observer) {
-  const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
-  currentObserver = observer;
-  currentMask = observer?.ca ?? DEFAULT_FLAGS;
-  notStale = true;
-  try {
-    return fn.call(observer, observer ? observer.m : void 0);
-  } finally {
-    setOwner(prevOwner);
-    currentObserver = prevObserver;
-    currentMask = prevMask;
-    notStale = prevNotStale;
+function setContext(context2, value, owner = getOwner()) {
+  if (!owner) {
+    throw new NoOwnerError();
   }
+  owner.D = {
+    ...owner.D,
+    [context2.id]: isUndefined(value) ? context2.defaultValue : value
+  };
+}
+function hasContext(context2, owner) {
+  return !isUndefined(owner?.D[context2.id]);
+}
+function isUndefined(value) {
+  return typeof value === "undefined";
 }
 
 // src/core/effect.ts
-var Effect = class extends Computation {
-  da;
-  $;
-  w;
-  ea = false;
-  T;
-  s;
-  constructor(initialValue, compute2, effect, error, options) {
-    super(initialValue, compute2, options);
-    this.da = effect;
-    this.$ = error;
-    this.T = initialValue;
-    this.s = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this.s === EFFECT_RENDER) {
-      this.P = function(p) {
-        return !this.d && clock > this.E.created && !(this.g & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
-      };
-    }
-    this.F();
-    !options?.defer && (this.s === EFFECT_USER ? getQueue(this).enqueue(this.s, this.x.bind(this)) : this.x(this.s));
-  }
-  write(value, flags = 0) {
-    if (this.a == STATE_DIRTY) {
-      this.g = flags;
-      if (this.s === EFFECT_RENDER) {
-        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.g);
-      }
-    }
-    if (value === UNCHANGED)
-      return this.m;
-    this.m = value;
-    this.ea = true;
-    this.O = void 0;
-    return value;
-  }
-  u(state, skipQueue) {
-    if (this.a >= state || skipQueue)
-      return;
-    if (this.a === STATE_CLEAN || this.d && !ActiveTransition)
-      getQueue(this).enqueue(this.s, this.x.bind(this));
-    this.a = state;
-  }
-  _(mask, newFlags2) {
-    if (this.d) {
-      if (this.a >= STATE_DIRTY)
-        return;
-      if (mask & 3) {
-        this.u(STATE_DIRTY);
-        return;
-      }
-    }
-    super._(mask, newFlags2);
-  }
-  N(error) {
-    this.O = error;
-    getQueue(this).notify(this, LOADING_BIT, 0);
-    this.g = ERROR_BIT;
-    if (this.s === EFFECT_USER) {
-      try {
-        return this.$ ? this.$(error, () => {
-          this.w?.();
-          this.w = void 0;
-        }) : console.error(error);
-      } catch (e) {
-        error = e;
-      }
-    }
-    if (!getQueue(this).notify(this, ERROR_BIT, ERROR_BIT))
-      throw error;
-  }
-  M() {
-    if (this.a === STATE_DISPOSED)
-      return;
-    this.da = void 0;
-    this.T = void 0;
-    this.$ = void 0;
-    this.w?.();
-    this.w = void 0;
-    getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
-    super.M();
-  }
-  x(type) {
-    if (type) {
-      const effect = this.d || this;
-      if (effect.ea && effect.a !== STATE_DISPOSED) {
-        effect.w?.();
-        try {
-          effect.w = effect.da(effect.m, effect.T);
-        } catch (e) {
-          if (!getQueue(effect).notify(effect, ERROR_BIT, ERROR_BIT))
-            throw e;
-        } finally {
-          effect.T = effect.m;
-          effect.ea = false;
+function effect(compute, effect2, error, initialValue, options) {
+  let initialized = false;
+  const node = computed(compute, initialValue, {
+    ...options,
+    ja: {
+      fa: true,
+      pa: initialValue,
+      ua: effect2,
+      qa: error,
+      L: void 0,
+      i: getOwner()?.i ?? globalQueue,
+      I: options?.render ? 1 /* Render */ : 2 /* User */,
+      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.i.enqueue(this.I, runEffect.bind(this));
+        }
+        if (this.f & 2 /* Error */) {
+          let error2 = this.B;
+          this.i.notify(this, 1 /* Pending */, 0);
+          if (this.I === 2 /* User */) {
+            try {
+              return this.qa ? this.qa(error2, () => {
+                this.L?.();
+                this.L = void 0;
+              }) : console.error(error2);
+            } catch (e) {
+              error2 = e;
+            }
+          }
+          if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
+            throw error2;
+        } else if (this.I === 1 /* Render */) {
+          this.i.notify(
+            this,
+            1 /* Pending */ | 2 /* Error */,
+            this.f
+          );
         }
       }
-    } else
-      this.a !== STATE_CLEAN && runTop(this);
-  }
-};
-var TrackedEffect = class extends Computation {
-  s = EFFECT_USER;
-  w;
-  constructor(compute2, options) {
-    super(
-      void 0,
-      () => {
-        this.w?.();
-        this.w = latest(compute2);
-        return void 0;
-      },
-      options
-    );
-    getQueue(this).enqueue(this.s, this.x.bind(this));
-  }
-  u(state, skipQueue) {
-    if (this.a >= state || skipQueue)
-      return;
-    if (this.a === STATE_CLEAN || this.d && !ActiveTransition)
-      getQueue(this).enqueue(this.s, this.x.bind(this));
-    this.a = state;
-  }
-  M() {
-    if (this.a === STATE_DISPOSED)
-      return;
-    this.w?.();
-    this.w = void 0;
-    getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
-    super.M();
-  }
-  x(type) {
-    if (type)
-      this.a !== STATE_CLEAN && runTop(this);
-  }
-};
-var EagerComputation = class extends Computation {
-  constructor(initialValue, compute2, options) {
-    super(initialValue, compute2, options);
-    !options?.defer && this.F();
-  }
-  u(state, skipQueue) {
-    if (this.a >= state && !this.H)
-      return;
-    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.H))
-      getQueue(this).enqueue(EFFECT_PURE, this.x.bind(this));
-    super.u(state, skipQueue);
-  }
-  x() {
-    this.a !== STATE_CLEAN && runTop(this);
-  }
-};
-var FirewallComputation = class extends Computation {
-  firewall = true;
-  constructor(compute2) {
-    super(void 0, compute2);
-  }
-  u(state, skipQueue) {
-    if (this.a >= state && !this.H)
-      return;
-    if (!skipQueue && (this.a === STATE_CLEAN || this.a === STATE_CHECK && this.H))
-      getQueue(this).enqueue(EFFECT_PURE, this.x.bind(this));
-    super.u(state, true);
-    this.H = !!skipQueue;
-  }
-  x() {
-    const prevFlags = this.g;
-    this.a !== STATE_CLEAN && runTop(this);
-    if (ActiveTransition && this.j && (this.g !== prevFlags || this.g !== this.j.flags)) {
-      getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this.g);
-      this.j.flags = this.g;
-      this.g = prevFlags;
-    }
-  }
-};
-function runTop(node) {
-  const ancestors = [];
-  for (let current = node; current !== null; current = current.l) {
-    if (ActiveTransition && current.f)
-      current = ActiveTransition.b.get(current);
-    if (current.a !== STATE_CLEAN) {
-      ancestors.push(current);
     }
+  });
+  initialized = true;
+  if (node.I === 1 /* Render */) {
+    node.ha = (p) => !(node.f & 2 /* Error */) ? staleValues(() => compute(p)) : compute(p);
   }
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    if (ancestors[i].a !== STATE_DISPOSED)
-      ancestors[i].F();
+  !options?.defer && !(node.f & (2 /* Error */ | 1 /* Pending */)) && (node.I === 2 /* User */ ? node.i.enqueue(node.I, runEffect.bind(node)) : runEffect.call(node));
+  onCleanup(() => node.L?.());
+}
+function runEffect() {
+  if (!this.fa || this.b & 64 /* Disposed */)
+    return;
+  this.L?.();
+  this.L = void 0;
+  try {
+    this.L = this.ua(this.g, this.pa);
+  } catch (error) {
+    if (!this.i.notify(this, 2 /* Error */, 2 /* Error */))
+      throw error;
+  } finally {
+    this.pa = this.g;
+    this.fa = false;
   }
 }
 
 // src/signals.ts
 function createSignal(first, second, third) {
   if (typeof first === "function") {
-    const node2 = new Computation(second, first, third);
+    const node2 = computed(first, second, third);
     return [
-      node2.wait.bind(node2),
-      (v) => {
-        node2.F();
-        return node2.write(v);
-      }
+      read.bind(null, node2),
+      setSignal.bind(null, node2)
     ];
   }
   const o = getOwner();
   const needsId = o?.id != null;
-  const node = new Computation(
+  const node = signal(
     first,
-    null,
-    needsId ? { id: o.getNextChildId(), ...second } : second
-  );
-  return [node.read.bind(node), node.write.bind(node)];
-}
-function createMemo(compute2, value, options) {
-  let node = new Computation(
-    value,
-    compute2,
-    options
-  );
-  let resolvedValue;
-  return () => {
-    if (node) {
-      if (node.a === STATE_DISPOSED) {
-        node = void 0;
-        return resolvedValue;
-      }
-      resolvedValue = node.wait();
-      if (!node.b?.length && node.n?.l !== node && !(node.g & UNINITIALIZED_BIT)) {
-        node.dispose();
-        node = void 0;
-      }
-    }
-    return resolvedValue;
-  };
-}
-function createAsync(compute2, value, options) {
-  let refreshing = false;
-  const node = new EagerComputation(
-    value,
-    (p) => {
-      const source = compute2(p, refreshing);
-      refreshing = false;
-      const isPromise = source instanceof Promise;
-      const iterator = source[Symbol.asyncIterator];
-      if (!isPromise && !iterator) {
-        return source;
-      }
-      let abort = false;
-      onCleanup(() => abort = true);
-      let transition2 = ActiveTransition;
-      if (isPromise) {
-        source.then(
-          (value3) => {
-            if (abort)
-              return;
-            if (transition2)
-              return transition2.runTransition(() => {
-                node.write(value3, 0, true);
-              }, true);
-            node.write(value3, 0, true);
-          },
-          (error) => {
-            if (abort)
-              return;
-            if (transition2)
-              return transition2.runTransition(() => node.N(error), true);
-            node.N(error);
-          }
-        );
-      } else {
-        (async () => {
-          try {
-            for await (let value3 of source) {
-              if (abort)
-                return;
-              if (transition2)
-                return transition2.runTransition(() => {
-                  node.write(value3, 0, true);
-                  transition2 = null;
-                }, true);
-              node.write(value3, 0, true);
-            }
-          } catch (error) {
-            if (abort)
-              return;
-            if (transition2)
-              return transition2.runTransition(() => {
-                node.N(error);
-                transition2 = null;
-              }, true);
-            node.N(error);
-          }
-        })();
-      }
-      throw new NotReadyError(getOwner());
-    },
-    options
+    needsId ? { id: getNextChildId(o), ...second } : second
   );
-  const read = node.wait.bind(node);
-  read.refresh = () => {
-    let n = node;
-    if (ActiveTransition && !node.d) {
-      n = cloneGraph(node);
-    }
-    n.a = STATE_DIRTY;
-    refreshing = true;
-    n.F();
-  };
-  return read;
-}
-function createEffect(compute2, effect, value, options) {
-  void new Effect(
+  return [
+    read.bind(null, node),
+    setSignal.bind(null, node)
+  ];
+}
+function createMemo(compute, value, options) {
+  let node = computed(compute, value, options);
+  return read.bind(null, node);
+}
+function createAsync(compute, value, options) {
+  const node = asyncComputed(compute, value, options);
+  const ret = read.bind(null, node);
+  ret.refresh = node.ta;
+  return ret;
+}
+function createEffect(compute, effectFn, value, options) {
+  void effect(
+    compute,
+    effectFn.effect || effectFn,
+    effectFn.error,
     value,
-    compute2,
-    effect.effect || effect,
-    effect.error,
     options
   );
 }
-function createRenderEffect(compute2, effect, value, options) {
-  void new Effect(value, compute2, effect, void 0, {
+function createRenderEffect(compute, effectFn, value, options) {
+  void effect(compute, effectFn, void 0, value, {
     render: true,
     ...options
   });
 }
-function createTrackedEffect(compute2, options) {
-  void new TrackedEffect(compute2, options);
-}
-function createReaction(effect, options) {
-  let cleanup = void 0;
-  onCleanup(() => cleanup?.());
-  return (tracking) => {
-    const node = new Effect(
-      void 0,
-      tracking,
-      () => {
-        cleanup?.();
-        cleanup = (effect.effect || effect)?.();
-        node.dispose(true);
-      },
-      effect.error,
-      {
-        defer: true,
-        ...options
-      }
-    );
-  };
-}
-function createRoot(init, options) {
-  const owner = new Owner(options?.id);
-  return compute(owner, !init.length ? init : () => init(() => owner.dispose()), null);
+function createTrackedEffect(compute, options) {
 }
-function runWithOwner(owner, run) {
-  return compute(owner, run, null);
+function createReaction(effect2, options) {
 }
 function resolve(fn) {
   return new Promise((res, rej) => {
     createRoot((dispose) => {
-      new EagerComputation(void 0, () => {
+      computed(() => {
         try {
           res(fn());
         } catch (err) {
@@ -1384,44 +1095,9 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  const node = typeof first === "function" ? new Computation(
-    second,
-    (prev) => {
-      if (node.j.f) {
-        latest(() => first(prev));
-        return prev;
-      }
-      return first(prev);
-    },
-    third
-  ) : new Computation(first, null, second);
-  node.j = () => node.write(first);
-  function write(v) {
-    if (!ActiveTransition)
-      throw new Error("createOptimistic can only be updated inside a transition");
-    ActiveTransition.addOptimistic(node.j);
-    queueMicrotask(() => {
-      if (node.j.f) {
-        node.F();
-        node.write(v);
-      }
-    });
-  }
-  return [node.wait.bind(node), write];
+  return {};
 }
-function transition(fn) {
-  let t = new Transition(new Computation(void 0, null));
-  queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
-}
-function useTransition() {
-  const [pending, setPending] = createOptimistic(false);
-  function start(fn) {
-    transition((resume) => {
-      setPending(true);
-      return fn(resume);
-    });
-  }
-  return [pending, start];
+function onSettled(callback) {
 }
 
 // src/store/reconcile.ts
@@ -1429,7 +1105,7 @@ function unwrap(value) {
   return value?.[$TARGET]?.[STORE_NODE] ?? value;
 }
 function getOverrideValue(value, override, nodes, key) {
-  return nodes && key in nodes ? nodes[key].read() : override && key in override ? override[key] : value[key];
+  return nodes && key in nodes ? read(nodes[key]) : override && key in override ? override[key] : value[key];
 }
 function getAllKeys(value, override, next) {
   const keys = getKeys(value, override);
@@ -1463,16 +1139,16 @@ function applyState(next, state, keyFn, all) {
       if (start > newEnd || start > end) {
         for (j = start; j <= newEnd; j++) {
           changed = true;
-          target[STORE_NODE][j]?.write(wrap(next[j], target));
+          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
         }
         for (; j < next.length; j++) {
           changed = true;
           const wrapped = wrap(temp[j], target);
-          target[STORE_NODE][j]?.write(wrapped);
+          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
           applyState(next[j], wrapped, keyFn, all);
         }
-        changed && target[STORE_NODE][$TRACK]?.write(void 0);
-        prevLength !== next.length && target[STORE_NODE].length?.write(next.length);
+        changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
+        prevLength !== next.length && target[STORE_NODE].length && setSignal(target[STORE_NODE].length, next.length);
         return;
       }
       newIndicesNext = new Array(newEnd + 1);
@@ -1496,10 +1172,10 @@ function applyState(next, state, keyFn, all) {
       for (j = start; j < next.length; j++) {
         if (j in temp) {
           const wrapped = wrap(temp[j], target);
-          target[STORE_NODE][j]?.write(wrapped);
+          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
           applyState(next[j], wrapped, keyFn, all);
         } else
-          target[STORE_NODE][j]?.write(wrap(next[j], target));
+          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
       }
       if (start < next.length)
         changed = true;
@@ -1511,9 +1187,9 @@ function applyState(next, state, keyFn, all) {
     }
     if (prevLength !== next.length) {
       changed = true;
-      target[STORE_NODE].length?.write(next.length);
+      target[STORE_NODE].length && setSignal(target[STORE_NODE].length, next.length);
     }
-    changed && target[STORE_NODE][$TRACK]?.write(void 0);
+    changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
     return;
   }
   if (nodes) {
@@ -1527,8 +1203,8 @@ function applyState(next, state, keyFn, all) {
       if (previousValue === nextValue)
         continue;
       if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue)) {
-        tracked?.write(void 0);
-        node?.write(isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
+        tracked && setSignal(tracked, void 0);
+        node && setSignal(node, isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
       } else
         applyState(nextValue, wrap(previousValue, target), keyFn, all);
     }
@@ -1536,7 +1212,8 @@ function applyState(next, state, keyFn, all) {
   if (nodes = target[STORE_HAS]) {
     const keys = Object.keys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
-      nodes[keys[i]].write(keys[i] in next);
+      const key = keys[i];
+      setSignal(nodes[key], key in next);
     }
   }
 }
@@ -1554,13 +1231,14 @@ function reconcile(value, key, all = false) {
 
 // src/store/projection.ts
 function createProjectionInternal(fn, initialValue = {}, options) {
+  let node;
   const wrappedMap = /* @__PURE__ */ new WeakMap();
   const traps = {
     ...storeTraps,
     get(target, property, receiver) {
       const o = getOwner();
-      const n = getTransitionSource(node);
-      (!o || o !== n) && n.wait();
+      const n = node;
+      (!o || o !== n) && n && read(n);
       return storeTraps.get(target, property, receiver);
     }
   };
@@ -1577,7 +1255,7 @@ function createProjectionInternal(fn, initialValue = {}, options) {
     return wrapped;
   };
   const wrappedStore = wrapProjection(initialValue);
-  const node = new FirewallComputation(() => {
+  node = computed(() => {
     storeSetter(wrappedStore, (s) => {
       const value = fn(s);
       if (value !== s && value !== void 0) {
@@ -1635,7 +1313,7 @@ function getNodes(target, type) {
 function getNode(nodes, property, value, equals = isEqual) {
   if (nodes[property])
     return nodes[property];
-  return nodes[property] = new Computation(value, null, {
+  return nodes[property] = signal(value, {
     equals,
     unobserved() {
       delete nodes[property];
@@ -1643,7 +1321,7 @@ function getNode(nodes, property, value, equals = isEqual) {
   });
 }
 function trackSelf(target, symbol = $TRACK) {
-  getObserver() && getNode(getNodes(target, STORE_NODE), symbol, void 0, false).read();
+  getObserver() && read(getNode(getNodes(target, STORE_NODE), symbol, void 0, false));
 }
 function getKeys(source, override, enumerable = true) {
   const baseKeys = untrack(() => enumerable ? Object.keys(source) : Reflect.ownKeys(source));
@@ -1691,7 +1369,7 @@ var storeTraps = {
         return desc.get.call(receiver);
     }
     if (Writing?.has(receiver)) {
-      let value2 = tracked && (overridden || !proxySource) ? tracked.m : storeValue[property];
+      let value2 = tracked && (overridden || !proxySource) ? tracked.e !== NOT_PENDING ? tracked.e : tracked.g : storeValue[property];
       value2 === $DELETED && (value2 = void 0);
       if (!isWrappable(value2))
         return value2;
@@ -1699,14 +1377,14 @@ var storeTraps = {
       Writing.add(wrapped);
       return wrapped;
     }
-    let value = tracked ? overridden || !proxySource ? nodes[property].read() : (nodes[property].read(), storeValue[property]) : storeValue[property];
+    let value = tracked ? overridden || !proxySource ? read(nodes[property]) : (read(nodes[property]), storeValue[property]) : storeValue[property];
     value === $DELETED && (value = void 0);
     if (!tracked) {
       if (!overridden && typeof value === "function" && !storeValue.hasOwnProperty(property)) {
         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 getNode(nodes, property, isWrappable(value) ? wrap(value, target) : value).read();
+        return read(getNode(nodes, property, isWrappable(value) ? wrap(value, target) : value));
       }
     }
     return isWrappable(value) ? wrap(value, target) : value;
@@ -1715,7 +1393,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() && getNode(getNodes(target, STORE_HAS), property, has).read();
+    getObserver() && read(getNode(getNodes(target, STORE_HAS), property, has));
     return has;
   },
   set(target, property, rawValue) {
@@ -1740,15 +1418,15 @@ var storeTraps = {
         }
         if (recursivelyNotify(store, storeLookup) && wrappable)
           recursivelyAddParent(value, store);
-        target[STORE_HAS]?.[property]?.write(true);
+        target[STORE_HAS]?.[property] && setSignal(target[STORE_HAS][property], true);
         const nodes = getNodes(target, STORE_NODE);
-        nodes[property]?.write(wrappable ? wrap(value, target) : value);
+        nodes[property] && setSignal(nodes[property], () => wrappable ? wrap(value, target) : value);
         if (Array.isArray(state)) {
           const index = parseInt(property) + 1;
           if (index > len)
-            nodes.length?.write(index);
+            nodes.length && setSignal(nodes.length, index);
         }
-        nodes[$TRACK]?.write(void 0);
+        nodes[$TRACK] && setSignal(nodes[$TRACK], void 0);
       });
     }
     return true;
@@ -1767,10 +1445,11 @@ var storeTraps = {
           const parents = PARENTS.get(prev);
           parents && (parents instanceof Set ? parents.delete(target) : PARENTS.delete(prev));
         }
-        target[STORE_HAS]?.[property]?.write(false);
+        if (target[STORE_HAS]?.[property])
+          setSignal(target[STORE_HAS][property], false);
         const nodes = getNodes(target, STORE_NODE);
-        nodes[property]?.write(void 0);
-        nodes[$TRACK]?.write(void 0);
+        nodes[property] && setSignal(nodes[property], void 0);
+        nodes[$TRACK] && setSignal(nodes[$TRACK], void 0);
       });
     }
     return true;
@@ -1824,7 +1503,7 @@ function recursivelyNotify(state, lookup) {
   if (target) {
     const deep2 = getNodes(target, STORE_NODE)[$DEEP];
     if (deep2) {
-      deep2.write(void 0);
+      setSignal(deep2, void 0);
       notified = true;
     }
     lookup = target[STORE_LOOKUP] || lookup;
@@ -1881,31 +1560,7 @@ function deep(store) {
 
 // src/store/optimistic.ts
 function createOptimisticStore(first, second, options) {
-  const derived = typeof first === "function";
-  const { store, node } = derived ? createProjectionInternal(
-    (draft) => {
-      if (reset.f) {
-        latest(() => first(draft));
-        return draft;
-      }
-      return first(draft);
-    },
-    second,
-    options
-  ) : createProjectionInternal(() => {
-  }, first);
-  const reset = () => storeSetter(
-    store,
-    reconcile(derived ? first(store) || store : first, options?.key || "id", options?.all)
-  );
-  const write = (v) => {
-    if (!ActiveTransition)
-      throw new Error("createOptimisticStore can only be updated inside a transition");
-    ActiveTransition.addOptimistic(reset);
-    queueMicrotask(() => reset.f && storeSetter(store, v));
-  };
-  node.j = reset;
-  return [store, write];
+  return [];
 }
 
 // src/store/utils.ts
@@ -2111,347 +1766,341 @@ function omit(props, ...keys) {
 // src/map.ts
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
-  return updateKeyedMap.bind({
-    U: new Owner(),
-    p: 0,
-    ka: list,
-    I: [],
-    R: map,
-    k: [],
-    e: [],
-    S: keyFn,
-    q: keyFn || options?.keyed === false ? [] : void 0,
-    r: map.length > 1 ? [] : void 0,
-    V: options?.fallback
-  });
+  return createMemo(
+    updateKeyedMap.bind({
+      z: createOwner(),
+      k: 0,
+      va: list,
+      F: [],
+      M: map,
+      d: [],
+      a: [],
+      N: keyFn,
+      l: keyFn || options?.keyed === false ? [] : void 0,
+      m: map.length > 1 ? [] : void 0,
+      Y: options?.fallback
+    })
+  );
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
-  const newItems = this.ka() || [], newLen = newItems.length;
+  const newItems = this.va() || [], newLen = newItems.length;
   newItems[$TRACK];
-  runWithOwner(this.U, () => {
-    let i, j, mapper = this.q ? () => {
-      this.q[j] = new Computation(newItems[j], null, pureOptions);
-      this.r && (this.r[j] = new Computation(j, null, pureOptions));
-      return this.R(
-        Computation.prototype.read.bind(this.q[j]),
-        this.r ? Computation.prototype.read.bind(this.r[j]) : void 0
+  runWithOwner(this.z, () => {
+    let i, j, mapper = this.l ? () => {
+      this.l[j] = signal(newItems[j], pureOptions);
+      this.m && (this.m[j] = signal(j, pureOptions));
+      return this.M(
+        read.bind(null, this.l[j]),
+        this.m ? read.bind(null, this.m[j]) : void 0
       );
-    } : this.r ? () => {
+    } : this.m ? () => {
       const item = newItems[j];
-      this.r[j] = new Computation(j, null, pureOptions);
-      return this.R(() => item, Computation.prototype.read.bind(this.r[j]));
+      this.m[j] = signal(j, pureOptions);
+      return this.M(
+        () => item,
+        read.bind(null, this.m[j])
+      );
     } : () => {
       const item = newItems[j];
-      return this.R(() => item);
+      return this.M(() => item);
     };
     if (newLen === 0) {
-      if (this.p !== 0) {
-        this.U.dispose(false);
-        this.e = [];
-        this.I = [];
-        this.k = [];
-        this.p = 0;
-        this.q && (this.q = []);
-        this.r && (this.r = []);
+      if (this.k !== 0) {
+        this.z.dispose(false);
+        this.a = [];
+        this.F = [];
+        this.d = [];
+        this.k = 0;
+        this.l && (this.l = []);
+        this.m && (this.m = []);
       }
-      if (this.V && !this.k[0]) {
-        this.k[0] = compute(
-          this.e[0] = new Owner(),
-          this.V,
-          null
+      if (this.Y && !this.d[0]) {
+        this.d[0] = runWithOwner(
+          this.a[0] = createOwner(),
+          this.Y
         );
       }
-    } else if (this.p === 0) {
-      if (this.e[0])
-        this.e[0].dispose();
-      this.k = new Array(newLen);
+    } else if (this.k === 0) {
+      if (this.a[0])
+        this.a[0].dispose();
+      this.d = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.I[j] = newItems[j];
-        this.k[j] = compute(this.e[j] = new Owner(), mapper, null);
+        this.F[j] = newItems[j];
+        this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
       }
-      this.p = newLen;
+      this.k = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.q ? new Array(newLen) : void 0, tempIndexes = this.r ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.p, newLen); start < end && (this.I[start] === newItems[start] || this.q && compare(this.S, this.I[start], newItems[start])); start++) {
-        if (this.q)
-          this.q[start].write(newItems[start]);
+      let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.l ? new Array(newLen) : void 0, tempIndexes = this.m ? new Array(newLen) : void 0;
+      for (start = 0, end = Math.min(this.k, newLen); start < end && (this.F[start] === newItems[start] || this.l && compare(this.N, this.F[start], newItems[start])); start++) {
+        if (this.l)
+          setSignal(this.l[start], newItems[start]);
       }
-      for (end = this.p - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.I[end] === newItems[newEnd] || this.q && compare(this.S, this.I[end], newItems[newEnd])); end--, newEnd--) {
-        temp[newEnd] = this.k[end];
-        tempNodes[newEnd] = this.e[end];
-        tempRows && (tempRows[newEnd] = this.q[end]);
-        tempIndexes && (tempIndexes[newEnd] = this.r[end]);
+      for (end = this.k - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.F[end] === newItems[newEnd] || this.l && compare(this.N, this.F[end], newItems[newEnd])); end--, newEnd--) {
+        temp[newEnd] = this.d[end];
+        tempNodes[newEnd] = this.a[end];
+        tempRows && (tempRows[newEnd] = this.l[end]);
+        tempIndexes && (tempIndexes[newEnd] = this.m[end]);
       }
       newIndices = /* @__PURE__ */ new Map();
       newIndicesNext = new Array(newEnd + 1);
       for (j = newEnd; j >= start; j--) {
         item = newItems[j];
-        key = this.S ? this.S(item) : item;
+        key = this.N ? this.N(item) : item;
         i = newIndices.get(key);
         newIndicesNext[j] = i === void 0 ? -1 : i;
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.I[i];
-        key = this.S ? this.S(item) : item;
+        item = this.F[i];
+        key = this.N ? this.N(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
-          temp[j] = this.k[i];
-          tempNodes[j] = this.e[i];
-          tempRows && (tempRows[j] = this.q[i]);
-          tempIndexes && (tempIndexes[j] = this.r[i]);
+          temp[j] = this.d[i];
+          tempNodes[j] = this.a[i];
+          tempRows && (tempRows[j] = this.l[i]);
+          tempIndexes && (tempIndexes[j] = this.m[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
         } else
-          this.e[i].dispose();
+          this.a[i].dispose();
       }
       for (j = start; j < newLen; j++) {
         if (j in temp) {
-          this.k[j] = temp[j];
-          this.e[j] = tempNodes[j];
+          this.d[j] = temp[j];
+          this.a[j] = tempNodes[j];
           if (tempRows) {
-            this.q[j] = tempRows[j];
-            this.q[j].write(newItems[j]);
+            this.l[j] = tempRows[j];
+            setSignal(this.l[j], newItems[j]);
           }
           if (tempIndexes) {
-            this.r[j] = tempIndexes[j];
-            this.r[j].write(j);
+            this.m[j] = tempIndexes[j];
+            setSignal(this.m[j], j);
           }
         } else {
-          this.k[j] = compute(this.e[j] = new Owner(), mapper, null);
+          this.d[j] = runWithOwner(this.a[j] = createOwner(), mapper);
         }
       }
-      this.k = this.k.slice(0, this.p = newLen);
-      this.I = newItems.slice(0);
+      this.d = this.d.slice(0, this.k = newLen);
+      this.F = newItems.slice(0);
     }
   });
-  return this.k;
+  return this.d;
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    U: new Owner(),
-    p: 0,
-    B: 0,
-    la: count,
-    R: map,
-    e: [],
-    k: [],
-    ma: options?.from,
-    V: options?.fallback
+    z: createOwner(),
+    k: 0,
+    w: 0,
+    wa: count,
+    M: map,
+    a: [],
+    d: [],
+    xa: options?.from,
+    Y: options?.fallback
   });
 }
 function updateRepeat() {
-  const newLen = this.la();
-  const from = this.ma?.() || 0;
-  runWithOwner(this.U, () => {
+  const newLen = this.wa();
+  const from = this.xa?.() || 0;
+  runWithOwner(this.z, () => {
     if (newLen === 0) {
-      if (this.p !== 0) {
-        this.U.dispose(false);
-        this.e = [];
-        this.k = [];
-        this.p = 0;
+      if (this.k !== 0) {
+        this.z.dispose(false);
+        this.a = [];
+        this.d = [];
+        this.k = 0;
       }
-      if (this.V && !this.k[0]) {
-        this.k[0] = compute(
-          this.e[0] = new Owner(),
-          this.V,
-          null
+      if (this.Y && !this.d[0]) {
+        this.d[0] = runWithOwner(
+          this.a[0] = createOwner(),
+          this.Y
         );
       }
       return;
     }
     const to = from + newLen;
-    const prevTo = this.B + this.p;
-    if (this.p === 0 && this.e[0])
-      this.e[0].dispose();
+    const prevTo = this.w + this.k;
+    if (this.k === 0 && this.a[0])
+      this.a[0].dispose();
     for (let i = to; i < prevTo; i++)
-      this.e[i - this.B].dispose();
-    if (this.B < from) {
-      let i = this.B;
-      while (i < from && i < this.p)
-        this.e[i++].dispose();
-      this.e.splice(0, from - this.B);
-      this.k.splice(0, from - this.B);
-    } else if (this.B > from) {
-      let i = prevTo - this.B - 1;
-      let difference = this.B - from;
-      this.e.length = this.k.length = newLen;
+      this.a[i - this.w].dispose();
+    if (this.w < from) {
+      let i = this.w;
+      while (i < from && i < this.k)
+        this.a[i++].dispose();
+      this.a.splice(0, from - this.w);
+      this.d.splice(0, from - this.w);
+    } else if (this.w > from) {
+      let i = prevTo - this.w - 1;
+      let difference = this.w - from;
+      this.a.length = this.d.length = newLen;
       while (i >= difference) {
-        this.e[i] = this.e[i - difference];
-        this.k[i] = this.k[i - difference];
+        this.a[i] = this.a[i - difference];
+        this.d[i] = this.d[i - difference];
         i--;
       }
       for (let i2 = 0; i2 < difference; i2++) {
-        this.k[i2] = compute(
-          this.e[i2] = new Owner(),
-          () => this.R(i2 + from),
-          null
+        this.d[i2] = runWithOwner(
+          this.a[i2] = createOwner(),
+          () => this.M(i2 + from)
         );
       }
     }
     for (let i = prevTo; i < to; i++) {
-      this.k[i - from] = compute(
-        this.e[i - from] = new Owner(),
-        () => this.R(i),
-        null
+      this.d[i - from] = runWithOwner(
+        this.a[i - from] = createOwner(),
+        () => this.M(i)
       );
     }
-    this.k = this.k.slice(0, newLen);
-    this.B = from;
-    this.p = newLen;
+    this.d = this.d.slice(0, newLen);
+    this.w = from;
+    this.k = newLen;
   });
-  return this.k;
+  return this.d;
 }
 function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 
 // src/boundaries.ts
-var BoundaryComputation = class extends EagerComputation {
-  W;
-  constructor(compute2, propagationMask) {
-    super(void 0, compute2, { defer: true });
-    this.W = propagationMask;
-  }
-  write(value, flags) {
-    super.write(value, flags & ~this.W);
-    if (this.W & LOADING_BIT && !(this.g & UNINITIALIZED_BIT || ActiveTransition)) {
-      flags &= ~LOADING_BIT;
+function boundaryComputed(fn, propagationMask) {
+  const node = computed(fn, void 0, {
+    ja: {
+      ma() {
+        let flags = this.f;
+        this.f &= ~this.Z;
+        if (this.Z & 1 /* Pending */ && !(this.f & 4 /* Uninitialized */)) {
+          flags &= ~1 /* Pending */;
+        }
+        this.i.notify(this, this.Z, flags);
+      },
+      Z: propagationMask
     }
-    getQueue(this).notify(this, this.W, flags);
-    return this.m;
-  }
-};
+  });
+  node.Z = propagationMask;
+  return node;
+}
 function createBoundChildren(owner, fn, queue, mask) {
-  const parentQueue = owner.E;
-  parentQueue.addChild(owner.E = queue);
-  onCleanup(() => parentQueue.removeChild(owner.E));
-  return compute(
-    owner,
-    () => {
-      const c = new Computation(void 0, fn);
-      return new BoundaryComputation(() => latest(() => flatten(c.wait())), mask);
-    },
-    null
-  );
+  const parentQueue = owner.i;
+  parentQueue.addChild(owner.i = queue);
+  onCleanup(() => parentQueue.removeChild(owner.i));
+  return runWithOwner(owner, () => {
+    const c = computed(fn);
+    return boundaryComputed(() => staleValues(() => flatten(read(c))), mask);
+  });
 }
 var ConditionalQueue = class extends Queue {
-  y;
-  X = /* @__PURE__ */ new Set();
-  t = /* @__PURE__ */ new Set();
+  t;
+  ga = /* @__PURE__ */ new Set();
+  h = /* @__PURE__ */ new Set();
   constructor(disabled) {
     super();
-    this.y = disabled;
+    this.t = disabled;
   }
   run(type) {
-    if (!type || this.y.read())
+    if (!type || read(this.t))
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (this.y.read()) {
-      if (type & LOADING_BIT) {
-        if (flags & LOADING_BIT) {
-          this.t.add(node);
-          type &= ~LOADING_BIT;
-        } else if (this.t.delete(node))
-          type &= ~LOADING_BIT;
+    if (read(this.t)) {
+      if (type & 1 /* Pending */) {
+        if (flags & 1 /* Pending */) {
+          this.h.add(node);
+          type &= ~1 /* Pending */;
+        } else if (this.h.delete(node))
+          type &= ~1 /* Pending */;
       }
-      if (type & ERROR_BIT) {
-        if (flags & ERROR_BIT) {
-          this.X.add(node);
-          type &= ~ERROR_BIT;
-        } else if (this.X.delete(node))
-          type &= ~ERROR_BIT;
+      if (type & 2 /* Error */) {
+        if (flags & 2 /* Error */) {
+          this.ga.add(node);
+          type &= ~2 /* Error */;
+        } else if (this.ga.delete(node))
+          type &= ~2 /* Error */;
       }
     }
     return type ? super.notify(node, type, flags) : true;
   }
-  merge(queue) {
-    queue.t.forEach((n) => this.notify(n, LOADING_BIT, LOADING_BIT));
-    queue.X.forEach((n) => this.notify(n, ERROR_BIT, ERROR_BIT));
-    super.merge(queue);
-  }
 };
 var CollectionQueue = class extends Queue {
-  L;
-  e = /* @__PURE__ */ new Set();
-  y = new Computation(false, null, { pureWrite: true });
+  O;
+  a = /* @__PURE__ */ new Set();
+  t = signal(false, { pureWrite: true });
+  ka = false;
   constructor(type) {
     super();
-    this.L = type;
+    this.O = type;
   }
   run(type) {
-    if (!type || this.y.read())
+    if (!type || read(this.t))
       return;
     return super.run(type);
   }
+  enqueue(type, fn) {
+    if (this.O & 1 /* Pending */ && this.ka) {
+      return this.q?.enqueue(type, fn);
+    }
+    return super.enqueue(type, fn);
+  }
   notify(node, type, flags) {
-    if (!(type & this.L))
+    if (!(type & this.O) || this.O & 1 /* Pending */ && this.ka)
       return super.notify(node, type, flags);
-    if (flags & this.L) {
-      this.e.add(node);
-      if (this.e.size === 1)
-        this.y.write(true);
-    } else if (this.e.size > 0) {
-      this.e.delete(node);
-      if (this.e.size === 0)
-        this.y.write(false);
-    }
-    type &= ~this.L;
+    if (flags & this.O) {
+      this.a.add(node);
+      if (this.a.size === 1)
+        setSignal(this.t, true);
+    } else if (this.a.size > 0) {
+      this.a.delete(node);
+      if (this.a.size === 0)
+        setSignal(this.t, false);
+    }
+    type &= ~this.O;
     return type ? super.notify(node, type, flags) : true;
   }
-  merge(queue) {
-    queue.e.forEach((n) => this.notify(n, this.L, this.L));
-    super.merge(queue);
-  }
 };
 function createBoundary(fn, condition) {
-  const owner = new Owner();
-  const queue = new ConditionalQueue(
-    new Computation(void 0, () => condition() === "hidden" /* HIDDEN */)
-  );
+  const owner = createOwner();
+  const queue = new ConditionalQueue(computed(() => condition() === "hidden" /* HIDDEN */));
   const tree = createBoundChildren(owner, fn, queue, 0);
-  new EagerComputation(void 0, () => {
-    const disabled = queue.y.read();
-    tree.W = disabled ? ERROR_BIT | LOADING_BIT : 0;
+  computed(() => {
+    const disabled = read(queue.t);
+    tree.Z = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
     if (!disabled) {
-      queue.t.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
-      queue.X.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
-      queue.t.clear();
-      queue.X.clear();
+      queue.h.forEach(
+        (node) => queue.notify(node, 1 /* Pending */, 1 /* Pending */)
+      );
+      queue.ga.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
+      queue.h.clear();
+      queue.ga.clear();
     }
   });
-  return () => queue.y.read() ? void 0 : tree.read();
+  return () => read(queue.t) ? void 0 : read(tree);
 }
 function createCollectionBoundary(type, fn, fallback) {
-  const owner = new Owner();
+  const owner = createOwner();
   const queue = new CollectionQueue(type);
   const tree = createBoundChildren(owner, fn, queue, type);
-  const decision = new Computation(void 0, () => {
-    if (!queue.y.read()) {
-      const resolved = tree.read();
-      if (!untrack(() => queue.y.read()))
-        return resolved;
+  const decision = computed(() => {
+    if (!read(queue.t)) {
+      const resolved = read(tree);
+      if (!untrack(() => read(queue.t)))
+        queue.ka = true;
+      return resolved;
     }
     return fallback(queue);
   });
-  return decision.read.bind(decision);
+  return read.bind(null, decision);
 }
-function createSuspense(fn, fallback) {
-  return createCollectionBoundary(LOADING_BIT, fn, () => fallback());
+function createLoadBoundary(fn, fallback) {
+  return createCollectionBoundary(1 /* Pending */, fn, () => fallback());
 }
 function createErrorBoundary(fn, fallback) {
-  return createCollectionBoundary(ERROR_BIT, fn, (queue) => {
-    let node = getTransitionSource(queue.e.values().next().value);
-    return fallback(node.O, () => {
-      incrementClock();
-      for (let node2 of queue.e) {
-        if (ActiveTransition && !node2.d)
-          node2 = cloneGraph(node2);
-        node2.a = STATE_DIRTY;
-        getQueue(node2).enqueue(node2.s, node2.x.bind(node2));
+  return createCollectionBoundary(2 /* Error */, fn, (queue) => {
+    let node = queue.a.values().next().value;
+    return fallback(node.B, () => {
+      for (let node2 of queue.a) {
+        recompute(node2, true);
       }
     });
   });
@@ -2511,4 +2160,4 @@ function flattenArray(children, results = [], options) {
   return needsUnwrap;
 }
 
-export { $PROXY, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createSuspense, createTrackedEffect, deep, flatten, flush, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithOwner, setContext, snapshot, transition, untrack, useTransition };
+export { $PROXY, $TARGET, $TRACK, ContextNotFoundError, NoOwnerError, NotReadyError, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createLoadBoundary, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getContext, getNextChildId, getObserver, getOwner, isEqual, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, repeat, resolve, runWithOwner, setContext, snapshot, untrack };