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

package/dist/observe/core/verdict.js

@@ -0,0 +1,551 @@
+import { NOT_PENDING, REACTIVE_DISPOSED, REACTIVE_DIRTY, REACTIVE_CHECK, unwrapOverride, REACTIVE_ZOMBIE, STATUS_UNINITIALIZED, STATUS_PENDING, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_MANUAL_WRITE, CONFIG_HAS_COMPANIONS, CONFIG_CHILD_COMPANIONS, STATUS_ERROR, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
+
+import { setSignal, pendingCheckActive, setPendingCheckActive, prepareComputed, read, context, stale, currentOptimisticLane, tracking, ext, setLatestReadActive, setContextInternal, optimisticComputed, latestReadActive, optimisticSignal } from "./core.js";
+
+import { NotReadyError } from "./error.js";
+
+import { link } from "./graph.js";
+
+import { insertIntoHeap, queueFor, markHeap, enqueueSub } from "./heap.js";
+
+import "./invariants.js";
+
+import { findLane, laneHeld, hasActiveOverride, assignOrMergeLane } from "./lanes.js";
+
+import { installOptimisticEngine } from "./optimistic.js";
+
+import { GlobalQueue, insertSubs, schedule, activeTransition, currentTransition, activeAffectsMarks } from "./scheduler.js";
+
+/**
+ * The isPending()/latest() verdict layer, moved out of core.ts. Importing this
+ * module installs the companion-maintenance hooks on GlobalQueue; apps that
+ * never import isPending/latest never pay for any of it.
+ */
+// Companions (pending signals / latest shadows) are optimistic nodes: their
+// writes go through the optimistic write path and their reversion rides the
+// same lanes, so the verdict layer brings the engine with it.
+installOptimisticEngine();
+
+let pendingProbe = null;
+
+/**
+ * Probes whose verdict was suppressed by the fresh-read pairing rule while
+ * the held write's fate was still undecided (see recordFreshRead /
+ * wakeSuppressedProbes): held node → the wrapper computeds that probed it.
+ * Entries die with the hold — the commit/revert snap clears them.
+ */ const suppressedProbes = new Map;
+
+/**
+ * Get or create the pending signal for a node (lazy).
+ * Used by isPending() to track pending state reactively.
+ */
+/** #3038: register a companion-carrying firewall child on its firewall's
+ * companion set and arm the post-recompute snap (CONFIG_CHILD_COMPANIONS is
+ * the one-load gate at the call sites). The snap then iterates exactly the
+ * children someone asked verdicts of — O(companions) — never the full
+ * `_child` chain, which carries one node per materialized leaf (the
+ * O(all-leaves-ever-read)-per-update pathology). Entries are permanent like
+ * the companions themselves; a store with no leaf-level isPending()/latest()
+ * reads never allocates the set or pays the walk. */ function markFirewallChildCompanions(e) {
+    const t = e.re;
+    if (!t) return;
+    t.T |= CONFIG_CHILD_COMPANIONS;
+    (ext(t).jt ??= new Set).add(e);
+}
+
+function getPendingSignal(e) {
+    let t = e.o?.be;
+    if (!t) {
+        // Start false, write true if pending - ensures reversion returns to false
+        t = optimisticSignal(false, {
+            ownedWrite: true
+        });
+        ext(e).be = t;
+        e.T |= CONFIG_HAS_COMPANIONS;
+        markFirewallChildCompanions(e);
+        ext(t).Qe = e;
+        if (computePendingState(e)) setSignal(t, true);
+    }
+    return t;
+}
+
+function collectPendingSources(e) {
+    if (!pendingProbe) return;
+    pendingProbe.sources.add(e);
+    const t = e.re || e;
+    if (t !== e) pendingProbe.sources.add(t);
+}
+
+/**
+ * Adds a node to the active isPending() probe without reading it. The store's
+ * untracked-probe fallback (`witnessAffectsMark`) reaches this through
+ * `GlobalQueue._witnessAffects` — its callers guard on `pendingCheckActive`,
+ * which only flips inside `isPending()`, so the hook is always installed by
+ * the time it can fire.
+ */ function witnessAffects(e) {
+    pendingProbe?.sources.add(e);
+}
+
+/**
+ * The affects() coverage walk — the read half of the dedicated mark channel.
+ * A node is covered by a live mark iff it carries one (`_affectsCount`) or
+ * derives, through its CURRENT deps (hopping store firewalls), from a node
+ * that does. Pull-based coverage means graph rewires, mid-window recomputes,
+ * and probe-triggered recomputes can never strand or strip a mark — there is
+ * nothing stored downstream to corrupt. Probe-created links
+ * (`_pendingObserver`) are skipped so an `isPending` wrapper memo never
+ * inherits the coverage it reports on.
+ */ function markWalk(e, t) {
+    if (e.o?.t) return true;
+    // A real error outranks an inherited mark (A16/A24c): an errored node
+    // answers probes with its error, not a coverage verdict, and coverage does
+    // not flow through it — matching the rails' behavior, where propagation
+    // stopped at errored nodes. A DIRECT mark on an errored node still reads
+    // pending (the count check above), also matching.
+        if (e.S & STATUS_ERROR) return false;
+    if (t.has(e)) return false;
+    t.add(e);
+    const n = e.re;
+    if (n && markWalk(n, t)) return true;
+    // Mid-recompute (the clearStatus companion poke runs before
+    // trimStaleDeps), only the validated prefix [_deps.._depsTail] is this
+    // pass's dependency set — walking past it would read dropped deps and
+    // latch a stale verdict on the companion.
+        const i = e;
+    const r = i.it & REACTIVE_RECOMPUTING_DEPS ? i.Dt : undefined;
+    if (r !== null) {
+        for (let e = i.te ?? null; e !== null; e = e.ne) {
+            if (!e.ye && markWalk(e.oe, t)) return true;
+            if (e === r) break;
+        }
+    }
+    return false;
+}
+
+function quietPending(e) {
+    if (e.o?.ee) {
+        for (const t of e.o.ee) if (!t.o?.Ne) return false;
+        return true;
+    }
+    return e.o?.Ne ?? false;
+}
+
+// NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
+// on purpose: commit #0 answers the question by declaration, so the window
+// reads NOT pending — first-load affordances live in the value channel
+// (null / skeleton provenance the author encoded), and isPending stays what
+// it always was: refetch truth for an answered question. This keeps the
+// verdict fully correlated with transition-class machinery and keeps server
+// (always false) and client hydration trivially consistent.
+function newQuestionInFlight(e) {
+    return !!(e.S & STATUS_PENDING) && !(e.S & STATUS_UNINITIALIZED) && !quietPending(e);
+}
+
+function computePendingState(e) {
+    const t = e;
+    if (t.it & REACTIVE_DISPOSED) return false;
+    // Mark coverage is transitive by dep-graph reachability: a latest() shadow
+    // reaches its owner (and a store leaf its firewall) through its own deps,
+    // so the one walk covers direct marks, derivation, and companion chains.
+    // Gated: apps with no live mark pay one integer compare.
+        if (activeAffectsMarks !== 0 && markWalk(e, new Set)) return true;
+    const n = e.re;
+    if (e.o?.Qe) {
+        const t = e.o?.Qe;
+        const n = t.re || t;
+        return newQuestionInFlight(n);
+    }
+    if (n && e.Pe !== NOT_PENDING && !hasActiveOverride(e)) {
+        return !!(n.it & REACTIVE_MANUAL_WRITE) || !n.o?.Se && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
+    }
+    // `!comp._loading`: a hold created while the loading window is still open is
+    // the window's own landing in flight to its commit — verdict-quiet like the
+    // rest of the window (the UNINITIALIZED check suppresses exactly this frame
+    // for windowless first loads; born-committed nodes need their own gate, #2990).
+        if (e.Pe !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.de) {
+        if (hasActiveOverride(e)) return !e.Ue || !e.Ue(e.Pe, unwrapOverride(e.o?.De));
+        // A quiet re-ask's held landing still answers the same question: the
+        // classification survives the landing (asyncWrite) and dies with the
+        // commit (commitPendingNode) — verdict-quiet through the reveal, like
+        // the loading window above (#3178).
+                if (!t.o?.Ne) return true;
+    }
+    return newQuestionInFlight(t);
+}
+
+function syncCompanions(e, t) {
+    if (e.o?.be) updatePendingSignal(e);
+    if (e.o?.pe) setSignal(e.o?.pe, t);
+}
+
+function updatePendingSignal(e) {
+    if (e.o?.be) {
+        setSignal(e.o?.be, computePendingState(e));
+    }
+    if (e.o?.pe) updatePendingSignal(e.o?.pe);
+}
+
+function updateChildCompanions(e) {
+    const t = e.o?.jt;
+    if (t === undefined) return;
+    for (const e of t) updatePendingSignal(e);
+}
+
+/**
+ * Re-derive every verdict companion downstream of `el` (subs + firewall
+ * children, dedup'd). The affects() channel's poke walk: registration and
+ * re-ask flips use the live write path (companion setSignal — its own lane
+ * lets the wake escape an incomplete transition's effect stash, #2887);
+ * mark release passes `snap` because it runs inside queue finalization,
+ * where companion writes must land committed (a setSignal there would open
+ * a fresh override window that nothing settles).
+ */ function repollDownstreamVerdicts(e, t = false) {
+    const n = t ? snapCompanionsToState : updatePendingSignal;
+    const i = new Set;
+    const visit = e => {
+        if (i.has(e)) return;
+        i.add(e);
+        if (e.o?.be || e.o?.pe) n(e);
+        for (let t = e.u; t !== null; t = t.se) visit(t.le);
+        for (let t = e.o?.i ?? null; t !== null; t = t.ue) {
+            visit(t);
+        }
+    };
+    visit(e);
+}
+
+/**
+ * The correction half of the provisional fresh-read suppression (see
+ * collectPending): fired from the sanctioned async-registration site
+ * (GlobalQueue.notify) when a transaction gains an in-flight async blocker.
+ * Every probe that returned "not pending" purely because it read a held
+ * value belonging to that transaction re-runs — its re-probe now sees the
+ * live blocker through heldAwaitingAsync and lands the true verdict. The
+ * wake mirrors a companion write's own notification (optimistic-dirty on the
+ * companion's lane) so the corrected verdict commits and flushes immediately
+ * instead of being held with the transaction it reports on.
+ */ function wakeSuppressedProbes(e) {
+    if (suppressedProbes.size === 0) return;
+    let t = false;
+    for (const [n, i] of suppressedProbes) {
+        const r = n.Ee;
+        const s = r ? currentTransition(r) : null;
+        if (!s) {
+            suppressedProbes.delete(n);
+            continue;
+        }
+        if (s !== e) continue;
+        suppressedProbes.delete(n);
+        const o = n.o?.be?.o?.Te;
+        for (const e of i) {
+            if (e.it & REACTIVE_DISPOSED) continue;
+            e.it |= REACTIVE_OPTIMISTIC_DIRTY;
+            if (o) assignOrMergeLane(e, o); else if (e.o !== null) e.o.Te = undefined;
+            enqueueSub(e);
+            t = true;
+        }
+    }
+    if (t) schedule();
+}
+
+function snapCompanionsToState(e) {
+    suppressedProbes.size !== 0 && suppressedProbes.delete(e);
+    const t = e.o?.be;
+    if (t && (t.o?.De === undefined || t.o?.De === NOT_PENDING)) {
+        const n = computePendingState(e);
+        if (t.ge !== n || t.Pe !== NOT_PENDING) {
+            t.ge = n;
+            t.Pe = NOT_PENDING;
+            insertSubs(t);
+            schedule();
+        }
+    }
+    const n = e.o?.pe;
+    if (n && !(n.it & REACTIVE_DISPOSED)) {
+        if ((n.o?.De === undefined || n.o?.De === NOT_PENDING) && n.Pe === NOT_PENDING && !Object.is(n.ge, e.ge) && !(n.it & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+            n.it |= REACTIVE_DIRTY;
+            insertIntoHeap(n, queueFor(n));
+            insertSubs(n);
+            schedule();
+        }
+        snapCompanionsToState(n);
+    }
+}
+
+function getLatestValueComputed(e) {
+    let t = e.o?.pe;
+    // A shadow disposed while unobserved (its gated reader unmounted at a
+    // landing) is a corpse: sync writes into it equality-swallow against its
+    // frozen _value, and a later read revives it via recompute — clearing
+    // DISPOSED and re-deriving from the committed view, so the banner showed
+    // the previous transition's target (#3041 follow-up). Treat it as absent;
+    // recreation backfills from the in-flight write below.
+        if (t && t.it & REACTIVE_DISPOSED) t = undefined;
+    if (!t) {
+        const n = latestReadActive;
+        setLatestReadActive(false);
+        const i = pendingCheckActive;
+        setPendingCheckActive(false);
+        const r = context;
+        setContextInternal(null);
+ // Detach from owner so it isn't disposed with effects
+                t = optimisticComputed(() => read(e));
+        ext(e).pe = t;
+        e.T |= CONFIG_HAS_COMPANIONS;
+        markFirewallChildCompanions(e);
+        ext(t).Qe = e;
+ // Parent-child lane relationship
+        // Backfill an in-flight write (mirrors getPendingSignal): the companion is
+        // created lazily, possibly after the write was processed — syncCompanions
+        // only pushes into companions that already exist, so the first latest()
+        // read inside a held transition showed the committed value (#3041).
+                if (e.Pe !== NOT_PENDING && !hasActiveOverride(e)) setSignal(t, e.Pe);
+        setContextInternal(r);
+        setPendingCheckActive(i);
+        setLatestReadActive(n);
+    }
+    return t;
+}
+
+/** The latest()-mode read path, installed as GlobalQueue._latestRead. */ function latestRead(e) {
+    const t = getLatestValueComputed(e);
+    const n = latestReadActive;
+    setLatestReadActive(false);
+    const i = e.o?.De !== undefined && e.o?.De !== NOT_PENDING ? unwrapOverride(e.o?.De) : e.ge;
+    let r;
+    try {
+        // An untracked latest() read has no reading context, so read() never
+        // performs its mid-tick pull — a plain write queued between two latest()
+        // calls left a still-subscribed shadow at its previous speculative value
+        // until the flush (#2922). Mirror the tracked-read pull here: mark the
+        // queued staleness through the graph, then bring the shadow up to date.
+        const e = queueFor(t);
+        if (t.At >= e.St && !(t.it & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+            markHeap(e);
+            // Suspend probe collection during the pull (mirrors pendingCheckRead's
+            // prepare): a probe through latest() answers for the SHADOW — the
+            // read() dispatch collects it deliberately, so the verdict reflects
+            // async still in flight for the latest view, not the parent's held
+            // write. A stale shadow recomputing HERE ran its `read(parent)` with
+            // the probe still live and collected the parent too, so the verdict
+            // depended on whether anything had pulled the shadow current earlier
+            // in the tick (#3104: reading latest(m) flipped a later
+            // latest(() => isPending(x)) from true to false).
+                        const n = pendingCheckActive;
+            setPendingCheckActive(false);
+            try {
+                prepareComputed(t, true);
+            } finally {
+                setPendingCheckActive(n);
+            }
+        }
+        r = read(t);
+    } catch (t) {
+        if (t instanceof NotReadyError && (!context || !(e.S & STATUS_UNINITIALIZED))) return i;
+        throw t;
+    } finally {
+        setLatestReadActive(n);
+    }
+    if (t.S & STATUS_PENDING) return i;
+    if (stale && currentOptimisticLane && t.o?.Te) {
+        const e = findLane(t.o?.Te);
+        const n = findLane(currentOptimisticLane);
+        if (e !== n && laneHeld(e)) {
+            return i;
+        }
+    }
+    // A shadow recomputed by the pull above (not at creation) holds its fresh
+    // speculative value in _pendingValue; a contextless read() only surfaces
+    // _value. Overrides stay authoritative (A17), and stale readers keep the
+    // other transition's committed view, matching read()'s own selection.
+        if (t.Pe !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ee && activeTransition !== t.Ee)) return t.Pe;
+    return r;
+}
+
+/**
+ * A latest() shadow that is uninitialized only because it was CREATED during
+ * an active flight — its parent source already has a committed value, so
+ * latest() serves that as the visible value and a tracked reader has
+ * something to pair a verdict with (#3166). Same parent resolution as
+ * computePendingState. The pending signal companion also carries
+ * `_parentSource` but is a plain signal (no `_fn`) that never goes pending,
+ * so the `_fn` check is belt-and-braces for this call site.
+ */ function latestShadowWithInitializedParent(e) {
+    if (typeof e.ot !== "function") return false;
+    const t = e.o?.Qe;
+    if (t === undefined) return false;
+    const n = t.re || t;
+    return !(n.S & STATUS_UNINITIALIZED);
+}
+
+/** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, i) {
+    setPendingCheckActive(false);
+    if (typeof e.ot === "function") prepareComputed(e, true);
+    const r = n.S;
+    if (t && r & STATUS_PENDING && r & STATUS_UNINITIALIZED && 
+    // The suspend-throw is for a genuinely-first-load source: the tracked
+    // reader has nothing to pair a verdict with, so it parks on the source.
+    // A latest() SHADOW created lazily mid-flight is born uninitialized even
+    // though its parent has a committed value latest() will serve — throwing
+    // here (swallowed by latestRead's fallback) dropped the shadow from the
+    // probe, so a tracked latest(isPending()) probe created during a
+    // new-question flight cached `false` for that whole flight (#3166).
+    // Defer to the PARENT's initialization state and fall through to normal
+    // collection; the plain pending throw downstream still links the reader.
+    !latestShadowWithInitializedParent(n)) {
+        if (tracking && e !== t) link(e, t);
+        setPendingCheckActive(true);
+        throw n.o?._;
+    }
+    collectPendingSources(e);
+    if (i) collectPendingSources(i);
+    setPendingCheckActive(true);
+}
+
+/**
+ * A held node whose transaction still has an async question in flight. The
+ * probe's fresh-read pairing rule (#2831 — "a reader that sees the fresh
+ * value must not also be told it is pending") only applies to LANDED answers
+ * awaiting reveal; while the answer is still computing, the fresh value the
+ * reader saw is an input, and pending remains the truth for every reader
+ * (#3028).
+ */ function heldAwaitingAsync(e) {
+    const t = e.Ee;
+    const n = t ? currentTransition(t) : activeTransition;
+    if (!n || n.Ut) return false;
+    // A plain staged write (a signal/store leaf — no _fn) held while an action
+    // is still running is an INPUT to a computation still in flight (#3078):
+    // the pairing rule must not suppress the verdict, or a memo recomputing
+    // mid-action reads the staged value, gets told "not pending", and
+    // disagrees with a direct isPending() probe for the whole action window.
+    // A computed's staged value is the opposite case — a LANDED answer
+    // awaiting reveal — where the pairing rule stands even inside an open
+    // action (#2831: a reader that saw the new value must not also see
+    // pending); still-computing answers are covered by the reporter scan.
+        if (n.ut.length && !e.ot) return true;
+    // A node not yet stamped with a transition only qualifies through the
+    // action check above; the reporter scan below is for transition-held
+    // writes whose source async is still computing.
+        if (!t) return false;
+    for (const [e, t] of n.Ie) {
+        if (t.size && e.S & STATUS_PENDING && e.o?._?.source === e) return true;
+    }
+    return false;
+}
+
+function recordFreshRead(e, t) {
+    if (pendingProbe !== null && e.Pe !== NOT_PENDING && t === e.Pe) {
+        if (heldAwaitingAsync(e)) return;
+        pendingProbe.freshReads.add(e);
+    }
+}
+
+function applyReask(e, t) {
+    const n = !!(e.S & STATUS_PENDING);
+    const i = t && !(n && !e.o?.Ne);
+    const r = n && (e.o?.Ne ?? false) !== i;
+    // Allocation-free for the quiet case: false is the extension default.
+        if (i) ext(e).Ne = true; else if (e.o !== null) e.o.Ne = false;
+    return r;
+}
+
+function latest(e) {
+    const t = latestReadActive;
+    setLatestReadActive(true);
+    try {
+        return e();
+    } finally {
+        setLatestReadActive(t);
+    }
+}
+
+function isPending(e) {
+    const t = pendingCheckActive;
+    const n = pendingProbe;
+    setPendingCheckActive(true);
+    const i = pendingProbe = {
+        found: false,
+        sources: new Set,
+        freshReads: new Set,
+        suppressed: []
+    };
+    const collectPending = () => {
+        setPendingCheckActive(false);
+        // Companion reads are mode-neutral plumbing: under an outer latest()
+        // (isPending inside a latest window — #3104's memo shape) leaving latest
+        // mode active dispatched these reads through latestRead, which built a
+        // SHADOW OF THE PENDING SIGNAL itself. The next updatePendingSignal then
+        // wrote that companion-on-companion from inside a recompute
+        // (syncCompanions → setSignal on a shadow created without ownedWrite)
+        // and halted dev with the owned-scope write guard. The creation paths
+        // (getLatestValueComputed / getPendingSignal) already suspend both
+        // modes; this read site must too.
+                const e = latestReadActive;
+        setLatestReadActive(false);
+        try {
+            i.sources.forEach(e => {
+                if (read(getPendingSignal(e))) {
+                    if (!i.freshReads.has(e)) i.found = true; else i.suppressed.push(e);
+                }
+            });
+        } finally {
+            setLatestReadActive(e);
+            setPendingCheckActive(true);
+        }
+        // A "not pending" verdict that exists only because this reader saw the
+        // fresh held value is provisional: if the write turns out NOT to commit
+        // this flush (a downstream async pends and holds it), the suppression was
+        // wrong and the wrapper must re-ask (#3028). Remember who to wake — the
+        // async registration (GlobalQueue.notify) triggers wakeSuppressedProbes.
+                if (!i.found && i.suppressed.length && context && typeof context.ot === "function") {
+            for (const e of i.suppressed) {
+                let t = suppressedProbes.get(e);
+                if (!t) suppressedProbes.set(e, t = new Set);
+                t.add(context);
+            }
+        }
+    };
+    try {
+        e();
+        collectPending();
+        return i.found;
+    } catch (e) {
+        collectPending();
+        if (e instanceof NotReadyError) {
+            const t = !!(e.source?.S & STATUS_UNINITIALIZED);
+            if (i.found && !t) return true;
+            if (context && t) throw e;
+        }
+        return i.found;
+    } finally {
+        setPendingCheckActive(t);
+        pendingProbe = n;
+    }
+}
+
+// Hook installation (same late-binding pattern as GlobalQueue._update /
+// _propagateAffects): core call sites fire these behind the same guards the
+// direct calls used, so behavior is identical once this module loads.
+GlobalQueue.Ae = syncCompanions;
+
+GlobalQueue.fe = updatePendingSignal;
+
+GlobalQueue.Ge = updateChildCompanions;
+
+GlobalQueue.Dn = snapCompanionsToState;
+
+GlobalQueue.In = latestRead;
+
+GlobalQueue.Nn = pendingCheckRead;
+
+GlobalQueue.Cn = recordFreshRead;
+
+GlobalQueue.gt = applyReask;
+
+GlobalQueue.k = repollDownstreamVerdicts;
+
+GlobalQueue.oi = witnessAffects;
+
+GlobalQueue.si = wakeSuppressedProbes;
+
+export { isPending, latest };

package/dist/observe/index.js

@@ -0,0 +1,55 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError } from "./core/error.js";
+
+export { clearSnapshots, isEqual, markSnapshotScope, releaseSnapshotScope, runWithOwner, setSnapshotCapture, untrack } from "./core/core.js";
+
+export { enableExternalSource } from "./core/external.js";
+
+export { createOwner, createRoot, getNextChildId, getObserver, getOwner, isDisposed, peekNextChildId } from "./core/owner.js";
+
+export { createContext, getContext, setContext } from "./core/context.js";
+
+export { $REFRESH, SUPPORTS_PROXY } from "./core/constants.js";
+
+import "./core/invariants.js";
+
+import { OBSERVE as OBSERVE$1 } from "./core/dev.js";
+
+export { enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
+
+export { isPending, latest } from "./core/verdict.js";
+
+import "./core/effect.js";
+
+export { action } from "./core/action.js";
+
+export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, refresh, resolve, until } from "./signals.js";
+
+export { affects } from "./affects.js";
+
+export { mapArray, repeat } from "./map.js";
+
+export { createStore, deep, reconcile, snapshot } from "./store/index.js";
+
+export { createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten } from "./boundaries.js";
+
+export { $PROXY, $TARGET, $TRACK, isWrappable } from "./store/store.js";
+
+export { createOptimisticStoreNext as createOptimisticStore } from "./store/next/optimistic.js";
+
+export { createProjectionNext as createProjection } from "./store/next/projection.js";
+
+export { merge, mergeSources, omit } from "./store/utils.js";
+
+export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store/next/store.js";
+
+export { storePath } from "./store/storePath.js";
+
+/**
+ * Observe tier (diagnostics channel, attribution hook slot + interaction
+ * frame): dev and observe builds. The attribution engine itself is the
+ * `@solidjs/signals/attribution` entry.
+ */ const OBSERVE = OBSERVE$1;
+
+/** Dev tier (devtools hooks, graph traversal, console reporting): dev builds only. */ const DEV = undefined;
+
+export { DEV, OBSERVE };