@solidjs/signals 2.0.0-beta.18 → 2.0.0-beta.20

package/dist/prod/store/storePath.js

@@ -0,0 +1,103 @@
+import { isWrappable, ownEnumerableKeys } from "./store.js";
+
+const DELETE = Symbol(0);
+
+function isPrototypePollutionKey(t) {
+    return t === "__proto__" || t === "constructor" || t === "prototype";
+}
+
+function updatePath(t, e, o = 0) {
+    let r, n = t;
+    if (o < e.length - 1) {
+        r = e[o];
+        const i = typeof r;
+        const f = Array.isArray(t);
+        if (i === "string" && isPrototypePollutionKey(r)) return;
+        if (Array.isArray(r)) {
+            for (let n = 0; n < r.length; n++) {
+                e[o] = r[n];
+                updatePath(t, e, o);
+            }
+            e[o] = r;
+            return;
+        } else if (f && i === "function") {
+            for (let n = 0; n < t.length; n++) {
+                if (r(t[n], n)) {
+                    e[o] = n;
+                    updatePath(t, e, o);
+                }
+            }
+            e[o] = r;
+            return;
+        } else if (f && i === "object") {
+            const {from: n = 0, to: i = t.length - 1, by: f = 1} = r;
+            for (let r = n; r <= i; r += f) {
+                e[o] = r;
+                updatePath(t, e, o);
+            }
+            e[o] = r;
+            return;
+        } else if (o < e.length - 2) {
+            updatePath(t[r], e, o + 1);
+            return;
+        }
+        n = t[r];
+    }
+    let i = e[e.length - 1];
+    if (typeof i === "function") {
+        i = i(n);
+        if (i === n) return;
+    }
+    if (r === undefined && i == undefined) return;
+    if (i === DELETE) {
+        delete t[r];
+    } else if (r === undefined || isWrappable(n) && isWrappable(i) && !Array.isArray(i)) {
+        const e = r !== undefined ? t[r] : t;
+        const o = ownEnumerableKeys(i);
+        for (let t = 0; t < o.length; t++) {
+            const r = o[t];
+            if (typeof r === "string" && isPrototypePollutionKey(r)) continue;
+            const n = Object.getOwnPropertyDescriptor(i, r);
+            if (n.get || n.set) Object.defineProperty(e, r, n); else e[r] = n.value;
+        }
+    } else {
+        t[r] = i;
+    }
+}
+
+/**
+ * Path-based setter helper for `createStore`. Call `storePath(...path, value)`
+ * to produce a draft-mutating function suitable for passing to `setStore`.
+ *
+ * The canonical setter form in Solid 2.0 is the draft-mutating callback
+ * (`setStore(s => { s.user.name = "Ada"; })`). `storePath` is a backwards-
+ * compatibility helper for users porting from Solid 1.x's
+ * `setStore("user", "name", "Ada")` style — it's optional and you can mix the
+ * two styles freely.
+ *
+ * Path parts can be:
+ * - a single key — `"user"`, `0`
+ * - an array of keys — `[0, 1, 2]`
+ * - a range over an array — `{ from?, to?, by? }`
+ * - a filter `(item, index) => boolean` for arrays
+ *
+ * The final argument is the new value or an updater `(prev) => next`. Use
+ * `storePath.DELETE` to remove a property.
+ *
+ * @example
+ * ```ts
+ * const [state, setState] = createStore({ user: { name: "Ada" }, todos: [] });
+ *
+ * setState(storePath("user", "name", "Grace"));
+ * setState(storePath("todos", t => !t.done, "done", true)); // mark all undone as done
+ * setState(storePath("user", "nickname", storePath.DELETE));
+ * ```
+ */ const storePath = /* @__PURE__ */ Object.assign(function storePath(...t) {
+    return e => {
+        updatePath(e, t);
+    };
+}, {
+    DELETE: DELETE
+});
+
+export { storePath };

package/dist/prod/store/utils.js

