@solidjs/signals 2.0.0-rc.17 → 2.0.0-rc.18

package/dist/prod/core/verdict.js

@@ -157,7 +157,7 @@ let probeFound = false;
  * flight — a staging equal to what is displayed changes nothing when it
  * lands: final now (maintainer, 2026-10-02). */ function heldNotFinal(e) {
     if ((e.m & STATUS_PENDING) !== 0 && !quietPending(e)) return true;
-    return e.se !== NOT_PENDING && !latestActive && !e.T.Ve && !(e.m & STATUS_UNINITIALIZED) && (!!e.T.de || !e.xe || !e.xe(e.Ie, e.se));
+    return e.ue !== NOT_PENDING && !latestActive && !e.T.Ve && !(e.m & STATUS_UNINITIALIZED) && (!!e.T.de || !e.xe || !e.xe(e.Ie, e.ue));
 }
 
 /** `isPending`'s answer for an unheld node whose flight is up (cause ii). */ function pendingVerdict(e, t) {
@@ -256,8 +256,8 @@ let probeFound = false;
 }
 
 /** The staging, or the staged error thrown (D-41). */ function staged(e) {
-    if (e.l & CONFIG_STAGED_ERROR) throw e.se;
-    return e.se;
+    if (e.l & CONFIG_STAGED_ERROR) throw e.ue;
+    return e.ue;
 }
 
 /** `latest()` of a held node: the flushed staging — the proposal — and, for
@@ -317,7 +317,7 @@ let probeFound = false;
         if (i) verdictRead(t, r._parent ?? r);
         const u = (n.m & STATUS_PENDING) !== 0 && !quietPending(n);
         if (e.l & CONFIG_GUESS) {
-            if (probing && (u || e.se !== NOT_PENDING && (!e.xe || !e.xe(e.T.v, e.se)))) probeFound = true;
+            if (probing && (u || e.ue !== NOT_PENDING && (!e.xe || !e.xe(e.T.v, e.ue)))) probeFound = true;
             // A lane a correction folded under (D-34): `latest()` shows the hold's
             // world whole — the truth beneath each guess, else what it covered.
                         if (latestActive && r.folded) return r.folded(null, e);
@@ -341,7 +341,7 @@ let probeFound = false;
             }
             if (i) verdictRead(t, r);
             if (probing && heldNotFinal(n)) probeFound = true;
-            if (latestActive && e.se !== NOT_PENDING) {
+            if (latestActive && e.ue !== NOT_PENDING) {
                 // An action body reading another transaction's proposal derives
                 // from it: the two settle as one (A15; posture C, 2026-09-15). An
                 // untracked read elsewhere has no transaction to entangle.
@@ -354,11 +354,11 @@ let probeFound = false;
         // committed value, so no verdict: `isPending` reads it as its read does —
         // the owner joins the hold (held with it, or caught by a boundary that
         // has not shown content) and answers for the commit, where it is final.
-                if (e.se !== NOT_PENDING && !(n.m & STATUS_PENDING)) {
+                if (e.ue !== NOT_PENDING && !(n.m & STATUS_PENDING)) {
             if (probing && r) joinPass(t, e);
             return staged(e);
         }
-    } else if (e.se !== NOT_PENDING) {
+    } else if (e.ue !== NOT_PENDING) {
         if (n.m & STATUS_PENDING && !u) pendingVerdict(i ? t : null, n); else if (i && globalQueue.q) provisionalVerdict(t, !latestActive && !u);
         // Outside a flush, the staging is an unflushed write (A28): the probe
         // answers for the flushed world, and watches the seam of the flush that

package/dist/prod/deferred.js

@@ -121,7 +121,7 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
      * does not replace (D-40) — restaged as the committed value, the hold's
      * readers would re-derive against the old input. */    const serve = e => {
         const r = handleAsync(t, e);
-        return t.l & CONFIG_HELD && t.se !== NOT_PENDING ? t.se : r;
+        return t.l & CONFIG_HELD && t.ue !== NOT_PENDING ? t.ue : r;
     };
     const end = () => t.R & REACTIVE_DISPOSED && land(o);
     return accessor(computed(r => {
@@ -133,26 +133,26 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
         // Sticky, and read before this wrapper ever opens the window itself.
                 const n = l ||= !(t.m & STATUS_UNINITIALIZED) && !t.ce;
         if (n) t.ce = true, t.l |= CONFIG_LAGS;
-        let c;
+        let s;
         try {
-            c = e(r);
+            s = e(r);
         } catch (e) {
             // The wrapping form: an unready source parks the node in the window,
             // and the wait is its flight until the source's settle re-runs it.
-            if (n && e instanceof NotReadyError) ask(e);
+            if (n && e instanceof NotReadyError) ask(e); else land(o);
             throw e;
         }
-        if (n && typeof c === "object" && c !== null) {
-            if (isThenable(c)) {
-                ask(c);
-                const done = () => land(c, true);
-                c.then(done, done);
-                return serve(c);
+        if (n && typeof s === "object" && s !== null) {
+            if (isThenable(s)) {
+                ask(s);
+                const done = () => land(s, true);
+                s.then(done, done);
+                return serve(s);
             }
-            const e = c[Symbol.asyncIterator];
+            const e = s[Symbol.asyncIterator];
             if (e) {
                 // A stream's flight ends at its first yield (or its end).
-                const r = e.call(c);
+                const r = e.call(s);
                 let t = true;
                 const done = () => land(o, true);
                 const o = {
@@ -160,7 +160,10 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
                     // promise, as for a plain flight: verdict and value in one flush.
                     next: e => {
                         const o = r.next(e);
-                        if (t) t = false, o.then(done, done);
+                        if (t) {
+                            t = false;
+                            if (isThenable(o)) o.then(done, done); else done();
+                        }
                         return o;
                     },
                     return: e => r.return?.(e) ?? Promise.resolve({
@@ -175,7 +178,7 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
             }
         }
         land(o);
-        return c;
+        return s;
     }, r));
 }
 

package/dist/prod/from.js

@@ -0,0 +1,248 @@
+import { isThenable, onSupersede } from "./core/async.js";
+
+import { CONFIG_CHILDREN_FORBIDDEN } from "./core/constants.js";
+
+import { cleanup, getOwner } from "./core/owner.js";
+
+// `from` — a push source (callback subscription, Observable, AsyncIterable)
+// as an AsyncIterable a computation can return or `for await` over:
+//   const value = createMemo(() => from(source));
+// A subscription keeps the latest value: values that arrive between pulls
+// coalesce. An AsyncIterable streams through unchanged. Either way the source
+// opens when the result is iterated and closes on return(), on supersede (the
+// owning computation re-runs) and on owner disposal, whichever comes first.
+function toSubscribe(e) {
+    if (typeof e === "function") return e;
+    // TC39 / RxJS interop: `Symbol.observable` (or "@@observable") returns the observable.
+    // Read per call, not at module scope, so the module stays side-effect free.
+        const n = Symbol.observable;
+    const r = (n && e?.[n]) ?? e?.["@@observable"];
+    const t = typeof r === "function" ? r.call(e) : e;
+    if (t && typeof t.subscribe === "function") return (e, n, r) => t.subscribe({
+        next: e,
+        error: n,
+        complete: r
+    });
+    return null;
+}
+
+const DONE = {
+    value: undefined,
+    done: true
+};
+
+/**
+ * Ties an iterator's `finish` to the computation iterating it. Solid reaches
+ * an iterator's return() only when the compute returns the iterable directly.
+ * Inside an async generator the generator's own return() is queued behind its
+ * pending `await`, and owner cleanups wait for the replacing pass to commit,
+ * so close on supersede, with owner disposal as the backstop. No owner (an
+ * async compute iterating it after its first `await`, or plain iteration):
+ * no registration and no diagnostic, so only return() closes it. Scopes that
+ * forbid cleanups rely on supersede and return().
+ */ function bindToOwner(e) {
+    const n = getOwner();
+    if (!n) return;
+    onSupersede(e);
+    if (!(n.l & CONFIG_CHILDREN_FORBIDDEN)) cleanup(e);
+}
+
+/**
+ * An AsyncIterable as a stream bound to the iterating computation: every
+ * value passes through (no coalescing). `finish` calls the inner return()
+ * once and settles pending pulls as done, so a `for await` over it exits as
+ * soon as the computation re-runs — even when the inner iterator is an async
+ * generator whose own return() the language queues behind its pending
+ * `await`.
+ */ function wrapIterable(e) {
+    return {
+        [Symbol.asyncIterator]() {
+            const n = e[Symbol.asyncIterator]();
+            let r = false;
+            const t = new Set;
+            const finish = () => {
+                if (r) return DONE;
+                r = true;
+                for (const e of t) e(DONE);
+                t.clear();
+                try {
+                    const e = n.return?.();
+                    if (isThenable(e)) e.then(undefined, () => {});
+                } catch {}
+                return DONE;
+            };
+            bindToOwner(finish);
+            return {
+                next(...e) {
+                    if (r) return Promise.resolve(DONE);
+                    const o = n.next(...e);
+                    // A bare result (the producer's buffered fast path) passes through.
+                                        if (!isThenable(o)) return o;
+                    return new Promise((e, n) => {
+                        t.add(e);
+                        o.then(n => t.delete(e) && e(n), r => t.delete(e) && n(r));
+                    });
+                },
+                return() {
+                    return Promise.resolve(finish());
+                }
+            };
+        }
+    };
+}
+
+const toCleanup = e => typeof e === "function" ? e : e && typeof e.unsubscribe === "function" ? () => e.unsubscribe() : () => {};
+
+/**
+ * Converts a callback subscription, an Observable or an AsyncIterable into an
+ * AsyncIterable for a Solid computation. A subscription keeps only the latest
+ * value, and a value the source emits during `subscribe` is served without a
+ * loading frame; an AsyncIterable streams every value through.
+ *
+ * The source closes on supersede — the owning computation re-running — and
+ * on owner disposal. Inside an async generator memo that holds for a
+ * `for await` that starts before the first `await`; one that starts after it
+ * has no owner to bind to, so its source closes only when the loop ends.
+ * Prefer returning `from(...)` from its own memo, with awaited inputs read
+ * from upstream memos and transforms done in a downstream memo.
+ *
+ * Iterate the result with `for await` or return it from a computation: its
+ * `next()` returns an already-buffered value as a bare result, not a promise.
+ *
+ * @example
+ * ```ts
+ * const position = createMemo(() =>
+ *   from<Position>((next, error) => {
+ *     const id = navigator.geolocation.watchPosition(next, error);
+ *     return () => navigator.geolocation.clearWatch(id);
+ *   })
+ * );
+ * const ticks = createMemo(() => from(interval$(rate())));
+ * ```
+ */ function from(e) {
+    const n = toSubscribe(e);
+    if (!n) {
+        if (e && typeof e[Symbol.asyncIterator] === "function") return wrapIterable(e);
+        throw new TypeError("from(): expected a subscribe function, an Observable or an AsyncIterable");
+    }
+    return {
+        [Symbol.asyncIterator]() {
+            let e;
+            let r = false;
+            let t = false;
+            let o = false;
+            let u;
+            let f = null;
+            let l = null;
+            let s = false;
+            const close = () => {
+                if (s) return;
+                s = true;
+                t = true;
+                const e = l;
+                l = null;
+                // A throwing unsubscribe must not escape: at supersede this runs
+                // inside flush(), ahead of the replacing pass (the returned-iterator
+                // path swallows it the same way).
+                                try {
+                    e?.();
+                } catch {}
+            };
+            const settle = () => {
+                if (!f) return;
+                const n = f;
+                if (r) {
+                    f = null;
+                    r = false;
+                    n.resolve({
+                        value: e,
+                        done: false
+                    });
+                } else if (o) {
+                    f = null;
+                    o = false;
+                    n.reject(u);
+                } else if (t) {
+                    f = null;
+                    n.resolve({
+                        value: undefined,
+                        done: true
+                    });
+                }
+            };
+            const i = n(n => {
+                if (t) return;
+                e = n;
+                r = true;
+                settle();
+            }, e => {
+                if (t) return;
+                o = true;
+                u = e;
+                t = true;
+                settle();
+                close();
+            }, () => {
+                if (t) return;
+                t = true;
+                settle();
+                close();
+            });
+            l = toCleanup(i);
+            // Completed or errored during subscribe: release what it just returned.
+                        if (s) {
+                const e = l;
+                l = null;
+                try {
+                    e();
+                } catch {}
+            }
+            // Idempotent: return(), supersede and disposal may all reach it.
+                        const finish = () => {
+                close();
+                r = false;
+                if (f) {
+                    const e = f;
+                    f = null;
+                    e.resolve(DONE);
+                }
+                return DONE;
+            };
+            bindToOwner(finish);
+            return {
+                next() {
+                    // A buffered value is returned as a bare result, not a promise: the
+                    // iterator consumer lands it in the same pass, so a source that
+                    // emits during subscribe (BehaviorSubject-style) shows its value
+                    // with no loading frame. `for await` accepts either form.
+                    if (r) {
+                        r = false;
+                        return {
+                            value: e,
+                            done: false
+                        };
+                    }
+                    if (o) {
+                        o = false;
+                        return Promise.reject(u);
+                    }
+                    if (t) return Promise.resolve({
+                        value: undefined,
+                        done: true
+                    });
+                    return new Promise((e, n) => {
+                        f = {
+                            resolve: e,
+                            reject: n
+                        };
+                    });
+                },
+                return() {
+                    return Promise.resolve(finish());
+                }
+            };
+        }
+    };
+}
+
+export { from };

package/dist/prod/index.js

@@ -36,6 +36,8 @@ export { affects } from "./affects.js";
 
 export { createDeferred } from "./deferred.js";
 
+export { from } from "./from.js";
+
 export { flatten } from "./flatten.js";
 
 export { createErrorBoundary, createLoadingBoundary } from "./boundaries.js";

package/dist/prod/store/optimistic.js

@@ -365,7 +365,7 @@ function arrangementEqual(e, n, t) {
         const t = txOf(n);
         joinPassAt(e, resolveTx(t._parent ?? t));
     }
-    if (n.se !== NOT_PENDING) return n.se;
+    if (n.ue !== NOT_PENDING) return n.ue;
     return n.l & CONFIG_SLOT_NODE ? GlobalQueue.fn(n) : n.Ie;
 }