@solidjs/signals 0.6.3 → 0.7.0

package/dist/dev.js

@@ -176,7 +176,7 @@ var Transition = class _Transition {
   constructor() {
     this._clonedQueues.set(globalQueue, this);
     for (const child of globalQueue._children) {
-      cloneQueue(child, this, this._clonedQueues);
+      cloneQueue(child, this, this);
     }
   }
   enqueue(type, fn) {
@@ -276,8 +276,7 @@ var Transition = class _Transition {
               try {
                 value = await temp.value;
               } finally {
-                while (transition2._done instanceof _Transition)
-                  transition2 = transition2._done;
+                transition2 = latestTransition(transition2);
                 transition2._promises.delete(temp.value);
               }
               ActiveTransition = transition2;
@@ -291,8 +290,7 @@ var Transition = class _Transition {
       if (result instanceof Promise) {
         transition2._promises.add(result);
         result.finally(() => {
-          while (transition2._done instanceof _Transition)
-            transition2 = transition2._done;
+          transition2 = latestTransition(transition2);
           transition2._promises.delete(result);
           ActiveTransition = null;
           finishTransition(transition2);
@@ -318,7 +316,7 @@ function transition(fn) {
   let t = new Transition();
   queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
 }
-function cloneGraph(node) {
+function cloneGraph(node, optimistic) {
   if (node._transition) {
     if (node._transition !== ActiveTransition) {
       mergeTransitions(node._transition, ActiveTransition);
@@ -332,48 +330,58 @@ function cloneGraph(node) {
     _nextSibling: null,
     _observers: null,
     _sources: node._sources ? [...node._sources] : null,
-    _cloned: node
+    _cloned: node,
+    _optimistic: !!optimistic
   });
+  delete clone._prevValue;
   ActiveTransition._sources.set(node, clone);
   node._transition = ActiveTransition;
-  if (node._sources) {
+  if (!optimistic && 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]));
+      !node._observers[i]._cloned && clone._observers.push(cloneGraph(node._observers[i], optimistic));
     }
   }
   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++) {
-    source = transition2._sources.get(node._sources[i]) || node._sources[i];
+    transitionSource = transition2._sources.get(node._sources[i]);
+    source = transitionSource || node._sources[i];
     if (source._observers && (swap = source._observers.indexOf(node)) !== -1) {
-      const remove = source._observers.indexOf(node._cloned) > -1;
-      source._observers[swap] = !remove ? node._cloned : source._observers[source._observers.length - 1];
-      remove && source._observers.pop();
+      source._observers[swap] = transitionSource ? node._cloned : source._observers[source._observers.length - 1];
+      !transitionSource && source._observers.pop();
     }
   }
 }
-function cloneQueue(queue, parent, clonedQueues) {
+function cloneQueue(queue, parent, transition2) {
   const clone = Object.create(Object.getPrototypeOf(queue));
   Object.assign(clone, queue, {
     _cloned: queue,
     _parent: parent,
     _children: [],
     enqueue(type, fn) {
-      ActiveTransition?.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;
-        ActiveTransition?.notify(node, LOADING_BIT, flags);
+        transition2 = latestTransition(transition2);
+        transition2.notify(node, LOADING_BIT, flags);
         if (!type)
           return true;
       }
@@ -381,9 +389,9 @@ function cloneQueue(queue, parent, clonedQueues) {
     }
   });
   parent._children.push(clone);
-  clonedQueues.set(queue, clone);
+  transition2._clonedQueues.set(queue, clone);
   for (const child of queue._children) {
-    cloneQueue(child, clone, clonedQueues);
+    cloneQueue(child, clone, transition2);
   }
 }
 function resolveQueues(children) {
@@ -447,6 +455,12 @@ function finishTransition(transition2) {
     }
     if (clone._sources)
       replaceSourceObservers(clone, transition2);
+    if (clone._optimistic) {
+      clone.dispose();
+      clone.emptyDisposal();
+      delete source._transition;
+      continue;
+    }
     if (clone._updated || clone._state === STATE_DISPOSED) {
       source.dispose(clone._state === STATE_DISPOSED);
       source.emptyDisposal();
@@ -645,6 +659,7 @@ var Computation = class extends Owner {
   _forceNotify = false;
   _transition;
   _cloned;
+  _optimistic = false;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
     this._compute = compute2;
@@ -654,10 +669,8 @@ var Computation = class extends Owner {
     this._name = options?.name ?? (this._compute ? "computed" : "signal");
     if (options?.equals !== void 0)
       this._equals = options.equals;
-    if (options?.pureWrite)
-      this._pureWrite = true;
-    if (options?.unobserved)
-      this._unobserved = options?.unobserved;
+    this._pureWrite = !!options?.pureWrite;
+    this._unobserved = options?.unobserved;
     if (ActiveTransition) {
       this._transition = ActiveTransition;
       ActiveTransition._sources.set(this, this);
@@ -969,46 +982,6 @@ function latest(fn, fallback) {
     notStale = prevNotStale;
   }
 }
-function runWithObserver(observer, run) {
-  const prevSources = newSources, prevSourcesIndex = newSourcesIndex, prevFlags = newFlags;
-  newSources = null;
-  newSourcesIndex = observer._sources ? observer._sources.length : 0;
-  newFlags = 0;
-  try {
-    return compute(observer, run, observer);
-  } catch (error) {
-    if (error instanceof NotReadyError) {
-      observer.write(
-        UNCHANGED,
-        newFlags | LOADING_BIT | observer._stateFlags & UNINITIALIZED_BIT
-      );
-    } else {
-      observer._setError(error);
-    }
-  } finally {
-    if (newSources) {
-      if (newSourcesIndex > 0) {
-        observer._sources.length = newSourcesIndex + newSources.length;
-        for (let i = 0; i < newSources.length; i++) {
-          observer._sources[newSourcesIndex + i] = newSources[i];
-        }
-      } else {
-        observer._sources = newSources;
-      }
-      let source;
-      for (let i = newSourcesIndex; i < observer._sources.length; i++) {
-        source = observer._sources[i];
-        if (!source._observers)
-          source._observers = [observer];
-        else
-          source._observers.push(observer);
-      }
-    }
-    newSources = prevSources;
-    newSourcesIndex = prevSourcesIndex;
-    newFlags = prevFlags;
-  }
-}
 function compute(owner, fn, observer) {
   const prevOwner = setOwner(owner), prevObserver = currentObserver, prevMask = currentMask, prevNotStale = notStale;
   currentObserver = observer;
@@ -1065,7 +1038,7 @@ var Effect = class extends Computation {
   _notify(state, skipQueue) {
     if (this._state >= state || skipQueue)
       return;
-    if (this._state === STATE_CLEAN)
+    if (this._state === STATE_CLEAN || this._cloned && !ActiveTransition)
       getQueue(this).enqueue(this._type, this._run.bind(this));
     this._state = state;
   }
@@ -1127,6 +1100,39 @@ var Effect = class extends Computation {
       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);
@@ -1179,12 +1185,208 @@ function runTop(node) {
   }
 }
 
+// src/signals.ts
+function createSignal(first, second, third) {
+  if (typeof first === "function") {
+    const node2 = new Computation(second, first, third);
+    return [node2.read.bind(node2), node2.write.bind(node2)];
+  }
+  const o = getOwner();
+  const needsId = o?.id != null;
+  const node = new Computation(
+    first,
+    null,
+    needsId ? { id: o.getNextChildId(), ...second } : second
+  );
+  return [node.read.bind(node), node.write.bind(node)];
+}
+function createMemo(compute2, value, options) {
+  let node = new Computation(
+    value,
+    compute2,
+    options
+  );
+  let resolvedValue;
+  return () => {
+    if (node) {
+      if (node._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();
+    },
+    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, {
+    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 runWithOwner(owner, run) {
+  return compute(owner, run, null);
+}
+function resolve(fn) {
+  return new Promise((res, rej) => {
+    createRoot((dispose) => {
+      new EagerComputation(void 0, () => {
+        try {
+          res(fn());
+        } catch (err) {
+          if (err instanceof NotReadyError)
+            throw err;
+          rej(err);
+        }
+        dispose();
+      });
+    });
+  });
+}
+function createOptimistic(first, second, third) {
+  const node = typeof first === "function" ? new Computation(second, first, third) : new Computation(first, null, second);
+  const reset = () => node.write(first);
+  function write(v) {
+    if (!ActiveTransition)
+      throw new Error("createOptimistic can only be updated inside a transition");
+    ActiveTransition.addOptimistic(reset);
+    cloneGraph(node, true);
+    queueMicrotask(() => reset._transition && node.write(v));
+  }
+  return [node.read.bind(node), write];
+}
+function useTransition() {
+  const [pending, setPending] = createOptimistic(false);
+  function start(fn) {
+    transition((resume) => {
+      setPending(true);
+      return fn(resume);
+    });
+  }
+  return [pending, start];
+}
+
 // src/store/reconcile.ts
 function unwrap(value) {
   return value?.[$TARGET]?.[STORE_NODE] ?? value;
 }
-function getOverrideValue(value, override, key) {
-  return override && key in override ? override[key] : value[key];
+function getOverrideValue(value, override, nodes, key) {
+  return nodes && key in nodes ? nodes[key].read() : override && key in override ? override[key] : value[key];
 }
 function getAllKeys(value, override, next) {
   const keys = getKeys(value, override);
@@ -1197,6 +1399,7 @@ function applyState(next, state, keyFn, all) {
     return;
   const previous = target[STORE_VALUE];
   const override = target[STORE_OVERRIDE];
+  let nodes = target[STORE_NODE];
   if (next === previous && !override)
     return;
   (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
@@ -1204,14 +1407,14 @@ function applyState(next, state, keyFn, all) {
   target[STORE_OVERRIDE] = void 0;
   if (Array.isArray(previous)) {
     let changed = false;
-    const prevLength = getOverrideValue(previous, override, "length");
+    const prevLength = getOverrideValue(previous, override, nodes, "length");
     if (next.length && prevLength && next[0] && keyFn(next[0]) != null) {
       let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
-      for (start = 0, end = Math.min(prevLength, next.length); start < end && ((item = getOverrideValue(previous, override, start)) === next[start] || item && next[start] && keyFn(item) === keyFn(next[start])); start++) {
+      for (start = 0, end = Math.min(prevLength, next.length); start < end && ((item = getOverrideValue(previous, override, nodes, start)) === next[start] || item && next[start] && keyFn(item) === keyFn(next[start])); start++) {
         applyState(next[start], wrap(item, target), keyFn, all);
       }
       const temp = new Array(next.length), newIndices = /* @__PURE__ */ new Map();
-      for (end = prevLength - 1, newEnd = next.length - 1; end >= start && newEnd >= start && ((item = getOverrideValue(previous, override, end)) === next[newEnd] || item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])); end--, newEnd--) {
+      for (end = prevLength - 1, newEnd = next.length - 1; end >= start && newEnd >= start && ((item = getOverrideValue(previous, override, nodes, end)) === next[newEnd] || item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])); end--, newEnd--) {
         temp[newEnd] = item;
       }
       if (start > newEnd || start > end) {
@@ -1238,7 +1441,7 @@ function applyState(next, state, keyFn, all) {
         newIndices.set(keyVal, j);
       }
       for (i = start; i <= end; i++) {
-        item = getOverrideValue(previous, override, i);
+        item = getOverrideValue(previous, override, nodes, i);
         keyVal = item ? keyFn(item) : item;
         j = newIndices.get(keyVal);
         if (j !== void 0 && j !== -1) {
@@ -1259,7 +1462,7 @@ function applyState(next, state, keyFn, all) {
         changed = true;
     } else if (prevLength && next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
-        const item = getOverrideValue(previous, override, i);
+        const item = getOverrideValue(previous, override, nodes, i);
         isWrappable(item) && applyState(next[i], wrap(item, target), keyFn, all);
       }
     }
@@ -1270,14 +1473,13 @@ function applyState(next, state, keyFn, all) {
     changed && target[STORE_NODE][$TRACK]?.write(void 0);
     return;
   }
-  let nodes = target[STORE_NODE];
   if (nodes) {
     const tracked = nodes[$TRACK];
     const keys = tracked || all ? getAllKeys(previous, override, next) : Object.keys(nodes);
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
       const node = nodes[key];
-      const previousValue = unwrap(getOverrideValue(previous, override, key));
+      const previousValue = unwrap(getOverrideValue(previous, override, nodes, key));
       let nextValue = unwrap(next[key]);
       if (previousValue === nextValue)
         continue;
@@ -1308,16 +1510,7 @@ function reconcile(value, key, all = false) {
 }
 
 // src/store/projection.ts
-function createProjection(fn, initialValue = {}, options) {
-  let wrappedStore;
-  const node = new FirewallComputation(() => {
-    storeSetter(wrappedStore, (s) => {
-      const value = fn(s);
-      if (value !== s && value !== void 0) {
-        reconcile(value, options?.key || "id", options?.all)(s);
-      }
-    });
-  });
+function createProjectionInternal(fn, initialValue = {}, options) {
   const wrappedMap = /* @__PURE__ */ new WeakMap();
   const traps = {
     ...storeTraps,
@@ -1328,7 +1521,7 @@ function createProjection(fn, initialValue = {}, options) {
       return storeTraps.get(target, property, receiver);
     }
   };
-  function wrapProjection(source) {
+  const wrapProjection = (source) => {
     if (wrappedMap.has(source))
       return wrappedMap.get(source);
     if (source[$TARGET]?.[STORE_WRAP] === wrapProjection)
@@ -1339,8 +1532,20 @@ function createProjection(fn, initialValue = {}, options) {
     });
     wrappedMap.set(source, wrapped);
     return wrapped;
-  }
-  return wrappedStore = wrapProjection(initialValue);
+  };
+  const wrappedStore = wrapProjection(initialValue);
+  const node = new FirewallComputation(() => {
+    storeSetter(wrappedStore, (s) => {
+      const value = fn(s);
+      if (value !== s && value !== void 0) {
+        reconcile(value, options?.key || "id", options?.all)(s);
+      }
+    });
+  });
+  return { store: wrappedStore, node };
+}
+function createProjection(fn, initialValue = {}, options) {
+  return createProjectionInternal(fn, initialValue, options).store;
 }
 
 // src/store/store.ts
@@ -1476,7 +1681,7 @@ var storeTraps = {
       untrack(() => {
         const state = target[STORE_VALUE];
         const base = state[property];
-        const prev = target[STORE_OVERRIDE]?.[property] || base;
+        const prev = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] : base;
         const value = rawValue?.[$TARGET]?.[STORE_VALUE] ?? rawValue;
         if (prev === value)
           return true;
@@ -1508,7 +1713,7 @@ var storeTraps = {
   deleteProperty(target, property) {
     if (Writing?.has(target[$PROXY]) && target[STORE_OVERRIDE]?.[property] !== $DELETED) {
       untrack(() => {
-        const prev = target[STORE_OVERRIDE]?.[property] || target[STORE_VALUE][property];
+        const prev = target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE] ? target[STORE_OVERRIDE][property] : target[STORE_VALUE][property];
         if (property in target[STORE_VALUE]) {
           (target[STORE_OVERRIDE] || (target[STORE_OVERRIDE] = /* @__PURE__ */ Object.create(null)))[property] = $DELETED;
         } else if (target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]) {
@@ -1567,7 +1772,7 @@ function storeSetter(store, fn) {
   }
 }
 function createStore(first, second, options) {
-  const derived = typeof first === "function", wrappedStore = derived ? createProjection(first, second, options) : wrap(first);
+  const derived = typeof first === "function", wrappedStore = derived ? createProjectionInternal(first, second, options).store : wrap(first);
   return [wrappedStore, (fn) => storeSetter(wrappedStore, fn)];
 }
 function recursivelyNotify(state, lookup) {
@@ -1631,6 +1836,29 @@ function deep(store) {
   return store[$DEEP];
 }
 
+// src/store/optimistic.ts
+function createOptimisticStore(first, second, options) {
+  const derived = typeof first === "function";
+  const { store, node } = derived ? createProjectionInternal(first, 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);
+    cloneGraph(node, true);
+    queueMicrotask(() => reset._transition && storeSetter(store, v));
+  };
+  return [store, write];
+}
+
 // src/store/utils.ts
 function snapshot(item, map, lookup) {
   let target, isArray, override, result, unwrapped, v;
@@ -1831,215 +2059,6 @@ function omit(props, ...keys) {
   return result;
 }
 
-// src/signals.ts
-function createSignal(first, second, third) {
-  if (typeof first === "function") {
-    const memo = createMemo((p) => {
-      const node2 = new Computation(
-        first(p ? untrack(p[0]) : second),
-        null,
-        third
-      );
-      return [node2.read.bind(node2), node2.write.bind(node2)];
-    });
-    return [() => memo()[0](), (value) => memo()[1](value)];
-  }
-  const o = getOwner();
-  const needsId = o?.id != null;
-  const node = new Computation(
-    first,
-    null,
-    needsId ? { id: o.getNextChildId(), ...second } : second
-  );
-  return [node.read.bind(node), node.write.bind(node)];
-}
-function createMemo(compute2, value, options) {
-  let node = new Computation(
-    value,
-    compute2,
-    options
-  );
-  let resolvedValue;
-  return () => {
-    if (node) {
-      if (node._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();
-    },
-    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 : effect,
-    effect.error,
-    { ...options, name: options?.name ?? "effect" } 
-  );
-}
-function createRenderEffect(compute2, effect, value, options) {
-  void new Effect(value, compute2, effect, void 0, {
-    render: 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 runWithOwner(owner, run) {
-  return compute(owner, run, null);
-}
-function resolve(fn) {
-  return new Promise((res, rej) => {
-    createRoot((dispose) => {
-      new EagerComputation(void 0, () => {
-        try {
-          res(fn());
-        } catch (err) {
-          if (err instanceof NotReadyError)
-            throw err;
-          rej(err);
-        }
-        dispose();
-      });
-    });
-  });
-}
-function createPending() {
-  const node = new Computation(false, null);
-  const reset = () => node.write(false);
-  function write() {
-    if (!ActiveTransition)
-      return false;
-    ActiveTransition.addOptimistic(reset);
-    queueMicrotask(() => reset._transition && node.write(true));
-  }
-  function read() {
-    const v = node.read();
-    return ActiveTransition ? false : v;
-  }
-  return [read, write];
-}
-function useTransition() {
-  const [pending, setPending] = createPending();
-  function start(fn) {
-    transition((resume) => {
-      setPending(true);
-      return fn(resume);
-    });
-  }
-  return [pending, start];
-}
-function createOptimistic(first, second, options) {
-  let store, setStore;
-  if (typeof first === "function") {
-    [store, setStore] = createStore((s) => {
-      const value = first(s);
-      if (!ActiveTransition)
-        return value;
-      ActiveTransition.addOptimistic(reset);
-    }, {});
-  } else
-    [store, setStore] = createStore(first);
-  const reset = () => setStore(
-    reconcile(
-      typeof first === "function" ? first(second) : first,
-      options?.key || "id",
-      options?.all
-    )
-  );
-  function write(v) {
-    if (!ActiveTransition)
-      throw new Error("createOptimistic can only be updated inside a transition");
-    ActiveTransition.addOptimistic(reset);
-    queueMicrotask(() => reset._transition && setStore(v));
-  }
-  return [store, write];
-}
-
 // src/map.ts
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
@@ -2282,8 +2301,6 @@ var ConditionalQueue = class extends Queue {
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
-      return ActiveTransition._clonedQueues.get(this).notify(node, type, flags);
     if (this._disabled.read()) {
       if (type & LOADING_BIT) {
         if (flags & LOADING_BIT) {
@@ -2322,8 +2339,6 @@ var CollectionQueue = class extends Queue {
     return super.run(type);
   }
   notify(node, type, flags) {
-    if (ActiveTransition && ActiveTransition._clonedQueues.has(this))
-      return ActiveTransition._clonedQueues.get(this).notify(node, type, flags);
     if (!(type & this._collectionType))
       return super.notify(node, type, flags);
     if (flags & this._collectionType) {
@@ -2447,4 +2462,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, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flush, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, snapshot, transition, untrack, useTransition };
+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 };