@solidjs/signals 0.9.2 → 0.9.4

package/dist/prod.js

@@ -32,6 +32,7 @@ const EFFECT_USER = 2;
 const NOT_PENDING = {};
 const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
+const $REFRESH = Symbol("refresh");
 function actualInsertIntoHeap(e, t) {
   const n = (e.i?.t ? e.i.u?.o : e.i?.o) ?? -1;
   if (n >= e.o) e.o = n + 1;
@@ -138,7 +139,7 @@ let scheduled = false;
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.k) queueMicrotask(flush);
+  if (!globalQueue.k) Promise.resolve().then(() => queueMicrotask(flush));
 }
 class Queue {
   i = null;
@@ -200,8 +201,8 @@ class Queue {
 }
 class GlobalQueue extends Queue {
   k = false;
-  $ = [];
   L = [];
+  $ = [];
   static F;
   static W;
   flush() {
@@ -213,7 +214,7 @@ class GlobalQueue extends Queue {
         if (!transitionComplete(activeTransition)) {
           let e = activeTransition;
           runHeap(zombieQueue, GlobalQueue.F);
-          this.$ = [];
+          this.L = [];
           this.stashQueues(activeTransition.queueStash);
           clock++;
           scheduled = false;
@@ -222,11 +223,13 @@ class GlobalQueue extends Queue {
           runOptimistic(e);
           return;
         }
-        this.$.push(...activeTransition.pendingNodes);
+        this.L.push(...activeTransition.pendingNodes);
+        this.$ !== activeTransition.optimisticNodes &&
+          this.$.push(...activeTransition.optimisticNodes);
         this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
-        runTransitionPending(this.$, false);
+        runTransitionPending(this.L, false);
       } else if (transitions.size) runHeap(zombieQueue, GlobalQueue.F);
       runOptimistic();
       clock++;
@@ -252,29 +255,30 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
-      activeTransition = e.K ?? {
+      activeTransition = e?.K ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
         optimisticNodes: [],
+        actions: [],
         queueStash: { G: [[], []], H: [] },
         done: false
       };
     }
     transitions.add(activeTransition);
     activeTransition.time = clock;
-    for (let e = 0; e < this.$.length; e++) {
-      const t = this.$[e];
+    for (let e = 0; e < this.L.length; e++) {
+      const t = this.L[e];
       t.K = activeTransition;
       activeTransition.pendingNodes.push(t);
     }
-    for (let e = 0; e < this.L.length; e++) {
-      const t = this.L[e];
+    for (let e = 0; e < this.$.length; e++) {
+      const t = this.$[e];
       t.K = activeTransition;
       activeTransition.optimisticNodes.push(t);
     }
-    this.$ = activeTransition.pendingNodes;
-    this.L = activeTransition.optimisticNodes;
+    this.L = activeTransition.pendingNodes;
+    this.$ = activeTransition.optimisticNodes;
   }
 }
 function notifySubs(e) {
@@ -286,7 +290,7 @@ function notifySubs(e) {
 }
 function runOptimistic(e = null) {
   let t = !e;
-  const n = globalQueue.L;
+  const n = globalQueue.$;
   optimisticRun = true;
   for (let t = 0; t < n.length; t++) {
     const i = n[t];
@@ -297,13 +301,13 @@ function runOptimistic(e = null) {
     i.K = e;
     notifySubs(i);
   }
-  globalQueue.L = [];
+  globalQueue.$ = [];
   if (dirtyQueue.h >= dirtyQueue.C) {
     t = true;
     runHeap(dirtyQueue, GlobalQueue.F);
   }
   optimisticRun = false;
-  t && runPending(globalQueue.$);
+  t && runPending(globalQueue.L);
 }
 function runPending(e) {
   for (let t = 0; t < e.length; t++) {
@@ -336,6 +340,7 @@ function runQueue(e, t) {
 }
 function transitionComplete(e) {
   if (e.done) return true;
+  if (e.actions.length) return false;
   let t = true;
   for (let n = 0; n < e.asyncNodes.length; n++) {
     if (e.asyncNodes[n].J & STATUS_PENDING) {
@@ -348,9 +353,38 @@ function transitionComplete(e) {
 }
 function runInTransition(e, t) {
   const n = activeTransition;
-  activeTransition = e.K;
-  t(e);
-  activeTransition = n;
+  try {
+    activeTransition = e;
+    return t();
+  } finally {
+    activeTransition = n;
+  }
+}
+function action(e) {
+  return (...t) => {
+    const n = e(...t);
+    globalQueue.initTransition();
+    let i = activeTransition;
+    i.actions.push(n);
+    const step = e => {
+      let t = n.next(e);
+      if (t instanceof Promise) return t.then(process);
+      process(t);
+    };
+    const process = e => {
+      if (e.done) {
+        i.actions.splice(i.actions.indexOf(n), 1);
+        activeTransition = i;
+        schedule();
+        flush();
+        return;
+      }
+      const t = e.value;
+      if (t instanceof Promise) return t.then(step);
+      runInTransition(i, () => step(t));
+    };
+    runInTransition(i, () => step());
+  };
 }
 GlobalQueue.F = recompute;
 GlobalQueue.W = disposeChildren;
@@ -410,7 +444,7 @@ function recompute(e, t = false) {
       else e.D = null;
     }
   }
-  const c = !e.ue || !e.ue(e.M === NOT_PENDING || e.oe || n ? e.Y : e.M, r);
+  const c = !e.ue || !e.ue(e.M === NOT_PENDING || (e.oe && e.K) || n ? e.Y : e.M, r);
   const a = e.J !== o || e.j !== u;
   e.le?.(a, o);
   if (c || a) {
@@ -425,9 +459,9 @@ function recompute(e, t = false) {
       insertIntoHeapHeight(t.A, t.A.S & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     }
   }
-  e.oe && !optimisticRun && globalQueue.L.push(e);
-  (!t || e.J & STATUS_PENDING) && !e.K && globalQueue.$.push(e);
-  e.K && n && runInTransition(e, recompute);
+  e.oe && !optimisticRun && globalQueue.$.push(e);
+  (!t || e.J & STATUS_PENDING) && !e.K && globalQueue.L.push(e);
+  e.K && n && runInTransition(e.K, () => recompute(e));
 }
 function handleAsync(e, t, n) {
   const i = typeof t === "object" && t !== null;
@@ -725,17 +759,6 @@ function read(e) {
       }
     }
   }
-  if (pendingCheck) {
-    if (!e.q) {
-      e.q = signal(false);
-      e.q.oe = true;
-      e.q.Z = t => setSignal(e.q, t);
-    }
-    const t = pendingCheck;
-    pendingCheck = null;
-    t.Y = read(e.q) || t.Y;
-    pendingCheck = t;
-  }
   if (pendingValueCheck) {
     if (!e.ce) {
       e.ce = signal(e.Y);
@@ -748,10 +771,22 @@ function read(e) {
       pendingValueCheck = true;
     }
   }
-  if (e.J & STATUS_PENDING && !pendingCheck) {
-    if ((t && !stale) || e.J & STATUS_UNINITIALIZED) throw e.j;
+  const n = e.m || e;
+  if (pendingCheck) {
+    if (!n.q) {
+      n.q = signal(false);
+      n.q.oe = true;
+      n.q.Z = e => setSignal(n.q, e);
+    }
+    const e = pendingCheck;
+    pendingCheck = null;
+    e.Y = read(n.q) || e.Y;
+    pendingCheck = e;
+  }
+  if (!pendingCheck && n.J & STATUS_PENDING) {
+    if ((t && !stale) || n.J & STATUS_UNINITIALIZED || e.m) throw n.j;
     else if (t && stale) {
-      setStatusFlags(t, t.J | 1, e.j);
+      setStatusFlags(t, t.J | STATUS_PENDING, n.j);
     }
   }
   if (e.J & STATUS_ERROR) {
@@ -773,19 +808,19 @@ function setSignal(e, t) {
   if (typeof t === "function") {
     t = t(e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M);
   }
-  const n = !e.ue || !e.ue(e.M === NOT_PENDING || e.oe ? e.Y : e.M, t);
+  const n = !e.ue || !e.ue(e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M, t);
   if (!n && !e.J) return t;
   if (n) {
     if (e.oe) e.Y = t;
     else {
-      if (e.M === NOT_PENDING) globalQueue.$.push(e);
+      if (e.M === NOT_PENDING) globalQueue.L.push(e);
       e.M = t;
     }
     if (e.ce) setSignal(e.ce, t);
   }
   setStatusFlags(e, STATUS_NONE);
   e.se = clock;
-  e.oe && !optimisticRun ? globalQueue.L.push(e) : notifySubs(e);
+  e.oe && !optimisticRun ? globalQueue.$.push(e) : notifySubs(e);
   schedule();
   return t;
 }
@@ -885,6 +920,10 @@ function refresh(e) {
   let t = refreshing;
   refreshing = true;
   try {
+    if (typeof e !== "function") {
+      recompute(e[$REFRESH]);
+      return e;
+    }
     return untrack(e);
   } finally {
     refreshing = t;
@@ -929,8 +968,8 @@ function effect(e, t, n, i, r) {
     pe: {
       X: true,
       Ae: i,
-      ge: t,
-      Ne: n,
+      Ne: t,
+      ge: n,
       Ie: undefined,
       B: r?.render ? EFFECT_RENDER : EFFECT_USER,
       le(e, t) {
@@ -944,8 +983,8 @@ function effect(e, t, n, i, r) {
           this._e.notify(this, STATUS_PENDING, 0);
           if (this.B === EFFECT_USER) {
             try {
-              return this.Ne
-                ? this.Ne(e, () => {
+              return this.ge
+                ? this.ge(e, () => {
                     this.Ie?.();
                     this.Ie = undefined;
                   })
@@ -973,7 +1012,7 @@ function runEffect() {
   this.Ie?.();
   this.Ie = undefined;
   try {
-    this.Ie = this.ge(this.Y, this.Ae);
+    this.Ie = this.Ne(this.Y, this.Ae);
   } catch (e) {
     if (!this._e.notify(this, STATUS_ERROR, STATUS_ERROR)) throw e;
   } finally {
@@ -986,10 +1025,8 @@ function createSignal(e, t, n) {
     const i = computed(e, t, n);
     return [read.bind(null, i), setSignal.bind(null, i)];
   }
-  const i = getOwner();
-  const r = i?.id != null;
-  const s = signal(e, r ? { id: getNextChildId(i), ...t } : t);
-  return [read.bind(null, s), setSignal.bind(null, s)];
+  const i = signal(e, t);
+  return [read.bind(null, i), setSignal.bind(null, i)];
 }
 function createMemo(e, t, n) {
   let i = computed(e, t, n);
@@ -1041,8 +1078,10 @@ function createOptimistic(e, t, n) {
   if (typeof e === "function") {
     const i = computed(
       t => {
-        let n = i || getOwner();
-        n.M = e(t);
+        const n = getOwner();
+        const i = e(t);
+        if (n.J & STATUS_UNINITIALIZED) return i;
+        n.M = i;
         return t;
       },
       t,
@@ -1051,15 +1090,13 @@ function createOptimistic(e, t, n) {
     i.oe = true;
     return [read.bind(null, i), setSignal.bind(null, i)];
   }
-  const i = getOwner();
-  const r = i?.id != null;
-  const s = signal(e, r ? { id: getNextChildId(i), ...t } : t);
-  s.oe = true;
+  const i = signal(e, t);
+  i.oe = true;
   return [
-    read.bind(null, s),
+    read.bind(null, i),
     t => {
-      s.M = e;
-      return setSignal(s, t);
+      i.M = e;
+      return setSignal(i, t);
     }
   ];
 }
@@ -1076,7 +1113,7 @@ function unwrap(e) {
   return e?.[$TARGET]?.[STORE_NODE] ?? e;
 }
 function getOverrideValue(e, t, n, i) {
-  return n && i in n ? read(n[i]) : t && i in t ? t[i] : e[i];
+  return t && i in t ? t[i] : e[i];
 }
 function getAllKeys(e, t, n) {
   const i = getKeys(e, t);
@@ -1157,10 +1194,12 @@ function applyState(e, t, n, i) {
         } else r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], wrap(e[a], r));
       }
       if (f < e.length) t = true;
-    } else if (l && e.length) {
+    } else if (e.length) {
       for (let t = 0, l = e.length; t < l; t++) {
         const l = getOverrideValue(s, o, u, t);
-        isWrappable(l) && applyState(e[t], wrap(l, r), n, i);
+        isWrappable(l)
+          ? applyState(e[t], wrap(l, r), n, i)
+          : r[STORE_NODE][t] && setSignal(r[STORE_NODE][t], e[t]);
       }
     }
     if (l !== e.length) {
@@ -1206,34 +1245,70 @@ function reconcile(e, t, n = false) {
 function createProjectionInternal(e, t = {}, n) {
   let i;
   const r = new WeakMap();
+  const wrapper = e => {
+    e[STORE_WRAP] = wrapProjection;
+    e[STORE_LOOKUP] = r;
+    Object.defineProperty(e, STORE_FIREWALL, {
+      get() {
+        return i;
+      },
+      configurable: true
+    });
+  };
   const wrapProjection = e => {
     if (r.has(e)) return r.get(e);
     if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
-    const t = createStoreProxy(e, storeTraps, {
-      [STORE_WRAP]: wrapProjection,
-      [STORE_LOOKUP]: r,
-      [STORE_FIREWALL]() {
-        return i;
-      }
-    });
+    const t = createStoreProxy(e, storeTraps, wrapper);
     r.set(e, t);
     return t;
   };
   const s = wrapProjection(t);
   i = computed(() => {
-    const t = i || getOwner();
-    storeSetter(s, i => {
+    const t = getOwner();
+    storeSetter(new Proxy(s, writeTraps), i => {
       const r = handleAsync(t, e(i), e => {
-        e !== i && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id", n?.all));
+        e !== s && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id", n?.all));
+        setSignal(t, undefined);
       });
-      r !== i && r !== undefined && reconcile(r, n?.key || "id", n?.all)(i);
+      r !== s && r !== undefined && reconcile(r, n?.key || "id", n?.all)(s);
     });
   });
+  i.Te = true;
   return { store: s, node: i };
 }
 function createProjection(e, t = {}, n) {
   return createProjectionInternal(e, t, n).store;
 }
+const writeTraps = {
+  get(e, t) {
+    let n;
+    setWriteOverride(true);
+    try {
+      n = e[t];
+    } finally {
+      setWriteOverride(false);
+    }
+    return typeof n === "object" && n !== null ? new Proxy(n, writeTraps) : n;
+  },
+  set(e, t, n) {
+    setWriteOverride(true);
+    try {
+      e[t] = n;
+    } finally {
+      setWriteOverride(false);
+    }
+    return true;
+  },
+  deleteProperty(e, t) {
+    setWriteOverride(true);
+    try {
+      delete e[t];
+    } finally {
+      setWriteOverride(false);
+    }
+    return true;
+  }
+};
 const $TRACK = Symbol(0),
   $DEEP = Symbol(0),
   $TARGET = Symbol(0),
@@ -1253,7 +1328,7 @@ function createStoreProxy(e, t = storeTraps, n) {
     i = [];
     i.v = e;
   } else i = { v: e };
-  n && Object.assign(i, n);
+  n && n(i);
   return (i[$PROXY] = new Proxy(i, t));
 }
 const storeLookup = new WeakMap();
@@ -1266,6 +1341,13 @@ function wrap(e, t) {
 function isWrappable(e) {
   return e != null && typeof e === "object" && !Object.isFrozen(e);
 }
+let writeOverride = false;
+function setWriteOverride(e) {
+  writeOverride = e;
+}
+function writeOnly(e) {
+  return writeOverride || !!Writing?.has(e);
+}
 function getNodes(e, t) {
   let n = e[t];
   if (!n) e[t] = n = Object.create(null);
@@ -1285,8 +1367,7 @@ function getNode(e, t, n, i, r = isEqual) {
   ));
 }
 function trackSelf(e, t = $TRACK) {
-  getObserver() &&
-    read(getNode(getNodes(e, STORE_NODE), t, undefined, e[STORE_FIREWALL]?.(), false));
+  getObserver() && read(getNode(getNodes(e, STORE_NODE), t, undefined, e[STORE_FIREWALL], false));
 }
 function getKeys(e, t, n = true) {
   const i = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
@@ -1312,6 +1393,7 @@ const storeTraps = {
   get(e, t, n) {
     if (t === $TARGET) return e;
     if (t === $PROXY) return n;
+    if (t === $REFRESH) return e[STORE_FIREWALL];
     if (t === $TRACK || t === $DEEP) {
       trackSelf(e, t);
       return n;
@@ -1325,12 +1407,12 @@ const storeTraps = {
       const e = Object.getOwnPropertyDescriptor(u, t);
       if (e && e.get) return e.get.call(n);
     }
-    if (Writing?.has(n)) {
+    if (writeOnly(n)) {
       let n = r && (s || !o) ? (r.M !== NOT_PENDING ? r.M : r.Y) : u[t];
       n === $DELETED && (n = undefined);
       if (!isWrappable(n)) return n;
       const i = wrap(n, e);
-      Writing.add(i);
+      Writing?.add(i);
       return i;
     }
     let l = r ? (s || !o ? read(i[t]) : (read(i[t]), u[t])) : u[t];
@@ -1344,7 +1426,7 @@ const storeTraps = {
           ? l.bind(u)
           : l;
       } else if (getObserver()) {
-        return read(getNode(i, t, isWrappable(l) ? wrap(l, e) : l, e[STORE_FIREWALL]?.()));
+        return read(getNode(i, t, isWrappable(l) ? wrap(l, e) : l, e[STORE_FIREWALL]));
       }
     }
     return isWrappable(l) ? wrap(l, e) : l;
@@ -1355,12 +1437,12 @@ const storeTraps = {
       e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
         ? e[STORE_OVERRIDE][t] !== $DELETED
         : t in e[STORE_VALUE];
-    getObserver() && read(getNode(getNodes(e, STORE_HAS), t, n, e[STORE_FIREWALL]?.()));
+    getObserver() && read(getNode(getNodes(e, STORE_HAS), t, n, e[STORE_FIREWALL]));
     return n;
   },
   set(e, t, n) {
     const i = e[$PROXY];
-    if (Writing?.has(e[$PROXY])) {
+    if (writeOnly(i)) {
       untrack(() => {
         const r = e[STORE_VALUE];
         const s = r[t];
@@ -1389,7 +1471,7 @@ const storeTraps = {
     return true;
   },
   deleteProperty(e, t) {
-    if (Writing?.has(e[$PROXY]) && e[STORE_OVERRIDE]?.[t] !== $DELETED) {
+    if (writeOnly(e[$PROXY]) && e[STORE_OVERRIDE]?.[t] !== $DELETED) {
       untrack(() => {
         const n =
           e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE] ? e[STORE_OVERRIDE][t] : e[STORE_VALUE][t];
@@ -1914,30 +1996,30 @@ function createBoundChildren(e, t, n, i) {
   });
 }
 class ConditionalQueue extends Queue {
-  $e;
-  Le = new Set();
-  $ = new Set();
+  Le;
+  $e = new Set();
+  L = new Set();
   constructor(e) {
     super();
-    this.$e = e;
+    this.Le = e;
   }
   run(e) {
-    if (!e || read(this.$e)) return;
+    if (!e || read(this.Le)) return;
     return super.run(e);
   }
   notify(e, t, n) {
-    if (read(this.$e)) {
+    if (read(this.Le)) {
       if (t & STATUS_PENDING) {
         if (n & STATUS_PENDING) {
-          this.$.add(e);
+          this.L.add(e);
           t &= ~STATUS_PENDING;
-        } else if (this.$.delete(e)) t &= ~STATUS_PENDING;
+        } else if (this.L.delete(e)) t &= ~STATUS_PENDING;
       }
       if (t & STATUS_ERROR) {
         if (n & STATUS_ERROR) {
-          this.Le.add(e);
+          this.$e.add(e);
           t &= ~STATUS_ERROR;
-        } else if (this.Le.delete(e)) t &= ~STATUS_ERROR;
+        } else if (this.$e.delete(e)) t &= ~STATUS_ERROR;
       }
     }
     return t ? super.notify(e, t, n) : true;
@@ -1946,24 +2028,24 @@ class ConditionalQueue extends Queue {
 class CollectionQueue extends Queue {
   Fe;
   Ve = new Set();
-  $e = signal(false, { pureWrite: true });
+  Le = signal(false, { pureWrite: true });
   We = false;
   constructor(e) {
     super();
     this.Fe = e;
   }
   run(e) {
-    if (!e || read(this.$e)) return;
+    if (!e || read(this.Le)) return;
     return super.run(e);
   }
   notify(e, t, n) {
     if (!(t & this.Fe) || (this.Fe & STATUS_PENDING && this.We)) return super.notify(e, t, n);
     if (n & this.Fe) {
       this.Ve.add(e);
-      if (this.Ve.size === 1) setSignal(this.$e, true);
+      if (this.Ve.size === 1) setSignal(this.Le, true);
     } else if (this.Ve.size > 0) {
       this.Ve.delete(e);
-      if (this.Ve.size === 0) setSignal(this.$e, false);
+      if (this.Ve.size === 0) setSignal(this.Le, false);
     }
     t &= ~this.Fe;
     return t ? super.notify(e, t, n) : true;
@@ -1979,25 +2061,25 @@ function createBoundary(e, t) {
   const i = new ConditionalQueue(computed(() => t() === BoundaryMode.HIDDEN));
   const r = createBoundChildren(n, e, i, 0);
   computed(() => {
-    const e = read(i.$e);
+    const e = read(i.Le);
     r.Qe = e ? STATUS_ERROR | STATUS_PENDING : 0;
     if (!e) {
-      i.$.forEach(e => i.notify(e, STATUS_PENDING, STATUS_PENDING));
-      i.Le.forEach(e => i.notify(e, STATUS_ERROR, STATUS_ERROR));
-      i.$.clear();
-      i.Le.clear();
+      i.L.forEach(e => i.notify(e, STATUS_PENDING, STATUS_PENDING));
+      i.$e.forEach(e => i.notify(e, STATUS_ERROR, STATUS_ERROR));
+      i.L.clear();
+      i.$e.clear();
     }
   });
-  return () => (read(i.$e) ? undefined : read(r));
+  return () => (read(i.Le) ? undefined : read(r));
 }
 function createCollectionBoundary(e, t, n) {
   const i = createOwner();
   const r = new CollectionQueue(e);
   const s = createBoundChildren(i, t, r, e);
   const o = computed(() => {
-    if (!read(r.$e)) {
+    if (!read(r.Le)) {
       const e = read(s);
-      if (!untrack(() => read(r.$e))) r.We = true;
+      if (!untrack(() => read(r.Le))) r.We = true;
       return e;
     }
     return n(r);
@@ -2088,6 +2170,7 @@ export {
   NoOwnerError,
   NotReadyError,
   SUPPORTS_PROXY,
+  action,
   createBoundary,
   createContext,
   createEffect,

package/dist/types/core/constants.d.ts

@@ -16,3 +16,4 @@ export declare const EFFECT_USER = 2;
 export declare const NOT_PENDING: {};
 export declare const SUPPORTS_PROXY: boolean;
 export declare const defaultContext: {};
+export declare const $REFRESH: unique symbol;

package/dist/types/core/core.d.ts

@@ -1,4 +1,4 @@
-import { NOT_PENDING } from "./constants.js";
+import { $REFRESH, NOT_PENDING } from "./constants.js";
 import { type IQueue, type Transition } from "./scheduler.js";
 export interface Disposable {
     (): void;
@@ -118,5 +118,7 @@ export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
 export declare function pending<T>(fn: () => T): T;
 export declare function isPending(fn: () => any): boolean;
-export declare function refresh<T>(fn: () => T): T;
+export declare function refresh<T>(fn: (() => T) | (T & {
+    [$REFRESH]: any;
+})): T;
 export declare function isRefreshing(): boolean;

package/dist/types/core/index.d.ts

@@ -2,5 +2,5 @@ export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";
 export { getObserver, isEqual, untrack, getOwner, runWithOwner, createOwner, createRoot, computed, dispose, signal, read, setSignal, onCleanup, getNextChildId, isPending, pending, refresh, isRefreshing, staleValues, handleAsync, type Owner, type Computed, type Root, type Signal, type SignalOptions } from "./core.js";
 export { effect, type Effect } from "./effect.js";
-export { flush, Queue, type IQueue, type QueueCallback } from "./scheduler.js";
+export { action, flush, Queue, type IQueue, type QueueCallback } from "./scheduler.js";
 export * from "./constants.js";

package/dist/types/core/scheduler.d.ts

@@ -15,8 +15,9 @@ export interface Transition {
     asyncNodes: Computed<any>[];
     pendingNodes: Signal<any>[];
     optimisticNodes: Signal<any>[];
+    actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
     queueStash: QueueStub;
-    done: boolean;
+    done: boolean | Transition;
 }
 export declare function schedule(): void;
 export interface IQueue {
@@ -51,7 +52,7 @@ export declare class GlobalQueue extends Queue {
     static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number): boolean;
-    initTransition(node: Computed<any>): void;
+    initTransition(node?: Computed<any>): void;
 }
 export declare function notifySubs(node: Signal<any> | Computed<any>): void;
 export declare function runOptimistic(activeTransition?: Transition | null): void;
@@ -61,5 +62,6 @@ export declare const globalQueue: GlobalQueue;
  * the queue synchronously to get the latest updates by calling `flush()`.
  */
 export declare function flush(): void;
-export declare function runInTransition(el: Computed<unknown>, recompute: (el: Computed<unknown>) => void): void;
+export declare function runInTransition<T>(transition: Transition, fn: () => T): T;
+export declare function action<Args extends any[], Y, R>(genFn: (...args: Args) => Generator<Y, R, any> | AsyncGenerator<Y, R, any>): (...args: Args) => void;
 export {};