@solidjs/signals 0.4.1 → 0.4.3

package/dist/dev.js

@@ -24,14 +24,22 @@ var EFFECT_RENDER = 1;
 var EFFECT_USER = 2;
 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/scheduler.ts
 var clock = 0;
-function getClock() {
-  return clock;
-}
 function incrementClock() {
   clock++;
 }
+var ActiveTransition = null;
+var unobserved = [];
 var scheduled = false;
 function schedule() {
   if (scheduled)
@@ -40,6 +48,14 @@ 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 Queue = class {
   _parent = null;
@@ -48,6 +64,8 @@ var Queue = class {
   _children = [];
   created = clock;
   enqueue(type, fn) {
+    if (ActiveTransition)
+      return ActiveTransition.enqueue(type, fn);
     pureQueue.push(fn);
     if (type)
       this._queues[type - 1].push(fn);
@@ -79,6 +97,7 @@ var Queue = class {
       this.run(EFFECT_USER);
     } finally {
       this._running = false;
+      unobserved.length && notifyUnobserved();
     }
   }
   addChild(child) {
@@ -109,6 +128,200 @@ 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 = [[], []];
+  _pureQueue = [];
+  _children = [];
+  _parent = null;
+  _running = false;
+  _scheduled = false;
+  created = clock;
+  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);
+    }
+  }
+  flush() {
+    if (this._running)
+      return;
+    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;
+    }
+  }
+  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);
+    } else {
+      this._pendingNodes.delete(node);
+    }
+    return true;
+  }
+  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 {
+      const result = fn();
+      const transition2 = ActiveTransition;
+      if (result instanceof Promise) {
+        transition2._promises.add(result);
+        result.finally(() => {
+          transition2._promises.delete(result);
+          finishTransition(transition2);
+        });
+      }
+    } finally {
+      const transition2 = ActiveTransition;
+      ActiveTransition = null;
+      finishTransition(transition2);
+    }
+  }
+  addOptimistic(fn) {
+    if (fn._transition && fn._transition !== this) {
+      mergeTransitions(fn._transition, this);
+      ActiveTransition = fn._transition;
+      return;
+    }
+    fn._transition = this;
+    this._optimistic.add(fn);
+  }
+};
+var Transitions = /* @__PURE__ */ new Set();
+function transition(fn) {
+  let t = new Transition();
+  Transitions.add(t);
+  queueMicrotask(() => t.runTransition(() => fn((fn2) => t.runTransition(fn2))));
+}
+function cloneGraph(node) {
+  if (node._transition) {
+    if (node._transition !== ActiveTransition) {
+      mergeTransitions(node._transition, ActiveTransition);
+      ActiveTransition = node._transition;
+    }
+    return node._transition._sources.get(node);
+  }
+  const clone = Object.create(Object.getPrototypeOf(node));
+  Object.assign(clone, node, { _disposal: null, _nextSibling: null, _cloned: node });
+  ActiveTransition._sources.set(node, clone);
+  node._transition = ActiveTransition;
+  if (node._observers) {
+    for (let i = 0, length = node._observers.length; i < length; i++) {
+      const o = node._observers[i];
+      node._observers.push(cloneGraph(o));
+    }
+  }
+  return clone;
+}
+function removeSourceObservers(node, index) {
+  let source;
+  let swap;
+  for (let i = index; i < node._sources.length; i++) {
+    source = ActiveTransition && ActiveTransition._sources.get(node._sources[i]) || 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 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));
+  t2._queues[0].forEach((f) => t1._queues[0].push(f));
+  t2._queues[1].forEach((f) => t1._queues[1].push(f));
+  t2._pureQueue.forEach((f) => t1._pureQueue.push(f));
+  t2._children.forEach((c) => t1.addChild(c));
+  t2._done = t1;
+  Transitions.delete(t2);
+}
+function finishTransition(transition2) {
+  if (transition2._done || transition2._scheduled || transition2._promises.size || transition2._pendingNodes.size)
+    return;
+  for (const [source, clone] of transition2._sources) {
+    if (source === clone || source._transition !== transition2)
+      continue;
+    if (clone._sources)
+      removeSourceObservers(clone, 0);
+    source.dispose(false);
+    source.emptyDisposal();
+    Object.assign(source, clone);
+    delete source._cloned;
+    delete source._transition;
+  }
+  transition2._done = true;
+  Transitions.delete(transition2);
+  transition2.run(EFFECT_RENDER);
+  transition2.run(EFFECT_USER);
+  for (const reset of transition2._optimistic) {
+    delete reset._transition;
+    reset();
+  }
+}
 
 // src/core/owner.ts
 var currentOwner = null;
