@solidjs/signals 2.0.0-rc.19 → 2.0.0-rc.20

package/dist/observe/core/async.js

@@ -1,4 +1,4 @@
-import { STATUS_ERROR, STATUS_PENDING, STATUS_NO_VALUE, STATUS_UNINITIALIZED, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, CONFIG_HELD, REACTIVE_STAGED_READ, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, NewSet, REACTIVE_DIRTY, CONFIG_INPUTS_PUBLISHED, NOT_PENDING, REACTIVE_DISPOSED, CONFIG_REDERIVE, CONFIG_VERDICT, CONFIG_OVERRIDE } from "./constants.js";
+import { STATUS_ERROR, STATUS_PENDING, STATUS_NO_VALUE, STATUS_UNINITIALIZED, CONFIG_GUESS, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_ASYNC, REACTIVE_WINDOW, CONFIG_HELD, REACTIVE_STAGED_READ, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, NewSet, REACTIVE_DIRTY, CONFIG_INPUTS_PUBLISHED, NOT_PENDING, REACTIVE_DISPOSED, CONFIG_REDERIVE, CONFIG_VERDICT, CONFIG_OVERRIDE } from "./constants.js";
 
 import { attrHooks } from "./attribution-hooks.js";
 
@@ -14,7 +14,7 @@ import { enqueueSub } from "./heap.js";
 
 import { disposeChildren, cleanup } from "./owner.js";
 
-import { passLane, joinFuture, question, MAINLINE_QUESTION, globalQueue, schedule, clock, flush, freshHook, txOf, laneStageHook, queuePendingNode } from "./scheduler.js";
+import { guessing, passLane, joinFuture, txOf, holdWorkHook, question, MAINLINE_QUESTION, globalQueue, schedule, clock, flush, freshHook, laneStageHook, queuePendingNode } from "./scheduler.js";
 
 // The lazily-created Set is the ONE container for pending sources. Its
 // predecessor — a singular slot promoted to a Set on the second source —