@@ -0,0 +1,316 @@
+import { pendingCheckActive } from "../core/core.js";
+
+import { SUPPORTS_PROXY } from "../core/constants.js";
+
+import "../core/scheduler.js";
+
+import "../core/invariants.js";
+
+import "../core/verdict.js";
+
+import "../core/effect.js";
+
+import { createMemo } from "../signals.js";
+
+import { ownEnumerableKeys, $PROXY, isWrappable, $TARGET, trackSelf, witnessAffectsMark, mergedOverlay, STORE_VALUE, storeLookup, STORE_LOOKUP, $DELETED, wrap, getStoreSymbols, getPropertyDescriptor, getStoreKeys, getKeys, $TRACK } from "./store.js";
+
+function snapshotImpl(e, t, r, n) {
+    let o, s, i, c, f, u;
+    if (!isWrappable(e)) return e;
+    if (r && r.has(e)) return r.get(e);
+    if (!r) r = new Map;
+    if (o = e[$TARGET] || n?.get(e)?.[$TARGET]) {
+        if (t) {
+            trackSelf(o, $TRACK);
+            // A tracked walk reads THROUGH the record without touching the proxy
+            // traps — witness the record's affects() channel like a trap read would.
+                        if (pendingCheckActive) witnessAffectsMark(o);
+        }
+        i = mergedOverlay(o);
+        s = Array.isArray(o[STORE_VALUE]);
+        r.set(e, i ? c = s ? [] : Object.create(Object.getPrototypeOf(o[STORE_VALUE])) : o[STORE_VALUE]);
+        e = o[STORE_VALUE];
+        n = o[STORE_LOOKUP] ?? storeLookup;
+    } else {
+        s = Array.isArray(e);
+        r.set(e, e);
+    }
+    if (s) {
+        const s = i?.length ?? e.length;
+        for (let p = 0; p < s; p++) {
+            u = i && p in i ? i[p] : e[p];
+            if (u === $DELETED) continue;
+            if (t && isWrappable(u)) wrap(u, o);
+            if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
+                if (!c) r.set(e, c = [ ...e ]);
+                c[p] = f;
+            }
+        }
+        // Enumerate array symbols separately to avoid scanning indices twice.
+        // Spread copies omit symbols, so assign them after the numeric walk.
+                const p = n ? getStoreSymbols(e, i) : [];
+        for (let s = 0, l = p.length; s < l; s++) {
+            const l = p[s];
+            const a = getPropertyDescriptor(e, i, l);
+            if (!a || a.get) continue;
+            u = i && l in i ? i[l] : e[l];
+            if (t && isWrappable(u)) wrap(u, o);
+            f = snapshotImpl(u, t, r, n);
+            if (f !== u || c) {
+                if (!c) r.set(e, c = Object.assign([ ...e ], e));
+                c[l] = f;
+            }
+        }
+        // Deleted trailing slots are skipped above, so restore length to preserve
+        // holes instead of truncating the copy (#2846) — mirrors unwrapStoreValue.
+                if (c) c.length = s;
+    } else if (!i) {
+        // Specialized walk for the common no-overlay case (from #2756): the own
+        // descriptor gives the value directly, so each property is read once with
+        // no overlay membership checks.
+        // A lookup means this object belongs to an immutable store backing tree,
+        // even if that nested value has not needed its own proxy yet.
+        const s = n ? getStoreKeys(e, undefined) : getKeys(e, undefined);
+        for (let i = 0, p = s.length; i < p; i++) {
+            const p = s[i];
+            const l = Object.getOwnPropertyDescriptor(e, p);
+            if (l.get) continue;
+            u = l.value;
+            if (t && isWrappable(u)) wrap(u, o);
+            if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
+                if (!c) {
+                    c = Object.create(Object.getPrototypeOf(e));
+                    Object.assign(c, e);
+                }
+                c[p] = f;
+            }
+        }
+    } else {
+        // An override only exists on a store record, and the target branch above
+        // always set `lookup` alongside it — so this branch is always store-keyed.
+        const s = getStoreKeys(e, i);
+        for (let p = 0, l = s.length; p < l; p++) {
+            let l = s[p];
+            const a = getPropertyDescriptor(e, i, l);
+            if (a.get) continue;
+            u = l in i ? i[l] : e[l];
+            if (t && isWrappable(u)) wrap(u, o);
+            if ((f = snapshotImpl(u, t, r, n)) !== e[l] || c) {
+                if (!c) {
+                    c = Object.create(Object.getPrototypeOf(e));
+                    Object.assign(c, e);
+                }
+                c[l] = f;
+            }
+        }
+    }
+    return c || e;
+}
+
+function snapshot(e, t, r) {
+    return snapshotImpl(e, false, t, r);
+}
+
+/**
+ * Returns a plain (non-proxy) deep copy **and** subscribes the current
+ * tracking scope to every nested change in the source store. Any write
+ * anywhere in the subtree invalidates the consumer.
+ *
+ * Use this when you need plain data inside a reactive scope and want to
+ * react to deep mutations (e.g. passing a snapshot to `reconcile()` or to a
+ * memo that should rerun on any nested change). For most read paths, prefer
+ * direct property access — Solid stores already track per-property reads
+ * with no `deep()` wrapper needed.
+ *
+ * @example
+ * ```ts
+ * const [state] = createStore({ a: { b: { c: 1 } } });
+ *
+ * createEffect(
+ *   () => deep(state),                  // reruns on any nested change
+ *   plain => sendToWorker(plain)        // worker gets a non-proxy copy
+ * );
+ * ```
+ */ function deep(e) {
+    return snapshotImpl(e, true);
+}
+
+function trueFn() {
+    return true;
+}
+
+const propTraps = {
+    get(e, t, r) {
+        if (t === $PROXY) return r;
+        return e.get(t);
+    },
+    has(e, t) {
+        if (t === $PROXY) return true;
+        return e.has(t);
+    },
+    set: trueFn,
+    deleteProperty: trueFn,
+    getOwnPropertyDescriptor(e, t) {
+        return {
+            configurable: true,
+            enumerable: true,
+            get() {
+                return e.get(t);
+            },
+            set: trueFn,
+            deleteProperty: trueFn
+        };
+    },
+    ownKeys(e) {
+        return e.keys();
+    }
+};
+
+function resolveSource(e) {
+    return !(e = typeof e === "function" ? e() : e) ? {} : e;
+}
+
+const $SOURCES = Symbol(0);
+
+/**
+ * Merges multiple props-like objects into a single proxy that *preserves
+ * reactivity*. Reads are forwarded to the right-most source that defines the
+ * property, so later sources override earlier ones (like `Object.assign`).
+ *
+ * Function arguments are treated as memo-backed sources — useful for passing
+ * derived defaults whose computation should track reactively.
+ *
+ * Use this in component bodies to merge defaults / overrides without losing
+ * Solid's per-property tracking.
+ *
+ * @example
+ * ```tsx
+ * function Button(_props: { label: string; type?: string; disabled?: boolean }) {
+ *   const props = merge({ type: "button", disabled: false }, _props);
+ *
+ *   return <button type={props.type} disabled={props.disabled}>{props.label}</button>;
+ * }
+ * ```
+ */ function merge(...e) {
+    if (e.length === 1 && typeof e[0] !== "function") return e[0];
+    let t = false;
+    const r = [];
+    for (let n = 0; n < e.length; n++) {
+        const o = e[n];
+        t = t || !!o && $PROXY in o;
+        const s = !!o && o[$SOURCES];
+        if (s) {
+            for (let e = 0; e < s.length; e++) r.push(s[e]);
+        } else r.push(typeof o === "function" ? (t = true, createMemo(o)) : o);
+    }
+    if (SUPPORTS_PROXY && t) {
+        return new Proxy({
+            get(e) {
+                if (e === $SOURCES) return r;
+                for (let t = r.length - 1; t >= 0; t--) {
+                    const n = resolveSource(r[t]);
+                    if (e in n) return n[e];
+                }
+            },
+            has(e) {
+                for (let t = r.length - 1; t >= 0; t--) {
+                    if (e in resolveSource(r[t])) return true;
+                }
+                return false;
+            },
+            keys() {
+                const e = new Set;
+                for (let t = 0; t < r.length; t++) {
+                    const n = ownEnumerableKeys(resolveSource(r[t]));
+                    for (let t = 0; t < n.length; t++) e.add(n[t]);
+                }
+                return [ ...e ];
+            }
+        }, propTraps);
+    }
+    const n = Object.create(null);
+    let o = false;
+    let s = r.length - 1;
+    for (let e = s; e >= 0; e--) {
+        const t = r[e];
+        if (!t) {
+            e === s && s--;
+            continue;
+        }
+        const i = Object.getOwnPropertyNames(t);
+        for (let r = i.length - 1; r >= 0; r--) {
+            const c = i[r];
+            if (c === "__proto__" || c === "constructor") continue;
+            if (!n[c]) {
+                o = o || e !== s;
+                const r = Object.getOwnPropertyDescriptor(t, c);
+                n[c] = r.get ? {
+                    enumerable: true,
+                    configurable: true,
+                    get: r.get.bind(t)
+                } : r;
+            }
+        }
+    }
+    if (!o) return r[s];
+    const i = {};
+    const c = Object.keys(n);
+    for (let e = c.length - 1; e >= 0; e--) {
+        const t = c[e], r = n[t];
+        if (r.get) Object.defineProperty(i, t, r); else i[t] = r.value;
+    }
+    i[$SOURCES] = r;
+    return i;
+}
+
+/**
+ * Returns a reactive proxy of `props` with the listed keys hidden. Tracking
+ * on the remaining keys is preserved.
+ *
+ * Use it to forward "rest" props to a child element while pulling out the
+ * keys your component handles itself — the equivalent of `splitProps(p, ["a","b"])[1]`.
+ *
+ * @example
+ * ```tsx
+ * function Input(props: { label: string; value: string; onInput: (v: string) => void } & JSX.HTMLAttributes<HTMLInputElement>) {
+ *   const rest = omit(props, "label", "value", "onInput");
+ *
+ *   return (
+ *     <label>
+ *       {props.label}
+ *       <input
+ *         {...rest}
+ *         value={props.value}
+ *         onInput={e => props.onInput(e.currentTarget.value)}
+ *       />
+ *     </label>
+ *   );
+ * }
+ * ```
+ */ function omit(e, ...t) {
+    if (SUPPORTS_PROXY && $PROXY in e) {
+        return new Proxy({
+            get(r) {
+                return t.includes(r) ? undefined : e[r];
+            },
+            has(r) {
+                return !t.includes(r) && r in e;
+            },
+            keys() {
+                return ownEnumerableKeys(e).filter(e => !t.includes(e));
+            }
+        }, propTraps);
+    }
+    const r = {};
+    const n = Object.getOwnPropertyNames(e);
+    const o = t.length > 4 && n.length > t.length ? new Set(t) : undefined;
+    for (const s of n) {
+        if (o ? !o.has(s) : !t.includes(s)) {
+            const t = Object.getOwnPropertyDescriptor(e, s);
+            !t.get && !t.set && t.enumerable && t.writable && t.configurable ? r[s] = t.value : Object.defineProperty(r, s, t);
+        }
+    }
+    return r;
+}
+
+export { deep, merge, omit, snapshot };

