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

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

@@ -1,186 +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";
-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[];
-}
-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 committed a changed value. A PLAIN memo run with
-     * `changed: false` was pure waste — the equality cutoff stopped it from
-     * notifying anyone; an effect run with `changed: false` computed without
-     * firing its effect phase. 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); "transition" = a transition was
-     * active 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" | "transition" | "optimistic";
-    /**
-     * The changed value was held in `_pendingValue` (a transition hold) rather
-     * than committed directly; its reveal happens on the transition's own
-     * schedule. Held runs are excluded from waste accounting.
-     */
-    held: boolean;
-}
-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;
-}
-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;
-}
-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[];
-    };
-    format: typeof formatRerun;
-}
-export declare const attribution: Attribution;

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

@@ -1,97 +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;
-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;
-};

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

@@ -1,36 +0,0 @@
-import type { Owner } from "./types.cjs";
-export interface Context<T> {
-    readonly id: symbol;
-    readonly defaultValue: T | undefined;
-}
-export type ContextRecord = Record<string | symbol, unknown>;
-/**
- * Context provides a form of dependency injection. It is used to save from needing to pass
- * data as props through intermediate components. This function creates a new context object
- * that can be used with `getContext` and `setContext`.
- *
- * A default value can be provided here which will be used when a specific value is not provided
- * via a `setContext` call.
- */
-export declare function createContext<T>(defaultValue?: T, description?: string): Context<T>;
-/**
- * Low-level owner-targeted context read. The user-facing read API is
- * `useContext` (in `solid-js`), which wraps this primitive. Exposed here for
- * cross-package wiring (e.g. hydration-aware context plumbing).
- *
- * @throws `NoOwnerError` if there's no owner at the time of call.
- * @throws `ContextNotFoundError` if a context value has not been set yet.
- *
- * @internal
- */
-export declare function getContext<T>(context: Context<T>, owner?: Owner | null): T;
-/**
- * Low-level owner-targeted context write. The user-facing API is
- * `createContext` (in `solid-js`); its provider component wraps this
- * primitive. Exposed here for cross-package wiring.
- *
- * @throws `NoOwnerError` if there's no owner at the time of call.
- *
- * @internal
- */
-export declare function setContext<T>(context: Context<T>, value?: T, owner?: Owner | null): void;

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

