@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.9

package/dist/types-cjs/core/attribution.d.cts

@@ -1,495 +0,0 @@
-import type { Computed } from "./types.cjs";
-/**
- * Dev-mode "why did this run" attribution.
- *
- * The runtime already knows the full dependency set of every scope; this
- * module surfaces it. Every value commit stamps its node with a ChangeRecord
- * (a write, an async landing, a refresh() invalidation, or a derived change
- * whose `causes` chain back to root writes). When a computation re-executes,
- * the deps whose stamp is newer than the node's last run are its causes, so
- * each re-run can be explained as a chain down to the originating write:
- *
- *   [why-run] effect "docTitle" ran (run 4)
- *     ← memo "userLabel" changed (#6)
- *       ← signal "notifications" write (#5) 2 → 3
- *
- * This module is the attribution ENGINE: all semantics live here, and it is
- * decoupled from the core. `enable()` installs it into the core's narrow
- * dev-only hook points (attribution-hooks.ts); core's only obligation is to
- * call those hooks with true facts. Disabled cost is one null check per hook
- * site; prod builds fold the sites out entirely. The same hook surface is the
- * intended substrate for external consumers (devtools) — one mechanism, two
- * front-ends.
- */
-export type ChangeKind = "write" | "derived" | "async" | "refresh";
-/**
- * Provenance of a root change: the imperative frame that performed it.
- *
- * - `interaction` — a user event handler (the web runtime marks dispatch via
- *   `withInteraction`). `name` is the event type, `target` the element hit
- *   (`button#next "Next →"`), `at` the dispatch time on the `performance.now()`
- *   clock — the base every feedback-latency number is measured from.
- * - `effect` — an effect callback (`name` = the effect's name; `run` = the
- *   compute run whose effect phase performed the write, when that run was
- *   recorded — so a write can be joined to the re-run that produced it).
- * - `action` — a step of an `action()` generator (`name` = the generator's
- *   name, when it has one). Writes after an `await` (not a `yield`) run in a
- *   bare microtask and stamp `external` — the documented escape.
- * - `async` — an async landing (`name` = the node whose flight landed).
- * - `external` — none of the above: timers, sockets, promise callbacks, setup.
- *
- * `interaction` on a non-interaction frame is the user event the frame runs
- * under — an action started by a click, an effect whose run was caused by a
- * click's write, a landing whose flight a click started. It is what lets
- * every downstream cost be keyed by the interaction that paid for it.
- */
-export interface ChangeOrigin {
-    kind: "interaction" | "effect" | "action" | "async" | "external";
-    name?: string;
-    target?: string;
-    at?: number;
-    interaction?: ChangeOrigin;
-    /** `effect` only: the `RerunEvent.run` of the compute run this callback belongs to. */
-    run?: number;
-}
-/** A user interaction, as the web runtime describes it to `withInteraction`. */
-export interface InteractionRef {
-    /** Event type — `click`, `keydown`, `input`… */
-    type: string;
-    /** The element hit, e.g. `button#next "Next →"`. */
-    target?: string;
-    /** Dispatch time on the `performance.now()` clock; defaults to now. */
-    at?: number;
-}
-export interface ChangeRecord {
-    /** Global monotonic change sequence — orders causes across the app. */
-    seq: number;
-    kind: ChangeKind;
-    name: string;
-    /** Short previews of the value transition (writes only). */
-    prev?: string;
-    value?: string;
-    /** First user frames of the triggering write's stack (opt-in). */
-    stack?: string[];
-    /** For derived changes: the upstream changes that produced this one. */
-    causes?: ChangeRecord[];
-    /** Root changes only: who performed the write. */
-    origin?: ChangeOrigin;
-    /** Root changes only: when the write was stamped (`performance.now()` clock). */
-    at?: number;
-}
-export interface RerunEvent {
-    /** Global monotonic run sequence. */
-    run: number;
-    /** How many times this node has re-run since attribution was enabled. */
-    nodeRuns: number;
-    nodeKind: "effect" | "memo";
-    nodeName: string;
-    node: Computed<any>;
-    /**
-     * The deps that changed since this node's previous run. Empty means the
-     * re-run was not triggered by a tracked value change (creation-adjacent
-     * pull, error retry, or a cause this prototype does not stamp yet).
-     */
-    causes: ChangeRecord[];
-    /** Dependency count after this run. */
-    depCount: number;
-    /** Names of deps this run subscribed to that the previous run did not. */
-    depsAdded: string[];
-    /** Names of deps the previous run had that this run dropped. */
-    depsRemoved: string[];
-    /** Wall time of this run excluding nested recomputes (ms). */
-    selfMs: number;
-    /** Wall time of this run including nested recomputes (ms). */
-    totalMs: number;
-    /**
-     * Whether the run produced a changed value. A PLAIN memo run with
-     * `changed: false` was pure waste — the equality cutoff stopped it from
-     * notifying anyone. Effects run with `_equals: false` in core (their
-     * 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.
-     * Summed as `wastedMs` in costs() (plain, non-held runs only — see
-     * `phase`).
-     */
-    changed: boolean;
-    /**
-     * Which posture this run executed under. "optimistic" = under an
-     * optimistic lane (overlay recompute); "held" = a hold was open or owns
-     * the node (the run may be replayed/settled later); "plain" = an ordinary
-     * committed run. Overlay runs are real work (they count toward time
-     * budgets) but are never blamed as waste, and costs() reports their time
-     * separately as `overlayMs`.
-     */
-    phase: "plain" | "held" | "optimistic";
-    /**
-     * The changed value was parked in `_pendingValue` (held) rather than
-     * committed directly; its reveal happens on the hold's own schedule. Held
-     * runs are excluded from waste accounting.
-     */
-    held: boolean;
-    /** The user interaction this run traces back to through its causes, if any. */
-    interaction?: ChangeOrigin;
-}
-export interface AttributionOptions {
-    /** Pretty-print each re-run to the console (default true). */
-    log?: boolean;
-    /** Capture the user stack frame of each write — slow (default false). */
-    stacks?: boolean;
-    /** Ring-buffer size for `history()` (default 200). */
-    historyLimit?: number;
-    /**
-     * Hot-scope warning: emit a diagnostic when one scope re-runs `count`
-     * times within `windowMs` (default 120 runs / 1000ms — deliberately above
-     * animation-frame cadence, so a legitimate rAF-driven scope at 60/s does
-     * not cry wolf). `false` disables.
-     */
-    hotRuns?: {
-        count: number;
-        windowMs: number;
-    } | 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.
-     */
-    wideDeps?: number | false;
-    /**
-     * Time-budget warning: emit a diagnostic when one scope's summed self-time
-     * inside `windowMs` exceeds `budgetMs` (default 8ms / 1000ms — half a frame
-     * spent in one scope). Unlike `hotRuns` this catches the few-but-expensive
-     * scope that run counts miss. `false` disables.
-     */
-    hotTime?: {
-        budgetMs: number;
-        windowMs: number;
-    } | false;
-    /**
-     * Unstable-output warning: emit a diagnostic when a memo commits a
-     * referentially-new but shallowly-equivalent plain object/array on this
-     * many consecutive runs (default 4). Such a memo's equality gate never
-     * closes — every subscriber re-runs on every upstream change — which makes
-     * it a fan-out amplifier that is otherwise only findable by profiling.
-     * `false` disables.
-     */
-    unstableMemos?: number | false;
-    /**
-     * Written-fan-out warning: emit a diagnostic when a committed root
-     * invalidation (write, refresh, async landing) reaches a node with at
-     * least this many subscribers (default 250). Complements the always-on
-     * HUGE_FAN_OUT graph-size warning, specced against it deliberately:
-     * HUGE_FAN_OUT fires at LINK time from GRAPH_SIZE_WARN_AT (2000) up —
-     * static structure so large it warns even if never written — while this
-     * fires at WRITE time from a much lower bar, because fan-out only costs
-     * anything when the node actually changes. Once per node, re-warning only
-     * on 2x subscriber growth, so the two never spam the same node. `false`
-     * disables.
-     */
-    wideWrites?: number | false;
-    /**
-     * Async-waterfall warning: emit a diagnostic when an async flight that
-     * could only start after an upstream flight resolved (its recompute's
-     * cause chain reaches the upstream's async landing, and its origin
-     * post-dates that landing) forms a sequential chain of 2+ flights, each
-     * of which took at least `minFlightMs` (default 50ms). The duration gate
-     * is one safety valve for what the graph cannot see: a settled
-     * preload/cache hit resolves fast and never warns. In-flight preloads are
-     * absolved by origin: `markFlight()` stamps (and first-seen identity)
-     * prove work predated the upstream landing — parallel, not sequential.
-     * Chains of 2 emit at `info` severity, structured channel only (a
-     * dependent fetch is sometimes intrinsic, and unmarked external preloads
-     * are invisible); 3+ escalate to `warn` with console output. `false`
-     * disables.
-     */
-    waterfalls?: {
-        minFlightMs: number;
-    } | false;
-    /**
-     * Silent-hold warning: emit a diagnostic when a user's writes were held
-     * behind async work for at least `infoMs` (default 100ms — RAIL's "feels
-     * instant" ceiling) and the screen never acknowledged the wait — no
-     * `isPending()`/`latest()` reader downstream of the held writes or their
-     * blockers, no optimistic value, no `affects()` mark, and no lane effect
-     * painted while held. Below `warnMs`
-     * (default 200ms — the INP "good" ceiling) the event is advisory
-     * (structured channel only); at or above it the console gets the finding.
-     * The engine measures to the commit, not the paint, so every number is a
-     * floor on what the user saw; the thresholds sit at the strict end of the
-     * band on purpose. Holds that staged no root write (initial loads, bare
-     * `refresh()`) are never judged: nothing the user did went unanswered.
-     * `false` disables hold tracking altogether (`longHolds` included).
-     */
-    holds?: {
-        infoMs: number;
-        warnMs: number;
-    } | false;
-    /**
-     * Long-hold warning: emit a diagnostic when a hold's quiescent tail — the
-     * time from the LAST write to join it until it committed — reached
-     * `infoMs` (default 500ms), `warn` from `warnMs` (default 1000ms, where
-     * RAIL says the user loses the thread). Measured from the last join so a
-     * hold that keeps taking input (typing) is judged by each wait, not by its
-     * lifetime. A hold this long is past what a stale screen should carry,
-     * acknowledged or not: the honest UI is a fallback, which a `Loading`
-     * boundary gives only when it has not revealed yet or its `on` prop
-     * changed. Reported as LONG_HOLD when the hold was acknowledged; a silent
-     * long hold stays one SILENT_HOLD with the boundary repair appended.
-     * `false` disables.
-     */
-    longHolds?: {
-        infoMs: number;
-        warnMs: number;
-    } | false;
-}
-export interface ScopeCost {
-    name: string;
-    kind: "effect" | "memo";
-    runs: number;
-    selfMs: number;
-    /**
-     * Self-time of PLAIN, non-held runs that produced an unchanged value —
-     * the recoverable number. Overlay runs (optimistic/transition) are never
-     * counted here: an optimistic recompute landing back on the committed
-     * value is the mechanism working, not waste.
-     */
-    wastedMs: number;
-    /** Self-time spent in optimistic/transition (overlay) runs. */
-    overlayMs: number;
-}
-export interface WriteCost {
-    /** Root cause name (a signal write, async landing, or refresh target). */
-    name: string;
-    /** Number of downstream re-runs this root triggered. */
-    runs: number;
-    /** Summed self-time of every downstream re-run it caused. */
-    downstreamMs: number;
-}
-/**
- * Run `fn` as the handler of a user interaction: every root write it performs
- * (and every action step or effect the write causes) carries the interaction
- * as provenance. The web runtime wraps event dispatch in this; it is dev-only
- * and safe to call with no engine enabled.
- */
-export declare function withInteraction<T>(ref: InteractionRef, fn: () => T): T;
-/** `click on button#next "Next →"`, `effect "syncTitle"`, `action "save"`, … */
-export declare function formatOrigin(origin: ChangeOrigin): string;
-export declare function formatRerun(event: RerunEvent): string;
-export interface Attribution {
-    enable(opts?: AttributionOptions): void;
-    disable(): void;
-    subscribe(listener: (event: RerunEvent) => void): () => void;
-    history(): readonly RerunEvent[];
-    /** Re-run history for one node — pass a memo/effect accessor or raw node. */
-    why(target: unknown): RerunEvent[];
-    /** Current dependency names of one scope — the devtools subscription view. */
-    subscriptions(target: unknown): string[];
-    /**
-     * Aggregated cost tables since enable(): `scopes` ranked by self-time
-     * (with `wastedMs` = time spent on unchanged-value runs), `writes` ranked
-     * by total downstream re-run time each root write caused.
-     */
-    costs(): {
-        scopes: ScopeCost[];
-        writes: WriteCost[];
-    };
-    /**
-     * Every graph-provable sequential flight chain observed since enable()
-     * (ring-buffered like history()). Facts, not verdicts: chains are recorded
-     * regardless of the duration gate — the ASYNC_WATERFALL diagnostic is the
-     * thresholded view of the same data.
-     */
-    waterfalls(): readonly WaterfallRecord[];
-    /**
-     * Every settled transition hold that staged at least one root write since
-     * enable() (ring-buffered like history()). Facts, not verdicts: recorded
-     * regardless of duration or acknowledgment — the SILENT_HOLD diagnostic is
-     * the thresholded, unacknowledged subset.
-     */
-    holds(): readonly HoldEvent[];
-    /**
-     * What the user waited on, folded from holds() and the interaction on each
-     * re-run: `sources` ranks async sources by the silent time writes spent
-     * held behind them (with which affordances answered, how often, and which
-     * interactions were held); `interactions` ranks user events by the total
-     * time they cost — re-run work caused (long-flush hazard) beside time held
-     * (silent-hold hazard). Facts at every duration; SILENT_HOLD is the
-     * thresholded verdict. Two more tables round out the picture: `flights`
-     * counts each async source's flights and how many were abandoned before
-     * landing (the re-ask storm), and `fallbacks` measures how long each
-     * loading boundary showed its fallback and how often that was a flash.
-     */
-    feedback(): AttributionFeedbackTables;
-    /**
-     * Cooperative preload declaration: stamp a flight object (promise or async
-     * iterable) with its true kickoff time BEFORE the reactive graph sees it.
-     * A route preloader or query cache calls this on the promise it hands out
-     * (on the WRAPPER it mints, with the original kickoff time — wrapping
-     * defeats identity tracking otherwise); any dependent that later awaits it
-     * is then judged against the real start — work already in the air when its
-     * upstream landed is parallel, never a waterfall link. Callable while
-     * attribution is disabled (marks made at navigation time must survive a
-     * later enable()). Dev-only, like the whole DEV surface.
-     */
-    markFlight(flight: object, startedAt?: number): void;
-    /**
-     * Run `fn` as a user interaction's handler: root writes inside stamp it as
-     * their origin, and actions/effects/flights it causes carry it. The web
-     * runtime wraps every event dispatch in this; custom renderers and test
-     * harnesses call it themselves. Callable while attribution is disabled.
-     */
-    withInteraction: typeof withInteraction;
-    format: typeof formatRerun;
-    formatOrigin: typeof formatOrigin;
-}
-/** One landed flight: its node name, wall duration, and upstream chain. */
-export interface FlightLink {
-    name: string;
-    ms: number;
-}
-export interface WaterfallRecord {
-    /** Sequential flights, oldest first, ending at the flight that landed. */
-    chain: FlightLink[];
-    /** Summed wall time of the chain — the serialized cost. */
-    sequentialMs: number;
-}
-export interface HeldWrite {
-    name: string;
-    prev?: string;
-    value?: string;
-    origin?: ChangeOrigin;
-}
-export interface HoldEvent {
-    /**
-     * Wall time the user waited: from the interaction that performed the held
-     * writes when one is known (`interaction.at`) or the first flush that
-     * parked them, whichever is earlier, to the commit.
-     */
-    holdMs: number;
-    /**
-     * The quiescent tail: from the LAST held write to join (the user's final
-     * input) to the commit. Equal to `holdMs` for a single write; shorter when
-     * the hold kept taking input. The LONG_HOLD measure.
-     */
-    tailMs: number;
-    /** The user interaction whose writes were held, when the stamp is known. */
-    interaction?: ChangeOrigin;
-    /** Flushes that ended with the hold still open. */
-    flushes: number;
-    /** Root signal writes staged behind the hold (the user's unanswered input). */
-    heldWrites: HeldWrite[];
-    /** Async nodes the hold waited on (union across its parked flushes). */
-    blockers: string[];
-    /**
-     * Feedback the graph provably rendered for this hold, as `"<kind>:<node>"`
-     * — `isPending:posts`, `latest:page`, `optimistic:todos`, `affects:list`.
-     * Empty and `paintedDuringHold === 0` is the SILENT_HOLD signature.
-     */
-    acknowledgedBy: string[];
-    /**
-     * Effect callbacks that ran inside the hold's parked flushes. Mainline
-     * effects are stashed while a hold is open, so these are lane effects —
-     * readers of optimistic values and of `isPending()`/`latest()` companions,
-     * i.e. the screen changing in response to the hold. An unrelated effect
-     * cannot land here: it waits with everything else.
-     */
-    paintedDuringHold: number;
-    /** The hold was opened (or joined) by an `action()`. */
-    action: boolean;
-}
-export interface FeedbackSource {
-    /** The async nodes the holds waited on; empty when an action alone kept them open. */
-    sources: string[];
-    holds: number;
-    /** Summed wait across the holds (ms). */
-    heldMs: number;
-    worstMs: number;
-    /** Holds with no acknowledgment at all — the SILENT_HOLD signature, at any duration. */
-    silent: number;
-    silentMs: number;
-    /** Holds whose only acknowledgment was a `latest()` shadow: the input showed, nothing said "loading". */
-    latestOnly: number;
-    /**
-     * Holds whose quiescent tail (last write to join → commit) reached
-     * `longHolds.infoMs`, acknowledged or not — the LONG_HOLD signature at the
-     * table level. The affordance is not the whole answer there: a fallback
-     * (`Loading` keyed with `on`), a preload, a cache, or a faster source is.
-     * `longMs` sums the tails.
-     */
-    long: number;
-    longMs: number;
-    /** Which affordances answered, and in how many holds — ranked. */
-    acknowledgedBy: {
-        by: string;
-        holds: number;
-    }[];
-    /** Interactions whose writes were held here, ranked by holds. */
-    interactions: {
-        interaction: string;
-        holds: number;
-    }[];
-    /** Distinct root writes that were held. */
-    writes: string[];
-    /** Holds an action opened or joined. */
-    actions: number;
-}
-export interface FeedbackInteraction {
-    /** `click on button#next "Next →"` — type and target; repeated dispatches fold together. */
-    interaction: string;
-    /** Distinct dispatches seen (by dispatch time). */
-    dispatches: number;
-    /** Re-runs traced back to this interaction, and their summed self-time. */
-    runs: number;
-    selfMs: number;
-    /** The most re-run self-time a single dispatch caused — the long-flush hazard. */
-    worstDispatchMs: number;
-    /** Holds this interaction's writes waited in — the silent-hold hazard. */
-    holds: number;
-    heldMs: number;
-    silentMs: number;
-    worstHoldMs: number;
-}
-/** Per async source: how many flights it started, and how many it threw away. */
-export interface FlightStats {
-    source: string;
-    /** Flights registered (a recompute that produced a new promise/iterable). */
-    flights: number;
-    /** Flights that landed (whether or not the value changed). */
-    landed: number;
-    /**
-     * Flights superseded by a newer one before landing — the search-as-you-type
-     * signature when large: every keystroke asked, most answers were discarded.
-     * A debounced/equality-gated derivation between input and fetch is the repair.
-     */
-    abandoned: number;
-    /** Summed and worst wall time of landed flights (ms). */
-    landedMs: number;
-    worstMs: number;
-}
-/** Per loading boundary: how long, and how briefly, it showed its fallback. */
-export interface FallbackStats {
-    /** The boundary's owner path (`<App> › <Feed>`), or `boundary` when unnamed. */
-    boundary: string;
-    /** Times the fallback was shown. */
-    shows: number;
-    /** Summed and worst fallback duration (ms) across completed shows. */
-    shownMs: number;
-    worstMs: number;
-    /**
-     * Shows shorter than the flash window (default 150ms): a spinner that
-     * appeared and vanished — the other end of the SILENT_HOLD spectrum, too
-     * much feedback for too little wait. A preload, a cache, or lifting the
-     * fetch above the boundary removes the flash.
-     */
-    flashes: number;
-}
-export interface AttributionFeedbackTables {
-    sources: FeedbackSource[];
-    interactions: FeedbackInteraction[];
-    /** Async sources ranked by abandoned flights, then by flights. */
-    flights: FlightStats[];
-    /** Loading boundaries ranked by flashes, then by time shown. */
-    fallbacks: FallbackStats[];
-}
-export declare const attribution: Attribution;