@@ -71,16 +71,16 @@ function retryReaches(e, t) {
 
 function setPendingError(e, t, n) {
     if (!t) {
-        if (e.T !== null) e.T.F = null;
+        if (e.T !== null) e.T.U = null;
         return;
     }
     if (n instanceof NotReadyError && n.source === t) {
-        ext(e).F = n;
+        ext(e).U = n;
         return;
     }
-    const r = e.T?.F;
+    const r = e.T?.U;
     if (!(r instanceof NotReadyError) || r.source !== t) {
-        ext(e).F = new NotReadyError(t);
+        ext(e).U = new NotReadyError(t);
     }
 }
 
@@ -150,13 +150,13 @@ function releaseSettledDependents(e) {
     // (#4109). A flush that parks nothing publishes it at its commit (S-38).
     // Not a projection's derive: its readers learn its error through the
     // family, which the commit's publish never reaches (#4189).
-    if (!(e.l & CONFIG_HELD || n && e.R & REACTIVE_STAGED_READ && globalQueue.q && !e.fam) || passLane) return false;
+    if (!(e.l & CONFIG_HELD || n && e.R & REACTIVE_STAGED_READ && globalQueue.Y && !e.fam) || passLane) return false;
     // The node answered (an error ends the wait — no longer pending, nor
     // blocked); a shown error stays its display until the commit.
         clearPendingSources(e);
     if (e.T) e.T.fe = false;
     if (!((e.m &= STATUS_ERROR | STATUS_UNINITIALIZED) & STATUS_ERROR)) setPendingError(e);
-    e.ie = t instanceof StatusError ? t : new StatusError(e, t);
+    e.ue = t instanceof StatusError ? t : new StatusError(e, t);
     e.l |= CONFIG_STAGED | CONFIG_STAGED_ERROR;
     // Readers parked on the flight re-run and derive from the staging; the
     // verdict readers the walk wakes need a flush (#4106).
@@ -171,7 +171,7 @@ function settleErroredDependents(e, t) {
     const visit = e => {
         if (r.has(e)) return;
         r.add(e);
-        if (e.T?.F === t) {
+        if (e.T?.U === t) {
             enqueueSub(e);
             n = true;
         }
@@ -205,10 +205,11 @@ function settlePendingSource(e, t = e) {
         // A19: a verdict reader holds no pending of its own (it was re-derived
         // when the source went pending, `propagateStatus`), and a landing
         // equal to the committed value notifies nobody — the source settling
-        // is its verdict changing: it runs again.
-        return s.l & CONFIG_VERDICT && enqueueSub(s);
+        // is its verdict changing: it runs again. (Verdict readers exist only
+        // with the verdict engine installed.)
+        return holdWorkHook && s.l & CONFIG_VERDICT && enqueueSub(s);
         o.add(s);
-        s.ae = clock;
+        s.ie = clock;
         const f = s.T?.se?.values().next().value;
         // STATUS_ERROR + pending sources only coexist via an errored loading
         // window's park (notifyStatus(STATUS_ERROR) clears pending sources
@@ -301,7 +302,10 @@ r) {
         });
     }
     if (!s && !o) {
-        if (e.T !== null) e.T.Ee = null;
+        if (e.T !== null) {
+            e.T.Ee = null;
+            if (holdWorkHook) e.l &= ~CONFIG_ASYNC;
+        }
         // A sync landing is the first real answer for a loadingValue node.
                 e.ce = false;
         return t;
@@ -312,9 +316,14 @@ r) {
     // fired _flightTeardown. A future non-recompute registration path must
     // release it here before overwriting _inFlight.
         ext(e).Ee = t;
+    // D-25 (verdict.ts `holdWork`): an async memo whose answering pass opened
+    // no verdict window of its own (`markVerdictReader` clears the bit).
+    // Kept by the verdict engine alone (`holdWorkHook`): a build without it
+    // folds the bit's upkeep away.
+        if (holdWorkHook && !(e.R & REACTIVE_WINDOW)) e.l |= CONFIG_ASYNC;
     // The question this flight answers (A18 provenance, lanes.ts): the action
     // whose slice asked it; mainline is always the current question.
-        e.T.de = question || MAINLINE_QUESTION;
+        e.T.Ie = question || MAINLINE_QUESTION;
     // The run that asked this flight read every input without throwing: an
     // input still in flight was masked for it (an active override, A17), so
     // pending state those inputs propagated onto the node earlier does not
@@ -340,7 +349,7 @@ r) {
             // error-retry pull (updateIfNecessary) can also re-ask.
             if (e.T !== null) e.T.Ee = null;
             parkLoadingWindow(e, o);
-            e.ae = clock;
+            e.ie = clock;
             return;
         }
         // D-41: a held node's error is staged (`stageError`). A derived store's
@@ -358,7 +367,7 @@ r) {
         // rejected flight will never settle its self entry, so transfer ownership
         // after notifyStatus has propagated the replacement source.
                 if (s) settlePendingSource(e);
-        e.ae = clock;
+        e.ie = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
         // the error twin of settlePendingSource's release (#2934).
@@ -390,7 +399,7 @@ r) {
             // a verdict reader of the next flight would suspend instead of being
             // served the screen; held, both at the derive's commit.
                         if (!(e.l & CONFIG_HELD)) {
-                e.T.Te = undefined;
+                e.T.Te = null;
                 e.l &= ~CONFIG_INPUTS_PUBLISHED;
             }
             if (s) landStatus(e, true);
@@ -422,7 +431,7 @@ r) {
         // (`_pendingValue` set inside setSignal) is not — commitPendingNode closes
         // the window when the flush commits it, so no one-frame pulse can leak to
         // observers between the landing and its commit (#2990).
-                if (e.ie === NOT_PENDING) {
+                if (e.ue === NOT_PENDING) {
             e.ce = false;
             // The landing published: the dependency tail the flight's pass left
             // linked goes now (A30, #3410). A staged landing has not replaced the
@@ -494,7 +503,7 @@ r) {
             }
         };
         const iterate = () => {
-            let n, r, l = false, a = false, S = true;
+            let n, r, l = false, S = false, a = true;
             // Protocol tolerance, matching `for await`: `await` unwraps whatever
             // next() returns — a thenable OR a bare IteratorResult. Real producers
             // use the bare form as a promise-free fast path when a value is already
@@ -512,7 +521,7 @@ r) {
                 // stash: it must write through the async path or the value is
                 // silently dropped. (The deferred posture never has a caller, so
                 // initialRead starts false there and everything writes through.)
-                if (S && i) {
+                if (a && i) {
                     n = r;
                     l = true;
                     if (r.done) u = true;
@@ -533,17 +542,17 @@ r) {
                     settleAutodispose();
                 }
             }, n => {
-                if (S && i) {
+                if (a && i) {
                     r = n;
-                    a = true;
+                    S = true;
                 } else if (e.T?.Ee === t) {
                     u = true;
                     handleError(n);
                     settleAutodispose();
                 }
             });
-            S = false;
-            if (a) {
+            a = false;
+            if (S) {
                 // Match the promise branch, but only rethrow during the initial read.
                 u = true;
                 handleError(r);
@@ -657,7 +666,7 @@ function clearStatus(e, t = false) {
     if (e.T?.se) clearPendingSources(e);
     if (e.T?.fe) e.T.fe = false;
     e.m = t ? 0 : e.m & STATUS_UNINITIALIZED;
-    if (e.T?.F) setPendingError(e);
+    if (e.T?.U) setPendingError(e);
     const n = statusNotifierOf(e);
     if (n) n.call(e);
 }
@@ -699,11 +708,11 @@ function clearStatus(e, t = false) {
 function notifyStatus(e, t, n) {
     // Wrap regular errors to track source node
     if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError)) n = new StatusError(e, n);
-    const r = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
+    const r = t === STATUS_PENDING && n instanceof NotReadyError && n.source;
     // (CARVE 2: the lane assignment went with the engine.)
         if (t === STATUS_PENDING && r) {
         // D-41: a re-ask of a shown error keeps it the display (`_shownError`).
-        if (e.m & STATUS_ERROR) e.T.Te = e.T.F;
+        if (e.m & STATUS_ERROR) e.T.Te = e.T.U;
         addPendingSource(e, r);
         // A re-ask of an error that answered the first read: still no value.
                 e.m = STATUS_PENDING | (e.m & STATUS_NO_VALUE ? STATUS_UNINITIALIZED : e.m & STATUS_UNINITIALIZED);
@@ -715,16 +724,21 @@ function notifyStatus(e, t, n) {
         // An error answering a node with no value marks it so; a re-ask of it
         // (pending) is uninitialized again; a write (STATUS_NONE) gives it one.
                 e.m = t | (t === STATUS_ERROR ? e.m & (STATUS_UNINITIALIZED | STATUS_NO_VALUE) ? STATUS_NO_VALUE : 0 : t === STATUS_PENDING && e.m & STATUS_NO_VALUE ? STATUS_UNINITIALIZED : e.m & STATUS_UNINITIALIZED);
-        ext(e).F = n;
+        ext(e).U = n;
     }
     // Lanes: a written guess is an optimistic boundary (A17 — "the optimistic
     // future value until we know otherwise"). Its own source in flight is its
     // status, not its readers': they read the guess. The flight is the parent
     // transition's to wait on — the frame it was asked in holds (A17: "a
     // transition whose optimistic node is still pending on its own fetch is
-    // not complete"), through the node itself (`blocked`).
-        if (t === STATUS_PENDING && e.l & CONFIG_GUESS) {
-        if (passLane === null) joinFuture(null);
+    // not complete"), through the node itself (`blocked`). An input changed
+    // from outside the guess's hold asks a new question: the frame that
+    // changed it is held with that hold (D-34, #4336) — it shows beside the
+    // guess's truth, which reveals at that hold's commit (F-1). A `refresh()`
+    // re-asks the same question: its frame is its own.
+    // (No guess written, no arm.)
+        if (guessing && t === STATUS_PENDING && e.l & CONFIG_GUESS) {
+        if (passLane === null) joinFuture(e.R & REACTIVE_REASK ? null : txOf(e)._parent);
         return;
     }
     const o = statusNotifierOf(e);
@@ -740,9 +754,9 @@ function notifyStatus(e, t, n) {
  * family's leaves, which are not the derive's dependents — the family
  * propagates the derive's status from each leaf to the leaf's readers
  * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */ function propagateStatus(e, t, n) {
-    const r = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
+    const r = t === STATUS_PENDING && n instanceof NotReadyError && n.source;
     forEachDependent(e, (o, s) => {
-        o.ae = clock;
+        o.ie = clock;
         // A pending mark on a kept-tail link re-derives the subscriber instead of
         // marking it (A30, #3494 review; fuzzer latest-1 #2141; #3519 review).
         // Past `_depsTail` lie the committed frame's deps, kept by A30 because
@@ -762,7 +776,13 @@ function notifyStatus(e, t, n) {
         // Inheriting the error would make a probe's reader errored. A boundary's
         // output (CONFIG_REDERIVE, boundaries.ts) the same: content or fallback
         // is its pass's call.
-                if (o.l & (CONFIG_REDERIVE | CONFIG_VERDICT) || t === STATUS_PENDING && s.Ie !== o.Ne) {
+        // Not one D-25 makes the hold's work (verdict.ts `holdWork`): an async
+        // memo with no verdict window of its own reads a verdict memo's value,
+        // and that source going pending changes none of its reads — re-derived,
+        // it is served the committed value it already derived from (A10) and
+        // asks that question again. It waits on the source like any derivation
+        // (F-9), and asks its next question once, at the landing (#4397).
+                if (o.l & CONFIG_REDERIVE || holdWorkHook && o.l & CONFIG_VERDICT && !(r && holdWorkHook(o, e)) || t === STATUS_PENDING && s.de !== o.Ne) {
             enqueueSub(o);
             schedule();
             return;
@@ -775,10 +795,10 @@ function notifyStatus(e, t, n) {
         // shape: the unmount it stages makes the observer a zombie whose say is
         // moot for this transaction, A15 #3463).
                 if (t === STATUS_PENDING && r && o.T?.se?.has(r)) {
-            if (passLane === null && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && globalQueue.q && !freshHook?.(o, r.ae === clock)) joinFuture(txOf(o));
+            if (passLane === null && (o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && globalQueue.Y && !freshHook?.(o, r.ie === clock)) joinFuture(txOf(o));
             return;
         }
-        if (t === STATUS_PENDING && r || t !== STATUS_PENDING && (o.T?.F !== n || o.T?.se)) {
+        if (t === STATUS_PENDING && r || t !== STATUS_PENDING && (o.T?.U !== n || o.T?.se)) {
             // The marked subscriber is queued for the commit sweep so its status
             // bookkeeping (loading window, uninitialized clear) runs with the flush
             // — with the lane, when the pass propagating is the lane's work and
@@ -801,4 +821,4 @@ function notifyStatus(e, t, n) {
     });
 }
 
-export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, onSupersede, parkLoadingWindow, propagateStatus, releaseFlightTeardown, releaseIfSettledUnobserved, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource, stageError };
+export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, onSupersede, parkLoadingWindow, propagateStatus, releaseFlightTeardown, releaseIfSettledUnobserved, releaseSettledDependents, removePendingSource, setPendingError, settleErroredDependents, settlePendingSource, stageError };

package/dist/observe/core/attribution.js

@@ -2705,7 +2705,7 @@ const engineHooks = {
             prevDeps: n || !wantsRerun() ? null : captureDeps(e),
             // Mirror recompute's own prev-value resolution: an earlier run in the
             // same flush may still be holding in _pendingValue.
-            prevValue: e.ie !== NOT_PENDING ? e.ie : e.le,
+            prevValue: e.ue !== NOT_PENDING ? e.ue : e.le,
             // A create run inherits the interaction of whatever is building it: the
             // enclosing recompute (a parent's fn creating children) or, at the top
             // of the recompute stack, the effect callback / handler frame.
@@ -2732,7 +2732,7 @@ const engineHooks = {
         // exempt — a side-effect-only compute's work IS its effect phase, and
         // identity of `undefined` proves nothing.
                 if (t && r.causes !== null && e.i) {
-            const n = e.ie !== NOT_PENDING ? e.ie : e.le;
+            const n = e.ue !== NOT_PENDING ? e.ue : e.le;
             if (n !== undefined && n === r.prevValue) t = false;
         }
         // Unstable-output check: memos only, non-create, plain runs with a
@@ -2740,12 +2740,12 @@ const engineHooks = {
         // plain-flush memo commits and in `_value` for direct ones. Overlay runs
         // are excluded — an optimistic re-derive legitimately produces fresh
         // equivalents while the lane settles.
-                if (r.causes !== null && t && !o && !i && !e.i) checkUnstableOutput(e, r.prevValue, e.ie !== NOT_PENDING ? e.ie : e.le);
+                if (r.causes !== null && t && !o && !i && !e.i) checkUnstableOutput(e, r.prevValue, e.ue !== NOT_PENDING ? e.ue : e.le);
         // The same exemption for memos: a run that committed `undefined` did its
         // work as a side effect (a projection's draft writes or reconcile, a
         // write from inside a memo), so core's `undefined === undefined` gate
         // proves nothing. Reported as changed, so no consumer counts it as waste.
-                if (!t && (e.ie !== NOT_PENDING ? e.ie : e.le) === undefined) t = true;
+                if (!t && (e.ue !== NOT_PENDING ? e.ue : e.le) === undefined) t = true;
         if (r.causes !== null) recordRerun(e, r, {
             selfMs: c,
             totalMs: a
@@ -2788,7 +2788,7 @@ const engineHooks = {
     },
     asyncStart(e) {
         asyncStartSeq = e.ge?.seq ?? 0;
-        asyncStartTime = e.ae;
+        asyncStartTime = e.ie;
         asyncStartValue = e.le;
     },
     asyncEnd(e, n, t, o) {
@@ -2799,7 +2799,7 @@ const engineHooks = {
             // (or `_time`, for a same-reference commit under `equals: false`), and
             // a transition hold parks the value in `_pendingValue`. A landing the
             // equality gate swallowed moves none of them and must leave no stamp.
-            const o = e.le !== asyncStartValue || e.ae !== asyncStartTime || e.ie === t;
+            const o = e.le !== asyncStartValue || e.ie !== asyncStartTime || e.ue === t;
             if (o) stampWrite(e, "async", n === undefined ? NO_VALUES : n, t);
             // Flight over either way — an equality-swallowed landing still spent
             // the wall time (finalizeFlight only chains through a fresh stamp).

package/dist/observe/core/constants.js

@@ -78,6 +78,11 @@ const REACTIVE_MANUAL_WRITE = 1 << 10;
  * later read of the same pass routed it into a verdict lane — that was not
  * the probe's answer (lanes.ts). Per pass. */ const REACTIVE_PROBE_UNANSWERED = 1 << 19;
 
+/** The pass opened a verdict window of its own (`isPending`/`latest`) — not
+ * only read a verdict memo (F-6, core.ts `read`). An async memo whose pass
+ * did not is D-25's hold work while its flight is up (verdict.ts
+ * `holdWork`). Per pass (1 << 20 is lanes.ts's LEFT_SHOWN). */ const REACTIVE_WINDOW = 1 << 21;
+
 // Static configuration bits packed into Owner/Computed/Signal _config.
 const CONFIG_OWNED_WRITE = 1 << 0;
 
@@ -219,6 +224,9 @@ const CONFIG_HAS_SNAPSHOT = 1 << 9;
  * joins nothing, so two mounts under one boundary made in separate flushes
  * keep their holds apart (D-4, S-5 rows 1′–3′, #4283). */ const CONFIG_FRAME = 1 << 23;
 
+/** The node's last answering pass registered a flight: an async memo. Kept
+ * by the verdict engine alone (verdict.ts `holdWork`), which reads it. */ const CONFIG_ASYNC = 1 << 29;
+
 const STATUS_NONE = 0;
 
 const STATUS_PENDING = 1 << 0;
@@ -258,4 +266,4 @@ const defaultContext = {};
 
 const NewSet = Set;
 
-export { $REFRESH, CAUGHT_REARMED, CONFIG_AUTHORITATIVE, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRAME, CONFIG_FRESH_READ, CONFIG_GUESS, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, CONFIG_HELD_FRAME, CONFIG_INPUTS_PUBLISHED, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_KEY_BAG, CONFIG_LAGS, CONFIG_MANUAL_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_OVERRIDE, CONFIG_OWNED_WRITE, CONFIG_PLUMBING, CONFIG_PROMOTED, CONFIG_REDERIVE, CONFIG_SLOT_NODE, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_SYNC, CONFIG_TRANSPARENT, CONFIG_VERDICT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, NewSet, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_JOINED, REACTIVE_LANE_DIRTY, REACTIVE_LANE_READ, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_PROBED, REACTIVE_PROBE_UNANSWERED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SCREEN_READ, REACTIVE_SNAPSHOT_STALE, REACTIVE_STAGED_READ, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_NONE, STATUS_NO_VALUE, STATUS_PENDING, STATUS_UNINITIALIZED, SUPPORTS_PROXY, defaultContext };
+export { $REFRESH, CAUGHT_REARMED, CONFIG_ASYNC, CONFIG_AUTHORITATIVE, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRAME, CONFIG_FRESH_READ, CONFIG_GUESS, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, CONFIG_HELD_FRAME, CONFIG_INPUTS_PUBLISHED, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_KEY_BAG, CONFIG_LAGS, CONFIG_MANUAL_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_OVERRIDE, CONFIG_OWNED_WRITE, CONFIG_PLUMBING, CONFIG_PROMOTED, CONFIG_REDERIVE, CONFIG_SLOT_NODE, CONFIG_STAGED, CONFIG_STAGED_ERROR, CONFIG_SYNC, CONFIG_TRANSPARENT, CONFIG_VERDICT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, NewSet, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_JOINED, REACTIVE_LANE_DIRTY, REACTIVE_LANE_READ, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_PROBED, REACTIVE_PROBE_UNANSWERED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SCREEN_READ, REACTIVE_SNAPSHOT_STALE, REACTIVE_STAGED_READ, REACTIVE_WINDOW, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_NONE, STATUS_NO_VALUE, STATUS_PENDING, STATUS_UNINITIALIZED, SUPPORTS_PROXY, defaultContext };

package/dist/observe/core/copies.js

@@ -0,0 +1,10 @@
+/** @internal Runs `fn` with this copy marked as the one running. */
+function runAsSolidCopy(n) {
+    return n();
+}
+
+/** @internal An ownerless component or context read: warns if another copy is running. */ function checkForeignOwnerless() {
+    return;
+}
+
+export { checkForeignOwnerless, runAsSolidCopy };