@@ -1,163 +0,0 @@
-import { type Refreshable } from "./constants.cjs";
-import { type OptimisticLane } from "./lanes.cjs";
-import type { Computed, FirewallSignal, NodeExtension, NodeOptions, Owner, Signal } from "./types.cjs";
-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 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;
-export declare function releaseSnapshotScope(owner: Owner): void;
-export declare function clearSnapshots(): void;
-export declare function recompute(el: Computed<any>, create?: boolean): void;
-export declare function computed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>): Computed<T>;
-export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
-/** Lazily allocate a node's cold extension (ONE shape for signals and
- * computeds — `_x` access stays monomorphic). Installers write through
- * this; hot paths read `el._x?._field` gated by the _config presence bits.
- * Never call ext() just to store a field's default. */
-export declare function ext(el: {
-    _x: NodeExtension | null;
-}): NodeExtension;
-/**
- * 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 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;
-/**
- * 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)`.
- */
-export declare let strictRead: string | false;
-export declare function setStrictRead(v: string | false): string | false;
-/**
- * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
- * subscribe the current scope. Returns whatever `fn` returns.
- *
- * 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.
- *
- * 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.
- *
- * @example
- * ```ts
- * createEffect(
- *   () => trigger(),                 // tracks `trigger` only
- *   () => {
- *     const snapshot = untrack(() => state); // read once, untracked
- *     log(snapshot);
- *   }
- * );
- * ```
- */
-export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
-/**
- * Bring a computed to a readable state: lazy/disposed nodes are (re)computed;
- * an isPending() probe (`refresh`) additionally pulls the node fully up to
- * date so its status flags reflect the current graph.
- */
-export declare function prepareComputed(comp: Computed<unknown>, refresh: boolean): void;
-/**
- * Sentinel returned by readNodeFast when the plain-signal fast path does not
- * apply and the caller must fall back to the full read().
- */
-export declare const READ_SLOW: unique symbol;
-/**
- * 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().
- */
-export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
-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.
- */
-export declare function devGuardStoreSetterWrite(): void;
-export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
-/**
- * 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.
- */
-export declare function suppressComputedRecompute(el: Computed<unknown>): void;
-/**
- * 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.
- */
-export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
-/**
- * Executes `fn` with the given `owner` set as the current owner. Any reactive
- * primitives (`createSignal`, `createMemo`, `createEffect`, `onCleanup`,
- * `cleanup`, etc.) created inside `fn` are attached to that owner, so they
- * are disposed when the owner is disposed.
- *
- * The classic pattern: capture the current owner with `getOwner()` inside a
- * component, then re-enter it from a callback (event handler, async resolve,
- * setTimeout) so disposables created in the callback get cleaned up with the
- * component.
- *
- * @example
- * ```ts
- * function delayed<T>(ms: number, fn: () => T) {
- *   const owner = getOwner();
- *   setTimeout(() => runWithOwner(owner, fn), ms);
- * }
- * ```
- */
-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>
- * ```
- */
-export declare function refresh<T>(target: Refreshable<T>): void;

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

@@ -1,81 +0,0 @@
-import { type Attribution } from "./attribution.cjs";
-import type { Computed, Link, Owner, Signal } from "./types.cjs";
-export interface DevHooks {
-    onOwner?: (owner: Owner) => void;
-    onGraph?: (value: any, owner: Owner | null) => void;
-    onUpdate?: () => void;
-    onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
-}
-export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WIDE_WRITE";
-export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error" | "perf" | "graph";
-/** First warning when a node's live edge count reaches this size. */
-export declare const GRAPH_SIZE_WARN_AT = 2000;
-/** Repeat the warning at this interval after the first. */
-export declare const GRAPH_SIZE_WARN_EVERY = 500;
-export interface DiagnosticEvent {
-    sequence: number;
-    code: DiagnosticCode;
-    kind: DiagnosticKind;
-    severity: DiagnosticSeverity;
-    message: string;
-    ownerId?: string;
-    ownerName?: string;
-    nodeName?: string;
-    data?: Record<string, unknown>;
-}
-export type DiagnosticListener = (event: DiagnosticEvent) => void;
-export interface DiagnosticCapture {
-    readonly events: readonly DiagnosticEvent[];
-    clear(): void;
-    stop(): DiagnosticEvent[];
-}
-export interface Diagnostics {
-    subscribe(listener: DiagnosticListener): () => void;
-    capture(): DiagnosticCapture;
-}
-export interface Dev {
-    hooks: DevHooks;
-    diagnostics: Diagnostics;
-    /** "Why did this run" re-run attribution — see attribution.ts. */
-    attribution: Attribution;
-    getChildren: typeof getChildren;
-    getSignals: typeof getSignals;
-    getParent: typeof getParent;
-    getSources: typeof getSources;
-    getObservers: typeof getObservers;
-}
-export declare const DEV: Dev;
-/**
- * Dev-mode internal consistency check. A failure means the reactive system
- * contradicted itself (not that user code misbehaved) — see
- * INTERNALS-ASYNC-STATE.md for the invariant catalog. Throws under __TEST__
- * so the suite (and fuzzing) treats any violation as a hard failure; logs in
- * dev builds so user apps degrade instead of crashing.
- */
-export declare function assertInvariant(condition: boolean, name: string, message: string): void;
-export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">): DiagnosticEvent;
-/**
- * Shared strict-read diagnostics for core read() and the store proxy traps.
- * Single source for the message text — the #2897 safeguard parity between
- * memos and stores is exactly these firing identically from both paths.
- */
-export declare function throwPendingUntrackedRead(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence" | "data">>): never;
-export declare function warnStrictReadUntracked(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence">>): void;
-export declare function registerGraph(value: any, owner: Owner | null): void;
-export declare function clearSignals(node: Owner): void;
-export declare function getChildren(owner: Owner): Owner[];
-export declare function getSignals(owner: Owner): any[];
-export declare function getParent(owner: Owner): Owner | null;
-export declare function getSources(computation: Computed<any>): (Signal<any> | Computed<any>)[];
-export declare function getObservers(node: Signal<any> | Computed<any>): Computed<any>[];
-/**
- * DEV-only: bump live edge counts after a new graph link and warn when a
- * node grows an unusually large fan-out (many subscribers on one source) or
- * fan-in (many sources on one computation). Repeat-reads that `link()`
- * dedupes never reach here. Always-on in dev — unlike the opt-in attribution
- * engine, a graph-size pathology should surface without asking.
- */
-export declare function noteGraphLink(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;
-/** DEV-only: drop live edge counts when a link is removed. */
-export declare function unnoteGraphLink(link: Link): void;

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

@@ -1,30 +0,0 @@
-import type { Computed, NodeOptions, Owner } from "./types.cjs";
-export interface Effect<T> extends Computed<T>, Owner {
-    _effectFn: (val: T, prev: T | undefined) => void | (() => void);
-    _errorFn?: (err: unknown, cleanup: () => void) => void;
-    _modified: boolean;
-    _prevValue: T | undefined;
-    _type: number;
-    _boundRunEffect?: () => void;
-}
-/**
- * Effects are the leaf nodes of our reactive graph. When their sources change, they are
- * automatically added to the queue of effects to re-execute, which will cause them to fetch their
- * sources and recompute
- */
-export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), options?: NodeOptions<any> & {
-    user?: boolean;
-    defer?: boolean;
-    schedule?: boolean;
-}): void;
-export interface TrackedEffect extends Computed<void> {
-    _modified: boolean;
-    _type: number;
-    _run: () => void;
-}
-/**
- * Internal tracked effect - bypasses heap, goes directly to effect queue.
- * Runs as a leaf owner: child primitives and onCleanup are forbidden (__DEV__ throws).
- * Uses stale reads.
- */
-export declare function trackedEffect(fn: () => void | (() => void), options?: NodeOptions<any>): void;

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

@@ -1,47 +0,0 @@
-/**
- * Thrown by a tracked read whose value is currently pending (an async memo /
- * `createSignal(asyncFn)` / projection / store derivation that hasn't settled
- * yet). Surfacing through the reactive graph is what suspends the consumer
- * scope — the nearest enclosing `<Loading>` boundary catches the throw and
- * renders its fallback until the source resolves.
- *
- * App code rarely catches this directly; `<Loading>` is the canonical
- * handler. The error type is exposed for advanced cases — e.g. interop layers
- * that bridge Solid's pending-throw protocol to a different async strategy,
- * or tests that want to assert on the suspension shape.
- *
- * @example
- * ```ts
- * // Advanced: distinguish "not ready yet" from a real error in custom
- * // boundary plumbing. App code should rely on `<Loading>` / `<Errored>`.
- * try {
- *   const value = readReactiveSource();
- * } catch (err) {
- *   if (err instanceof NotReadyError) throw err; // re-throw to suspend
- *   reportError(err);
- * }
- * ```
- */
-export declare class NotReadyError extends Error {
-    /**
-     * Tags a visibility-only notification on the affects() boundary channel:
-     * boundaries update display state from it, but the root queue never
-     * registers a reporter — marks are invisible to completion accounting by
-     * construction.
-     */
-    _markVisual?: boolean;
-    source: any;
-    constructor(source: any);
-}
-export declare class StatusError extends Error {
-    source: any;
-    constructor(source: any, original: any);
-}
-/** Return the user's error from an internal status wrapper. */
-export declare function unwrapStatusError(error: unknown): unknown;
-export declare class NoOwnerError extends Error {
-    constructor();
-}
-export declare class ContextNotFoundError extends Error {
-    constructor();
-}

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

@@ -1,15 +0,0 @@
-export type ExternalSourceFactory = (fn: (prev: any) => any, trigger: () => void) => ExternalSource;
-export interface ExternalSource {
-    track: (prev: any) => any;
-    dispose: () => void;
-}
-export interface ExternalSourceConfig {
-    factory: ExternalSourceFactory;
-    untrack?: <T>(fn: () => T) => T;
-}
-export declare let externalSourceConfig: {
-    factory: ExternalSourceFactory;
-    untrack: <T>(fn: () => T) => T;
-} | null;
-export declare function enableExternalSource(config: ExternalSourceConfig): void;
-export declare function _resetExternalSourceConfig(): void;

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

@@ -1,6 +0,0 @@
-import type { Computed, Link, Signal } from "./types.cjs";
-export declare function unlinkSubs(link: Link): Link | null;
-export declare function trimStaleDeps(el: Computed<any>): void;
-export declare function clearDeps(el: Computed<unknown>): void;
-export declare function unobserved(el: Computed<unknown>): void;
-export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>, pendingObserver?: boolean): void;