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

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

@@ -4,20 +4,28 @@ export declare const REACTIVE_DIRTY: number;
 export declare const REACTIVE_RECOMPUTING_DEPS: number;
 export declare const REACTIVE_IN_HEAP: number;
 export declare const REACTIVE_IN_HEAP_HEIGHT: number;
+/** L2 — the node sits on its owner's parked frame (`_x._pendingFirstChild`):
+ * it is the displayed frame until the owner's commit disposes it. Set by
+ * `markDisposal` over the parked subtree; carried through every per-pass
+ * flag wipe (#3543). Scheduling reads it once, at the heap pop: a zombie's
+ * recompute is deferred past the seam (`deferZombie`). */
 export declare const REACTIVE_ZOMBIE: number;
 export declare const REACTIVE_DISPOSED: number;
-export declare const REACTIVE_OPTIMISTIC_DIRTY: number;
+/** L2 — this pass read the future (a tracked read of a CONFIG_HELD node).
+ * Lives for the pass only: set by `read`, consumed by `recompute`'s publish
+ * (a first pass that read the future is born held, A29), wiped with the
+ * pass's other per-pass bits. */
+export declare const REACTIVE_JOINED: number;
 export declare const REACTIVE_SNAPSHOT_STALE: number;
 export declare const REACTIVE_LAZY: number;
 export declare const REACTIVE_MANUAL_WRITE: number;
-/**
- * The pending recompute is a re-ask of the same question: `refresh()` dirtied
- * the node while no tracked input changed value. Cleared whenever a real
- * value-change notification arrives (`insertSubs`), and consumed by
- * `recompute` into the node's `_reask` classification — a quiet (re-ask)
- * pending window does not read as pending (question-scoped pending model).
- */
-export declare const REACTIVE_REASK: number;
+/** L2, rule 3 — the node's LAST pass was a render effect's read of the
+ * future as committed (`frameRead`): the frame shows the committed world
+ * beside a future it also derives from, and re-derives at the landing.
+ * Survives its own pass's wipe; the next pass's wipe clears it (a pass that
+ * re-derived the frame — in the future, or without the held read — owes the
+ * landing nothing). The landing consumes it (the transaction's `_reruns`). */
+export declare const REACTIVE_FRAME_READ: number;
 /**
  * A dependency write landed while this subscriber was mid-recompute — a
  * nested pull committed beneath one of its reads (#3037). The heap refuses
@@ -27,6 +35,44 @@ export declare const REACTIVE_REASK: number;
  * either re-read later in the pass (fresh) or trimmed with it (not a dep).
  */
 export declare const REACTIVE_MISSED_WAKE: number;
+/** A `refresh()` asked this node to re-ask its question (A19 exc. 2, A24):
+ * consumed by the next pass, which — going pending — classifies its flight
+ * quiet (`_x._reask`). */
+export declare const REACTIVE_REASK: number;
+/** The pass was served a node's ambient staging — written this flush, not
+ * held. If the flush parks, the pass is the frame's with it (the same sync
+ * frame as the async): a verdict read cannot break it out. Per pass. */
+export declare const REACTIVE_STAGED_READ: number;
+/** The pass entered a verdict window (`isPending`/`latest`). Per pass: a
+ * pass that did not keeps CONFIG_VERDICT no longer — the frame-reader
+ * posture lasts exactly as long as the probing does. */
+export declare const REACTIVE_PROBED: number;
+/** Lanes — the node (a lane's member) was dirtied by the lane's own
+ * re-staging (a re-guess, lane work re-derived): its next pass is the
+ * lane's from the start (`recompute`), not a stale reader's re-run by an
+ * unrelated write (#3460). Consumed by the pass. */
+export declare const REACTIVE_LANE_DIRTY: number;
+/** Lanes (plan sec. 28) — the pass read a lane's value as lane work (`enterLane`): a
+ * tracked derivation's read of displayed optimism, a verdict read routed
+ * into the holder's verdict lane. A pass in a lane's seat that read none of
+ * its world has left the lane (`recompute`'s tail). Per pass. */
+export declare const REACTIVE_LANE_READ: number;
+/** Lanes (plan sec. 28) — a render effect in the frame's seat was served the screen
+ * for a lane's node (`laneRead`: a stale reader of a lane that has not
+ * shown). Its pass computing exactly what it last applied has nothing to
+ * run — an effect has no comparator, and the guess's notification is not a
+ * change it can see. Per pass. */
+export declare const REACTIVE_SCREEN_READ: number;
+/** A verdict reader whose probe was answered before the flush had a
+ * transaction (verdict.ts `watchVerdict`): the seam re-runs it even if a
+ * later read of the same pass routed it into a verdict lane — that was not
+ * the probe's answer (lanes.ts). Per pass. */
+export declare const REACTIVE_PROBE_UNANSWERED: number;
+/** 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). */
+export declare const REACTIVE_WINDOW: number;
 export declare const CONFIG_OWNED_WRITE: number;
 export declare const CONFIG_NO_SNAPSHOT: number;
 export declare const CONFIG_TRANSPARENT: number;