@@ -248,22 +461,12 @@ function isUndefined(value) {
   return typeof value === "undefined";
 }
 
-// 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/core.ts
 var currentObserver = null;
 var currentMask = DEFAULT_FLAGS;
 var newSources = null;
 var newSourcesIndex = 0;
 var newFlags = 0;
-var unobserved = [];
 var notStale = false;
 var updateCheck = null;
 var staleCheck = null;
@@ -290,6 +493,8 @@ var Computation = class extends Owner {
   _handlerMask = DEFAULT_FLAGS;
   _time = -1;
   _forceNotify = false;
+  _transition;
+  _cloned;
   constructor(initialValue, compute2, options) {
     super(options?.id, compute2 === null);
     this._compute = compute2;
@@ -303,14 +508,12 @@ var Computation = class extends Owner {
       this._pureWrite = true;
     if (options?.unobserved)
       this._unobserved = options?.unobserved;
+    if (ActiveTransition) {
+      this._transition = ActiveTransition;
+      ActiveTransition._sources.set(this, this);
+    }
   }
   _read() {
-    if (this._compute) {
-      if (this._stateFlags & ERROR_BIT && this._time <= getClock())
-        update(this);
-      else
-        this._updateIfNecessary();
-    }
     track(this);
     newFlags |= this._stateFlags & ~currentMask;
     if (this._stateFlags & ERROR_BIT) {
@@ -324,6 +527,17 @@ var Computation = class extends Owner {
    * Automatically re-executes the surrounding computation when the value changes
    */
   read() {
+    if (ActiveTransition && ActiveTransition._sources.has(this)) {
+      const clone = ActiveTransition._sources.get(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();
   }
   /**
@@ -334,13 +548,19 @@ var Computation = class extends Owner {
    * before continuing
    */
   wait() {
-    if (this._compute && this._stateFlags & ERROR_BIT && this._time <= getClock()) {
-      update(this);
-    } else {
-      this._updateIfNecessary();
+    if (ActiveTransition && ActiveTransition._sources.has(this)) {
+      const clone = ActiveTransition._sources.get(this);
+      if (clone !== this)
+        return clone.wait();
+    }
+    if (this._compute) {
+      if (this._stateFlags & ERROR_BIT && this._time <= clock)
+        update(this);
+      else
+        this._updateIfNecessary();
     }
-    track(this);
     if ((notStale || this._stateFlags & UNINITIALIZED_BIT) && this._stateFlags & LOADING_BIT) {
+      track(this);
       throw new NotReadyError();
     }
     if (staleCheck && this._stateFlags & LOADING_BIT) {
@@ -350,6 +570,10 @@ var Computation = class extends Owner {
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
+    if (ActiveTransition && !this._cloned) {
+      const clone = cloneGraph(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;
@@ -361,7 +585,7 @@ var Computation = class extends Owner {
     }
     const changedFlagsMask = this._stateFlags ^ flags, changedFlags = changedFlagsMask & flags;
     this._stateFlags = flags;
-    this._time = getClock() + 1;
+    this._time = clock + 1;
     if (this._observers) {
       for (let i = 0; i < this._observers.length; i++) {
         if (valueChanged) {
@@ -377,6 +601,11 @@ var Computation = class extends Owner {
    * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
    */
   _notify(state, skipQueue) {
+    if (ActiveTransition && ActiveTransition._sources.has(this)) {
+      const clone = ActiveTransition._sources.get(this);
+      if (clone !== this)
+        return clone._notify(state, skipQueue);
+    }
     if (this._state >= state && !this._forceNotify)
       return;
     this._forceNotify = !!skipQueue;
@@ -439,8 +668,9 @@ var Computation = class extends Owner {
     let observerFlags = 0;
     if (this._state === STATE_CHECK) {
       for (let i = 0; i < this._sources.length; i++) {
-        this._sources[i]._updateIfNecessary();
-        observerFlags |= this._sources[i]._stateFlags;
+        const source = ActiveTransition && ActiveTransition._sources.get(this._sources[i]) || this._sources[i];
+        source._updateIfNecessary();
+        observerFlags |= source._stateFlags;
         if (this._state === STATE_DIRTY) {
           break;
         }
@@ -465,6 +695,8 @@ var Computation = class extends Owner {
   }
 };
 function track(computation) {
+  if (ActiveTransition && computation._cloned)
+    computation = computation._cloned;
   if (currentObserver) {
     if (!newSources && currentObserver._sources && currentObserver._sources[newSourcesIndex] === computation) {
       newSourcesIndex++;
@@ -518,36 +750,13 @@ function update(node) {
       removeSourceObservers(node, newSourcesIndex);
       node._sources.length = newSourcesIndex;
     }
-    unobserved.length && notifyUnobserved();
     newSources = prevSources;
     newSourcesIndex = prevSourcesIndex;
     newFlags = prevFlags;
-    node._time = getClock() + 1;
+    node._time = clock + 1;
     node._state = STATE_CLEAN;
   }
 }
-function removeSourceObservers(node, index) {
-  let source;
-  let swap;
-  for (let i = index; i < node._sources.length; i++) {
-    source = node._sources[i];
-    if (source._observers) {
-      swap = source._observers.indexOf(node);
-      source._observers[swap] = source._observers[source._observers.length - 1];
-      source._observers.pop();
-      if (!source._observers.length)
-        unobserved.push(source);
-    }
-  }
-}
-function notifyUnobserved() {
-  for (let i = 0; i < unobserved.length; i++) {
-    const source = unobserved[i];
-    if (!source._observers || !source._observers.length)
-      unobserved[i]._unobserved?.();
-  }
-  unobserved = [];
-}
 function isEqual(a, b) {
   return a === b;
 }
@@ -675,19 +884,18 @@ var Effect = class extends Computation {
     this._prevValue = initialValue;
     this._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
     if (this._type === EFFECT_RENDER) {
-      this._compute = (p) => getClock() > this._queue.created && !(this._stateFlags & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
+      this._compute = (p) => !ActiveTransition && clock > this._queue.created && !(this._stateFlags & ERROR_BIT) ? latest(() => compute2(p)) : compute2(p);
     }
     this._updateIfNecessary();
-    !options?.defer && (this._type === EFFECT_USER ? this._queue.enqueue(this._type, this._run.bind(this)) : this._run(this._type));
+    !options?.defer && (this._type === EFFECT_USER ? (ActiveTransition || this._queue).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;
       this._stateFlags = flags;
       if (this._type === EFFECT_RENDER) {
-        this._queue.notify(this, LOADING_BIT | ERROR_BIT, flags);
+        (ActiveTransition || this._queue).notify(this, LOADING_BIT | ERROR_BIT, flags);
       }
     }
     if (value === UNCHANGED)
@@ -697,15 +905,29 @@ var Effect = class extends Computation {
     return value;
   }
   _notify(state, skipQueue) {
+    if (ActiveTransition && ActiveTransition._sources.has(this)) {
+      return ActiveTransition._sources.get(this)._notify(state, skipQueue);
+    }
     if (this._state >= state || skipQueue)
       return;
     if (this._state === STATE_CLEAN)
-      this._queue.enqueue(this._type, this._run.bind(this));
+      (ActiveTransition || this._queue).enqueue(this._type, this._run.bind(this));
     this._state = state;
   }
+  _notifyFlags(mask, newFlags2) {
+    if (ActiveTransition && ActiveTransition._sources.has(this)) {
+      if (this._state >= STATE_CHECK)
+        return;
+      if (mask & 3) {
+        this._notify(STATE_DIRTY);
+        return;
+      }
+    }
+    super._notifyFlags(mask, newFlags2);
+  }
   _setError(error) {
     this._error = error;
-    this._queue.notify(this, LOADING_BIT, 0);
+    (ActiveTransition || this._queue).notify(this, LOADING_BIT, 0);
     this._stateFlags = ERROR_BIT;
     if (this._type === EFFECT_USER) {
       try {
@@ -717,7 +939,7 @@ var Effect = class extends Computation {
         error = e;
       }
     }
-    if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT))
+    if (!(ActiveTransition || this._queue).notify(this, ERROR_BIT, ERROR_BIT))
       throw error;
   }
   _disposeNode() {
@@ -737,7 +959,7 @@ var Effect = class extends Computation {
         try {
           this._cleanup = this._effect(this._value, this._prevValue);
         } catch (e) {
-          if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT))
+          if (!(ActiveTransition || this._queue).notify(this, ERROR_BIT, ERROR_BIT))
             throw e;
         } finally {
           this._prevValue = this._value;
@@ -756,10 +978,13 @@ var EagerComputation = class extends Computation {
       console.warn("Eager Computations created outside a reactive context will never be disposed");
   }
   _notify(state, skipQueue) {
+    if (ActiveTransition && ActiveTransition._sources.has(this)) {
+      return ActiveTransition._sources.get(this)._notify(state, skipQueue);
+    }
     if (this._state >= state && !this._forceNotify)
       return;
     if (!skipQueue && (this._state === STATE_CLEAN || this._state === STATE_CHECK && this._forceNotify))
-      this._queue.enqueue(EFFECT_PURE, this._run.bind(this));
+      (ActiveTransition || this._queue).enqueue(EFFECT_PURE, this._run.bind(this));
     super._notify(state, skipQueue);
   }
   _run() {
@@ -774,10 +999,13 @@ var FirewallComputation = class extends Computation {
       console.warn("Eager Computations created outside a reactive context will never be disposed");
   }
   _notify(state, skipQueue) {
+    if (ActiveTransition && ActiveTransition._sources.has(this)) {
+      return ActiveTransition._sources.get(this)._notify(state, skipQueue);
+    }
     if (this._state >= state && !this._forceNotify)
       return;
     if (!skipQueue && (this._state === STATE_CLEAN || this._state === STATE_CHECK && this._forceNotify))
-      this._queue.enqueue(EFFECT_PURE, this._run.bind(this));
+      (ActiveTransition || this._queue).enqueue(EFFECT_PURE, this._run.bind(this));
     super._notify(state, true);
     this._forceNotify = !!skipQueue;
   }
@@ -798,168 +1026,6 @@ function runTop(node) {
   }
 }
 
-// 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.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);
-      if (isPromise) {
-        source.then(
-          (value3) => {
-            if (abort)
-              return;
-            node.write(value3, 0, true);
-          },
-          (error) => {
-            if (abort)
-              return;
-            node._setError(error);
-          }
-        );
-      } else {
-        (async () => {
-          try {
-            for await (let value3 of source) {
-              if (abort)
-                return;
-              node.write(value3, 0, true);
-            }
-          } catch (error) {
-            if (abort)
-              return;
-            node.write(error, ERROR_BIT);
-          }
-        })();
-      }
-      throw new NotReadyError();
-    },
-    options
-  );
-  const read = node.wait.bind(node);
-  read.refresh = () => {
-    node._state = STATE_DIRTY;
-    refreshing = true;
-    node._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 tryCatch(fn) {
-  try {
-    const v = fn();
-    if (v instanceof Promise) {
-      return v.then(
-        (v2) => [void 0, v2],
-        (e) => {
-          if (e instanceof NotReadyError)
-            throw e;
-          return [e];
-        }
-      );
-    }
-    return [void 0, v];
-  } catch (e) {
-    if (e instanceof NotReadyError)
-      throw e;
-    return [e];
-  }
-}
-function transition(fn) {
-}
-function createOptimistic(initial, compute2, options) {
-  return [];
-}
-
 // src/store/projection.ts
 function createProjection(fn, initialValue = {}) {
   let wrappedStore;
@@ -1589,6 +1655,213 @@ 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.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);
+      const 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;
+              node.write(value3, 0, true);
+            }
+          } catch (error) {
+            if (abort)
+              return;
+            node.write(error, ERROR_BIT);
+          }
+        })();
+      }
+      throw new NotReadyError();
+    },
+    options
+  );
+  const read = node.wait.bind(node);
+  read.refresh = () => {
+    node._state = STATE_DIRTY;
+    refreshing = true;
+    node._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 tryCatch(fn) {
+  try {
+    const v = fn();
+    if (v instanceof Promise) {
+      return v.then(
+        (v2) => [void 0, v2],
+        (e) => {
+          if (e instanceof NotReadyError)
+            throw e;
+          return [e];
+        }
+      );
+    }
+    return [void 0, v];
+  } catch (e) {
+    if (e instanceof NotReadyError)
+      throw e;
+    return [e];
+  }
+}
+function createOptimistic(initial, compute2, key) {
+  if (!compute2) {
+    let write2 = function(v) {
+      if (!ActiveTransition)
+        throw new Error("createOptimistic can only be updated inside a transition");
+      ActiveTransition.addOptimistic(reset2);
+      queueMicrotask(() => node.write(v));
+    };
+    var write = write2;
+    const node = new Computation(initial, null);
+    const reset2 = () => node.write(initial);
+    return [node.read.bind(node), write2];
+  }
+  let store, setStore;
+  if (typeof initial === "function") {
+    [store, setStore] = createStore(
+      (s) => {
+        const value = initial();
+        if (!ActiveTransition)
+          s.value = value;
+      },
+      { value: void 0 }
+    );
+  } else
+    [store, setStore] = createStore({ value: initial });
+  const reset = () => setStore(
+    (s) => reconcile(
+      typeof initial === "function" ? initial() : initial,
+      key
+    )(s.value)
+  );
+  let lastChange = void 0;
+  function write(v) {
+    if (!ActiveTransition)
+      throw new Error("createOptimistic can only be updated inside a transition");
+    ActiveTransition.addOptimistic(reset);
+    queueMicrotask(
+      () => setStore((s) => {
+        lastChange = typeof v === "function" ? v(lastChange) : v;
+        compute2(s.value, lastChange);
+      })
+    );
+  }
+  return [() => store.value, write];
+}
+
 // src/map.ts
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;