@solidjs/signals 0.7.5 → 0.8.1

package/dist/dev.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,31 +19,136 @@ 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._parent?._root ? n._parent._parentComputed?._height : n._parent?._height) ?? -1;
+  if (parentHeight >= n._height)
+    n._height = parentHeight + 1;
+  const height = n._height;
+  const heapAtHeight = heap._heap[height];
+  if (heapAtHeight === void 0) {
+    heap._heap[height] = n;
+  } else {
+    const tail = heapAtHeight._prevHeap;
+    tail._nextHeap = n;
+    n._prevHeap = tail;
+    heapAtHeight._prevHeap = n;
+  }
+  if (height > heap._max) {
+    heap._max = height;
+  }
+}
+function insertIntoHeap(n, heap) {
+  let flags = n._flags;
+  if (flags & (8 /* InHeap */ | 4 /* RecomputingDeps */))
+    return;
+  if (flags & 1 /* Check */) {
+    n._flags = flags & ~(1 /* Check */ | 2 /* Dirty */) | 2 /* Dirty */ | 8 /* InHeap */;
+  } else
+    n._flags = flags | 8 /* InHeap */;
+  if (!(flags & 16 /* InHeapHeight */)) {
+    actualInsertIntoHeap(n, heap);
+  }
+}
+function insertIntoHeapHeight(n, heap) {
+  let flags = n._flags;
+  if (flags & (8 /* InHeap */ | 4 /* RecomputingDeps */ | 16 /* InHeapHeight */))
+    return;
+  n._flags = flags | 16 /* InHeapHeight */;
+  actualInsertIntoHeap(n, heap);
+}
+function deleteFromHeap(n, heap) {
+  const flags = n._flags;
+  if (!(flags & (8 /* InHeap */ | 16 /* InHeapHeight */)))
+    return;
+  n._flags = flags & ~(8 /* InHeap */ | 16 /* InHeapHeight */);
+  const height = n._height;
+  if (n._prevHeap === n) {
+    heap._heap[height] = void 0;
+  } else {
+    const next = n._nextHeap;
+    const dhh = heap._heap[height];
+    const end = next ?? dhh;
+    if (n === dhh) {
+      heap._heap[height] = next;
+    } else {
+      n._prevHeap._nextHeap = next;
+    }
+    end._prevHeap = n._prevHeap;
+  }
+  n._prevHeap = n;
+  n._nextHeap = void 0;
+}
+function markHeap(heap) {
+  if (heap._marked)
+    return;
+  heap._marked = true;
+  for (let i = 0; i <= heap._max; i++) {
+    for (let el = heap._heap[i]; el !== void 0; el = el._nextHeap) {
+      if (el._flags & 8 /* InHeap */)
+        markNode(el);
+    }
+  }
+}
+function markNode(el, newState = 2 /* Dirty */) {
+  const flags = el._flags;
+  if ((flags & (1 /* Check */ | 2 /* Dirty */)) >= newState)
+    return;
+  el._flags = flags & ~(1 /* Check */ | 2 /* Dirty */) | newState;
+  for (let link2 = el._subs; link2 !== null; link2 = link2._nextSub) {
+    markNode(link2._sub, 1 /* Check */);
+  }
+  if (el._child !== null) {
+    for (let child = el._child; child !== null; child = child._nextChild) {
+      for (let link2 = child._subs; link2 !== null; link2 = link2._nextSub) {
+        markNode(link2._sub, 1 /* Check */);
+      }
+    }
+  }
+}
+function runHeap(heap, recompute2) {
+  heap._marked = false;
+  for (heap._min = 0; heap._min <= heap._max; heap._min++) {
+    let el = heap._heap[heap._min];
+    while (el !== void 0) {
+      if (el._flags & 8 /* InHeap */)
+        recompute2(el);
+      else {
+        adjustHeight(el, heap);
+      }
+      el = heap._heap[heap._min];
+    }
+  }
+  heap._max = 0;
+}
+function adjustHeight(el, heap) {
+  deleteFromHeap(el, heap);
+  let newHeight = el._height;
+  for (let d = el._deps; d; d = d._nextDep) {
+    const dep1 = d._dep;
+    const dep = "_owner" in dep1 ? dep1._owner : dep1;
+    if ("_fn" in dep) {
+      if (dep._height >= newHeight) {
+        newHeight = dep._height + 1;
+      }
+    }
+  }
+  if (el._height !== newHeight) {
+    el._height = newHeight;
+    for (let s = el._subs; s !== null; s = s._nextSub) {
+      insertIntoHeapHeight(s._sub, 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)
@@ -52,33 +157,41 @@ function schedule() {
   if (!globalQueue._running)
     queueMicrotask(flush);
 }
-function notifyUnobserved() {
-  for (let i = 0; i < Unobserved.length; i++) {
-    const source = Unobserved[i];
-    if (!source._observers || !source._observers.length)
-      Unobserved[i]._unobserved?.();
-  }
-  Unobserved = [];
-}
-var pureQueue = [];
+var dirtyQueue = {
+  _heap: new Array(2e3).fill(void 0),
+  _marked: false,
+  _min: 0,
+  _max: 0
+};
+var zombieQueue = {
+  _heap: new Array(2e3).fill(void 0),
+  _marked: false,
+  _min: 0,
+  _max: 0
+};
 var Queue = class {
   _parent = null;
-  _running = false;
   _queues = [[], []];
   _children = [];
   created = clock;
-  enqueue(type, fn) {
-    pureQueue.push(fn);
-    if (type)
-      this._queues[type - 1].push(fn);
-    schedule();
+  addChild(child) {
+    this._children.push(child);
+    child._parent = this;
+  }
+  removeChild(child) {
+    const index = this._children.indexOf(child);
+    if (index >= 0) {
+      this._children.splice(index, 1);
+      child._parent = null;
+    }
+  }
+  notify(node, mask, flags) {
+    if (this._parent)
+      return this._parent.notify(node, mask, flags);
+    return false;
   }
   run(type) {
-    if (type === EFFECT_PURE) {
-      pureQueue.length && runQueue(pureQueue, type);
-      pureQueue = [];
-      return;
-    } else if (this._queues[type - 1].length) {
+    if (this._queues[type - 1].length) {
       const effects = this._queues[type - 1];
       this._queues[type - 1] = [];
       runQueue(effects, type);
@@ -87,54 +200,109 @@ var Queue = class {
       this._children[i].run(type);
     }
   }
+  enqueue(type, fn) {
+    if (type)
+      this._queues[type - 1].push(fn);
+    schedule();
+  }
+};
+var GlobalQueue = class _GlobalQueue extends Queue {
+  _running = false;
+  _pendingNodes = [];
+  static _update;
+  static _dispose;
   flush() {
     if (this._running)
       return;
     this._running = true;
     try {
-      this.run(EFFECT_PURE);
-      incrementClock();
+      runHeap(dirtyQueue, _GlobalQueue._update);
+      if (activeTransition) {
+        if (!transitionComplete(activeTransition)) {
+          runHeap(zombieQueue, _GlobalQueue._update);
+          globalQueue._pendingNodes = [];
+          activeTransition.queues[0].push(...globalQueue._queues[0]);
+          activeTransition.queues[1].push(...globalQueue._queues[1]);
+          globalQueue._queues = [[], []];
+          clock++;
+          scheduled = false;
+          runPending(activeTransition.pendingNodes, true);
+          activeTransition = null;
+          return;
+        }
+        globalQueue._pendingNodes.push(...activeTransition.pendingNodes);
+        globalQueue._queues[0].push(...activeTransition.queues[0]);
+        globalQueue._queues[1].push(...activeTransition.queues[1]);
+        transitions.delete(activeTransition);
+        activeTransition = null;
+        if (runPending(globalQueue._pendingNodes, false))
+          runHeap(dirtyQueue, _GlobalQueue._update);
+      } else if (transitions.size)
+        runHeap(zombieQueue, _GlobalQueue._update);
+      for (let i = 0; i < globalQueue._pendingNodes.length; i++) {
+        const n = globalQueue._pendingNodes[i];
+        if (n._pendingValue !== NOT_PENDING) {
+          n._value = n._pendingValue;
+          n._pendingValue = NOT_PENDING;
+        }
+        if (n._fn)
+          _GlobalQueue._dispose(n, false, true);
+      }
+      globalQueue._pendingNodes.length = 0;
+      clock++;
       scheduled = false;
-      this.run(EFFECT_RENDER);
-      this.run(EFFECT_USER);
+      this.run(1 /* Render */);
+      this.run(2 /* User */);
     } finally {
       this._running = false;
-      Unobserved.length && notifyUnobserved();
+      unobserved.length && notifyUnobserved();
     }
   }
-  addChild(child) {
-    if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
-      return ActiveTransition._clonedQueues.get(this).addChild(child);
-    this._children.push(child);
-    child._parent = this;
-  }
-  removeChild(child) {
-    if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
-      return ActiveTransition._clonedQueues.get(this).removeChild(child);
-    const index = this._children.indexOf(child);
-    if (index >= 0) {
-      this._children.splice(index, 1);
-      child._parent = null;
+  notify(node, mask, flags) {
+    if (mask & 1 /* Pending */) {
+      if (flags & 1 /* Pending */) {
+        if (activeTransition && !activeTransition.asyncNodes.includes(node._error.cause))
+          activeTransition.asyncNodes.push(node._error.cause);
+      }
+      return true;
     }
-  }
-  notify(...args) {
-    if (this._parent)
-      return this._parent.notify(...args);
     return false;
   }
-  merge(queue) {
-    this._queues[0].push.apply(this._queues[0], queue._queues[0]);
-    this._queues[1].push.apply(this._queues[1], queue._queues[1]);
-    for (let i = 0; i < queue._children.length; i++) {
-      const og = this._children.find((c) => c._cloned === queue._children[i]._cloned);
-      if (og)
-        og.merge(queue._children[i]);
-      else
-        this.addChild(queue._children[i]);
+  initTransition(node) {
+    if (activeTransition && activeTransition.time === clock)
+      return;
+    if (!activeTransition) {
+      activeTransition = node._transition ?? {
+        time: clock,
+        pendingNodes: [],
+        asyncNodes: [],
+        queues: [[], []]
+      };
+    }
+    transitions.add(activeTransition);
+    activeTransition.time = clock;
+    for (let i = 0; i < globalQueue._pendingNodes.length; i++) {
+      const n = globalQueue._pendingNodes[i];
+      n._transition = activeTransition;
+      activeTransition.pendingNodes.push(n);
     }
+    globalQueue._pendingNodes = 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._transition = activeTransition;
+    if (n._pendingCheck) {
+      n._pendingCheck._set(value);
+      needsReset = true;
+    }
+  }
+  return needsReset;
+}
+var globalQueue = new GlobalQueue();
 function flush() {
   let count = 0;
   while (scheduled) {
@@ -143,826 +311,621 @@ function flush() {
     globalQueue.flush();
   }
 }
-function removeSourceObservers(node, index) {
-  let source;
-  let swap;
-  for (let i = index; i < node._sources.length; i++) {
-    source = getTransitionSource(node._sources[i]);
-    if (source._observers) {
-      if ((swap = source._observers.indexOf(node)) !== -1) {
-        source._observers[swap] = source._observers[source._observers.length - 1];
-        source._observers.pop();
-      }
-      if (!source._observers.length)
-        Unobserved.push(source);
-    }
-  }
-}
 function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++)
     queue[i](type);
 }
-var Transition = class _Transition {
-  _sources = /* @__PURE__ */ new Map();
-  _pendingNodes = /* @__PURE__ */ new Set();
-  _promises = /* @__PURE__ */ new Set();
-  _optimistic = /* @__PURE__ */ new Set();
-  _done = false;
-  _queues = [[], []];
-  _clonedQueues = /* @__PURE__ */ new Map();
-  _pureQueue = [];
-  _children = [];
-  _parent = null;
-  _running = false;
-  _scheduled = false;
-  _cloned = globalQueue;
-  _signal;
-  created = clock;
-  constructor(signal) {
-    this._signal = signal;
-    this._clonedQueues.set(globalQueue, this);
-    for (const child of globalQueue._children) {
-      cloneQueue(child, this, this);
+function transitionComplete(transition) {
+  let done = true;
+  for (let i = 0; i < transition.asyncNodes.length; i++) {
+    if (transition.asyncNodes[i]._statusFlags & 1 /* Pending */) {
+      done = false;
+      break;
     }
   }
-  enqueue(type, fn) {
-    this._pureQueue.push(fn);
-    if (type)
-      this._queues[type - 1].push(fn);
-    this.schedule();
-  }
-  run(type) {
-    if (type === EFFECT_PURE) {
-      this._pureQueue.length && runQueue(this._pureQueue, type);
-      this._pureQueue = [];
-      return;
-    } else if (this._queues[type - 1].length) {
-      const effects = this._queues[type - 1];
-      this._queues[type - 1] = [];
-      runQueue(effects, type);
-    }
-    for (let i = 0; i < this._children.length; i++) {
-      this._children[i].run(type);
-    }
+  return done;
+}
+function notifyUnobserved() {
+  for (let i = 0; i < unobserved.length; i++) {
+    const source = unobserved[i];
+    if (!source._subs)
+      unobserved[i]._unobserved?.();
   }
-  flush() {
-    if (this._running || this._done)
-      return;
-    globalQueue.flush();
-    this._running = true;
-    let currentTransition = ActiveTransition;
-    ActiveTransition = this;
-    try {
-      this.run(EFFECT_PURE);
-      incrementClock();
-      this._scheduled = false;
-      ActiveTransition = currentTransition;
-      finishTransition(this);
-    } finally {
-      this._running = false;
-      ActiveTransition = currentTransition;
+  unobserved = [];
+}
+
+// src/core/core.ts
+GlobalQueue._update = recompute;
+GlobalQueue._dispose = 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._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+  if (el._pendingValue !== NOT_PENDING || el._pendingFirstChild || el._pendingDisposal)
+    disposeChildren(el);
+  else {
+    markDisposal(el);
+    globalQueue._pendingNodes.push(el);
+    el._pendingDisposal = el._disposal;
+    el._pendingFirstChild = el._firstChild;
+    el._disposal = null;
+    el._firstChild = null;
+  }
+  const oldcontext = context;
+  context = el;
+  el._depsTail = null;
+  el._flags = 4 /* RecomputingDeps */;
+  el._time = clock;
+  let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+  let oldHeight = el._height;
+  let prevStatusFlags = el._statusFlags;
+  let prevError = el._error;
+  let prevTracking = tracking;
+  clearStatusFlags(el);
+  tracking = true;
+  try {
+    value = el._fn(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._children.push(child);
-    child._parent = this;
-  }
-  removeChild(child) {
-    const index = this._children.indexOf(child);
-    if (index >= 0)
-      this._children.splice(index, 1);
-  }
-  notify(node, type, flags) {
-    if (!(type & LOADING_BIT))
-      return false;
-    if (flags & LOADING_BIT) {
-      this._pendingNodes.add(node);
+  el._flags = 0 /* None */;
+  context = oldcontext;
+  const depsTail = el._depsTail;
+  let toRemove = depsTail !== null ? depsTail._nextDep : el._deps;
+  if (toRemove !== null) {
+    do {
+      toRemove = unlinkSubs(toRemove);
+    } while (toRemove !== null);
+    if (depsTail !== null) {
+      depsTail._nextDep = null;
     } else {
-      this._pendingNodes.delete(node);
+      el._deps = null;
     }
-    return true;
   }
-  merge(queue) {
-    this._queues[0].push.apply(this._queues[0], queue._queues[0]);
-    this._queues[1].push.apply(this._queues[1], queue._queues[1]);
-    this._pureQueue.push.apply(this._pureQueue, queue._pureQueue);
-    queue._queues[0].length = 0;
-    queue._queues[1].length = 0;
-    queue._pureQueue.length = 0;
-    for (let i = 0; i < queue._children.length; i++) {
-      const og = this._children.find((c) => c._cloned === queue._children[i]._cloned);
-      if (og)
-        og.merge(queue._children[i]);
-      else
-        this.addChild(queue._children[i]);
-    }
-  }
-  schedule() {
-    if (this._scheduled)
-      return;
-    this._scheduled = true;
-    if (!this._running)
-      queueMicrotask(() => this.flush());
-  }
-  runTransition(fn, force = false) {
-    if (this._done) {
-      if (this._done instanceof _Transition)
-        return this._done.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._promises.add(temp.value);
-              try {
-                value = await temp.value;
-              } finally {
-                transition2 = latestTransition(transition2);
-                transition2._promises.delete(temp.value);
-              }
-              ActiveTransition = transition2;
-            } else
-              value = temp.value;
-          }
-          ActiveTransition = null;
-          finishTransition(transition2);
-        })();
-      }
-      if (result instanceof Promise) {
-        transition2._promises.add(result);
-        result.finally(() => {
-          transition2 = latestTransition(transition2);
-          transition2._promises.delete(result);
-          ActiveTransition = null;
-          finishTransition(transition2);
-        });
+  const valueChanged = !el._equals || !el._equals(el._pendingValue === NOT_PENDING ? el._value : el._pendingValue, value);
+  const statusFlagsChanged = el._statusFlags !== prevStatusFlags || el._error !== prevError;
+  el._notifyQueue?.(statusFlagsChanged, prevStatusFlags);
+  if (valueChanged || statusFlagsChanged) {
+    if (valueChanged) {
+      if (create || el._optimistic || el._type)
+        el._value = value;
+      else {
+        if (el._pendingValue === NOT_PENDING)
+          globalQueue._pendingNodes.push(el);
+        el._pendingValue = value;
       }
-    } finally {
-      const transition2 = ActiveTransition;
-      ActiveTransition = null;
-      finishTransition(transition2);
+      if (el._pendingSignal)
+        el._pendingSignal._set(value);
     }
-  }
-  addOptimistic(fn) {
-    if (fn._transition && fn._transition !== this) {
-      mergeTransitions(fn._transition, this);
-      ActiveTransition = fn._transition;
-      return;
+    for (let s = el._subs; s !== null; s = s._nextSub) {
+      const queue = s._sub._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+      if (s._sub._height < el._height && queue._min > s._sub._height)
+        queue._min = s._sub._height;
+      insertIntoHeap(s._sub, queue);
     }
-    fn._transition = this;
-    this._optimistic.add(fn);
-  }
-};
-function cloneGraph(node) {
-  if (node._optimistic) {
-    if (node._state !== STATE_DISPOSED) {
-      !node._transition && node._optimistic._init?.();
-      ActiveTransition.addOptimistic(node._optimistic);
-    }
-    return node;
-  }
-  if (node._transition) {
-    if (node._transition !== ActiveTransition) {
-      mergeTransitions(node._transition, ActiveTransition);
-      ActiveTransition = node._transition;
+  } else if (el._height != oldHeight) {
+    for (let s = el._subs; s !== null; s = s._nextSub) {
+      insertIntoHeapHeight(s._sub, s._sub._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
     }
-    return node._transition._sources.get(node);
   }
-  const clone = Object.create(Object.getPrototypeOf(node));
-  Object.assign(clone, node, {
-    _disposal: null,
-    _nextSibling: null,
-    _observers: null,
-    _sources: node._sources ? [...node._sources] : null,
-    _cloned: node
-  });
-  delete clone._prevValue;
-  ActiveTransition._sources.set(node, clone);
-  node._transition = ActiveTransition;
-  if (node._sources) {
-    for (let i = 0; i < node._sources.length; i++)
-      node._sources[i]._observers.push(clone);
-  }
-  if (node._observers) {
-    clone._observers = [];
-    for (let i = 0, length = node._observers.length; i < length; i++) {
-      !node._observers[i]._cloned && clone._observers.push(cloneGraph(node._observers[i]));
-    }
-  }
-  return clone;
-}
-function latestTransition(t) {
-  while (t._done instanceof Transition)
-    t = t._done;
-  return t;
-}
-function replaceSourceObservers(node, transition2) {
-  let source;
-  let transitionSource;
-  let swap;
-  for (let i = 0; i < node._sources.length; i++) {
-    transitionSource = transition2._sources.get(node._sources[i]);
-    source = transitionSource || node._sources[i];
-    if (source._observers && (swap = source._observers.indexOf(node)) !== -1) {
-      source._observers[swap] = transitionSource ? node._cloned : source._observers[source._observers.length - 1];
-      !transitionSource && source._observers.pop();
-    }
-  }
-}
-function cloneQueue(queue, parent, transition2) {
-  const clone = Object.create(Object.getPrototypeOf(queue));
-  Object.assign(clone, queue, {
-    _cloned: queue,
-    _parent: parent,
-    _children: [],
-    enqueue(type, fn) {
-      transition2 = latestTransition(transition2);
-      transition2.enqueue(type, fn);
-    },
-    notify(node, type, flags) {
-      node = node._cloned || node;
-      if (!clone._collectionType || type & LOADING_BIT) {
-        type &= ~LOADING_BIT;
-        transition2 = latestTransition(transition2);
-        transition2.notify(node, LOADING_BIT, flags);
-        if (!type)
-          return true;
+}
+function updateIfNecessary(el) {
+  if (el._flags & 1 /* Check */) {
+    for (let d = el._deps; d; d = d._nextDep) {
+      const dep1 = d._dep;
+      const dep = "_owner" in dep1 ? dep1._owner : dep1;
+      if ("_fn" in dep) {
+        updateIfNecessary(dep);
+      }
+      if (el._flags & 2 /* Dirty */) {
+        break;
       }
-      return queue.notify.call(this, node, type, flags);
-    }
-  });
-  parent._children.push(clone);
-  transition2._clonedQueues.set(queue, clone);
-  for (const child of queue._children) {
-    cloneQueue(child, clone, transition2);
-  }
-}
-function resolveQueues(children) {
-  for (const child of children) {
-    const og = child._cloned;
-    if (og) {
-      const clonedChildren = child._children;
-      delete child.enqueue;
-      delete child.notify;
-      delete child._parent;
-      delete child._children;
-      Object.assign(og, child);
-      delete og._cloned;
-      resolveQueues(clonedChildren);
-    } else if (child._parent._cloned) {
-      child._parent._cloned.addChild(child);
-    }
-  }
-}
-function mergeTransitions(t1, t2) {
-  t2._sources.forEach((value, key) => {
-    key._transition = t1;
-    t1._sources.set(key, value);
-  });
-  t2._optimistic.forEach((c) => {
-    c._transition = t1;
-    t1._optimistic.add(c);
-  });
-  t2._promises.forEach((p) => t1._promises.add(p));
-  t2._pendingNodes.forEach((n) => t1._pendingNodes.add(n));
-  t1.merge(t2);
-  t2._done = t1;
-}
-function getTransitionSource(input) {
-  return ActiveTransition && ActiveTransition._sources.get(input) || input;
-}
-function getQueue(node) {
-  const transition2 = ActiveTransition || node._cloned?._transition;
-  return transition2 && transition2._clonedQueues.get(node._queue) || node._queue;
-}
-function initialDispose(node) {
-  let current = node._nextSibling;
-  while (current !== null && current._parent === node) {
-    initialDispose(current);
-    const clone = ActiveTransition._sources.get(current);
-    if (clone && !clone._updated)
-      clone.dispose(true);
-    current = current._nextSibling;
-  }
-}
-function finishTransition(transition2) {
-  if (transition2._done || transition2._scheduled || transition2._promises.size || transition2._pendingNodes.size)
-    return;
-  globalQueue._queues[0].push.apply(globalQueue._queues[0], transition2._queues[0]);
-  globalQueue._queues[1].push.apply(globalQueue._queues[1], transition2._queues[1]);
-  resolveQueues(transition2._children);
-  for (const [source, clone] of transition2._sources) {
-    if (source === clone || source._transition !== transition2) {
-      delete source._transition;
-      continue;
-    }
-    if (clone._sources)
-      replaceSourceObservers(clone, transition2);
-    if (clone._updated || clone._state === STATE_DISPOSED) {
-      source.dispose(clone._state === STATE_DISPOSED);
-      source.emptyDisposal();
-      delete clone._updated;
-    } else {
-      delete clone._nextSibling;
-      delete clone._disposal;
-    }
-    Object.assign(source, clone);
-    delete source._cloned;
-    let current = clone._nextSibling;
-    if (current?._prevSibling === clone)
-      current._prevSibling = source;
-    while (current?._parent === clone) {
-      current._parent = source;
-      current = current._nextSibling;
     }
-    delete source._transition;
   }
-  transition2._done = true;
-  for (const reset of transition2._optimistic) {
-    delete reset._transition;
-    reset();
+  if (el._flags & 2 /* Dirty */) {
+    recompute(el);
   }
-  transition2._signal.write(true);
-  globalQueue.flush();
-}
-
-// src/core/owner.ts
-var currentOwner = null;
-var defaultContext = {};
-function getOwner() {
-  return currentOwner;
+  el._flags = 0 /* None */;
 }
-function setOwner(owner) {
-  const out = currentOwner;
-  currentOwner = owner;
-  return out;
+function unlinkSubs(link2) {
+  const dep = link2._dep;
+  const nextDep = link2._nextDep;
+  const nextSub = link2._nextSub;
+  const prevSub = link2._prevSub;
+  if (nextSub !== null) {
+    nextSub._prevSub = prevSub;
+  } else {
+    dep._subsTail = prevSub;
+  }
+  if (prevSub !== null) {
+    prevSub._nextSub = nextSub;
+  } else {
+    dep._subs = nextSub;
+  }
+  return nextDep;
 }
-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
-  _parent = null;
-  _nextSibling = null;
-  _prevSibling = null;
-  _state = STATE_CLEAN;
-  _disposal = null;
-  _context = defaultContext;
-  _queue = globalQueue;
-  _childCount = 0;
-  id = null;
-  constructor(id = null, skipAppend = false) {
-    this.id = id;
-    if (currentOwner) {
-      !skipAppend && currentOwner.append(this);
-    }
-  }
-  append(child) {
-    child._parent = this;
-    child._prevSibling = this;
-    if (this._nextSibling)
-      this._nextSibling._prevSibling = child;
-    child._nextSibling = this._nextSibling;
-    this._nextSibling = child;
-    if (this.id != null && child.id == null)
-      child.id = this.getNextChildId();
-    if (child._context !== this._context) {
-      child._context = { ...this._context, ...child._context };
-    }
-    if (this._queue)
-      child._queue = this._queue;
-  }
-  dispose(self = true) {
-    if (this._state === STATE_DISPOSED)
-      return;
-    let head = self ? this._prevSibling || this._parent : this, current = this._nextSibling, next = null;
-    while (current && current._parent === this) {
-      current.dispose(true);
-      next = current._nextSibling;
-      current._nextSibling = null;
-      current = next;
-    }
-    this._childCount = 0;
-    if (self)
-      this._disposeNode();
-    if (current)
-      current._prevSibling = !self ? this : this._prevSibling;
-    if (head)
-      head._nextSibling = current;
-  }
-  _disposeNode() {
-    if (this._prevSibling)
-      this._prevSibling._nextSibling = null;
-    this._parent = null;
-    this._prevSibling = null;
-    this._context = defaultContext;
-    this._state = STATE_DISPOSED;
-    this.emptyDisposal();
-  }
-  emptyDisposal() {
-    if (!this._disposal)
+function link(dep, sub) {
+  const prevDep = sub._depsTail;
+  if (prevDep !== null && prevDep._dep === dep) {
+    return;
+  }
+  let nextDep = null;
+  const isRecomputing = sub._flags & 4 /* RecomputingDeps */;
+  if (isRecomputing) {
+    nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
+    if (nextDep !== null && nextDep._dep === dep) {
+      sub._depsTail = nextDep;
       return;
-    if (Array.isArray(this._disposal)) {
-      for (let i = 0; i < this._disposal.length; i++) {
-        const callable = this._disposal[i];
-        callable.call(callable);
-      }
-    } else {
-      this._disposal.call(this._disposal);
     }
-    this._disposal = null;
   }
-  getNextChildId() {
-    if (this.id != null)
-      return formatId(this.id, this._childCount++);
-    throw new Error("Cannot get child id from owner without an id");
+  const prevSub = dep._subsTail;
+  if (prevSub !== null && prevSub._sub === 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._depsTail = dep._subsTail = {
+    _dep: dep,
+    _sub: sub,
+    _nextDep: nextDep,
+    _prevSub: prevSub,
+    _nextSub: null
+  };
+  if (prevDep !== null) {
+    prevDep._nextDep = newLink;
+  } else {
+    sub._deps = newLink;
   }
-  const value = hasContext(context, owner) ? owner._context[context.id] : context.defaultValue;
-  if (isUndefined(value)) {
-    throw new ContextNotFoundError();
+  if (prevSub !== null) {
+    prevSub._nextSub = newLink;
+  } else {
+    dep._subs = newLink;
   }
-  return value;
 }
-function setContext(context, value, owner = currentOwner) {
-  if (!owner) {
-    throw new NoOwnerError();
+function isValidLink(checkLink, sub) {
+  const depsTail = sub._depsTail;
+  if (depsTail !== null) {
+    let link2 = sub._deps;
+    do {
+      if (link2 === checkLink) {
+        return true;
+      }
+      if (link2 === depsTail) {
+        break;
+      }
+      link2 = link2._nextDep;
+    } while (link2 !== null);
   }
-  owner._context = {
-    ...owner._context,
-    [context.id]: isUndefined(value) ? context.defaultValue : value
-  };
+  return false;
 }
-function hasContext(context, owner = currentOwner) {
-  return !isUndefined(owner?._context[context.id]);
+function setStatusFlags(signal2, flags, error = null) {
+  signal2._statusFlags = flags;
+  signal2._error = error;
 }
-function onCleanup(fn) {
-  if (!currentOwner)
-    return fn;
-  const node = currentOwner;
-  if (!node._disposal) {
-    node._disposal = fn;
-  } else if (Array.isArray(node._disposal)) {
-    node._disposal.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._firstChild;
+  while (child) {
+    child._flags |= 32 /* Zombie */;
+    const inHeap = child._flags & 8 /* InHeap */;
+    if (inHeap) {
+      deleteFromHeap(child, dirtyQueue);
+      insertIntoHeap(child, zombieQueue);
+    }
+    markDisposal(child);
+    child = child._nextSibling;
+  }
+}
+function disposeChildren(node, self = false, zombie) {
+  if (node._flags & 64 /* Disposed */)
+    return;
+  if (self)
+    node._flags = 64 /* Disposed */;
+  let child = zombie ? node._pendingFirstChild : node._firstChild;
+  while (child) {
+    const nextChild = child._nextSibling;
+    if (child._deps) {
+      const n = child;
+      deleteFromHeap(n, n._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue);
+      let toRemove = n._deps;
+      do {
+        toRemove = unlinkSubs(toRemove);
+      } while (toRemove !== null);
+      n._deps = null;
+      n._depsTail = null;
+    }
+    disposeChildren(child, true);
+    child = nextChild;
+  }
+  if (zombie) {
+    node._pendingFirstChild = null;
   } else {
-    node._disposal = [node._disposal, fn];
+    node._firstChild = null;
+    node._nextSibling = null;
   }
-  return fn;
+  runDisposal(node, zombie);
+}
+function runDisposal(node, zombie) {
+  let disposal = zombie ? node._pendingDisposal : node._disposal;
+  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._pendingDisposal = null : node._disposal = null;
+}
+function withOptions(obj, options) {
+  obj._name = options?.name ?? (obj._fn ? "computed" : "signal");
+  obj.id = options?.id ?? (context?.id != null ? getNextChildId(context) : void 0);
+  obj._equals = options?.equals != null ? options.equals : isEqual;
+  obj._pureWrite = !!options?.pureWrite;
+  obj._unobserved = options?.unobserved;
+  if (options?._internal)
+    Object.assign(obj, options._internal);
+  return obj;
+}
+function getNextChildId(owner) {
+  if (owner.id != null)
+    return formatId(owner.id, owner._childCount++);
+  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";
+function computed(fn, initialValue, options) {
+  const self = withOptions(
+    {
+      _disposal: null,
+      _queue: globalQueue,
+      _context: defaultContext,
+      _childCount: 0,
+      _fn: fn,
+      _value: initialValue,
+      _height: 0,
+      _child: null,
+      _nextHeap: void 0,
+      _prevHeap: null,
+      _deps: null,
+      _depsTail: null,
+      _subs: null,
+      _subsTail: null,
+      _parent: context,
+      _nextSibling: null,
+      _firstChild: null,
+      _flags: 0 /* None */,
+      _statusFlags: 4 /* Uninitialized */,
+      _time: clock,
+      _pendingValue: NOT_PENDING,
+      _pendingDisposal: null,
+      _pendingFirstChild: null
+    },
+    options
+  );
+  self._prevHeap = self;
+  const parent = context?._root ? context._parentComputed : context;
+  if (context) {
+    context._queue && (self._queue = context._queue);
+    context._context && (self._context = context._context);
+    const lastChild = context._firstChild;
+    if (lastChild === null) {
+      context._firstChild = self;
+    } else {
+      self._nextSibling = lastChild;
+      context._firstChild = self;
+    }
+  }
+  if (parent)
+    self._height = parent._height + 1;
+  recompute(self, true);
+  return self;
 }
-
-// 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;
-}
-var UNCHANGED = Symbol("unchanged" );
-var Computation = class extends Owner {
-  _sources = null;
-  _observers = null;
-  _value;
-  _error;
-  _compute;
-  // Used in __DEV__ mode, hopefully removed in production
-  _name;
-  // Using false is an optimization as an alternative to _equals: () => false
-  // which could enable more efficient DIRTY notification
-  _equals = isEqual;
-  _unobserved;
-  _pureWrite = false;
-  /** Whether the computation is an error or has ancestors that are unresolved */
-  _stateFlags = 0;
-  /** Which flags raised by sources are handled, vs. being passed through. */
-  _handlerMask = DEFAULT_FLAGS;
-  _time = -1;
-  _forceNotify = false;
-  _transition;
-  _cloned;
-  _optimistic;
-  constructor(initialValue, compute2, options) {
-    super(options?.id, compute2 === null);
-    this._compute = compute2;
-    this._state = compute2 ? STATE_DIRTY : STATE_CLEAN;
-    this._stateFlags = compute2 && initialValue === void 0 ? UNINITIALIZED_BIT : 0;
-    this._value = initialValue;
-    this._name = options?.name ?? (this._compute ? "computed" : "signal");
-    if (options?.equals !== void 0)
-      this._equals = options.equals;
-    this._pureWrite = !!options?.pureWrite;
-    this._unobserved = options?.unobserved;
-    if (ActiveTransition) {
-      this._transition = ActiveTransition;
-      ActiveTransition._sources.set(this, this);
-    }
-  }
-  _read() {
-    if (staleCheck && (this._stateFlags & LOADING_BIT || this._transition)) {
-      staleCheck._value = true;
-      this._transition?._signal.read();
-    }
-    track(this);
-    newFlags |= this._stateFlags & ~currentMask;
-    if (this._stateFlags & ERROR_BIT) {
-      throw this._error;
+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._value;
-    }
-  }
-  /**
-   * Return the current value of this computation
-   * Automatically re-executes the surrounding computation when the value changes
-   */
-  read() {
-    if (ActiveTransition && (ActiveTransition._sources.has(this) || !this._cloned && this._stateFlags & (UNINITIALIZED_BIT | ERROR_BIT))) {
-      const clone = ActiveTransition._sources.get(this) || cloneGraph(this);
-      if (clone !== this)
-        return clone.read();
-    }
-    if (this._compute) {
-      if (this._stateFlags & ERROR_BIT && this._time <= clock)
-        update(this);
-      else
-        this._updateIfNecessary();
-    }
-    return this._read();
-  }
-  /**
-   * 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._sources.has(this) || !this._cloned && this._stateFlags & (UNINITIALIZED_BIT | ERROR_BIT))) {
-      const clone = ActiveTransition._sources.get(this) || cloneGraph(this);
-      if (clone !== this)
-        return clone.wait();
-    }
-    if (this._compute) {
-      if (this._stateFlags & ERROR_BIT && this._time <= clock)
-        update(this);
-      else
-        this._updateIfNecessary();
-    }
-    if ((notStale || this._stateFlags & UNINITIALIZED_BIT) && this._stateFlags & LOADING_BIT) {
-      throw new NotReadyError(this);
-    }
-    return this._read();
-  }
-  /** Update the computation with a new value. */
-  write(value, flags = 0, raw = false) {
-    if (ActiveTransition && !this._cloned) {
-      const clone = cloneGraph(this);
-      if (clone !== this)
-        return clone.write(value, flags, raw);
-    }
-    if (!this._compute && !this._pureWrite && getOwner() && !getOwner().firewall)
-      console.warn("A Signal was written to in an owned scope.");
-    const newValue = !raw && typeof value === "function" ? value(this._value) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(this._stateFlags & UNINITIALIZED_BIT) || // this._stateFlags & LOADING_BIT & ~flags ||
-    this._equals === false || !this._equals(this._value, newValue));
-    if (valueChanged) {
-      this._value = newValue;
-      this._error = void 0;
-    }
-    const changedFlagsMask = this._stateFlags ^ flags, changedFlags = changedFlagsMask & flags;
-    this._stateFlags = flags;
-    this._time = clock + 1;
-    if (this._observers && !(this._optimistic && ActiveTransition)) {
-      for (let i = 0; i < this._observers.length; i++) {
-        if (valueChanged) {
-          this._observers[i]._notify(STATE_DIRTY);
-        } else if (changedFlagsMask) {
-          this._observers[i]._notifyFlags(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._value;
+    globalQueue.initTransition(context);
+    throw new NotReadyError(context);
+  };
+  const self = computed(fn, initialValue, options);
+  self._refresh = () => {
+    refreshing = true;
+    recompute(self);
+    flush();
+  };
+  return self;
+}
+function signal(v, options, firewall = null) {
+  if (firewall !== null) {
+    return firewall._child = withOptions(
+      {
+        _value: v,
+        _subs: null,
+        _subsTail: null,
+        _owner: firewall,
+        _nextChild: firewall._child,
+        _statusFlags: 0 /* None */,
+        _time: clock,
+        _pendingValue: NOT_PENDING
+      },
+      options
+    );
+  } else {
+    return withOptions(
+      {
+        _value: v,
+        _subs: null,
+        _subsTail: null,
+        _statusFlags: 0 /* None */,
+        _time: clock,
+        _pendingValue: NOT_PENDING
+      },
+      options
+    );
   }
-  /**
-   * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
-   */
-  _notify(state, skipQueue) {
-    if (this._state >= state && !this._forceNotify)
-      return;
-    this._forceNotify = !!skipQueue;
-    this._state = state;
-    if (this._observers && !(this._optimistic && ActiveTransition)) {
-      for (let i = 0; i < this._observers.length; i++) {
-        this._observers[i]._notify(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?._root)
+    c = c._parentComputed;
+  if (c && tracking) {
+    link(el, c);
+    const owner = "_owner" in el ? el._owner : el;
+    if ("_fn" in owner) {
+      const isZombie = el._flags & 32 /* Zombie */;
+      if (owner._height >= (isZombie ? zombieQueue._min : dirtyQueue._min)) {
+        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.
-   */
-  _notifyFlags(mask, newFlags2) {
-    if (this._state >= STATE_DIRTY)
-      return;
-    if (mask & this._handlerMask || this._optimistic && ActiveTransition) {
-      this._notify(STATE_DIRTY);
-      return;
-    }
-    if (this._state >= STATE_CHECK && !this._forceNotify)
-      return;
-    const prevFlags = this._stateFlags & mask;
-    const deltaFlags = prevFlags ^ newFlags2;
-    if (newFlags2 === prevFlags) ; else if (deltaFlags & prevFlags & mask) {
-      this._notify(STATE_CHECK);
-    } else {
-      this._stateFlags ^= deltaFlags;
-      if (this._observers) {
-        for (let i = 0; i < this._observers.length; i++) {
-          this._observers[i]._notifyFlags(mask, newFlags2);
-        }
+      const height = owner._height;
+      if (height >= c._height && el._parent !== c) {
+        c._height = height + 1;
       }
     }
   }
-  _setError(error) {
-    if (ActiveTransition && !this._cloned) {
-      const clone = cloneGraph(this);
-      if (clone !== this)
-        return clone._setError(error);
-    }
-    this._error = error;
-    this.write(UNCHANGED, this._stateFlags & ~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
-   */
-  _updateIfNecessary() {
-    if (!this._compute) {
-      return;
+  if (pendingCheck) {
+    const pendingResult = (el._statusFlags & 1 /* Pending */) !== 0 || !!el._transition || false;
+    if (!el._pendingCheck) {
+      el._pendingCheck = signal(pendingResult);
+      el._pendingCheck._optimistic = true;
+      el._pendingCheck._set = (v) => setSignal(el._pendingCheck, v);
     }
-    if (this._state === STATE_DISPOSED) {
-      return;
+    const prev = pendingCheck;
+    pendingCheck = null;
+    read(el._pendingCheck);
+    pendingCheck = prev;
+    prev._value = pendingResult || prev._value;
+  }
+  if (pendingValueCheck) {
+    if (!el._pendingSignal) {
+      el._pendingSignal = signal(
+        el._pendingValue === NOT_PENDING ? el._value : el._pendingValue
+      );
+      el._pendingSignal._optimistic = true;
+      el._pendingSignal._set = (v) => queueMicrotask(() => queueMicrotask(() => setSignal(el._pendingSignal, v)));
     }
-    if (this._state === STATE_CLEAN) {
-      return;
+    pendingValueCheck = false;
+    try {
+      return read(el._pendingSignal);
+    } finally {
+      pendingValueCheck = true;
     }
-    let observerFlags = 0;
-    if (this._state === STATE_CHECK) {
-      for (let i = 0; i < this._sources.length; i++) {
-        const source = getTransitionSource(this._sources[i]);
-        source._updateIfNecessary();
-        observerFlags |= source._stateFlags & ~UNINITIALIZED_BIT;
-        if (this._state === STATE_DIRTY) {
-          break;
-        }
-      }
+  }
+  if (el._statusFlags & 1 /* Pending */) {
+    if (c && !stale || el._statusFlags & 4 /* Uninitialized */)
+      throw el._error;
+    else if (c && stale && !pendingCheck) {
+      setStatusFlags(
+        c,
+        c._statusFlags | 1,
+        el._error
+      );
     }
-    if (this._state === STATE_DIRTY) {
-      update(this);
+  }
+  if (el._statusFlags & 2 /* Error */) {
+    if (el._time < clock) {
+      recompute(el, true);
+      return read(el);
     } else {
-      this.write(UNCHANGED, observerFlags);
-      this._state = STATE_CLEAN;
+      throw el._error;
     }
   }
-  /**
-   * Remove ourselves from the owner graph and the computation graph
-   */
-  _disposeNode() {
-    if (this._state === STATE_DISPOSED)
-      return;
-    if (this._sources)
-      removeSourceObservers(this, 0);
-    super._disposeNode();
+  return !c || el._pendingValue === NOT_PENDING || stale && !pendingCheck && el._transition && activeTransition !== el._transition ? el._value : el._pendingValue;
+}
+function setSignal(el, v) {
+  if (!el._pureWrite && context && !context.firewall)
+    console.warn("A Signal was written to in an owned scope.");
+  if (typeof v === "function") {
+    v = v(
+      el._pendingValue === NOT_PENDING ? el._value : el._pendingValue
+    );
   }
-};
-function track(computation) {
-  if (ActiveTransition && computation._cloned)
-    computation = computation._cloned;
-  if (currentObserver) {
-    if (!newSources && currentObserver._sources && currentObserver._sources[newSourcesIndex] === computation) {
-      newSourcesIndex++;
-    } else if (!newSources)
-      newSources = [computation];
-    else if (computation !== newSources[newSources.length - 1]) {
-      newSources.push(computation);
-    }
-    if (updateCheck) {
-      updateCheck._value = computation._time > currentObserver._time;
-    }
-  }
-}
-function update(node) {
-  const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
-  newSources = null;
-  newSourcesIndex = 0;
-  newFlags = 0;
-  try {
-    if (ActiveTransition && node._cloned && !node._updated) {
-      initialDispose(node._cloned);
-      node._updated = true;
-    }
-    node.dispose(false);
-    node.emptyDisposal();
-    const result = compute(node, node._compute, 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._stateFlags & UNINITIALIZED_BIT);
-    } else {
-      node._setError(error);
+  const valueChanged = !el._equals || !el._equals(el._pendingValue === NOT_PENDING ? el._value : el._pendingValue, v);
+  if (!valueChanged && !el._statusFlags)
+    return v;
+  if (valueChanged) {
+    if (el._optimistic)
+      el._value = v;
+    else {
+      if (el._pendingValue === NOT_PENDING)
+        globalQueue._pendingNodes.push(el);
+      el._pendingValue = v;
+    }
+    if (el._pendingSignal)
+      el._pendingSignal._set(v);
+  }
+  clearStatusFlags(el);
+  el._time = clock;
+  for (let s = el._subs; s !== null; s = s._nextSub) {
+    const queue = s._sub._flags & 32 /* Zombie */ ? zombieQueue : dirtyQueue;
+    if (queue._min > s._sub._height)
+      queue._min = s._sub._height;
+    insertIntoHeap(s._sub, 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._disposal) {
+    node._disposal = fn;
+  } else if (Array.isArray(node._disposal)) {
+    node._disposal.push(fn);
+  } else {
+    node._disposal = [node._disposal, fn];
+  }
+  return fn;
+}
+function createOwner(options) {
+  const parent = context;
+  const owner = {
+    _root: true,
+    _parentComputed: parent?._root ? parent._parentComputed : parent,
+    _firstChild: null,
+    _nextSibling: null,
+    _disposal: null,
+    id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : void 0),
+    _queue: parent?._queue ?? globalQueue,
+    _context: parent?._context || defaultContext,
+    _childCount: 0,
+    _pendingDisposal: null,
+    _pendingFirstChild: null,
+    _parent: parent,
+    dispose(self = true) {
+      disposeChildren(owner, self);
     }
-  } finally {
-    if (newSources) {
-      if (node._sources)
-        removeSourceObservers(node, newSourcesIndex);
-      if (node._sources && newSourcesIndex > 0) {
-        node._sources.length = newSourcesIndex + newSources.length;
-        for (let i = 0; i < newSources.length; i++) {
-          node._sources[newSourcesIndex + i] = newSources[i];
-        }
-      } else {
-        node._sources = newSources;
-      }
-      let source;
-      for (let i = newSourcesIndex; i < node._sources.length; i++) {
-        source = getTransitionSource(node._sources[i]);
-        if (!source._observers)
-          source._observers = [node];
-        else
-          source._observers.push(node);
-      }
-    } else if (node._sources && newSourcesIndex < node._sources.length) {
-      removeSourceObservers(node, newSourcesIndex);
-      node._sources.length = newSourcesIndex;
+  };
+  if (parent) {
+    const lastChild = parent._firstChild;
+    if (lastChild === null) {
+      parent._firstChild = owner;
+    } else {
+      owner._nextSibling = lastChild;
+      parent._firstChild = owner;
     }
-    newSources = prevSources;
-    newSourcesIndex = prevSourcesIndex;
-    newFlags = prevFlags;
-    node._time = clock + 1;
-    node._state = 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();
-  return compute(getOwner(), fn, null);
+  } finally {
+    context = oldContext;
+  }
 }
-function hasUpdated(fn) {
-  const current = updateCheck;
-  updateCheck = { _value: false };
+function staleValues(fn, set = true) {
+  const prevStale = stale;
+  stale = set;
   try {
-    fn();
-    return updateCheck._value;
+    return fn();
   } finally {
-    updateCheck = current;
+    stale = prevStale;
   }
 }
-function pendingCheck(fn, loadingValue) {
-  const current = staleCheck;
-  staleCheck = { _value: false };
+function pending(fn) {
+  const prevLatest = pendingValueCheck;
+  pendingValueCheck = true;
   try {
-    latest(fn);
-    return staleCheck._value;
+    return staleValues(fn, false);
+  } finally {
+    pendingValueCheck = prevLatest;
+  }
+}
+function isPending(fn, loadingValue) {
+  const current = pendingCheck;
+  pendingCheck = { _value: false };
+  try {
+    staleValues(fn);
+    return pendingCheck._value;
   } catch (err) {
     if (!(err instanceof NotReadyError))
       return false;
@@ -970,421 +933,163 @@ 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._optimistic = () => c.write(false);
-  c._optimistic._init = () => globalQueue.enqueue(0, () => c._optimistic._transition && c.write(true));
-  c._handlerMask |= LOADING_BIT;
-  const res = c.wait();
-  c._disposal = () => {
-    if (c._optimistic._transition) {
-      c._optimistic._transition._optimistic.delete(c._optimistic);
-      delete c._optimistic._transition;
-    }
-  };
-  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._context[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?._handlerMask ?? DEFAULT_FLAGS;
-  notStale = true;
-  try {
-    return fn.call(observer, observer ? observer._value : void 0);
-  } finally {
-    setOwner(prevOwner);
-    currentObserver = prevObserver;
-    currentMask = prevMask;
-    notStale = prevNotStale;
+function setContext(context2, value, owner = getOwner()) {
+  if (!owner) {
+    throw new NoOwnerError();
   }
+  owner._context = {
+    ...owner._context,
+    [context2.id]: isUndefined(value) ? context2.defaultValue : value
+  };
+}
+function hasContext(context2, owner) {
+  return !isUndefined(owner?._context[context2.id]);
+}
+function isUndefined(value) {
+  return typeof value === "undefined";
 }
 
 // src/core/effect.ts
-var Effect = class extends Computation {
-  _effect;
-  _onerror;
-  _cleanup;
-  _modified = false;
-  _prevValue;
-  _type;
-  constructor(initialValue, compute2, effect, error, options) {
-    super(initialValue, compute2, options);
-    this._effect = effect;
-    this._onerror = error;
-    this._prevValue = initialValue;
-    this._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
-    if (this._type === EFFECT_RENDER) {
-      this._compute = function(p) {
-        return !this._cloned && clock > this._queue.created && !(this._stateFlags & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
-      };
-    }
-    this._updateIfNecessary();
-    !options?.defer && (this._type === EFFECT_USER ? getQueue(this).enqueue(this._type, this._run.bind(this)) : this._run(this._type));
-    if (!this._parent)
-      console.warn("Effects created outside a reactive context will never be disposed");
-  }
-  write(value, flags = 0) {
-    if (this._state == STATE_DIRTY) {
-      this._stateFlags = flags;
-      if (this._type === EFFECT_RENDER) {
-        getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this._stateFlags);
-      }
-    }
-    if (value === UNCHANGED)
-      return this._value;
-    this._value = value;
-    this._modified = true;
-    this._error = void 0;
-    return value;
-  }
-  _notify(state, skipQueue) {
-    if (this._state >= state || skipQueue)
-      return;
-    if (this._state === STATE_CLEAN || this._cloned && !ActiveTransition)
-      getQueue(this).enqueue(this._type, this._run.bind(this));
-    this._state = state;
-  }
-  _notifyFlags(mask, newFlags2) {
-    if (this._cloned) {
-      if (this._state >= STATE_DIRTY)
-        return;
-      if (mask & 3) {
-        this._notify(STATE_DIRTY);
-        return;
-      }
-    }
-    super._notifyFlags(mask, newFlags2);
-  }
-  _setError(error) {
-    this._error = error;
-    getQueue(this).notify(this, LOADING_BIT, 0);
-    this._stateFlags = ERROR_BIT;
-    if (this._type === EFFECT_USER) {
-      try {
-        return this._onerror ? this._onerror(error, () => {
-          this._cleanup?.();
-          this._cleanup = void 0;
-        }) : console.error(error);
-      } catch (e) {
-        error = e;
-      }
-    }
-    if (!getQueue(this).notify(this, ERROR_BIT, ERROR_BIT))
-      throw error;
-  }
-  _disposeNode() {
-    if (this._state === STATE_DISPOSED)
-      return;
-    this._effect = void 0;
-    this._prevValue = void 0;
-    this._onerror = void 0;
-    this._cleanup?.();
-    this._cleanup = void 0;
-    getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
-    super._disposeNode();
-  }
-  _run(type) {
-    if (type) {
-      const effect = this._cloned || this;
-      if (effect._modified && effect._state !== STATE_DISPOSED) {
-        effect._cleanup?.();
-        try {
-          effect._cleanup = effect._effect(effect._value, effect._prevValue);
-        } catch (e) {
-          if (!getQueue(effect).notify(effect, ERROR_BIT, ERROR_BIT))
-            throw e;
-        } finally {
-          effect._prevValue = effect._value;
-          effect._modified = false;
+function effect(compute, effect2, error, initialValue, options) {
+  let initialized = false;
+  const node = computed(compute, initialValue, {
+    ...options,
+    _internal: {
+      _modified: true,
+      _prevValue: initialValue,
+      _effectFn: effect2,
+      _errorFn: error,
+      _cleanup: void 0,
+      _queue: getOwner()?._queue ?? globalQueue,
+      _type: options?.render ? 1 /* Render */ : 2 /* User */,
+      _notifyQueue(statusFlagsChanged, prevStatusFlags) {
+        if (initialized) {
+          const errorChanged = this._statusFlags && this._statusFlags === prevStatusFlags && statusFlagsChanged;
+          this._modified = !(this._statusFlags & 2 /* Error */) && !(this._statusFlags & 1 /* Pending */ & ~prevStatusFlags) && !errorChanged;
+          if (this._modified)
+            this._queue.enqueue(this._type, runEffect.bind(this));
+        }
+        if (this._statusFlags & 2 /* Error */) {
+          let error2 = this._error;
+          this._queue.notify(this, 1 /* Pending */, 0);
+          if (this._type === 2 /* User */) {
+            try {
+              return this._errorFn ? this._errorFn(error2, () => {
+                this._cleanup?.();
+                this._cleanup = void 0;
+              }) : console.error(error2);
+            } catch (e) {
+              error2 = e;
+            }
+          }
+          if (!this._queue.notify(this, 2 /* Error */, 2 /* Error */))
+            throw error2;
+        } else if (this._type === 1 /* Render */) {
+          this._queue.notify(
+            this,
+            1 /* Pending */ | 2 /* Error */,
+            this._statusFlags
+          );
         }
       }
-    } else
-      this._state !== STATE_CLEAN && runTop(this);
-  }
-};
-var TrackedEffect = class extends Computation {
-  _type = EFFECT_USER;
-  _cleanup;
-  constructor(compute2, options) {
-    super(
-      void 0,
-      () => {
-        this._cleanup?.();
-        this._cleanup = latest(compute2);
-        return void 0;
-      },
-      options
-    );
-    getQueue(this).enqueue(this._type, this._run.bind(this));
-    if (!this._parent)
-      console.warn("Effects created outside a reactive context will never be disposed");
-  }
-  _notify(state, skipQueue) {
-    if (this._state >= state || skipQueue)
-      return;
-    if (this._state === STATE_CLEAN || this._cloned && !ActiveTransition)
-      getQueue(this).enqueue(this._type, this._run.bind(this));
-    this._state = state;
-  }
-  _disposeNode() {
-    if (this._state === STATE_DISPOSED)
-      return;
-    this._cleanup?.();
-    this._cleanup = void 0;
-    getQueue(this).notify(this, ERROR_BIT | LOADING_BIT, 0);
-    super._disposeNode();
-  }
-  _run(type) {
-    if (type)
-      this._state !== STATE_CLEAN && runTop(this);
-  }
-};
-var EagerComputation = class extends Computation {
-  constructor(initialValue, compute2, options) {
-    super(initialValue, compute2, options);
-    !options?.defer && this._updateIfNecessary();
-    if (!this._parent)
-      console.warn("Eager Computations created outside a reactive context will never be disposed");
-  }
-  _notify(state, skipQueue) {
-    if (this._state >= state && !this._forceNotify)
-      return;
-    if (!skipQueue && (this._state === STATE_CLEAN || this._state === STATE_CHECK && this._forceNotify))
-      getQueue(this).enqueue(EFFECT_PURE, this._run.bind(this));
-    super._notify(state, skipQueue);
-  }
-  _run() {
-    this._state !== STATE_CLEAN && runTop(this);
-  }
-};
-var FirewallComputation = class extends Computation {
-  firewall = true;
-  constructor(compute2) {
-    super(void 0, compute2);
-    if (!this._parent)
-      console.warn("Eager Computations created outside a reactive context will never be disposed");
-  }
-  _notify(state, skipQueue) {
-    if (this._state >= state && !this._forceNotify)
-      return;
-    if (!skipQueue && (this._state === STATE_CLEAN || this._state === STATE_CHECK && this._forceNotify))
-      getQueue(this).enqueue(EFFECT_PURE, this._run.bind(this));
-    super._notify(state, true);
-    this._forceNotify = !!skipQueue;
-  }
-  _run() {
-    const prevFlags = this._stateFlags;
-    this._state !== STATE_CLEAN && runTop(this);
-    if (ActiveTransition && this._optimistic && (this._stateFlags !== prevFlags || this._stateFlags !== this._optimistic.flags)) {
-      getQueue(this).notify(this, LOADING_BIT | ERROR_BIT, this._stateFlags);
-      this._optimistic.flags = this._stateFlags;
-      this._stateFlags = prevFlags;
-    }
-  }
-};
-function runTop(node) {
-  const ancestors = [];
-  for (let current = node; current !== null; current = current._parent) {
-    if (ActiveTransition && current._transition)
-      current = ActiveTransition._sources.get(current);
-    if (current._state !== STATE_CLEAN) {
-      ancestors.push(current);
     }
+  });
+  initialized = true;
+  if (node._type === 1 /* Render */) {
+    node._fn = (p) => !(node._statusFlags & 2 /* Error */) ? staleValues(() => compute(p)) : compute(p);
   }
-  for (let i = ancestors.length - 1; i >= 0; i--) {
-    if (ancestors[i]._state !== STATE_DISPOSED)
-      ancestors[i]._updateIfNecessary();
+  !options?.defer && !(node._statusFlags & (2 /* Error */ | 1 /* Pending */)) && (node._type === 2 /* User */ ? node._queue.enqueue(node._type, runEffect.bind(node)) : runEffect.call(node));
+  onCleanup(() => node._cleanup?.());
+  if (!node._parent)
+    console.warn("Effects created outside a reactive context will never be disposed");
+}
+function runEffect() {
+  if (!this._modified || this._flags & 64 /* Disposed */)
+    return;
+  this._cleanup?.();
+  this._cleanup = void 0;
+  try {
+    this._cleanup = this._effectFn(this._value, this._prevValue);
+  } catch (error) {
+    if (!this._queue.notify(this, 2 /* Error */, 2 /* Error */))
+      throw error;
+  } finally {
+    this._prevValue = this._value;
+    this._modified = 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._updateIfNecessary();
-        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
+    needsId ? { id: getNextChildId(o), ...second } : second
   );
-  return [node.read.bind(node), node.write.bind(node)];
-}
-function createMemo(compute2, value, options) {
-  let node = new Computation(
+  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._refresh;
+  return ret;
+}
+function createEffect(compute, effectFn, value, options) {
+  void effect(
+    compute,
+    effectFn.effect || effectFn,
+    effectFn.error,
     value,
-    compute2,
-    options
-  );
-  let resolvedValue;
-  return () => {
-    if (node) {
-      if (node._state === STATE_DISPOSED) {
-        node = void 0;
-        return resolvedValue;
-      }
-      resolvedValue = node.wait();
-      if (!node._sources?.length && node._nextSibling?._parent !== node && !(node._stateFlags & 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._setError(error), true);
-            node._setError(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._setError(error);
-                transition2 = null;
-              }, true);
-            node._setError(error);
-          }
-        })();
-      }
-      throw new NotReadyError(getOwner());
-    },
-    options
-  );
-  const read = node.wait.bind(node);
-  read.refresh = () => {
-    let n = node;
-    if (ActiveTransition && !node._cloned) {
-      n = cloneGraph(node);
-    }
-    n._state = STATE_DIRTY;
-    refreshing = true;
-    n._updateIfNecessary();
-  };
-  return read;
-}
-function createEffect(compute2, effect, value, options) {
-  void new Effect(
-    value,
-    compute2,
-    effect.effect || effect,
-    effect.error,
     { ...options, name: options?.name ?? "effect" } 
   );
 }
-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, name: options?.name ?? "effect" } 
   });
 }
-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, name: options?.name ?? "effect" } 
-      }
-    );
-  };
-}
-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) {
@@ -1398,44 +1103,9 @@ function resolve(fn) {
   });
 }
 function createOptimistic(first, second, third) {
-  const node = typeof first === "function" ? new Computation(
-    second,
-    (prev) => {
-      if (node._optimistic._transition) {
-        latest(() => first(prev));
-        return prev;
-      }
-      return first(prev);
-    },
-    third
-  ) : new Computation(first, null, second);
-  node._optimistic = () => node.write(first);
-  function write(v) {
-    if (!ActiveTransition)
-      throw new Error("createOptimistic can only be updated inside a transition");
-    ActiveTransition.addOptimistic(node._optimistic);
-    queueMicrotask(() => {
-      if (node._optimistic._transition) {
-        node._updateIfNecessary();
-        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
@@ -1443,7 +1113,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);
@@ -1477,16 +1147,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);
@@ -1510,10 +1180,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;
@@ -1525,9 +1195,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) {
@@ -1541,8 +1211,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);
     }
@@ -1550,7 +1220,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);
     }
   }
 }
@@ -1568,13 +1239,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);
     }
   };
@@ -1591,7 +1263,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) {
@@ -1649,7 +1321,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];
@@ -1657,7 +1329,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));
@@ -1705,7 +1377,7 @@ var storeTraps = {
         return desc.get.call(receiver);
     }
     if (Writing?.has(receiver)) {
-      let value2 = tracked && (overridden || !proxySource) ? tracked._value : storeValue[property];
+      let value2 = tracked && (overridden || !proxySource) ? tracked._pendingValue !== NOT_PENDING ? tracked._pendingValue : tracked._value : storeValue[property];
       value2 === $DELETED && (value2 = void 0);
       if (!isWrappable(value2))
         return value2;
@@ -1713,14 +1385,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;
@@ -1729,7 +1401,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) {
@@ -1754,15 +1426,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;
@@ -1781,10 +1453,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;
@@ -1838,7 +1511,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;
@@ -1895,31 +1568,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._transition) {
-        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._transition && storeSetter(store, v));
-  };
-  node._optimistic = reset;
-  return [store, write];
+  return [];
 }
 
 // src/store/utils.ts
@@ -2125,19 +1774,21 @@ 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({
-    _owner: new Owner(),
-    _len: 0,
-    _list: list,
-    _items: [],
-    _map: map,
-    _mappings: [],
-    _nodes: [],
-    _key: keyFn,
-    _rows: keyFn || options?.keyed === false ? [] : void 0,
-    _indexes: map.length > 1 ? [] : void 0,
-    _fallback: options?.fallback
-  });
+  return createMemo(
+    updateKeyedMap.bind({
+      _owner: createOwner(),
+      _len: 0,
+      _list: list,
+      _items: [],
+      _map: map,
+      _mappings: [],
+      _nodes: [],
+      _key: keyFn,
+      _rows: keyFn || options?.keyed === false ? [] : void 0,
+      _indexes: map.length > 1 ? [] : void 0,
+      _fallback: options?.fallback
+    })
+  );
 }
 var pureOptions = { pureWrite: true };
 function updateKeyedMap() {
@@ -2145,16 +1796,19 @@ function updateKeyedMap() {
   newItems[$TRACK];
   runWithOwner(this._owner, () => {
     let i, j, mapper = this._rows ? () => {
-      this._rows[j] = new Computation(newItems[j], null, pureOptions);
-      this._indexes && (this._indexes[j] = new Computation(j, null, pureOptions));
+      this._rows[j] = signal(newItems[j], pureOptions);
+      this._indexes && (this._indexes[j] = signal(j, pureOptions));
       return this._map(
-        Computation.prototype.read.bind(this._rows[j]),
-        this._indexes ? Computation.prototype.read.bind(this._indexes[j]) : void 0
+        read.bind(null, this._rows[j]),
+        this._indexes ? read.bind(null, this._indexes[j]) : void 0
       );
     } : this._indexes ? () => {
       const item = newItems[j];
-      this._indexes[j] = new Computation(j, null, pureOptions);
-      return this._map(() => item, Computation.prototype.read.bind(this._indexes[j]));
+      this._indexes[j] = signal(j, pureOptions);
+      return this._map(
+        () => item,
+        read.bind(null, this._indexes[j])
+      );
     } : () => {
       const item = newItems[j];
       return this._map(() => item);
@@ -2170,10 +1824,9 @@ function updateKeyedMap() {
         this._indexes && (this._indexes = []);
       }
       if (this._fallback && !this._mappings[0]) {
-        this._mappings[0] = compute(
-          this._nodes[0] = new Owner(),
-          this._fallback,
-          null
+        this._mappings[0] = runWithOwner(
+          this._nodes[0] = createOwner(),
+          this._fallback
         );
       }
     } else if (this._len === 0) {
@@ -2182,14 +1835,14 @@ function updateKeyedMap() {
       this._mappings = new Array(newLen);
       for (j = 0; j < newLen; j++) {
         this._items[j] = newItems[j];
-        this._mappings[j] = compute(this._nodes[j] = new Owner(), mapper, null);
+        this._mappings[j] = runWithOwner(this._nodes[j] = createOwner(), mapper);
       }
       this._len = newLen;
     } else {
       let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this._rows ? new Array(newLen) : void 0, tempIndexes = this._indexes ? new Array(newLen) : void 0;
       for (start = 0, end = Math.min(this._len, newLen); start < end && (this._items[start] === newItems[start] || this._rows && compare(this._key, this._items[start], newItems[start])); start++) {
         if (this._rows)
-          this._rows[start].write(newItems[start]);
+          setSignal(this._rows[start], newItems[start]);
       }
       for (end = this._len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this._items[end] === newItems[newEnd] || this._rows && compare(this._key, this._items[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this._mappings[end];
@@ -2226,14 +1879,14 @@ function updateKeyedMap() {
           this._nodes[j] = tempNodes[j];
           if (tempRows) {
             this._rows[j] = tempRows[j];
-            this._rows[j].write(newItems[j]);
+            setSignal(this._rows[j], newItems[j]);
           }
           if (tempIndexes) {
             this._indexes[j] = tempIndexes[j];
-            this._indexes[j].write(j);
+            setSignal(this._indexes[j], j);
           }
         } else {
-          this._mappings[j] = compute(this._nodes[j] = new Owner(), mapper, null);
+          this._mappings[j] = runWithOwner(this._nodes[j] = createOwner(), mapper);
         }
       }
       this._mappings = this._mappings.slice(0, this._len = newLen);
@@ -2244,7 +1897,7 @@ function updateKeyedMap() {
 }
 function repeat(count, map, options) {
   return updateRepeat.bind({
-    _owner: new Owner(),
+    _owner: createOwner(),
     _len: 0,
     _offset: 0,
     _count: count,
@@ -2267,10 +1920,9 @@ function updateRepeat() {
         this._len = 0;
       }
       if (this._fallback && !this._mappings[0]) {
-        this._mappings[0] = compute(
-          this._nodes[0] = new Owner(),
-          this._fallback,
-          null
+        this._mappings[0] = runWithOwner(
+          this._nodes[0] = createOwner(),
+          this._fallback
         );
       }
       return;
@@ -2297,18 +1949,16 @@ function updateRepeat() {
         i--;
       }
       for (let i2 = 0; i2 < difference; i2++) {
-        this._mappings[i2] = compute(
-          this._nodes[i2] = new Owner(),
-          () => this._map(i2 + from),
-          null
+        this._mappings[i2] = runWithOwner(
+          this._nodes[i2] = createOwner(),
+          () => this._map(i2 + from)
         );
       }
     }
     for (let i = prevTo; i < to; i++) {
-      this._mappings[i - from] = compute(
-        this._nodes[i - from] = new Owner(),
-        () => this._map(i),
-        null
+      this._mappings[i - from] = runWithOwner(
+        this._nodes[i - from] = createOwner(),
+        () => this._map(i)
       );
     }
     this._mappings = this._mappings.slice(0, newLen);
@@ -2322,33 +1972,31 @@ function compare(key, a, b) {
 }
 
 // src/boundaries.ts
-var BoundaryComputation = class extends EagerComputation {
-  _propagationMask;
-  constructor(compute2, propagationMask) {
-    super(void 0, compute2, { defer: true });
-    this._propagationMask = propagationMask;
-  }
-  write(value, flags) {
-    super.write(value, flags & ~this._propagationMask);
-    if (this._propagationMask & LOADING_BIT && !(this._stateFlags & UNINITIALIZED_BIT || ActiveTransition)) {
-      flags &= ~LOADING_BIT;
+function boundaryComputed(fn, propagationMask) {
+  const node = computed(fn, void 0, {
+    _internal: {
+      _notifyQueue() {
+        let flags = this._statusFlags;
+        this._statusFlags &= ~this._propagationMask;
+        if (this._propagationMask & 1 /* Pending */ && !(this._statusFlags & 4 /* Uninitialized */)) {
+          flags &= ~1 /* Pending */;
+        }
+        this._queue.notify(this, this._propagationMask, flags);
+      },
+      _propagationMask: propagationMask
     }
-    getQueue(this).notify(this, this._propagationMask, flags);
-    return this._value;
-  }
-};
+  });
+  node._propagationMask = propagationMask;
+  return node;
+}
 function createBoundChildren(owner, fn, queue, mask) {
   const parentQueue = owner._queue;
   parentQueue.addChild(owner._queue = queue);
   onCleanup(() => parentQueue.removeChild(owner._queue));
-  return compute(
-    owner,
-    () => {
-      const c = new Computation(void 0, fn);
-      return new BoundaryComputation(() => latest(() => flatten(c.wait())), mask);
-    },
-    null
-  );
+  return runWithOwner(owner, () => {
+    const c = computed(fn);
+    return boundaryComputed(() => staleValues(() => flatten(read(c))), mask);
+  });
 }
 var ConditionalQueue = class extends Queue {
   _disabled;
@@ -2359,113 +2007,108 @@ var ConditionalQueue = class extends Queue {
     this._disabled = disabled;
   }
   run(type) {
-    if (!type || this._disabled.read())
+    if (!type || read(this._disabled))
       return;
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (this._disabled.read()) {
-      if (type & LOADING_BIT) {
-        if (flags & LOADING_BIT) {
+    if (read(this._disabled)) {
+      if (type & 1 /* Pending */) {
+        if (flags & 1 /* Pending */) {
           this._pendingNodes.add(node);
-          type &= ~LOADING_BIT;
+          type &= ~1 /* Pending */;
         } else if (this._pendingNodes.delete(node))
-          type &= ~LOADING_BIT;
+          type &= ~1 /* Pending */;
       }
-      if (type & ERROR_BIT) {
-        if (flags & ERROR_BIT) {
+      if (type & 2 /* Error */) {
+        if (flags & 2 /* Error */) {
           this._errorNodes.add(node);
-          type &= ~ERROR_BIT;
+          type &= ~2 /* Error */;
         } else if (this._errorNodes.delete(node))
-          type &= ~ERROR_BIT;
+          type &= ~2 /* Error */;
       }
     }
     return type ? super.notify(node, type, flags) : true;
   }
-  merge(queue) {
-    queue._pendingNodes.forEach((n) => this.notify(n, LOADING_BIT, LOADING_BIT));
-    queue._errorNodes.forEach((n) => this.notify(n, ERROR_BIT, ERROR_BIT));
-    super.merge(queue);
-  }
 };
 var CollectionQueue = class extends Queue {
   _collectionType;
   _nodes = /* @__PURE__ */ new Set();
-  _disabled = new Computation(false, null, { pureWrite: true });
+  _disabled = signal(false, { pureWrite: true });
+  _initialized = false;
   constructor(type) {
     super();
     this._collectionType = type;
   }
   run(type) {
-    if (!type || this._disabled.read())
+    if (!type || read(this._disabled))
       return;
     return super.run(type);
   }
+  enqueue(type, fn) {
+    if (this._collectionType & 1 /* Pending */ && this._initialized) {
+      return this._parent?.enqueue(type, fn);
+    }
+    return super.enqueue(type, fn);
+  }
   notify(node, type, flags) {
-    if (!(type & this._collectionType))
+    if (!(type & this._collectionType) || this._collectionType & 1 /* Pending */ && this._initialized)
       return super.notify(node, type, flags);
     if (flags & this._collectionType) {
       this._nodes.add(node);
       if (this._nodes.size === 1)
-        this._disabled.write(true);
+        setSignal(this._disabled, true);
     } else if (this._nodes.size > 0) {
       this._nodes.delete(node);
       if (this._nodes.size === 0)
-        this._disabled.write(false);
+        setSignal(this._disabled, false);
     }
     type &= ~this._collectionType;
     return type ? super.notify(node, type, flags) : true;
   }
-  merge(queue) {
-    queue._nodes.forEach((n) => this.notify(n, this._collectionType, this._collectionType));
-    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._disabled.read();
-    tree._propagationMask = disabled ? ERROR_BIT | LOADING_BIT : 0;
+  computed(() => {
+    const disabled = read(queue._disabled);
+    tree._propagationMask = disabled ? 2 /* Error */ | 1 /* Pending */ : 0;
     if (!disabled) {
-      queue._pendingNodes.forEach((node) => queue.notify(node, LOADING_BIT, LOADING_BIT));
-      queue._errorNodes.forEach((node) => queue.notify(node, ERROR_BIT, ERROR_BIT));
+      queue._pendingNodes.forEach(
+        (node) => queue.notify(node, 1 /* Pending */, 1 /* Pending */)
+      );
+      queue._errorNodes.forEach((node) => queue.notify(node, 2 /* Error */, 2 /* Error */));
       queue._pendingNodes.clear();
       queue._errorNodes.clear();
     }
   });
-  return () => queue._disabled.read() ? void 0 : tree.read();
+  return () => read(queue._disabled) ? 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._disabled.read()) {
-      const resolved = tree.read();
-      if (!untrack(() => queue._disabled.read()))
-        return resolved;
+  const decision = computed(() => {
+    if (!read(queue._disabled)) {
+      const resolved = read(tree);
+      if (!untrack(() => read(queue._disabled)))
+        queue._initialized = 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._nodes.values().next().value);
+  return createCollectionBoundary(2 /* Error */, fn, (queue) => {
+    let node = queue._nodes.values().next().value;
     return fallback(node._error, () => {
-      incrementClock();
       for (let node2 of queue._nodes) {
-        if (ActiveTransition && !node2._cloned)
-          node2 = cloneGraph(node2);
-        node2._state = STATE_DIRTY;
-        getQueue(node2).enqueue(node2._type, node2._run.bind(node2));
+        recompute(node2, true);
       }
     });
   });
@@ -2525,4 +2168,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 };