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

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

@@ -1,25 +1,39 @@
-import { type Refreshable } from "./constants.js";
-import { type OptimisticLane } from "./lanes.js";
-import type { Computed, FirewallSignal, NodeExtension, NodeOptions, Owner, Signal } from "./types.js";
+import type { Transaction } from "./scheduler.js";
+import type { Computed, NodeExtension, NodeOptions, Owner, Signal } from "./types.js";
 export declare const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE = "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
+export declare const PRIMITIVE_IN_EFFECT_CALLBACK_MESSAGE: string;
+/** Dev: the effect phase (render and user effects, their cleanups) runs with
+ * no ambient owner, and a computation created there with none is outside
+ * every owner and every hold (maintainer, 2026-10-01: ownerless only —
+ * `runWithOwner` in a callback is deliberate, Portal and createReaction do
+ * it; a bare createRoot is the mistake). Computeds and roots; a signal
+ * created there is inert and harmless. Tracked effects and onSettled are
+ * children-forbidden and refuse through PRIMITIVE_IN_FORBIDDEN_SCOPE. */
+export declare function assertNotInEffectCallback(): void;
 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;
 export declare let context: Owner | null;
-export declare let currentOptimisticLane: OptimisticLane | null;
 export declare let snapshotCaptureActive: boolean;
 export declare let snapshotSources: Set<any> | null;
 export declare function setSnapshotCapture(active: boolean): void;
-export declare function markSnapshotScope(owner: Owner): void;
+/**
+ * Marks `owner` a snapshot scope: while capture is on, the readers created
+ * under it serve each source's snapshot (the value it had when hydration
+ * began) and replay at `releaseSnapshotScope`.
+ *
+ * With `served` (hydration), `owner` is instead a hydrated computed and
+ * `served` its server answer — what the server rendered every reader of the
+ * node with — landing after the node was created pending (so the creation
+ * arm skipped it). It becomes the node's snapshot when it has none, whether
+ * the node committed the answer or a client write had already taken its
+ * compute over. A claim made later reads the value its markup shows, and
+ * replays the node's own value at its release, as for a written signal.
+ */
+export declare function markSnapshotScope(owner: Owner, served?: unknown): void;
 export declare function releaseSnapshotScope(owner: Owner): void;
 export declare function clearSnapshots(): void;
 export declare function recompute(el: Computed<any>, create?: boolean): void;
@@ -32,24 +46,126 @@ export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncI
 export declare function ext(el: {
     _x: NodeExtension | null;
 }): NodeExtension;
+/** A tracked read of a held node (the reader derives from its transaction's
+ * world): the reading pass is marked as having read it (born-held decision
+ * in `recompute`), and the flush joins the node's transaction — unless the
+ * reader is a render effect. A render effect is the frame, not a derivation
+ * (rule 3): in that transaction's own flush, or born into it (uninitialized,
+ * A29), it reads the staged value and holds nothing of its own; otherwise it
+ * reads the committed value instead (`frameRead`). A node born into the
+ * future has no committed value: every reader joins it. A first pass is
+ * something not ready under a loading boundary that has not shown content:
+ * the boundary collects it and shows its fallback, and the pass is the
+ * boundary's, not the tick's (A29's boundary exemption, #3540). */
+export declare function joinPass(c: Computed<any>, el: Signal<any> | Computed<any>): void;
+/** `joinPass` into the hold `t` (a folded guess's: store/optimistic.ts
+ * `foldedRead`, D-34) — a reader is never a render effect there. */
+export declare function joinPassAt(c: Computed<any>, t: Transaction): void;
+/** A node born into transaction `t`: held by it and never committed (A29,
+ * ruling A) — uninitialized (born held), or a member of the frame one of its
+ * held passes built (CONFIG_HELD_FRAME). Its branch exists only in `t`: it
+ * has no screen to read, so it reads `t`'s values, whichever flush runs it,
+ * and keeps staging (#4010). */
+export declare function bornInto(c: Computed<any>, t: Transaction): unknown;
+/** The computed whose pass a creation under `owner` belongs to (a root's is
+ * its nearest computed ancestor's), or null outside every pass. */
+export declare function creatorPass(owner: Owner | null): Computed<any> | null;
+/** What `born` and the passes still running around `p` read — its
+ * creator's, theirs — of the future or a staging (REACTIVE_JOINED |
+ * REACTIVE_STAGED_READ): a pass created by one that did has no screen; its
+ * branch exists only in that world (#4341). */
+export declare function creatorReads(p: Computed<any> | null, born: number): number;
 /**
  * Build an Effect node with all effect-specific fields baked into a single object literal,
  * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
  * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
  * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
  */