package/dist/types/affects.d.ts

@@ -1,5 +1,5 @@
-import { type Store } from "./store/store.js";
 import type { Accessor } from "./signals.js";
+import { type Store } from "./store/store.js";
 /**
  * Declares that in-flight work will change the targeted data: the named
  * slot(s) — and everything DERIVED from them — read as pending

package/dist/types/boundaries.d.ts

@@ -20,7 +20,7 @@ export declare class RevealController {
     _evaluating: boolean;
     constructor(order: OrderAccessor, collapsed: BoolAccessor);
     _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
-    isReady(): boolean;
+    _isReady(): boolean;
     /**
      * "Minimally ready" = this group has something visible to show under its own policy.
      * Used by an enclosing `together` group to decide when it can release.
@@ -28,10 +28,10 @@ export declare class RevealController {
      * - `sequential`: the first owned slot is minimally ready (frontier can advance).
      * - `natural`: any owned slot is minimally ready.
      */
-    isMinimallyReady(): boolean;
-    register(slot: RevealSlot): void;
-    unregister(slot: RevealSlot): void;
-    evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
+    _isMinimallyReady(): boolean;
+    _register(slot: RevealSlot): void;
+    _unregister(slot: RevealSlot): void;
+    _evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
 }
 export declare class CollectionQueue extends Queue {
     _collectionType: number;
@@ -48,7 +48,7 @@ export declare class CollectionQueue extends Queue {
     constructor(type: number);
     run(type: number): void;
     notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
-    checkSources(): void;
+    _checkSources(): void;
 }
 /**
  * Lower-level primitive that backs the `<Loading>` flow control. Catches

package/dist/types/core/action.d.ts

@@ -4,10 +4,22 @@
  * surrounding UI sees one atomic update per yielded step; nothing is committed
  * until the action either completes or the next `yield` resolves.
  *
- * Yield promises (or any awaitable) inside the generator — the action waits
- * for each before continuing, but the writes you made beforehand are already
- * visible (or held by `<Loading>` if optimistic). Yield bare values for
- * synchronous batched steps.
+ * `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:
+ *
+ * ```ts
+ * const saved = await api.createTodo(text); // typed result
+ * yield; // re-enter the transaction before writing
+ * setTodos(t => { ... });
+ * ```
+ *
+ * (For the same reason, don't call `flush()` inside an action body — it
+ * drains the transaction mid-step.)
  *
  * Each call returns a `Promise` that resolves with the generator's return
  * value, or rejects if it throws. Pair with `createOptimistic` /
@@ -18,10 +30,11 @@
  * ```ts
  * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
  *
- * const addTodo = action(function* (text: string) {
+ * const addTodo = action(async function* (text: string) {
  *   const tempId = crypto.randomUUID();
  *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
- *   const saved = yield api.createTodo(text); // network round-trip
+ *   const saved = await api.createTodo(text); // network round-trip, typed
+ *   yield; // re-enter the transaction
  *   setTodos(t => {
  *     const i = t.findIndex(x => x.id === tempId);
  *     if (i >= 0) t[i] = saved;

package/dist/types/core/async.d.ts

@@ -1,44 +1,10 @@
 import { type OptimisticLane } from "./lanes.js";
-import type { Computed, Signal } from "./types.js";
+import type { Computed, Link } from "./types.js";
+export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
+export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
+export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
 export declare function settlePendingSource(el: Computed<any>, source?: Computed<any>, snap?: boolean): void;
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
 export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
 export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;
 export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;
-/**
- * The pending-source identity of a live `affects()` mark on `node` (lazy,
- * one per node, shared by overlapping registrations via the refcount).
- *
- * A mark rides the SAME status rails as real in-flight async — downstream
- * subscribers hold the sentinel in `_pendingSources` — but under its own
- * identity so the two channels can't clear each other:
- * - `_reask` is permanently `false`: a mark is by definition a declared
- *   value change, so `quietPending` never silences a window it participates
- *   in — even when the mark rides over an otherwise-quiet `refresh()`
- *   re-ask of the same node (the whole point of declaring one).
- * - A landing on the marked node settles only the node's OWN source entry;
- *   the sentinel entry survives until the mark's transaction releases it.
- * - The sentinel itself never carries `STATUS_PENDING`, so
- *   `transitionComplete` never counts a mark as a blocker of its own
- *   transaction (release happens AT settle — self-blocking would deadlock),
- *   and reads of the marked node never throw (marks are value-transparent
- *   at the source; pendingness is what propagates).
- */
-export declare function getAffectsSentinel(node: Signal<any> | Computed<any>): Computed<any>;
-/**
- * Push a live mark's pendingness downstream from the marked node through the
- * normal status rails. Runs on every registration (dedup in `notifyStatus`
- * stops re-descent at already-covered subscribers). Subscribers that
- * recompute mid-window shed this via `clearStatus` and re-acquire it through
- * the read path (`applyAffectsReads`) — the same shape as real async, where
- * the re-throw on read re-establishes the source.
- */
-export declare function propagateAffectsMark(node: Signal<any> | Computed<any>): void;
-/**
- * Re-establish mark pendingness on a computed that read marked sources
- * during its recompute (`clearStatus` at the top of the commit path wiped
- * any sentinel entries it held). Called by `recompute` after the commit —
- * not before, because setting `_error` earlier would make the commit path
- * treat the node as errored and skip the value write.
- */
-export declare function applyAffectsReads(el: Computed<any>, sources: (Signal<any> | Computed<any>)[]): void;

package/dist/types/core/constants.d.ts

@@ -35,6 +35,18 @@ export declare const EFFECT_USER = 2;
 export declare const EFFECT_TRACKED = 3;
 export declare const NOT_PENDING: {};
 export declare const NO_SNAPSHOT: {};
+/**
+ * Stand-in stored in `_overrideValue` for an optimistic write of literal
+ * `undefined` (#2898). The slot doubles as the optimistic-node brand
+ * (`undefined` = not optimistic, `NOT_PENDING` = at rest), so the raw value
+ * would erase the node's optimistic identity: the write turns invisible and
+ * follow-up writes route off the optimistic path and commit permanently.
+ * Same shape as NO_SNAPSHOT. Sites that surface the override VALUE unwrap
+ * via `visibleOverrideValue`; slot identity tests stay raw.
+ */
+export declare const OVERRIDE_UNDEFINED: {};
+/** Unwrap an active override's stored value for surfacing to readers (#2898). */
+export declare function unwrapOverride<T = any>(v: unknown): T;
 export declare const STORE_SNAPSHOT_PROPS = "sp";
 export declare const SUPPORTS_PROXY: boolean;
 export declare const defaultContext: {};

package/dist/types/core/core.d.ts

@@ -5,6 +5,12 @@ export declare const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE = "[PRIMITIVE_IN_FORBI
 export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_SIGNAL_MESSAGE: string;
 export declare const REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE: string;
 export declare let tracking: boolean;
+/** @internal verdict-module glue */
+export declare function setPendingCheckActive(v: boolean): void;
+/** @internal verdict-module glue */
+export declare function setLatestReadActive(v: boolean): void;
+/** @internal verdict-module glue */
+export declare function setContextInternal(v: Owner | null): void;
 export declare let stale: boolean;
 export declare let pendingCheckActive: boolean;
 export declare let latestReadActive: boolean;
@@ -60,6 +66,12 @@ export declare function setStrictRead(v: string | false): string | false;
  * ```
  */
 export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
+/**
+ * Bring a computed to a readable state: lazy/disposed nodes are (re)computed;
+ * an isPending() probe (`refresh`) additionally pulls the node fully up to
+ * date so its status flags reflect the current graph.
+ */
+export declare function prepareComputed(comp: Computed<unknown>, refresh: boolean): void;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**
@@ -97,85 +109,7 @@ export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
  * ```
  */
 export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
-/**
- * Adds a node to the active isPending() probe without reading it. The store's
- * untracked-probe fallback (`witnessAffectsMark`) calls this with `affects()`
- * carrier nodes: an untracked read through a marked record may touch no real
- * signal node at all, so the probe collects the mark's carrier directly.
- *
- * @internal
- */
-export declare function witnessAffects(node: Signal<any> | Computed<any>): void;
-/**
- * Keep the lazily-created isPending()/latest() companion nodes in sync with a
- * new value. Every path that produces a value for `el` — direct set, async
- * resolution, transition-held sync recompute — must route through here so a
- * new write path can't silently skip the companions (#2831).
- */
-export declare function syncCompanions<T>(el: Signal<T> | Computed<T>, value: T): void;
-/**
- * Update _pendingSignal when pending state changes. When the override clears
- * (pending -> not pending), merge the sub-lane into the source's lane so
- * isPending effects are blocked until the full scope resolves.
- */
-export declare function updatePendingSignal(el: Signal<any> | Computed<any>): void;
-/**
- * A firewall's status change re-derives the verdicts of its probed leaves:
- * leaf companions consult the firewall (broad inheritance), so async
- * starting/settling on the firewall must poke them or they keep a stale
- * verdict forever (V4 stuck-companion class, #2838).
- */
-export declare function updateChildCompanions(el: Computed<any>): void;
-/**
- * Settlement checkpoint (#2838): re-derive a node's companions directly from
- * its committed state. Called when the transition machinery for the node is
- * done with it — a pending commit or an optimistic revert. Verdicts are
- * written committed (not through setSignal) because a transition-scoped
- * override window opened here would itself need a settlement, re-scheduling
- * forever while async is still in flight. This is what keeps companions
- * coherent past transition completion: a verdict is a property of the data
- * (A19), so it must survive the transition that happened to produce it.
- */
-export declare function snapCompanionsToState(owner: Signal<any> | Computed<any>): void;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
-/**
- * Reads reactive expressions while bypassing any pending async overlay — i.e.
- * always returns the most-recently-committed value, even when newer reads
- * inside `fn` are still in flight.
- *
- * Useful inside a `<Loading>` boundary's children when you want to keep
- * showing the previous resolved data instead of the fallback while the next
- * value loads.
- *
- * @example
- * ```tsx
- * <Loading fallback={<Skeleton />}>
- *   {/* During a transition, render the previous user instead of skeleton: *\/}
- *   <UserCard user={latest(() => user())} />
- * </Loading>
- * ```
- */
-export declare function latest<T>(fn: () => T): T;
-/**
- * Returns `true` if any reactive read inside `fn` is showing a stale value
- * while newer async work is pending. Does not subscribe — pair with a tracked
- * memo if you want to react to pending status changes.
- *
- * Useful for showing inline transition indicators alongside the previous
- * value (rather than swapping to a `<Loading>` fallback).
- * Because `fn` is read normally, `isPending` participates in Loading/SSR
- * readiness the same way the read itself would.
- *
- * @example
- * ```tsx
- * const pending = createMemo(() => isPending(() => user()));
- *
- * <button disabled={pending()}>{pending() ? "Saving…" : "Save"}</button>
- *
- * <button disabled={isPending(() => user())}>Save</button>
- * ```
- */
-export declare function isPending(fn: () => any): boolean;
 /**
  * Invalidates one reactive source, forcing it to re-execute even if its inputs
  * haven't changed.