@solidjs/signals 2.0.0-rc.13 → 2.0.0-rc.14

package/dist/observe/core/action.js

@@ -1,28 +1,30 @@
-import { setOrigin, globalQueue, activeTransition, currentTransition, schedule, actionStepDepth, flush, enterActionStep, exitActionStep } from "./scheduler.js";
-
 import { isThenable } from "./async.js";
 
 import "./core.js";
 
 import "./dev.js";
 
-import { attrHooks } from "./attribution-hooks.js";
+import { joinFuture, newTransaction, enterAction, exitAction, resolveTx, schedule, actionDepth, flush, nextQuestion, setQuestion, question } from "./scheduler.js";
 
-/** Invocation order across all actions — the provenance every slice of an
- * action runs under (scheduler `origin`): the flights and overrides its
- * ambient windows issue are stamped with it, so a later action's override
- * can tell this action's late answer from its own (#3331). */ let actionSeq = 0;
+import { attrHooks } from "./attribution-hooks.js";
 
-function restoreTransition(t, e, r) {
-    const n = setOrigin(t);
-    globalQueue.initTransition(e);
-    const i = r();
-    // A nested action resuming synchronously (its body yielded a non-thenable)
-    // runs this inside the OUTER action's slice: draining here would park the
-    // shared transaction and detach the outer body's remaining writes (the
-    // flush() rule, scheduler.ts). The outer step's own return drains.
-        if (actionStepDepth === 0) flush();
-    setOrigin(n);
+/** A slice of the body runs in the action's transaction: the flush that
+ * carries its writes parks into it (`joinFuture` — merging whatever the tick
+ * already joined: O1, an action that opens in a tick owns it; a second
+ * action in the tick, or one called from the body, merges into the first).
+ * A resumed slice drains at once: the seam parks what it wrote (the action
+ * holds the transaction open) or, the body having returned, lands it. A
+ * nested action resuming synchronously inside the outer body does not drain
+ * — that would park the outer's remaining writes' frame mid-slice; the outer
+ * step's own return does. */ function inTransaction(t, n, e) {
+    // The slice and its flush ask this action's question (A18 provenance):
+    // the guesses it writes and the flights it starts are stamped with it.
+    const o = question;
+    setQuestion(n);
+    joinFuture(t);
+    const i = e();
+    if (actionDepth === 0) flush();
+    setQuestion(o);
     return i;
 }
 
@@ -44,9 +46,9 @@ function restoreTransition(t, e, r) {
  * submission tracking layered on top. The shared name is deliberate.
  *
  * Wraps a generator function so each invocation runs as a single transaction
- * (a "transition") that batches every signal/store write between yields. The
- * surrounding UI sees one atomic update per yielded step; nothing is committed
- * until the action either completes or the next `yield` resolves.
+ * that holds every signal/store write between yields. The surrounding UI sees
+ * one atomic update when the action completes; nothing is committed until
+ * every action in the transaction has returned.
  *
  * `yield` is the transaction-safe suspension point: the action waits for a
  * yielded promise and re-enters the transaction before running the code after
@@ -56,8 +58,7 @@ function restoreTransition(t, e, r) {
  * 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
+ * transaction and replayed at its commit. `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:
@@ -70,7 +71,7 @@ function restoreTransition(t, e, r) {
  * ```
  *
  * (For the same reason, don't call `flush()` inside an action body — it
- * drains the transaction mid-step.)
+ * cannot reveal the held writes and is refused.)
  *
  * Each call returns a `Promise` that resolves with the generator's return
  * value, or rejects if it throws. Pair with `createOptimistic` /
@@ -96,52 +97,42 @@ function restoreTransition(t, e, r) {
  * await addTodo("buy milk");
  * ```
  */ function action(t) {
-    return (...e) => new Promise((r, n) => {
-        const i = t(...e);
-        const o = ++actionSeq;
-        // The first slice's window runs to the scheduled flush, which clears
-        // the provenance with the window — no restore here.
-                setOrigin(o);
-        globalQueue.initTransition();
-        let s = activeTransition;
-        s.tt.push(i);
-        s.et = true;
-        const done = (t, e, o = false) => {
-            s = currentTransition(s);
-            const u = s.tt.indexOf(i);
-            if (u >= 0) s.tt.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
-            // (held writes on a merging transition, optimistic overrides,
-            // affects() marks) lands there with nothing to ever finalize it.
-                        globalQueue.initTransition(s);
+    return (...n) => new Promise((e, o) => {
+        const i = t(...n);
+        // The action's transaction, held open until the body returns. The
+        // first slice's writes are carried by the tick's scheduled flush.
+                const r = newTransaction(false);
+        r.tt = 1;
+        r.nt = true;
+        const s = nextQuestion();
+        const done = (t, n, i = false) => {
+            resolveTx(r).tt--;
             schedule();
-            o ? n(e) : r(t);
+            i ? o(n) : e(t);
         };
-        const step = (e, r) => {
-            let n;
+        const step = (n, e) => {
+            let o;
             // Attribution hooks bracket the synchronous slice of generator body
             // this step runs (up to the next yield): writes inside are the
             // action's. Both sites sit outside the try (attribution-hooks.ts).
                         if (attrHooks !== null) attrHooks.actionStepStart(i, t.name || undefined);
             // The body is on the stack between these brackets: flush() is
             // refused inside (FLUSH_IN_ACTION, scheduler.ts).
-                        enterActionStep();
+                        enterAction();
             try {
-                n = r ? i.throw(e) : i.next(e);
+                o = e ? i.throw(n) : i.next(n);
             } catch (t) {
-                exitActionStep();
+                exitAction();
                 if (attrHooks !== null) attrHooks.actionStepEnd(i);
                 return done(undefined, t, true);
             }
-            exitActionStep();
+            exitAction();
             if (attrHooks !== null) attrHooks.actionStepEnd(i);
             // A rejected iterator result (async generators) means the error already
             // escaped the generator body — it is completed, and throwing back in
             // would just reject again forever. Settle instead.
-                        if (isThenable(n)) return void n.then(run, t => done(undefined, t, true));
-            run(n);
+                        if (isThenable(o)) return void o.then(run, t => done(undefined, t, true));
+            run(o);
         };
         const run = t => {
             if (t.done) return done(t.value);
@@ -149,28 +140,34 @@ function restoreTransition(t, e, r) {
             // getter, or a `then()` method that throws — #2918). Match `await`
             // semantics: the failure is thrown back into the generator at the
             // yield point (catchable there); if uncaught, step()'s guard settles
-            // the action so its iterator never leaks in the transition. The
-            // settled flag implements A+ 2.3.3.3.4.1: a throw after the thenable
-            // already called a callback is ignored.
-                        let e = false;
+            // the action. The settled flag implements A+ 2.3.3.3.4.1: a throw
+            // after the thenable already called a callback is ignored.
+                        let n = false;
             try {
                 if (isThenable(t.value)) return void t.value.then(t => {
-                    if (e) return;
-                    e = true;
-                    restoreTransition(o, s, () => step(t));
+                    if (n) return;
+                    n = true;
+                    inTransaction(r, s, () => step(t));
                 }, t => {
-                    if (e) return;
-                    e = true;
-                    restoreTransition(o, s, () => step(t, true));
+                    if (n) return;
+                    n = true;
+                    inTransaction(r, s, () => step(t, true));
                 });
             } catch (t) {
-                if (e) return;
-                e = true;
-                return void restoreTransition(o, s, () => step(t, true));
+                if (n) return;
+                n = true;
+                return void inTransaction(r, s, () => step(t, true));
             }
-            restoreTransition(o, s, () => step(t.value));
+            inTransaction(r, s, () => step(t.value));
         };
+        // The first slice's writes are carried by the tick's scheduled flush;
+        // the slice itself asks the action's question (its guesses are stamped
+        // at the write).
+                joinFuture(r);
+        const u = question;
+        setQuestion(s);
         step();
+        setQuestion(u);
     });
 }