@@ -34,46 +80,152 @@ export declare const CONFIG_IN_SNAPSHOT_SCOPE: number;
 export declare const CONFIG_CHILDREN_FORBIDDEN: number;
 export declare const CONFIG_AUTO_DISPOSE: number;
 export declare const CONFIG_SYNC: number;
-export declare const CONFIG_OPTIMISTIC: number;
-export declare const CONFIG_HAS_COMPANIONS: number;
+/** The node has a pass awaiting commit: its live children (and `_disposal`)
+ * are that pass's and were never shown — a re-pass tears them down on the
+ * spot, while the frame parked on `_x._pendingFirstChild` keeps waiting for
+ * the commit. Set by `recompute` when it queues the node. */
+export declare const CONFIG_STAGED: number;
+/** The node's staged state is in the future: the flush that staged it
+ * parked. A write to it, a tracked read of it by a derivation, or a pass
+ * over a derivation holding it joins the future (the flush parks). Render
+ * effects are the frame, not derivations (rule 3): reading it outside a
+ * parking flush they see the committed value and hold nothing, and are
+ * re-derived at the landing. Set at the park seam on every staged node. */
+export declare const CONFIG_HELD: number;
+/** A member of the uncommitted frame a held pass built (ruling A): set at
+ * the park seam on every computed under a staged node (`holdFrame`). Never
+ * shown, it has no screen: its reads are its transaction's, whichever flush
+ * runs it (`bornInto`, #4010). Cleared by its commit. */
+export declare const CONFIG_HELD_FRAME: number;
+/** A15's reveal corollary (#3305): a commit published this flight's inputs
+ * beneath it — the node was pending, nothing staged, when it committed — so
+ * its committed value is torn against the visible frame. A render effect
+ * revealing it cannot be a stale reader: it observes the flight (pends,
+ * holds) instead of showing the pre-flight value. Outlives the flight that
+ * earned it for as long as the node stays pending, and no longer: the
+ * commit that lands a value clears it. */
+export declare const CONFIG_INPUTS_PUBLISHED: number;
+/** Lanes (plan sec. 28) — the node has a lane's value (`_x._lane`): a written guess
+ * (CONFIG_GUESS) or a lane pass's derivation of one. Its lane is
+ * `_x._transaction`. The gate to the lane arm of `read`; `_value` stays the
+ * committed truth and `_pendingValue` a transaction's staging throughout —
+ * a value's world is where it lives, never a bit. */
+export declare const CONFIG_OVERRIDE: number;
+/** A store slot node (`slotSignal`): a leaf, presence, container or deep
+ * witness of a store target. One literal, no `_x` at birth; the last-one-out
+ * sweep dispatches it to the store's shared release hook (graph.ts) instead
+ * of a per-node `_unobserved` closure. */
+export declare const CONFIG_SLOT_NODE: number;
+/** A store slot node whose staging is a USER setter's proposal, not its
+ * derive's derivation (A34 (3)'s discriminator for derived stores — the
+ * leaf twin of REACTIVE_MANUAL_WRITE). Set by the user setter, cleared by
+ * the derive's own write to the key. */
+export declare const CONFIG_MANUAL_WRITE: number;
+/** D-41: the staged value in `_pendingValue` is an error — an
+ * answer of the held frame, published at its landing like a value. */
+export declare const CONFIG_STAGED_ERROR: number;
+/** Lanes — the node carries a written guess (`optimisticWrite`): its own
+ * source recomputing it, or a plain write landing on it, is the truth
+ * (`supersede`). A lane's derived staging is not. */
+export declare const CONFIG_GUESS: number;
+/** The node's pass read a verdict (`isPending`/`latest`): a dependency going
+ * pending is a question for its next pass — the verdict changed — so the
+ * propagation re-derives it instead of marking it pending (as a kept-tail
+ * link does, A30). Set at the window, never cleared: a reader that stopped
+ * asking re-derives once and goes pending through its own read. The same
+ * bit as REACTIVE_PROBED: a pass's probe (or a read of a verdict memo,
+ * core.ts `read`) carries into the config at its end without a shift. */
+export declare const CONFIG_VERDICT: number;
+/** A dependency's status is a question for this node's pass, not a fact
+ * about its current one: the propagation re-derives it instead of marking
+ * it, for errors as for pending (as CONFIG_VERDICT). A boundary's output
+ * (show the content, or the fallback) and its `on` node (boundaries.ts); a
+ * promise over an expression (`resolve`/`until`, signals.ts: the pass reads
+ * the error and rejects, or re-asks a pending source). */
+export declare const CONFIG_REDERIVE: number;
+/** An answered `createDeferred` node (deferred.ts): held because a
+ * downstream hold staged its landing, its re-pass is a lagging question,
+ * not an answer, and joins no transaction (D-40). */
+export declare const CONFIG_LAGS: number;
+/** The reader wants the truth, not the lane's guess (`until`, signals.ts):
+ * a read of displayed optimism serves the base the guess covers, makes the
+ * pass no lane's, and the truth landing wakes it even when it confirms the
+ * guess (the one case ordinary subscribers are not told — A17's silence). */
+export declare const CONFIG_AUTHORITATIVE: number;
 export declare const CONFIG_HAS_SNAPSHOT: number;
