@solidjs/signals 2.0.0-rc.11 → 2.0.0-rc.14

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

@@ -144,8 +144,9 @@ export interface RerunEvent {
      * effect phase re-fires on every recompute), so the engine derives this
      * fact itself: an effect run whose compute output is identical to the
      * previous run's reports `changed: false` — the phase re-fired with the
-     * same input, pure waste. Side-effect-only computes (`undefined` output)
-     * are exempt: identity of `undefined` proves nothing about their work.
+     * same input, pure waste. Side-effect-only computes (`undefined` output —
+     * effects, projections, memos that work by writing) report `true`:
+     * identity of `undefined` proves nothing about their work.
      * Summed as `wastedMs` in costs() (plain, non-held runs only — see
      * `phase`).
      */
@@ -390,8 +391,11 @@ export interface AttributionOptions {
     } | false;
     /**
      * Wide-scope warning: emit a diagnostic when a scope's dependency count
-     * reaches this (default 30) — the coarse-read / helper-leak signature.
-     * Re-warns only if the count then grows by another 50%. `false` disables.
+     * reaches this (default 200) — the coarse-read / helper-leak signature.
+     * Re-warns only if the count then grows by another 50%. HMR plumbing is
+     * not counted, and in dev builds the renderer's insert child-resolution
+     * pass (which must track every row's resolved child) is not judged;
+     * HUGE_FAN_IN (2000, always on) still covers both. `false` disables.
      */
     wideDeps?: number | false;
     /**
@@ -437,8 +441,8 @@ export interface AttributionOptions {
      * same code the always-on core check emits from GRAPH_SIZE_WARN_AT (2000)
      * up, with `data.write` naming the invalidation; the engine hands over to
      * the core there, so one change never carries two findings. Once per
-     * node, re-warning once the count has grown by another 500. `false`
-     * leaves only the always-on threshold.
+     * node, re-warning once the count has grown by another 500. HMR plumbing
+     * subscribers are not counted. `false` leaves only the always-on threshold.
      */
     fanOut?: number | false;
     /**
@@ -511,7 +515,9 @@ export interface AttributionOptions {
      * abandons `count` flights within `windowMs` — each superseded by the
      * next before it landed (default 3 / 1000ms: the request-per-keystroke
      * signature, every input asking again and the answers discarded). Once
-     * per window per source. `false` disables.
+     * per window per source. In dev builds a framework node that supersedes
+     * its own flights by design (a frames slot arg re-read by each re-shipped
+     * record) is not judged. `false` disables.
      */
     abandonedFlights?: {
         count: number;
@@ -815,6 +821,15 @@ export interface NavigationEvent {
     params?: Readonly<Record<string, string | undefined>>;
     /** When the navigation was requested (`performance.now()` clock). */
     at: number;
+    /**
+     * The route the document arrived on, declared by the router at its initial
+     * match (`NavigationRef.initial`): `at` is the document's navigation start
+     * (`0` unless the router passed its own), there is no `from`, `writes` is
+     * `0`, and it settles `committed` when the router's frame closes — the
+     * record names the route the page loaded as; its timing is Navigation
+     * Timing's, not the runtime's.
+     */
+    initial?: true;
     /** The user interaction it ran under, when known — a link click. */
     interaction?: ChangeOrigin;
     /** Root writes the frame performed, redirect hops included. */
@@ -852,7 +867,11 @@ export interface InteractionEvent {
      * INP counts as input delay. Present only when `at` predates the frame.
      */
     inputDelayMs?: number;
-    /** Wall time of the handler itself, entry to return. */
+    /**
+     * Wall time of the handler itself, entry to return — for the frames of one
+     * event (`InteractionRef.event`), the first listener's entry to the last
+     * one's return, as Event Timing measures processing.
+     */
     handlerMs: number;
     /** Root writes attributed to the frame: the handler's, and those of frames it opened (a navigation). */
     writes: number;
@@ -875,7 +894,8 @@ export interface InteractionEvent {
     outcome?: "idle" | "committed" | "held";
     /**
      * The handler returned a thenable (`async () => { await save(); … }`) and
-     * the record waited for it: handler return → the promise settling, in
+     * the record waited for it: handler return → the promise settling (the last
+     * one, when several listeners of one event returned one), in
      * milliseconds, capped at `ASYNC_HANDLER_CAP_MS`. The continuation runs
      * with no frame on the stack, so writes it makes are not attributed to
      * this interaction — only its duration is. Absent when the handler

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,39 @@ 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;
 export declare const CONFIG_OWNED_WRITE: number;
 export declare const CONFIG_NO_SNAPSHOT: number;
 export declare const CONFIG_TRANSPARENT: number;
@@ -34,51 +75,65 @@ 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;
+/** 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;
+/** 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. */
+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;
+/** 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;
-/** Authoritative-view reader (`until()`): while this node computes, reads
- * dodge active optimistic OVERRIDES only — the predicate must observe
- * arriving truth, never the caller's own tentative writes (which would
- * trivially satisfy it). Everything else reads normally, INCLUDING
- * transition-staged `_pendingValue`: staged data is authoritative (optimism
- * lives only in override slots), and a hold that refused staged reads would
- * deadlock on data the open transaction itself is holding (a refresh the
- * action issued lands staged and cannot commit until the hold releases).
- * read() checks the bit on the reading computation (`context`) directly — no
- * ambient flag — so a shared computed the predicate pulls recomputes as
- * itself (no bit) under the normal view, and its cache never forks. */
-export declare const CONFIG_AUTHORITATIVE_READ: number;
-/** Sticky mark: an authoritative-view reader read this node PAST an active
- * override. The ack shape — an authoritative arrival EQUAL to the override —
- * rides paths that are deliberately silent under A17 (every ordinary reader
- * sees the override, so an equal landing changes nothing for them). A marked
- * node notifies those readers on such paths anyway, so the landed truth is
- * seen without re-firing ordinary subscribers. Never cleared — only nodes an
- * until() predicate observed mid-override pay. */
-export declare const CONFIG_AUTHORITATIVE_OBSERVED: number;
-/** Promise-delivery effect (resolve()/until()): commits its computed value
- * directly even when recomputing under its own held transition. These
- * effects deliver applies on a microtask (#2930) instead of the stashed
- * effect queues, so the value must ride the same immediate schedule — a
- * staged value with an immediate apply delivers stale state (resolve) or
- * deadlocks the hold (until). Safe because the node is a private leaf: no
- * subscriber reads an effect's value, only its own apply does. */
-export declare const CONFIG_DIRECT_COMMIT: 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
@@ -89,118 +144,33 @@ export declare const CONFIG_DIRECT_COMMIT: number;
  * deliberately keeps that race — its contract is "first settled value"
  * (#2930), not "next quiescent state". */
 export declare const CONFIG_FRESH_READ: number;
-/** HELD truth (#3164): this node's staged `_pendingValue` is confirming
- * truth riding a transaction that retains optimism, revealed only at that
- * transaction's settle. Two arming sites, one meaning: the store fold
- * (a landing staged into the retaining transaction) and until()'s
- * flip-entanglement (a foreign carrier's staged write, stolen when it
- * flipped the awaited predicate truthy). Override-covered nodes never
- * arm: the override is their display and its revert their notification
- * (A17).
- *
- * To a DERIVING reader the truth is a staged value like any other: a memo
- * or user effect served it enters the transaction and is held with it
- * (A29), so a pass that composes it with a superseded override's truth
- * composes ONE staged world — never staged truth beside committed
- * neighbours (#3568: the mask served the retaining transaction's own pass
- * the landed `length` through the override while the rows past it stayed
- * committed, and `<For>` walked into a hole). Stale readers of a foreign
- * transaction keep committed through the stale-of-foreign clause,
- * untracked reads keep committed (Rule 1), and latest() and until()'s
- * predicate tunnel through — the exemption that keeps holds deadlock-free.
- *
- * The one reader the mark gates is a LANE pass, owning transaction or not
- * (ruled 2026-09-22, superseding #3589's owner exemption): a lane applies
- * its frame display-ahead at the park, so a lane pass served the truth
- * would paint the confirmation beside the optimism it confirms —
- * `saving=true` beside the saved row, a frame no timeline contains
- * (GabbeV's union tear). It keeps committed and is re-run by the reveal's
- * post-revert wake. A lane under the retaining transaction owns its
- * overrides and its lane cargo (`ownsLane`), not the transaction's
- * confirming truth. Cleared at commit (the commit IS the reveal);
- * subscribers masked during the hold are woken by finalizePureQueue's
- * post-revert pass. */
-export declare const CONFIG_HELD_TRUTH: number;
-/** SLOT node (store leaf): created through `slotSignal` with `_host`/`_key`
- * backrefs baked into the literal. The unobserved sweep dispatches these to
- * the ONE shared hook (`setSlotUnobserved`) instead of a per-node closure
- * held in a per-node extension — store mounts materialize one signal per
- * touched leaf, so per-node allocations (options object, equals closure,
- * unobserved closure, NodeExtension) were the measured create-floor bytes
- * (warm dbmon profile: store node machinery ~36% + GC ~29%). */
-export declare const CONFIG_SLOT_NODE: number;
-/** Optimistic node whose own source arrived with a value DIFFERENT from its
- * active override (A18 supersession, #3331). The override survives only as
- * the displayed value — untracked reads and the applied frame keep it until
- * the owning transaction commits — while the graph has already moved to the
- * staged truth in `_pendingValue`: tracked readers see it and the corrected
- * cascade is that transaction's held work. Set by the two own-source write
- * paths (asyncWrite, transition-held recompute); cleared by a fresh optimistic
- * write (a new override re-masks) and by the revert. */
-export declare const CONFIG_OVERRIDE_SUPERSEDED: number;
-/** HELD children (#3404): this node's `_firstChild` chain (and `_disposal`
- * list) was built by a recompute whose result has not committed — a staged
- * value, a pending window, or a run under a held transaction. A later
- * recompute may tear those children down immediately: nothing observable
- * was ever built on them. Unset, the children belong to the committed frame
- * and a recompute defers them as zombies (`_pendingFirstChild`) until this
- * node commits — regardless of whether the recompute runs under a
- * transaction. A parked node (status propagation stamps `_transition`
- * without recomputing) recomputed when its source lands otherwise disposed
- * its committed children mid-hold, running their cleanups before the
- * transaction's atomic reveal. Cleared by `commitPendingNode`. */
-export declare const CONFIG_HELD_CHILDREN: number;
-/** The frame parked in `_pendingFirstChild` / `_pendingDisposal` is a LANE
- * frame (#3662, A15 lanes corollary): an effect's lane pass direct-commits,
- * so the frame it replaces leaves the screen when the lane's queue applies
- * the run (A30) — not at the action's commit like #3404's transaction
- * zombies, and not at the pass (a held lane defers the run). Drained by the
- * lane's render entry the parking site pushed ahead of the new frame's
- * effects (cleanups before side effects), by `commitPendingNode` if a hold
- * commits the node first, or with the owner's death. While set the parked
- * frame is not a hold (the node is not queued or stamped for it), a
- * superseding pass disposes the never-shown live children on the spot, and a
- * lane-channel dirty on a member is cancelled (`laneZombie`). Effects only: a
- * memo's lane pass publishes an override (A17, #3479). */
-export declare const CONFIG_LANE_FRAME: number;
-/** In-flight async node whose inputs were PUBLISHED while it was pending: a
- * batch or transaction committed with the node still `STATUS_PENDING` (an
- * unobserved flight, #3305), so the inputs are on screen and the node's
- * committed `_value` is stale against them. Governs read()'s reveal
- * carve-out: a stale (render) reader in some OTHER transaction may show a
- * foreign-held pending node's committed value — parallel transactions, no
- * entanglement — only while that value is coherent with the visible frame,
- * i.e. while the flight's inputs are themselves held (unpublished) and not
- * lane-revealed. Set by `commitPendingNodes`; cleared when the node next
- * enters pending fresh (a new flight from a settled state). */
-export declare const CONFIG_INPUTS_PUBLISHED: 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;
-/** A28 for same-tick adoption: the node was staged outside a flush and then
- * adopted by a transaction (initTransition) before any flush carried the
- * staging — the stamp says "held", but nothing flushed is staged for it, so
- * on no channel is the write visible yet: `latest()` answers the committed
- * value, the verdict sees nothing pending (as the store's leaves already did
- * through their own selection). Cleared when the carrying flush re-stamps the
- * transaction's pending nodes (reassignPendingTransition). */
-export declare const CONFIG_ADOPTED_UNFLUSHED: number;
-/** The node's active override is a DERIVED one: a lane pass published its
- * speculative result into the override slot instead of `_value` (lanes
- * stage — an optimistic derivation is an override, #3479). Its truth is not
- * `_value` but a recompute from its inputs' truth, so the body-end
- * supersession (`endOptimism`) and the authoritative-flight blockage
- * (`transitionBlocked`) skip it; the revert drops the override and re-derives
- * it (`resolveOptimisticNodes`). Cleared with the override. */
-export declare const CONFIG_DERIVED_OVERRIDE: 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), while the nodes it owns stay fully observed.
+ * 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;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;
@@ -209,24 +179,8 @@ export declare const EFFECT_PURE = 0;
 export declare const EFFECT_RENDER = 1;
 export declare const EFFECT_USER = 2;
 export declare const EFFECT_TRACKED = 3;
-/** OR-ed into the `type` a lane passes to its effect runners: lane runs
- * apply ahead of their transaction and are exempt from ownership parking. */
-export declare const LANE_RUN = 4;
 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: {};
 /**