@solidjs/signals 0.9.11 → 0.10.0

package/dist/dev.js

@@ -147,81 +147,6 @@ let clock = 0;
 let activeTransition = null;
 let scheduled = false;
 let projectionWriteActive = false;
-const signalLanes = new WeakMap();
-const activeLanes = new Set();
-let currentOptimisticLane = null;
-function setCurrentOptimisticLane(lane) {
-  currentOptimisticLane = lane;
-}
-function getOrCreateLane(signal) {
-  let lane = signalLanes.get(signal);
-  if (lane) {
-    return findLane(lane);
-  }
-  const parentSource = signal._parentSource;
-  const parentLane = parentSource?._optimisticLane ? findLane(parentSource._optimisticLane) : null;
-  lane = {
-    _source: signal,
-    _pendingAsync: new Set(),
-    _effectQueues: [[], []],
-    _mergedInto: null,
-    _transition: activeTransition,
-    _parentLane: parentLane
-  };
-  signalLanes.set(signal, lane);
-  activeLanes.add(lane);
-  signal._laneVersion = signal._overrideVersion || 0;
-  return lane;
-}
-function findLane(lane) {
-  while (lane._mergedInto) lane = lane._mergedInto;
-  return lane;
-}
-function mergeLanes(lane1, lane2) {
-  lane1 = findLane(lane1);
-  lane2 = findLane(lane2);
-  if (lane1 === lane2) return lane1;
-  lane2._mergedInto = lane1;
-  for (const node of lane2._pendingAsync) lane1._pendingAsync.add(node);
-  lane1._effectQueues[0].push(...lane2._effectQueues[0]);
-  lane1._effectQueues[1].push(...lane2._effectQueues[1]);
-  return lane1;
-}
-function clearLaneEntry(signal) {
-  signalLanes.delete(signal);
-}
-function resolveLane(el) {
-  const lane = el._optimisticLane;
-  if (!lane) return undefined;
-  const root = findLane(lane);
-  if (activeLanes.has(root)) return root;
-  el._optimisticLane = undefined;
-  return undefined;
-}
-function hasActiveOverride(el) {
-  return !!(el._optimistic && el._pendingValue !== NOT_PENDING);
-}
-function assignOrMergeLane(el, sourceLane) {
-  const sourceRoot = findLane(sourceLane);
-  const existing = el._optimisticLane;
-  if (existing) {
-    if (existing._mergedInto) {
-      el._optimisticLane = sourceLane;
-      return;
-    }
-    const existingRoot = findLane(existing);
-    if (activeLanes.has(existingRoot)) {
-      if (existingRoot !== sourceRoot && !hasActiveOverride(el)) {
-        if (sourceRoot._parentLane && findLane(sourceRoot._parentLane) === existingRoot) {
-          el._optimisticLane = sourceLane;
-        } else if (existingRoot._parentLane && findLane(existingRoot._parentLane) === sourceRoot);
-        else mergeLanes(sourceRoot, existingRoot);
-      }
-      return;
-    }
-  }
-  el._optimisticLane = sourceLane;
-}
 function runLaneEffects(type) {
   for (const lane of activeLanes) {
     if (lane._mergedInto || lane._pendingAsync.size > 0) continue;
@@ -550,6 +475,9 @@ function currentTransition(transition) {
   while (transition._done && typeof transition._done === "object") transition = transition._done;
   return transition;
 }
+function setActiveTransition(transition) {
+  activeTransition = transition;
+}
 function runInTransition(transition, fn) {
   const prevTransition = activeTransition;
   try {
@@ -559,201 +487,104 @@ function runInTransition(transition, fn) {
     activeTransition = prevTransition;
   }
 }
-function restoreTransition(transition, fn) {
-  globalQueue.initTransition(transition);
-  const result = fn();
-  flush();
-  return result;
+const signalLanes = new WeakMap();
+const activeLanes = new Set();
+function getOrCreateLane(signal) {
+  let lane = signalLanes.get(signal);
+  if (lane) {
+    return findLane(lane);
+  }
+  const parentSource = signal._parentSource;
+  const parentLane = parentSource?._optimisticLane ? findLane(parentSource._optimisticLane) : null;
+  lane = {
+    _source: signal,
+    _pendingAsync: new Set(),
+    _effectQueues: [[], []],
+    _mergedInto: null,
+    _transition: activeTransition,
+    _parentLane: parentLane
+  };
+  signalLanes.set(signal, lane);
+  activeLanes.add(lane);
+  signal._laneVersion = signal._overrideVersion || 0;
+  return lane;
 }
-function action(genFn) {
-  return (...args) =>
-    new Promise((resolve, reject) => {
-      const it = genFn(...args);
-      globalQueue.initTransition();
-      let ctx = activeTransition;
-      ctx._actions.push(it);
-      const done = (v, e) => {
-        ctx = currentTransition(ctx);
-        const i = ctx._actions.indexOf(it);
-        if (i >= 0) ctx._actions.splice(i, 1);
-        activeTransition = ctx;
-        schedule();
-        e ? reject(e) : resolve(v);
-      };
-      const step = (v, err) => {
-        let r;
-        try {
-          r = err ? it.throw(v) : it.next(v);
-        } catch (e) {
-          return done(undefined, e);
-        }
-        if (r instanceof Promise)
-          return void r.then(run, e => restoreTransition(ctx, () => step(e, true)));
-        run(r);
-      };
-      const run = r => {
-        if (r.done) return done(r.value);
-        if (r.value instanceof Promise)
-          return void r.value.then(
-            v => restoreTransition(ctx, () => step(v)),
-            e => restoreTransition(ctx, () => step(e, true))
-          );
-        restoreTransition(ctx, () => step(r.value));
-      };
-      step();
-    });
+function findLane(lane) {
+  while (lane._mergedInto) lane = lane._mergedInto;
+  return lane;
 }
-GlobalQueue._update = recompute;
-GlobalQueue._dispose = disposeChildren;
-let tracking = false;
-let stale = false;
-let refreshing = false;
-let pendingCheckActive = false;
-let foundPending = false;
-let pendingReadActive = false;
-let context = null;
-let leafEffectActive = false;
-function setLeafEffectActive(v) {
-  leafEffectActive = v;
+function mergeLanes(lane1, lane2) {
+  lane1 = findLane(lane1);
+  lane2 = findLane(lane2);
+  if (lane1 === lane2) return lane1;
+  lane2._mergedInto = lane1;
+  for (const node of lane2._pendingAsync) lane1._pendingAsync.add(node);
+  lane1._effectQueues[0].push(...lane2._effectQueues[0]);
+  lane1._effectQueues[1].push(...lane2._effectQueues[1]);
+  return lane1;
 }
-function recompute(el, create = false) {
-  const isEffect = el._type;
-  if (!create) {
-    if (el._transition && (!isEffect || activeTransition) && activeTransition !== el._transition)
-      globalQueue.initTransition(el._transition);
-    deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-    if (el._transition || isEffect === EFFECT_TRACKED) disposeChildren(el);
-    else {
-      markDisposal(el);
-      el._pendingDisposal = el._disposal;
-      el._pendingFirstChild = el._firstChild;
-      el._disposal = null;
-      el._firstChild = null;
+function resolveLane(el) {
+  const lane = el._optimisticLane;
+  if (!lane) return undefined;
+  const root = findLane(lane);
+  if (activeLanes.has(root)) return root;
+  el._optimisticLane = undefined;
+  return undefined;
+}
+function hasActiveOverride(el) {
+  return !!(el._optimistic && el._pendingValue !== NOT_PENDING);
+}
+function assignOrMergeLane(el, sourceLane) {
+  const sourceRoot = findLane(sourceLane);
+  const existing = el._optimisticLane;
+  if (existing) {
+    if (existing._mergedInto) {
+      el._optimisticLane = sourceLane;
+      return;
+    }
+    const existingRoot = findLane(existing);
+    if (activeLanes.has(existingRoot)) {
+      if (existingRoot !== sourceRoot && !hasActiveOverride(el)) {
+        if (sourceRoot._parentLane && findLane(sourceRoot._parentLane) === existingRoot) {
+          el._optimisticLane = sourceLane;
+        } else if (existingRoot._parentLane && findLane(existingRoot._parentLane) === sourceRoot);
+        else mergeLanes(sourceRoot, existingRoot);
+      }
+      return;
     }
   }
-  const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
-  const hasOverride = hasActiveOverride(el);
-  const wasPending = !!(el._statusFlags & STATUS_PENDING);
-  const oldcontext = context;
-  context = el;
-  el._depsTail = null;
-  el._flags = REACTIVE_RECOMPUTING_DEPS;
-  el._time = clock;
-  let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
-  let oldHeight = el._height;
-  let prevTracking = tracking;
-  let prevLane = currentOptimisticLane;
-  tracking = true;
-  if (isOptimisticDirty) {
-    const lane = resolveLane(el);
-    if (lane) setCurrentOptimisticLane(lane);
+  el._optimisticLane = sourceLane;
+}
+function handleAsync(el, result, setter) {
+  const isObject = typeof result === "object" && result !== null;
+  const iterator = isObject && untrack(() => result[Symbol.asyncIterator]);
+  const isThenable = !iterator && isObject && untrack(() => typeof result.then === "function");
+  if (!isThenable && !iterator) {
+    el._inFlight = null;
+    return result;
   }
-  try {
-    value = handleAsync(el, el._fn(value));
+  el._inFlight = result;
+  let syncValue;
+  const handleError = error => {
+    if (el._inFlight !== result) return;
+    globalQueue.initTransition(el._transition);
+    notifyStatus(el, error instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, error);
+    el._time = clock;
+  };
+  const asyncWrite = (value, then) => {
+    if (el._inFlight !== result) return;
+    if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+    globalQueue.initTransition(el._transition);
     clearStatus(el);
-    const resolvedLane = resolveLane(el);
-    if (resolvedLane) {
-      resolvedLane._pendingAsync.delete(el);
-      updatePendingSignal(resolvedLane._source);
-    }
-  } catch (e) {
-    if (e instanceof NotReadyError && currentOptimisticLane) {
-      const lane = findLane(currentOptimisticLane);
-      if (lane._source !== el) {
-        lane._pendingAsync.add(el);
-        el._optimisticLane = lane;
-        updatePendingSignal(lane._source);
-      }
-    }
-    notifyStatus(
-      el,
-      e instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
-      e,
-      undefined,
-      e instanceof NotReadyError ? el._optimisticLane : undefined
-    );
-  } finally {
-    tracking = prevTracking;
-    el._flags = REACTIVE_NONE;
-    context = oldcontext;
-  }
-  if (!el._error) {
-    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 el._deps = null;
-    }
-    const compareValue = hasOverride
-      ? el._value
-      : el._pendingValue === NOT_PENDING
-        ? el._value
-        : el._pendingValue;
-    const valueChanged = !el._equals || !el._equals(compareValue, value);
-    if (valueChanged) {
-      const prevVisible = hasOverride ? el._value : undefined;
-      if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty)
-        el._value = value;
-      else el._pendingValue = value;
-      if (hasOverride && !isOptimisticDirty && wasPending) {
-        const ov = el._overrideVersion || 0;
-        const lv = el._laneVersion || 0;
-        if (ov <= lv) el._value = value;
-      }
-      if (!hasOverride || isOptimisticDirty || el._value !== prevVisible) {
-        insertSubs(el, isOptimisticDirty || hasOverride);
-      }
-    } else if (hasOverride) {
-      el._pendingValue = value;
-    } else if (el._height != oldHeight) {
-      for (let s = el._subs; s !== null; s = s._nextSub) {
-        insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-      }
-    }
-  }
-  setCurrentOptimisticLane(prevLane);
-  (!create || el._statusFlags & STATUS_PENDING) &&
-    !el._transition &&
-    !(activeTransition && el._optimistic) &&
-    globalQueue._pendingNodes.push(el);
-  el._transition &&
-    isEffect &&
-    activeTransition !== el._transition &&
-    runInTransition(el._transition, () => recompute(el));
-}
-function handleAsync(el, result, setter) {
-  const isObject = typeof result === "object" && result !== null;
-  const iterator = isObject && untrack(() => result[Symbol.asyncIterator]);
-  const isThenable = !iterator && isObject && untrack(() => typeof result.then === "function");
-  if (!isThenable && !iterator) {
-    el._inFlight = null;
-    return result;
-  }
-  el._inFlight = result;
-  let syncValue;
-  const handleError = error => {
-    if (el._inFlight !== result) return;
-    globalQueue.initTransition(el._transition);
-    notifyStatus(el, error instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, error);
-    el._time = clock;
-  };
-  const asyncWrite = (value, then) => {
-    if (el._inFlight !== result) return;
-    if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-    globalQueue.initTransition(el._transition);
-    clearStatus(el);
-    const lane = resolveLane(el);
-    if (lane) lane._pendingAsync.delete(el);
-    if (setter) setter(value);
-    else if (el._optimistic) {
-      const hadOverride = el._pendingValue !== NOT_PENDING;
-      if (el._fn) el._pendingValue = value;
-      if (!hadOverride) {
-        el._value = value;
-        insertSubs(el);
+    const lane = resolveLane(el);
+    if (lane) lane._pendingAsync.delete(el);
+    if (setter) setter(value);
+    else if (el._optimistic) {
+      const hadOverride = el._pendingValue !== NOT_PENDING;
+      if (el._fn) el._pendingValue = value;
+      if (!hadOverride) {
+        el._value = value;
+        insertSubs(el);
       }
       el._time = clock;
     } else if (lane) {
@@ -886,86 +717,102 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     }
   }
 }
-function updateIfNecessary(el) {
-  if (el._flags & REACTIVE_CHECK) {
-    for (let d = el._deps; d; d = d._nextDep) {
-      const dep1 = d._dep;
-      const dep = dep1._firewall || dep1;
-      if (dep._fn) {
-        updateIfNecessary(dep);
-      }
-      if (el._flags & REACTIVE_DIRTY) {
-        break;
-      }
-    }
-  }
-  if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (el._error && el._time < clock)) {
-    recompute(el);
-  }
-  el._flags = REACTIVE_NONE;
-}
-function unlinkSubs(link) {
-  const dep = link._dep;
-  const nextDep = link._nextDep;
-  const nextSub = link._nextSub;
-  const prevSub = link._prevSub;
-  if (nextSub !== null) nextSub._prevSub = prevSub;
-  else dep._subsTail = prevSub;
-  if (prevSub !== null) prevSub._nextSub = nextSub;
-  else {
-    dep._subs = nextSub;
-    if (nextSub === null) {
-      dep._unobserved?.();
-      dep._fn && !dep._preventAutoDisposal && unobserved(dep);
+let leafEffectActive = false;
+function effect(compute, effect, error, initialValue, options) {
+  let initialized = false;
+  const node = computed(
+    options?.render ? p => staleValues(() => compute(p)) : compute,
+    initialValue,
+    {
+      ...options,
+      equals: () => {
+        node._modified = !node._error;
+        if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
+        return false;
+      },
+      lazy: true
     }
-  }
-  return nextDep;
-}
-function unobserved(el) {
-  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-  let dep = el._deps;
-  while (dep !== null) {
-    dep = unlinkSubs(dep);
-  }
-  el._deps = null;
-  disposeChildren(el, true);
+  );
+  node._prevValue = initialValue;
+  node._effectFn = effect;
+  node._errorFn = error;
+  node._cleanup = undefined;
+  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
+  node._notifyStatus = (status, error) => {
+    const actualStatus = status !== undefined ? status : node._statusFlags;
+    const actualError = error !== undefined ? error : node._error;
+    if (actualStatus & STATUS_ERROR) {
+      let err = actualError;
+      node._queue.notify(node, STATUS_PENDING, 0);
+      if (node._type === EFFECT_USER) {
+        try {
+          return node._errorFn
+            ? node._errorFn(err, () => {
+                node._cleanup?.();
+                node._cleanup = undefined;
+              })
+            : console.error(err);
+        } catch (e) {
+          err = e;
+        }
+      }
+      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
+    } else if (node._type === EFFECT_RENDER)
+      node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
+  };
+  recompute(node, true);
+  !options?.defer &&
+    (node._type === EFFECT_USER
+      ? node._queue.enqueue(node._type, runEffect.bind(node))
+      : runEffect.call(node));
+  initialized = true;
+  onCleanup(() => node._cleanup?.());
+  if (!node._parent)
+    console.warn("Effects created outside a reactive context will never be disposed");
 }
-function link(dep, sub) {
-  const prevDep = sub._depsTail;
-  if (prevDep !== null && prevDep._dep === dep) return;
-  let nextDep = null;
-  const isRecomputing = sub._flags & REACTIVE_RECOMPUTING_DEPS;
-  if (isRecomputing) {
-    nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
-    if (nextDep !== null && nextDep._dep === dep) {
-      sub._depsTail = nextDep;
-      return;
-    }
+function runEffect() {
+  if (!this._modified || this._flags & REACTIVE_DISPOSED) return;
+  this._cleanup?.();
+  this._cleanup = undefined;
+  try {
+    this._cleanup = this._effectFn(this._value, this._prevValue);
+  } catch (error) {
+    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
+  } finally {
+    this._prevValue = this._value;
+    this._modified = false;
   }
-  const prevSub = dep._subsTail;
-  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub)))
-    return;
-  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;
-  if (prevSub !== null) prevSub._nextSub = newLink;
-  else dep._subs = newLink;
 }
-function isValidLink(checkLink, sub) {
-  const depsTail = sub._depsTail;
-  if (depsTail !== null) {
-    let link = sub._deps;
-    do {
-      if (link === checkLink) return true;
-      if (link === depsTail) break;
-      link = link._nextDep;
-    } while (link !== null);
-  }
-  return false;
+function trackedEffect(fn, options) {
+  const run = () => {
+    if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
+    node._modified = false;
+    recompute(node);
+  };
+  const node = computed(
+    () => {
+      leafEffectActive = true;
+      try {
+        node._cleanup?.();
+        node._cleanup = undefined;
+        node._cleanup = staleValues(fn) || undefined;
+      } finally {
+        leafEffectActive = false;
+      }
+    },
+    undefined,
+    { ...options, lazy: true, pureWrite: true }
+  );
+  node._cleanup = undefined;
+  node._modified = true;
+  node._type = EFFECT_TRACKED;
+  node._run = run;
+  node._queue.enqueue(EFFECT_USER, run);
+  onCleanup(() => node._cleanup?.());
+  if (!node._parent)
+    console.warn("Effects created outside a reactive context will never be disposed");
 }
+const PENDING_OWNER = {};
 function markDisposal(el) {
   let child = el._firstChild;
   while (child) {
@@ -1036,8 +883,257 @@ function formatId(prefix, id) {
     len = num.length - 1;
   return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
 }
-function computed(fn, initialValue, options) {
-  const self = {
+function getObserver() {
+  if (pendingCheckActive || pendingReadActive) return PENDING_OWNER;
+  return tracking ? context : null;
+}
+function getOwner() {
+  return context;
+}
+function onCleanup(fn) {
+  if (!context) return fn;
+  if (!context._disposal) context._disposal = fn;
+  else if (Array.isArray(context._disposal)) context._disposal.push(fn);
+  else context._disposal = [context._disposal, fn];
+  return fn;
+}
+function createOwner(options) {
+  const parent = context;
+  const owner = {
+    id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : undefined),
+    _root: true,
+    _parentComputed: parent?._root ? parent._parentComputed : parent,
+    _firstChild: null,
+    _nextSibling: null,
+    _disposal: null,
+    _queue: parent?._queue ?? globalQueue,
+    _context: parent?._context || defaultContext,
+    _childCount: 0,
+    _pendingDisposal: null,
+    _pendingFirstChild: null,
+    _parent: parent,
+    dispose(self = true) {
+      disposeChildren(owner, self);
+    }
+  };
+  if (leafEffectActive && parent) {
+    throw new Error("Cannot create reactive primitives inside createTrackedEffect");
+  }
+  if (parent) {
+    const lastChild = parent._firstChild;
+    if (lastChild === null) {
+      parent._firstChild = owner;
+    } else {
+      owner._nextSibling = lastChild;
+      parent._firstChild = owner;
+    }
+  }
+  return owner;
+}
+function createRoot(init, options) {
+  const owner = createOwner(options);
+  return runWithOwner(owner, () => init(owner.dispose));
+}
+function unlinkSubs(link) {
+  const dep = link._dep;
+  const nextDep = link._nextDep;
+  const nextSub = link._nextSub;
+  const prevSub = link._prevSub;
+  if (nextSub !== null) nextSub._prevSub = prevSub;
+  else dep._subsTail = prevSub;
+  if (prevSub !== null) prevSub._nextSub = nextSub;
+  else {
+    dep._subs = nextSub;
+    if (nextSub === null) {
+      dep._unobserved?.();
+      dep._fn && !dep._preventAutoDisposal && unobserved(dep);
+    }
+  }
+  return nextDep;
+}
+function unobserved(el) {
+  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let dep = el._deps;
+  while (dep !== null) {
+    dep = unlinkSubs(dep);
+  }
+  el._deps = null;
+  disposeChildren(el, true);
+}
+function link(dep, sub) {
+  const prevDep = sub._depsTail;
+  if (prevDep !== null && prevDep._dep === dep) return;
+  let nextDep = null;
+  const isRecomputing = sub._flags & REACTIVE_RECOMPUTING_DEPS;
+  if (isRecomputing) {
+    nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
+    if (nextDep !== null && nextDep._dep === dep) {
+      sub._depsTail = nextDep;
+      return;
+    }
+  }
+  const prevSub = dep._subsTail;
+  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub)))
+    return;
+  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;
+  if (prevSub !== null) prevSub._nextSub = newLink;
+  else dep._subs = newLink;
+}
+function isValidLink(checkLink, sub) {
+  const depsTail = sub._depsTail;
+  if (depsTail !== null) {
+    let link = sub._deps;
+    do {
+      if (link === checkLink) return true;
+      if (link === depsTail) break;
+      link = link._nextDep;
+    } while (link !== null);
+  }
+  return false;
+}
+GlobalQueue._update = recompute;
+GlobalQueue._dispose = disposeChildren;
+let tracking = false;
+let stale = false;
+let refreshing = false;
+let pendingCheckActive = false;
+let foundPending = false;
+let pendingReadActive = false;
+let context = null;
+let currentOptimisticLane = null;
+function recompute(el, create = false) {
+  const isEffect = el._type;
+  if (!create) {
+    if (el._transition && (!isEffect || activeTransition) && activeTransition !== el._transition)
+      globalQueue.initTransition(el._transition);
+    deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    if (el._transition || isEffect === EFFECT_TRACKED) disposeChildren(el);
+    else {
+      markDisposal(el);
+      el._pendingDisposal = el._disposal;
+      el._pendingFirstChild = el._firstChild;
+      el._disposal = null;
+      el._firstChild = null;
+    }
+  }
+  const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
+  const hasOverride = hasActiveOverride(el);
+  const wasPending = !!(el._statusFlags & STATUS_PENDING);
+  const oldcontext = context;
+  context = el;
+  el._depsTail = null;
+  el._flags = REACTIVE_RECOMPUTING_DEPS;
+  el._time = clock;
+  let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+  let oldHeight = el._height;
+  let prevTracking = tracking;
+  let prevLane = currentOptimisticLane;
+  tracking = true;
+  if (isOptimisticDirty) {
+    const lane = resolveLane(el);
+    if (lane) currentOptimisticLane = lane;
+  }
+  try {
+    value = handleAsync(el, el._fn(value));
+    clearStatus(el);
+    const resolvedLane = resolveLane(el);
+    if (resolvedLane) {
+      resolvedLane._pendingAsync.delete(el);
+      updatePendingSignal(resolvedLane._source);
+    }
+  } catch (e) {
+    if (e instanceof NotReadyError && currentOptimisticLane) {
+      const lane = findLane(currentOptimisticLane);
+      if (lane._source !== el) {
+        lane._pendingAsync.add(el);
+        el._optimisticLane = lane;
+        updatePendingSignal(lane._source);
+      }
+    }
+    notifyStatus(
+      el,
+      e instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
+      e,
+      undefined,
+      e instanceof NotReadyError ? el._optimisticLane : undefined
+    );
+  } finally {
+    tracking = prevTracking;
+    el._flags = REACTIVE_NONE;
+    context = oldcontext;
+  }
+  if (!el._error) {
+    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 el._deps = null;
+    }
+    const compareValue = hasOverride
+      ? el._value
+      : el._pendingValue === NOT_PENDING
+        ? el._value
+        : el._pendingValue;
+    const valueChanged = !el._equals || !el._equals(compareValue, value);
+    if (valueChanged) {
+      const prevVisible = hasOverride ? el._value : undefined;
+      if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty)
+        el._value = value;
+      else el._pendingValue = value;
+      if (hasOverride && !isOptimisticDirty && wasPending) {
+        const ov = el._overrideVersion || 0;
+        const lv = el._laneVersion || 0;
+        if (ov <= lv) el._value = value;
+      }
+      if (!hasOverride || isOptimisticDirty || el._value !== prevVisible) {
+        insertSubs(el, isOptimisticDirty || hasOverride);
+      }
+    } else if (hasOverride) {
+      el._pendingValue = value;
+    } else if (el._height != oldHeight) {
+      for (let s = el._subs; s !== null; s = s._nextSub) {
+        insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      }
+    }
+  }
+  currentOptimisticLane = prevLane;
+  (!create || el._statusFlags & STATUS_PENDING) &&
+    !el._transition &&
+    !(activeTransition && el._optimistic) &&
+    globalQueue._pendingNodes.push(el);
+  el._transition &&
+    isEffect &&
+    activeTransition !== el._transition &&
+    runInTransition(el._transition, () => recompute(el));
+}
+function updateIfNecessary(el) {
+  if (el._flags & REACTIVE_CHECK) {
+    for (let d = el._deps; d; d = d._nextDep) {
+      const dep1 = d._dep;
+      const dep = dep1._firewall || dep1;
+      if (dep._fn) {
+        updateIfNecessary(dep);
+      }
+      if (el._flags & REACTIVE_DIRTY) {
+        break;
+      }
+    }
+  }
+  if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || (el._error && el._time < clock)) {
+    recompute(el);
+  }
+  el._flags = REACTIVE_NONE;
+}
+function computed(fn, initialValue, options) {
+  const self = {
     id: options?.id ?? (context?.id != null ? getNextChildId(context) : undefined),
     _equals: options?.equals != null ? options.equals : isEqual,
     _pureWrite: !!options?.pureWrite,
@@ -1111,66 +1207,8 @@ function optimisticSignal(v, options) {
 }
 function optimisticComputed(fn, initialValue, options) {
   const c = computed(fn, initialValue, options);
-  c._optimistic = true;
-  return c;
-}
-function getPendingSignal(el) {
-  if (!el._pendingSignal) {
-    el._pendingSignal = optimisticSignal(false, { pureWrite: true });
-    if (el._parentSource) {
-      el._pendingSignal._parentSource = el;
-    }
-    if (computePendingState(el)) setSignal(el._pendingSignal, true);
-  }
-  return el._pendingSignal;
-}
-function computePendingState(el) {
-  const comp = el;
-  if (el._optimistic && el._pendingValue !== NOT_PENDING) {
-    if (comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED))
-      return true;
-    if (el._parentSource) {
-      const lane = el._optimisticLane ? findLane(el._optimisticLane) : null;
-      return !!(lane && lane._pendingAsync.size > 0);
-    }
-    return true;
-  }
-  if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
-  return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
-}
-function getPendingValueComputed(el) {
-  if (!el._pendingValueComputed) {
-    const prevPending = pendingReadActive;
-    pendingReadActive = false;
-    const prevCheck = pendingCheckActive;
-    pendingCheckActive = false;
-    const prevContext = context;
-    context = null;
-    el._pendingValueComputed = optimisticComputed(() => read(el));
-    el._pendingValueComputed._parentSource = el;
-    context = prevContext;
-    pendingCheckActive = prevCheck;
-    pendingReadActive = prevPending;
-  }
-  return el._pendingValueComputed;
-}
-function updatePendingSignal(el) {
-  if (el._pendingSignal) {
-    const pending = computePendingState(el);
-    const sig = el._pendingSignal;
-    setSignal(sig, pending);
-    if (!pending && sig._optimisticLane) {
-      const sourceLane = resolveLane(el);
-      if (sourceLane && sourceLane._pendingAsync.size > 0) {
-        const sigLane = findLane(sig._optimisticLane);
-        if (sigLane !== sourceLane) {
-          mergeLanes(sourceLane, sigLane);
-        }
-      }
-      clearLaneEntry(sig);
-      sig._optimisticLane = undefined;
-    }
-  }
+  c._optimistic = true;
+  return c;
 }
 function isEqual(a, b) {
   return a === b;
@@ -1311,58 +1349,6 @@ function setSignal(el, v) {
   schedule();
   return v;
 }
-const PENDING_OWNER = {};
-function getObserver() {
-  if (pendingCheckActive || pendingReadActive) return PENDING_OWNER;
-  return tracking ? context : null;
-}
-function getOwner() {
-  return context;
-}
-function onCleanup(fn) {
-  if (!context) return fn;
-  if (!context._disposal) context._disposal = fn;
-  else if (Array.isArray(context._disposal)) context._disposal.push(fn);
-  else context._disposal = [context._disposal, fn];
-  return fn;
-}
-function createOwner(options) {
-  const parent = context;
-  const owner = {
-    id: options?.id ?? (parent?.id != null ? getNextChildId(parent) : undefined),
-    _root: true,
-    _parentComputed: parent?._root ? parent._parentComputed : parent,
-    _firstChild: null,
-    _nextSibling: null,
-    _disposal: null,
-    _queue: parent?._queue ?? globalQueue,
-    _context: parent?._context || defaultContext,
-    _childCount: 0,
-    _pendingDisposal: null,
-    _pendingFirstChild: null,
-    _parent: parent,
-    dispose(self = true) {
-      disposeChildren(owner, self);
-    }
-  };
-  if (leafEffectActive && parent) {
-    throw new Error("Cannot create reactive primitives inside createTrackedEffect");
-  }
-  if (parent) {
-    const lastChild = parent._firstChild;
-    if (lastChild === null) {
-      parent._firstChild = owner;
-    } else {
-      owner._nextSibling = lastChild;
-      parent._firstChild = owner;
-    }
-  }
-  return owner;
-}
-function createRoot(init, options) {
-  const owner = createOwner(options);
-  return runWithOwner(owner, () => init(owner.dispose));
-}
 function runWithOwner(owner, fn) {
   const oldContext = context;
   const prevTracking = tracking;
@@ -1375,6 +1361,64 @@ function runWithOwner(owner, fn) {
     tracking = prevTracking;
   }
 }
+function getPendingSignal(el) {
+  if (!el._pendingSignal) {
+    el._pendingSignal = optimisticSignal(false, { pureWrite: true });
+    if (el._parentSource) {
+      el._pendingSignal._parentSource = el;
+    }
+    if (computePendingState(el)) setSignal(el._pendingSignal, true);
+  }
+  return el._pendingSignal;
+}
+function computePendingState(el) {
+  const comp = el;
+  if (el._optimistic && el._pendingValue !== NOT_PENDING) {
+    if (comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED))
+      return true;
+    if (el._parentSource) {
+      const lane = el._optimisticLane ? findLane(el._optimisticLane) : null;
+      return !!(lane && lane._pendingAsync.size > 0);
+    }
+    return true;
+  }
+  if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
+  return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
+}
+function updatePendingSignal(el) {
+  if (el._pendingSignal) {
+    const pending = computePendingState(el);
+    const sig = el._pendingSignal;
+    setSignal(sig, pending);
+    if (!pending && sig._optimisticLane) {
+      const sourceLane = resolveLane(el);
+      if (sourceLane && sourceLane._pendingAsync.size > 0) {
+        const sigLane = findLane(sig._optimisticLane);
+        if (sigLane !== sourceLane) {
+          mergeLanes(sourceLane, sigLane);
+        }
+      }
+      signalLanes.delete(sig);
+      sig._optimisticLane = undefined;
+    }
+  }
+}
+function getPendingValueComputed(el) {
+  if (!el._pendingValueComputed) {
+    const prevPending = pendingReadActive;
+    pendingReadActive = false;
+    const prevCheck = pendingCheckActive;
+    pendingCheckActive = false;
+    const prevContext = context;
+    context = null;
+    el._pendingValueComputed = optimisticComputed(() => read(el));
+    el._pendingValueComputed._parentSource = el;
+    context = prevContext;
+    pendingCheckActive = prevCheck;
+    pendingReadActive = prevPending;
+  }
+  return el._pendingValueComputed;
+}
 function staleValues(fn, set = true) {
   const prevStale = stale;
   stale = set;
@@ -1455,99 +1499,49 @@ function hasContext(context, owner) {
 function isUndefined(value) {
   return typeof value === "undefined";
 }
-function effect(compute, effect, error, initialValue, options) {
-  let initialized = false;
-  const node = computed(
-    options?.render ? p => staleValues(() => compute(p)) : compute,
-    initialValue,
-    {
-      ...options,
-      equals: () => {
-        node._modified = !node._error;
-        if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
-        return false;
-      },
-      lazy: true
-    }
-  );
-  node._prevValue = initialValue;
-  node._effectFn = effect;
-  node._errorFn = error;
-  node._cleanup = undefined;
-  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
-  node._notifyStatus = (status, error) => {
-    const actualStatus = status !== undefined ? status : node._statusFlags;
-    const actualError = error !== undefined ? error : node._error;
-    if (actualStatus & STATUS_ERROR) {
-      let err = actualError;
-      node._queue.notify(node, STATUS_PENDING, 0);
-      if (node._type === EFFECT_USER) {
+function restoreTransition(transition, fn) {
+  globalQueue.initTransition(transition);
+  const result = fn();
+  flush();
+  return result;
+}
+function action(genFn) {
+  return (...args) =>
+    new Promise((resolve, reject) => {
+      const it = genFn(...args);
+      globalQueue.initTransition();
+      let ctx = activeTransition;
+      ctx._actions.push(it);
+      const done = (v, e) => {
+        ctx = currentTransition(ctx);
+        const i = ctx._actions.indexOf(it);
+        if (i >= 0) ctx._actions.splice(i, 1);
+        setActiveTransition(ctx);
+        schedule();
+        e ? reject(e) : resolve(v);
+      };
+      const step = (v, err) => {
+        let r;
         try {
-          return node._errorFn
-            ? node._errorFn(err, () => {
-                node._cleanup?.();
-                node._cleanup = undefined;
-              })
-            : console.error(err);
+          r = err ? it.throw(v) : it.next(v);
         } catch (e) {
-          err = e;
+          return done(undefined, e);
         }
-      }
-      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
-    } else if (node._type === EFFECT_RENDER)
-      node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
-  };
-  recompute(node, true);
-  !options?.defer &&
-    (node._type === EFFECT_USER
-      ? node._queue.enqueue(node._type, runEffect.bind(node))
-      : runEffect.call(node));
-  initialized = true;
-  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 & REACTIVE_DISPOSED) return;
-  this._cleanup?.();
-  this._cleanup = undefined;
-  try {
-    this._cleanup = this._effectFn(this._value, this._prevValue);
-  } catch (error) {
-    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
-  } finally {
-    this._prevValue = this._value;
-    this._modified = false;
-  }
-}
-function trackedEffect(fn, options) {
-  const run = () => {
-    if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
-    node._modified = false;
-    recompute(node);
-  };
-  const node = computed(
-    () => {
-      setLeafEffectActive(true);
-      try {
-        node._cleanup?.();
-        node._cleanup = undefined;
-        node._cleanup = staleValues(fn) || undefined;
-      } finally {
-        setLeafEffectActive(false);
-      }
-    },
-    undefined,
-    { ...options, lazy: true, pureWrite: true }
-  );
-  node._cleanup = undefined;
-  node._modified = true;
-  node._type = EFFECT_TRACKED;
-  node._run = run;
-  node._queue.enqueue(EFFECT_USER, run);
-  onCleanup(() => node._cleanup?.());
-  if (!node._parent)
-    console.warn("Effects created outside a reactive context will never be disposed");
+        if (r instanceof Promise)
+          return void r.then(run, e => restoreTransition(ctx, () => step(e, true)));
+        run(r);
+      };
+      const run = r => {
+        if (r.done) return done(r.value);
+        if (r.value instanceof Promise)
+          return void r.value.then(
+            v => restoreTransition(ctx, () => step(v)),
+            e => restoreTransition(ctx, () => step(e, true))
+          );
+        restoreTransition(ctx, () => step(r.value));
+      };
+      step();
+    });
 }
 function createSignal(first, second, third) {
   if (typeof first === "function") {
@@ -2732,36 +2726,6 @@ function createBoundChildren(owner, fn, queue, mask) {
     return boundaryComputed(() => staleValues(() => flatten(read(c))), mask);
   });
 }
-class ConditionalQueue extends Queue {
-  _disabled;
-  _errorNodes = new Set();
-  _pendingNodes = new Set();
-  constructor(disabled) {
-    super();
-    this._disabled = disabled;
-  }
-  run(type) {
-    if (!type || read(this._disabled)) return;
-    return super.run(type);
-  }
-  notify(node, type, flags, error) {
-    if (read(this._disabled)) {
-      if (type & STATUS_PENDING) {
-        if (flags & STATUS_PENDING) {
-          this._pendingNodes.add(node);
-          type &= ~STATUS_PENDING;
-        } else if (this._pendingNodes.delete(node)) type &= ~STATUS_PENDING;
-      }
-      if (type & STATUS_ERROR) {
-        if (flags & STATUS_ERROR) {
-          this._errorNodes.add(node);
-          type &= ~STATUS_ERROR;
-        } else if (this._errorNodes.delete(node)) type &= ~STATUS_ERROR;
-      }
-    }
-    return type ? super.notify(node, type, flags, error ?? node._error) : true;
-  }
-}
 class CollectionQueue extends Queue {
   _collectionType;
   _sources = new Set();
@@ -2799,31 +2763,6 @@ class CollectionQueue extends Queue {
     if (!this._sources.size) setSignal(this._disabled, false);
   }
 }
-var BoundaryMode;
-(function (BoundaryMode) {
-  BoundaryMode["VISIBLE"] = "visible";
-  BoundaryMode["HIDDEN"] = "hidden";
-})(BoundaryMode || (BoundaryMode = {}));
-function createBoundary(fn, condition) {
-  const owner = createOwner();
-  const queue = new ConditionalQueue(computed(() => condition() === BoundaryMode.HIDDEN));
-  const tree = createBoundChildren(owner, fn, queue, 0);
-  computed(() => {
-    const disabled = read(queue._disabled);
-    tree._propagationMask = disabled ? STATUS_ERROR | STATUS_PENDING : 0;
-    if (!disabled) {
-      queue._pendingNodes.forEach(node =>
-        queue.notify(node, STATUS_PENDING, STATUS_PENDING, node._error)
-      );
-      queue._errorNodes.forEach(node =>
-        queue.notify(node, STATUS_ERROR, STATUS_ERROR, node._error)
-      );
-      queue._pendingNodes.clear();
-      queue._errorNodes.clear();
-    }
-  });
-  return () => (read(queue._disabled) ? undefined : read(tree));
-}
 function createCollectionBoundary(type, fn, fallback) {
   const owner = createOwner();
   const queue = new CollectionQueue(type);
@@ -2918,7 +2857,6 @@ export {
   NotReadyError,
   SUPPORTS_PROXY,
   action,
-  createBoundary,
   createContext,
   createEffect,
   createErrorBoundary,
@@ -2926,6 +2864,7 @@ export {
   createMemo,
   createOptimistic,
   createOptimisticStore,
+  createOwner,
   createProjection,
   createReaction,
   createRenderEffect,