-export declare const CONFIG_HAS_LANE: number;
-/** Set on a FIREWALL computed when any of its child signals creates an
- * isPending()/latest() companion. Gates the post-recompute child-companion
- * walk (#3038): a store computed's `_child` chain holds one node per
- * materialized leaf, so walking it unconditionally makes every update cost
- * O(all leaves ever read). Sticky — set at companion creation, never
- * cleared; sync-only apps never set it and never pay the walk. */
-export declare const CONFIG_CHILD_COMPANIONS: number;
-/** Set on a computed when its first firewall child signal is installed
- * (projection machinery). Gates markNode's firewall-children walk with one
- * masked read of the always-present _config — the walk's old `_child` read
- * moved into the cold extension (§12), and an unconditional `_x` deref per
- * marked node measurably taxed the propagation hot path (diamond -22%). */
-export declare const CONFIG_FW_CHILDREN: number;
+/** Fresh-pull reader (awaitable `refresh()`'s waiter effect): a read of a
+ * dirty source recomputes it inline even when the height gate defers to the
+ * flush. Closes the same-flush ordering race where a waiter created
+ * alongside a refresh() mark read the PRE-re-ask value as settled and
+ * delivered stale; with the pull, the waiter either parks on the re-ask's
+ * pending window (async — woken by the settle walk, which runs on every
+ * landing including equal-value ones) or serves its sync answer. resolve()
+ * deliberately keeps that race — its contract is "first settled value"
+ * (#2930), not "next quiescent state". */
+export declare const CONFIG_FRESH_READ: number;
+/** A28 (4): the node was written inside a recompute that ran OUTSIDE a flush
+ * (a creation-time compute — boundary machinery, a mapArray's first run). Such
+ * a write is promoted at that recompute's end: readers in the same block see
+ * it. Cleared when the next flush begins; set only on that rare path. */
+export declare const CONFIG_PROMOTED: number;
+/** Observe tiers only: the node is framework plumbing (the `solid-js/refresh`
+ * HMR memo between a component's root and its body) — it has no name, is no
+ * segment of any owner path, and the attribution engine records nothing about
+ * it (creation, re-runs, checks) and does not count it toward another scope's
+ * WIDE_SCOPE_DEPS or a write's engine-side HUGE_FAN_OUT, while the nodes it
+ * owns stay fully observed.
+ * Set from the internal `_plumbing` option at creation; never set in prod. */
+export declare const CONFIG_PLUMBING: number;
+/** Observe tiers only: a framework scope wide by construction (`@solidjs/web`'s
+ * insert child-resolution pass, which must track each row's resolved child) —
+ * the attribution engine's WIDE_SCOPE_DEPS skips it; the always-on HUGE_FAN_IN
+ * does not. Set from the internal `_wide` option at creation by dev builds only
+ * (the observe artifact mangles the option name, as it does `_plumbing`). */
+export declare const CONFIG_WIDE: number;
+/** Observe tiers only: a framework async node that supersedes its own flights
+ * by design (`@solidjs/web/frames`' per-key slot-arg memo, re-run by every
+ * re-shipped record while the arg is still pending) — the attribution
+ * engine's ABANDONED_FLIGHTS skips it; its flight records and the feedback
+ * fold's counts are unchanged. Set from the internal `_supersedes` option at
+ * creation by dev builds only (the observe artifact mangles the option name,
+ * as it does `_wide`). */
+export declare const CONFIG_SUPERSEDES: number;
+/** Observe tiers only: the memo `merge()` creates for a function source — a
+ * key bag readers consume key by key, built by the framework (a compiled
+ * component spread) with options no user can reach. The attribution engine's
+ * UNSTABLE_MEMO_OUTPUT skips it: a fresh-but-equal bag is the idiom
+ * (`{...(on() ? { a } : {})}`), and the advice (`equals`) cannot be applied
+ * (#4256). Set through `_extraConfig` by observe builds only. */
+export declare const CONFIG_KEY_BAG: number;
+/** The frame (rule 3, D-3): a render effect (set at creation, as
+ * `EFFECT_RENDER << 23` — keep the two in step), and a boundary's tree and
+ * output (boundaries.ts) — structure between the content and the render
+ * effect that shows it, not a user derivation of the content. Outside a
+ * hold's own flush it reads that hold's values as committed and is
+ * re-derived at its landing, and a re-pass of it publishes mainline: it
+ * joins nothing, so two mounts under one boundary made in separate flushes
+ * keep their holds apart (D-4, S-5 rows 1′–3′, #4283). */
+export declare const CONFIG_FRAME: number;
+/** The node's last answering pass registered a flight: an async memo. Kept
+ * by the verdict engine alone (verdict.ts `holdWork`), which reads it. */
+export declare const CONFIG_ASYNC: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;
 export declare const STATUS_UNINITIALIZED: number;