-export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val: T, prev: T | undefined) => void | (() => void), errorFn: ((err: unknown, cleanup: () => void) => void | (() => void)) | undefined, type: number, notifyStatus: ((status?: number, error?: any) => void) | undefined, options: NodeOptions<T> | undefined): any;
+export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val: T, prev: T | undefined) => void | (() => void), errorFn: ((err: unknown, cleanup: () => void) => void | (() => void)) | undefined, type: number, options: NodeOptions<T> | undefined): any;
+/**
+ * The shared status notifier for effect nodes, installed once by effect.ts
+ * at module evaluation (`this`-dispatched — one function serves every
+ * effect, so nodes never store it). CARVE 4: the boundaries' per-node
+ * channel (`_x._notifyStatus`) went with them; effects are the only
+ * display consumers.
+ */
+export declare let effectStatusNotify: ((this: any) => void) | null;
+export declare function setEffectStatusNotify(fn: NonNullable<typeof effectStatusNotify>): void;
+/** Resolve a node's status notifier: effect nodes (`_type` — EFFECT_PURE is
+ * 0, and only effect literals carry the field) get the shared notifier.
+ * Presence doubles as the "display consumer" membership test in the status
+ * walks, exactly as the per-node field did when every effect carried one. */
+export declare function statusNotifierOf(el: any): ((this: any) => void) | null;
 export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