package/dist/types-cjs/core/constants.d.cts

@@ -1,159 +0,0 @@
-export declare const REACTIVE_NONE = 0;
-export declare const REACTIVE_CHECK: number;
-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;
-export declare const REACTIVE_ZOMBIE: number;
-export declare const REACTIVE_DISPOSED: number;
-export declare const REACTIVE_OPTIMISTIC_DIRTY: 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;
-/**
- * A dependency write landed while this subscriber was mid-recompute — a
- * nested pull committed beneath one of its reads (#3037). The heap refuses
- * RECOMPUTING nodes, so recompute's tail consumes this latch and reschedules:
- * values the pass read before the nested commit are stale. Only set for
- * links validated this pass (gen-current): a write to an untouched link is
- * either re-read later in the pass (fresh) or trimmed with it (not a dep).
- */
-export declare const REACTIVE_MISSED_WAKE: number;
-export declare const CONFIG_OWNED_WRITE: number;
-export declare const CONFIG_NO_SNAPSHOT: number;
-export declare const CONFIG_TRANSPARENT: number;
-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;
-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
- * 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;
-/** 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). Until the reveal, ordinary
- * readers — lane and speculative recomputes included — keep committed:
- * the staging notified subscribers as a plain write, so without the mask
- * a mid-hold recompute composes live optimism with the confirming truth,
- * a frame no timeline contains (GabbeV's union tear). Authoritative
- * readers (until()'s predicate) and latest() tunnel through — the
- * exemption that keeps holds deadlock-free. Override-covered nodes never
- * arm: the override is their display and its revert their notification
- * (A17). 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;
-export declare const STATUS_NONE = 0;
-export declare const STATUS_PENDING: number;
-export declare const STATUS_ERROR: number;
-export declare const STATUS_UNINITIALIZED: number;
-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: {};
-/**
- * Brand symbol used by `Refreshable<T>` values (projection stores, async
- * memos) to expose their underlying computation to `refresh()`. Not part of
- * the user-facing API.
- *
- * @internal
- */
-export declare const $REFRESH: unique symbol;
-/**
- * Brand applied to values that participate in the `refresh()` re-run protocol.
- * Accessors receive this handle internally; projected stores expose it through
- * their public return type so user-defined hooks that wrap `createOptimisticStore`
- * / `createProjection` / projection-form `createStore` can have their return
- * types inferred without leaking the internal `$REFRESH` symbol into public type
- * signatures (TS4058).
- */
-export type Refreshable<T> = T & {
-    readonly [$REFRESH]: any;
-};