+/** An error that answered a node's first read (no value has ever landed):
+ * the error, not UNINITIALIZED, is its status while shown, but a re-ask
+ * makes it uninitialized-pending again — it still has no value (#4244). */
+export declare const STATUS_NO_VALUE: number;
+/** `catchHook`'s answer when the catcher is a boundary re-armed by
+ * `on` (truthy, as any catch): what it collects is its own, not the hold's. */
+export declare const CAUGHT_REARMED = 2;
 export declare const EFFECT_PURE = 0;
 export declare const EFFECT_RENDER = 1;
 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: {};
 /**
@@ -95,3 +247,8 @@ export declare const $REFRESH: unique symbol;
 export type Refreshable<T> = T & {
     readonly [$REFRESH]: any;
 };
+/** `Set` under a module binding. Bundlers mark a bare `new Set()` pure with
+ * a `/* @__PURE__ *\/` comment that survives minification (16 bytes a site);
+ * a construction through a binding carries none. Same constructor, so the
+ * same objects. */
+export declare const NewSet: SetConstructor;

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

@@ -0,0 +1,54 @@
+/**
+ * Dev: duplicate-copy detection.
+ *
+ * Two copies of Solid on a page are only a bug when they meet: one copy's
+ * code runs inside the other's computation or component and finds no owner
+ * or listener of its own (each copy keeps them in its own module state), so
+ * it neither reacts nor sees the other's providers. That is the shape of
+ * every duplicate report on record: a library's precompiled JSX on copy B
+ * reading the app's props or signals from copy A, a runtime that bundled its
+ * own solid-js. Copies that never meet (a devtools panel rendering into its
+ * own root, an isolated widget) are fine at any version, so nothing is
+ * checked when a copy loads.
+ *
+ * Every copy from 2.0 on shares one global record, `Solid$$copies`. It is a
+ * contract between all future versions of Solid, so its shape never changes:
+ *
+ * - `copies`: each copy adds 1 when it loads.
+ * - `running`: while `copies > 1`, each copy names itself here (an object
+ *   with a `rooted` boolean, compared by identity) around its computations
+ *   and components, and restores the previous value after.
+ *
+ * A copy that sees `copies < 2` skips the slot entirely, so a page with one
+ * copy pays one property read per check. v1 keeps its own load-time `Solid$$`
+ * check, which this never sets, so neither side warns about the other.
+ */
+interface SolidCopy {
+    /** This copy has created a root of its own (it renders by itself). */
+    rooted: boolean;
+}
+interface SolidCopies {
+    copies: number;
+    running: SolidCopy | undefined;
+}
+declare global {
+    var Solid$$copies: SolidCopies | undefined;
+}
+export declare function markCopyRooted(): void;
+/**
+ * Marks this copy as the one running; returns the slot's previous value. A
+ * nested run of the same copy (most runs inside a flush) only reads the slot.
+ */
+export declare function enterCopy(): SolidCopy | undefined;
+export declare function exitCopy(prev: SolidCopy | undefined): void;
+/** @internal Runs `fn` with this copy marked as the one running. */
+export declare function runAsSolidCopy<T>(fn: () => T): T;
+/** @internal An ownerless component or context read: warns if another copy is running. */
+export declare function checkForeignOwnerless(): void;
+/**
+ * An untracked read: warns if another copy's computation is running, unless
+ * both copies render through roots of their own (an app calling into an
+ * isolated copy's API, which reads its own state untracked by design).
+ */
+export declare function checkForeignRead(): void;
+export {};