-export declare function signal<T>(v: T, options?: NodeOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
-export declare function optimisticSignal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
-export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
+/** A store slot node (CONFIG_SLOT_NODE): the whole node in ONE literal — the
+ * target and key as back-refs in place of closures (`equals` is a method
+ * call, `this` the node; the unobserved sweep dispatches to one shared hook,
+ * graph.ts), the store's wrap cache (`px`/`pxv`: the proxy last served for
+ * this key and the raw it wrapped — one pointer compare replaces a WeakMap
+ * lookup per read) and the accessor verdict (`acc`) pre-shaped. No options
+ * object, no NodeExtension, no post-construction expandos. `ownedWrite` is
+ * baked in: the setter carries the owned-scope guard; node-level writes are
+ * the store's notification machinery. The observe literal adds the label
+ * and location slots (the store relabels `store.<key>` and stamps the
+ * store's `loc` when the engine is installed). */
+export declare function slotSignal<T>(v: T, equals: (a: T, b: T) => boolean, host: object, key: PropertyKey, acc: boolean): Signal<T>;
 /**
  * When set to a component name string, any reactive read that is not inside a nested tracking
  * scope will log a dev-mode warning. Managed automatically by `untrack(fn, strictReadLabel)`.
  */
+/** The verdict windows' read (verdict.ts), installed while a `latest` or
+ * `isPending` window is open and null otherwise: `read` dispatches to it
+ * then, and a program that never imports them never has one. */
+export declare let verdict: ((el: Signal<any> | Computed<any>, c: Computed<any> | null) => unknown) | null;
+export declare function setVerdict(fn: typeof verdict): void;
 export declare let strictRead: string | false;
-export declare function setStrictRead(v: string | false): string | false;
+/** Dev-only: explicit untrack() nesting, so deliberate post-await reads stay quiet. */
+export declare let untrackDepth: number;
+/**
+ * Dev-only: > 0 while Solid runs user code that is imperative by construction
+ * — an effect callback (effect.ts) or an action body's synchronous slice
+ * (action.ts). Both run with no owner, exactly like an async continuation, so
+ * the post-await read check (dev.ts) consults this rather than blame the
+ * continuation that called flush() or invoked the action. Both sites bracket
+ * with try/finally, so a throw cannot leave it raised.
+ */
+export declare let callbackDepth: number;
+export declare function enterCallback(): void;
+export declare function exitCallback(): void;
+/**
+ * Dev-only: > 0 while owner teardown runs cleanups (`_disposal` entries and
+ * effect-returned cleanups — owner.ts), for the same reason. The owned-scope
+ * write guard (setSignal, markRefresh, the store setter) stands down here
+ * too: a cleanup is teardown, not part of whichever computation is disposing
+ * its owner (a list pass removing a row, a branch switching away), so its
+ * writes are imperative like an effect callback's (#4165). Kept apart from
+ * `callbackDepth` because its sites cannot use try/finally (the frame would
+ * survive into prod). A throwing cleanup is caught (owner.ts `runCleanup`);
+ * anything else escaping a teardown leaves it raised, and dev.ts resets it on
+ * the next microtask, which teardown — synchronous — never spans.
+ */
+export declare let disposalDepth: number;
+export declare function enterDisposal(): void;
+export declare function exitDisposal(): void;
+export declare function resetDisposalDepth(): void;
+/**
+ * Dev-only: the DOM event being dispatched when the open strict-read window
+ * opened (`globalThis.event`; null between dispatches and off the main
+ * thread's Window), or `ANY_EVENT` when the window did not record one. A DOM
+ * call made in an effect callback that dispatches events synchronously
+ * (`el.focus()`, `el.click()`, `dialog.showModal()`) runs that event's
+ * handlers inside the window; a handler is a one-shot snapshot whoever
+ * dispatched the event, so a read made while a different event is current is
+ * outside the window (#4235). Only queued effect runs record the event, read
+ * once per queue (the getter is costly under jsdom); `strictReadActive` is
+ * the check.
+ */
+export declare let strictReadEvent: unknown;
+export declare const dispatchingEvent: () => unknown;
+export declare function setStrictRead(v: string | false, event?: unknown): string | false;
+/** Dev-only: is the strict-read window open for a read made now? */
+export declare function strictReadActive(): boolean;
 /**
  * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
  * subscribe the current scope. Returns whatever `fn` returns.
@@ -57,6 +173,16 @@ export declare function setStrictRead(v: string | false): string | false;
  * Use `untrack` inside a memo or effect when you need to read a signal once
  * without making the surrounding computation depend on its future changes.
  *
+ * `untrack` stops dependency tracking, not async settlement. Reading an
+ * uninitialized async source still suspends the owning computation; it runs
+ * again when that source first resolves. Afterward, the untracked read is a
+ * snapshot and does not subscribe the computation to later changes.
+ *
+ * If the first read must return immediately, give the async source a
+ * `loadingValue` before reading it with `untrack`. `isPending` and `latest`
+ * inspect updates to an existing value; neither supplies a missing initial
+ * value.
+ *
  * Pass a `strictReadLabel` string to enable a dev-mode warning: any reactive
  * read inside `fn` that isn't inside a nested tracking scope will log a
  * warning naming the label.
@@ -70,53 +196,170 @@ export declare function setStrictRead(v: string | false): string | false;
  *     log(snapshot);
  *   }
  * );
+ *
+ * const color = createMemo<string>(() => fetchColor(), { loadingValue: "gray" });
+ * const initialColor = untrack(color); // "gray" while the fetch is unresolved
  * ```
  */
 export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
+/**
+ * Set while runtime bookkeeping reads a node inside another node's pass (a
+ * loading boundary priming its tree at creation, from whatever pass is
+ * mounting it). `context` is that node, but the read is nobody's: the value
+ * is probed, never derived from, so nothing the read would normally record
+ * on `context` may be recorded — not the untracked-pending re-run link
+ * (`read`, `!tracking`; #3528: a boundary's `on` key read this way from
+ * `notify` linked the key's source into an unrelated async memo, a cycle that
+ * never converged), and not a transaction entry (`enterStagedRead`; #3540: a
+ * born-held tree would otherwise pull the mounting pass into the hold).
+ */
+export declare let spectating: boolean;
+/**
+ * Evaluates `fn` untracked, recording nothing on the current `context`: no
+ * untracked-pending re-run link, no transaction entry. For bookkeeping reads
+ * made on behalf of no node — see `spectating`.
+ */
+export declare function spectate<T>(fn: () => T): 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.
+ * `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;
 /**
- * Sentinel returned by readNodeFast when the plain-signal fast path does not
- * apply and the caller must fall back to the full read().
+ * Rule 1 (value selection): does this reader see a STAGED node's COMMITTED
+ * value? One implementation of the rule the fast paths (read's fast block)
+ * carry as their trivial ternary. In order:
+ * - no reader at all (an untracked read) — the committed frame;
+ * - nothing staged;
+ * - a children-forbidden reader (createTrackedEffect / onSettled: the frame,
+ *   never the graph — A32).
+ * False means the reader derives from the staged value.
  */
-export declare const READ_SLOW: unique symbol;
+export declare function readerSeesCommitted(el: Signal<any> | Computed<any>, c: Computed<any> | null): boolean;
+/** A28 — set when a node is staged (queuePendingNode) OUTSIDE a flush;
+ * cleared when the next flush begins. The read sites test this one module
+ * boolean instead of `globalQueue._running`: inside a flush it is false and
+ * the A28 arm costs nothing; outside, only a tick with unflushed writes pays
+ * the staged-node check. */
+export declare let unflushedStaged: boolean;
+export declare function markUnflushedStaged(): void;
+/** A28 — a write becomes visible at flush. Outside a flush, a node holding a
+ * staged value was written since the last flush: staging commits at flush
+ * end, so nothing else leaves a node in this state. Inside a flush the rule
+ * does not apply (A28 (4): promoted within the round). The value an
+ * unflushed node serves is its committed value, or NOT_PENDING when nothing
+ * is unflushed. Exempt: promoted writes (A28 (4): a write issued inside a
+ * recompute is promoted at that recompute's end — boundary and loading
+ * machinery, signals declared for in-computation writes). */
+export declare function unflushedValue(el: Signal<any> | Computed<any>): unknown;
+/** A28: a held node rewritten outside a flush keeps the staging the last
+ * flush left (`_flushed`) until the flush that carries the rewrite — the
+ * stash is stamped with the clock, which that flush advances. */
+export declare function stashFlushed(el: Signal<any> | Computed<any>): void;
+/** A derivation served the committed value because of an unflushed write
+ * (A28) must run again in the flush that carries it — the late-linker case
+ * (#3337's reason to defer the walk): it linked after the write walked. */
+export declare function markLateLinker(c: Computed<any>): true;
+export declare function resyncUnflushedCompanions(): void;
+/** A tracked read's pull of a computed: bring it current when the flush has
+ * reached its height (or the reader is a fresh-pull waiter), and sit the
+ * reader above it. */
+export declare function pullComputed(owner: Computed<any>, c: Computed<any>): void;
 /**
- * read()'s plain-signal fast path as a standalone entry for hot callers
- * (store traps). Safe to substitute for read() only because the bail
- * conditions mirror read()'s prelude and fast-path guard exactly: the
- * latestRead and pendingCheck windows run side-effectful hooks before the
- * fast path, `_fn` nodes need prepareComputed, and firewall / override /
- * snapshot / transition / lane / dev-strictRead state all take the full
- * resolution. Anything slow returns READ_SLOW; the caller then calls read().
+ * Dev only: a read's diagnostics — the devtools read hook, the foreign-read
+ * check and the post-await untracked-read check. Every caller guards with
+ * `__DEV__`: `read` here, and a store leaf's read that is served without
+ * `read` (`nodeValue`'s first landing), so no read goes unseen in dev.
  */
-export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
+export declare function devRead(el: Signal<any> | Computed<any>): void;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 /**
- * Store-rewrite setter guard: the rewrite parks writes in a pending backing
- * (no setSignal at write time), so the owned-scope write protection must
- * fire at the setter entry instead. Mirrors setSignal's guard condition
- * minus the node-specific exemptions (ownedWrite/firewall), which don't
- * apply to plain store setters.
+ * Rule 1, the one slow implementation (DESIGN-CONSOLIDATION move 3b, step
+ * 6c): the value a reader `c` (null = untracked, no pass) is served from
+ * `el`. Called by read()'s slow tail; the fast path (read's fast block) keeps
+ * its trivial ternary by design (perf, see the doc). Arms, in order:
+ * - a node born staged has nothing for an untracked reader (A19 exception 1);
+ * - an unflushed write serves committed and re-runs the reader in the
+ *   carrying flush (A28);
+ * - readerSeesCommitted, else the staged value.
  */
-export declare function devGuardStoreSetterWrite(): void;
-export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
+export declare function serve(el: Signal<any> | Computed<any>, c: Computed<any> | null): unknown;
+/** A pass read a staging of this flush: it derives from what the flush may
+ * yet hold (REACTIVE_STAGED_READ — the seam decides). Lane work too (plan sec. 28, a
+ * lane sees the screen plus its own guesses) — a folded lane's only before
+ * the frame has a transaction (after, it reads the screen like a verdict
+ * reader, `stagedScreen` — a list pass never pairs a held length with the
+ * guess's rows, D-34): the staging is the screen if
+ * the frame commits — one pass, the common case — and a held write if it
+ * parks, which the seam repairs (`stagedReaders`): the pass re-derives on
+ * the committed world and its lane's runs wait that round, so the held
+ * write never shows through the lane. A verdict lane's work likewise: the
+ * lane holds verdicts, not the frame's other stagings (#3851) — except a
+ * verdict reader, which answered for itself (the lane seam, lanes.ts). Not
+ * a read of a node born staged at all: it has no committed value to
+ * re-derive on, and a re-run would read the same staging and re-queue every
+ * round (#3969: nor does it make a later lane read a re-derive, `enterLane`). */
+export declare function stagedRead(c: Computed<any>, el?: Signal<any> | Computed<any>): void;
+/** A10 for a staged node: a verdict reader (the pass entered a window) that
+ * also reads a frame's proposal plainly sees the screen — `[latest(q), q()]`
+ * is `[b, a]` — once the frame has a transaction, and re-derives when it
+ * lands: at this very seam if nothing holds it (the stale run is void,
+ * #3322 — one run, on the committed world), or with the hold. Before any
+ * transaction the answer is the seam's and the reader watches it
+ * (verdict.ts). A node born into the future has no screen: its staging is
+ * its only value (A29). Nor has a reader born into the flush's transaction
+ * (`bornInto`, #4010): its branch exists only there. */
+export declare function stagedScreen(c: Computed<any>): boolean;
+export declare function ownedScopeWriteMessage(owner: Owner): string;
+/** A28 (4) — written inside a recompute that runs OUTSIDE a flush (a
+ * creation-time compute): promoted at that pass's end, visible to the rest of
+ * the block. Cold: only contextual writes reach here. */
+export declare function notePromotedWrite(el: Signal<any> | Computed<any>): void;
+/** Cold half of setSignal's snapshot arm (see there), shared with a store
+ * container's structural notify: first write during capture to a plain
+ * signal without a live snapshot records the pre-write value. Only plain
+ * user signals qualify. Computeds reach setSignal from an
+ * async landing (asyncWrite), and a value arriving from async during the pass
+ * REVEALS — the creation-time arm skips pending computeds for the same
+ * reason. Firewall leaves belong to a projection whose compute is the tree's
+ * own work, captured (or deliberately not) at creation. */
+export declare function captureWriteSnapshot<T>(el: Signal<T> | Computed<T>, current: T): void;
+/**
+ * A callback run before every signal or store write lands, while set, with
+ * the written signal or the store proxy whose setter runs. The
+ * server-components client sets it while slot occurrences are left
+ * unmounted after hydration (deferred hydration): a write may be one an
+ * unmounted component would have observed, so the client mounts what is
+ * left before the write applies, and clears the hook. `null` otherwise.
+ */
+export declare let writeHook: ((node?: object) => void) | null;
+/** @internal */
+export declare function setWriteHook(hook: ((node?: object) => void) | null): void;
 /**
- * Suppresses automatic recomputation of `el` until the scheduler drains. Used
- * when a manual write should win over dependency changes queued in the same
- * tick. The MANUAL_WRITE flag is cleared by the pending-node drain; projection
- * computeds don't commit values, but they still need the same end-of-tick
- * cleanup point.
+ * `el`'s comparator verdict (`_equals`), the one guarded call for recompute,
+ * setSignal (user setters and async landings) and the seam's
+ * staged-equals-committed check.
+ * - A comparator that read an unresolved async source has not shown the
+ *   values equal (#4111): falsy, a change, whose readers suspend in their own
+ *   tracked context.
+ * - Any other throw is an error of `el`'s computation (A3, #2837): routed
+ *   through the status path so error boundaries contain it, instead of
+ *   unwinding a flush or a setter; answered "same" so nothing commits.
+ * @internal
  */
-export declare function suppressComputedRecompute(el: Computed<unknown>): void;
+export declare function isSame(el: Signal<any>, a: unknown, b: unknown): unknown;
+export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**
- * User-facing setter for the memo form of `createSignal(fn)`. Behaves like
- * `setSignal`, but also cancels any pending recompute of the memo so the
- * manual value wins over a value that would otherwise be produced by an
- * upstream change in the same tick.
+ * User-facing setter for the memo form of `createSignal(fn)`. A write applies
+ * first, then derivations re-run (A34 as amended 2026-10-01, rule B; core
+ * R31): the write stages like any other, and a source change — in this flush
+ * or a later one, under a hold or on mainline — re-derives with the staged
+ * write as `prev`. The write never refuses the re-run (the frame-scoped mask
+ * of #3733/#3740 and #2692's "write wins the tick" before it are gone; call
+ * order inside a flush was never observable) and on its own never causes one.
+ * REACTIVE_MANUAL_WRITE only marks the staging as a user proposal — the A34
+ * (1)/(3) discriminator — until a pass re-derives it or the commit lands it.
  */
 export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
 /**
@@ -141,23 +384,10 @@ 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;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
 /**
- * Invalidates one reactive source, forcing it to re-execute even if its inputs
- * haven't changed.
- *
- * Pass either a Solid-created accessor or a projected store created from
- * `createStore(fn, ...)` / `createProjection(...)`. `refresh()` is a
- * write-like invalidation operation: it does not read the target's value, and
- * refreshing a plain signal accessor is a no-op.
- *
- * Use it to invalidate cached async values (e.g. force a re-fetch) without
- * tearing the consumer down.
- *
- * @example
- * ```ts
- * const user = createMemo(async () => fetch(`/users/${id()}`).then(r => r.json()));
- *
- * // Re-fetch on demand
- * <button onClick={() => refresh(user)}>Reload</button>
- * ```
+ * Core marking half of `refresh()` (the public wrapper lives in signals.ts —
+ * it validates the target, marks through here, then builds the quiescence
+ * promise on the resolve()/until() effect machinery). Flags the node's next
+ * recompute as a quiet re-ask and schedules it; no-ops for non-derived or
+ * disposed targets.
  */
-export declare function refresh<T>(target: Refreshable<T>): void;
+export declare function markRefresh(node: Computed<any>): void;