@solidjs/signals 2.0.0-rc.8 → 2.0.0-rc.9

package/dist/observe/core/action.js

@@ -4,6 +4,8 @@ import { isThenable } from "./async.js";
 
 import "./core.js";
 
+import "./dev.js";
+
 import { attrHooks } from "./attribution-hooks.js";
 
 /** Invocation order across all actions — the provenance every slice of an
@@ -49,15 +51,22 @@ function restoreTransition(t, e, r) {
  * `yield` is the transaction-safe suspension point: the action waits for a
  * yielded promise and re-enters the transaction before running the code after
  * it. A plain `await` does NOT — the runtime has no hook into an async
- * generator's internal await continuations, so writes to fresh signals
- * between an `await` and the next `yield` escape the transaction and commit
- * immediately. `await` is still the ergonomic choice for typed results; just
- * put a bare `yield` before any writes that follow it:
+ * generator's internal await continuations, so code between an `await` and
+ * the next `yield` runs OUTSIDE the transaction: writes to fresh signals
+ * commit immediately, and anything that creates a reader there — `until()`,
+ * `latest()`, a memo or effect, a mount — is created mainline, where a read of
+ * this action's held state makes it born held (A29): staged with the
+ * transaction and replayed at its commit. For `until()` that commit is the
+ * settle its own promise holds open (#3482). `await` is still the ergonomic
+ * choice for typed results; just put a bare `yield` before any write or
+ * reader creation that follows it — including the expression of the next
+ * `yield`, which is evaluated before the step re-enters:
  *
  * ```ts
  * const saved = await api.createTodo(text); // typed result
- * yield; // re-enter the transaction before writing
+ * yield; // re-enter the transaction before writing or reading
  * setTodos(t => { ... });
+ * yield until(() => todos.some(t => t.id === saved.id));
  * ```
  *
  * (For the same reason, don't call `flush()` inside an action body — it
@@ -95,11 +104,12 @@ function restoreTransition(t, e, r) {
                 setOrigin(o);
         globalQueue.initTransition();
         let s = activeTransition;
-        s.ut.push(i);
+        s.dt.push(i);
+        s.Tt = true;
         const done = (t, e, o = false) => {
             s = currentTransition(s);
-            const u = s.ut.indexOf(i);
-            if (u >= 0) s.ut.splice(u, 1);
+            const u = s.dt.indexOf(i);
+            if (u >= 0) s.dt.splice(u, 1);
             // Re-adopt through initTransition like every other resumption site:
             // a bare setActiveTransition leaves globalQueue._batch as a detached
             // ambient batch, and anything registered before the scheduled flush