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

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

@@ -1,124 +0,0 @@
-import type { Computed, Disposable, Owner, Root } from "./types.cjs";
-export declare function markDisposal(el: Owner): void;
-export declare function dispose(node: Computed<unknown>): void;
-export declare function disposeChildren(node: Owner, self?: boolean, zombie?: boolean): void;
-/**
- * Allocates and returns the next stable child id for `owner`. Used by
- * hydration plumbing and `createUniqueId`. Not part of the user-facing API.
- *
- * @internal
- */
-export declare function getNextChildId(owner: Owner): string;
-/**
- * The id a freshly-created node inherits: an explicit `options.id` wins;
- * transparent nodes share their parent's id; otherwise the parent's next
- * child id is consumed (or `undefined` outside an id-carrying tree).
- */
-export declare function inheritId(options: {
-    id?: string;
-} | undefined, transparent: boolean, parent: Owner | null | undefined): string | undefined;
-/**
- * Returns the *next* child id for `owner` without consuming it. Used by
- * hydration plumbing to peek at the id a future child will receive.
- *
- * @internal
- */
-export declare function peekNextChildId(owner: Owner): string;
-/**
- * Returns the currently-tracking observer (the computation that subscribes to
- * reactive reads at this point), or `null` if reads here would be untracked.
- * Used by reactive primitives that need to know whether they're inside a
- * tracking scope. App code rarely needs this — see `getOwner()` for the
- * lifecycle owner instead.
- *
- * @example
- * ```ts
- * // Library predicate: only register a hot-path subscription when the
- * // caller is inside a tracking scope (memo / effect compute / JSX).
- * function trackIfTracked(source: () => unknown) {
- *   if (getObserver()) source();
- * }
- * ```
- */
-export declare function getObserver(): Owner | null;
-/**
- * Returns the current reactive **owner** — the lifecycle node that the next
- * `cleanup()` / `onCleanup()` / `createSignal()` etc. will be attached to.
- *
- * Returns `null` if called outside any owner. Capture the owner with
- * `getOwner()` and re-enter it later with `runWithOwner(owner, fn)` to attach
- * disposables created from a callback (event handler, async resolution, etc.)
- * back to a component's lifecycle.
- *
- * @example
- * ```ts
- * function defer<T>(fn: () => T) {
- *   const owner = getOwner();
- *   queueMicrotask(() => runWithOwner(owner, fn));
- * }
- * ```
- */
-export declare function getOwner(): Owner | null;
-/**
- * Low-level: registers `fn` as a disposal callback on the current owner.
- * Most code should use `onCleanup()` from `solid-js`, which adds dev-mode
- * checks. `cleanup()` is the unchecked primitive used by internals.
- */
-export declare function cleanup(fn: Disposable): Disposable;
-/**
- * Returns `true` if the owner has been disposed (or marked zombie pending
- * disposal). Pair with a captured owner to bail out of late callbacks whose
- * surrounding component already unmounted.
- *
- * @example
- * ```ts
- * function onSettleSafe(fn: () => void) {
- *   const owner = getOwner();
- *   queueMicrotask(() => {
- *     if (owner && isDisposed(owner)) return; // component unmounted; skip
- *     runWithOwner(owner, fn);
- *   });
- * }
- * ```
- */
-export declare function isDisposed(node: Owner): boolean;
-/**
- * Creates a fresh owner attached as a child of the current owner (or as a
- * detached root if there is none). Used by framework internals to group
- * cleanups; app code should use `createRoot()` (host a reactive scope outside
- * a component) or `runWithOwner()` (re-enter a captured owner).
- *
- * @internal
- */
-export declare function createOwner(options?: {
-    id?: string;
-    transparent?: boolean;
-}): Root;
-/**
- * Creates a detached reactive root. The callback receives a `dispose()`
- * function which, when called, tears down every signal, memo, effect, and
- * `onCleanup` registered inside the root.
- *
- * Use this to host long-lived reactive scopes outside of a component (custom
- * controllers, app bootstrapping, tests). Inside a component, prefer
- * letting Solid's component lifecycle own things.
- *
- * @example
- * ```ts
- * const dispose = createRoot(dispose => {
- *   const [n, setN] = createSignal(0);
- *   createEffect(() => n(), value => console.log(value));
- *   setInterval(() => setN(x => x + 1), 1000);
- *   return dispose;
- * });
- *
- * // Later, to tear everything down:
- * dispose();
- * ```
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
- */
-export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
-    id?: string;
-    transparent?: boolean;
-}): T;

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

@@ -1,236 +0,0 @@
-import { type Heap } from "./heap.cjs";
-import { activeLanes, assignOrMergeLane, findLane, type OptimisticLane } from "./lanes.cjs";
-import type { Computed, Signal } from "./types.cjs";
-export { activeLanes, assignOrMergeLane, findLane };
-export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane } from "./lanes.cjs";
-export declare const dirtyQueue: Heap;
-export declare const zombieQueue: Heap;
-export declare let clock: number;
-export declare let activeTransition: Transition | null;
-export declare let projectionWriteActive: boolean;
-export declare let _hitUnhandledAsync: boolean;
-/**
- * Consume the unhandled-async hit. Returns whether this is the first report
- * of the current enforcement window — the caller warns only then.
- */
-export declare function resetUnhandledAsync(): boolean;
-/**
- * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
- * window. Only `render()` calls this — wrapping the initial mount so that a
- * top-level uncaught async read surfaces the diagnostic. Not part of the
- * user-facing API.
- *
- * @internal
- */
-export declare function enforceLoadingBoundary(enabled: boolean): void;
-export declare function setProjectionWriteActive(value: boolean): void;
-export declare function setTrackedQueueCallback(value: boolean): void;
-export declare function setEffectCallback(value: boolean): void;
-export type QueueCallback = (type: number) => void;
-type QueueStub = {
-    _queues: [QueueCallback[], QueueCallback[]];
-    _children: QueueStub[];
-};
-type OptimisticNode = Signal<any> | Computed<any>;
-export interface Transition {
-    _time: number;
-    _asyncReporters: Map<Computed<any>, Set<Computed<any>>>;
-    _pendingNodes: Signal<any>[];
-    _optimisticNodes: OptimisticNode[];
-    _affectsNodes: OptimisticNode[];
-    _optimisticStores: Set<any>;
-    _actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
-    _queueStash: QueueStub;
-    _done: boolean | Transition;
-    _gatedSubs: Set<Computed<any>>;
-}
-/**
- * Flip-entanglement (#3164 follow-up): `until()` is a declaration of
- * relatedness — the predicate names the condition that confirms the awaiting
- * transaction. When the predicate settles truthy, every live foreign
- * transition whose staged write it read IS the confirming event by the
- * user's own definition, so it merges into the awaiting transaction and
- * reveals at the joint settle — the cross-primitive twin of the family fold
- * (a landing on an optimism-carrying family joins the retaining
- * transaction). Non-flipping updates never pass through here: falsy
- * evaluations don't entangle, so unrelated traffic on the watched sources
- * reveals freely on its own schedule.
- *
- * Runs inside the predicate's compute (pure phase) — the confirming
- * transition's stamps are still live and its commit decision hasn't run, so
- * the merge lands before any reveal. Only the tree-shaken graphs that call
- * `until()` retain this.
- */
-export declare function entangleConfirmingTransitions(obs: Computed<any>, target: Transition): void;
-export declare function schedule(): void;
-/**
- * Permanently halts the reactive system. Called when a user error escapes
- * every boundary — app state is undefined at that point, so scheduling stops
- * entirely rather than limping along with a half-applied update.
- */
-export declare function haltReactivity(cause?: unknown): void;
-/** @internal Test/dev-reload hook. Revives scheduling after a halt. */
-export declare function resetErrorHalt(): void;
-export interface IQueue {
-    enqueue(type: number, fn: QueueCallback): void;
-    run(type: number): boolean | void;
-    addChild(child: IQueue): void;
-    removeChild(child: IQueue): void;
-    created: number;
-    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
-    stashQueues(stub: QueueStub): void;
-    restoreQueues(stub: QueueStub): void;
-    _parent: IQueue | null;
-}
-export declare class Queue implements IQueue {
-    _parent: IQueue | null;
-    _queues: [QueueCallback[], QueueCallback[]];
-    _children: IQueue[];
-    _ranAt: number;
-    created: number;
-    addChild(child: IQueue): void;
-    removeChild(child: IQueue): void;
-    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
-    run(type: number): void;
-    enqueue(type: number, fn: QueueCallback): void;
-    stashQueues(stub: QueueStub): void;
-    restoreQueues(stub: QueueStub): void;
-}
-export declare class GlobalQueue extends Queue {
-    _running: boolean;
-    _batch: Transition;
-    static _update: (el: Computed<unknown>) => void;
-    static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
-    static _runEffect: (el: Computed<unknown>) => void;
-    static _clearOptimisticStores: ((stores: Set<any>, completing: Transition | null) => void) | null;
-    static _releaseAffectsScope: ((node: OptimisticNode) => void) | null;
-    static _releaseAffectsMarks: ((nodes: OptimisticNode[]) => void) | null;
-    static _markAffects: ((node: OptimisticNode) => void) | null;
-    static _releaseAffectsMark: ((node: OptimisticNode) => void) | null;
-    static _wireExternalSource: ((self: Computed<any>) => void) | null;
-    static _externalUntrack: (<T>(fn: () => T) => T) | null;
-    static _syncCompanions: (<T>(el: Signal<T> | Computed<T>, value: T) => void) | null;
-    static _updatePendingSignal: ((el: OptimisticNode) => void) | null;
-    static _updateChildCompanions: ((el: Computed<any>) => void) | null;
-    static _snapCompanions: ((el: OptimisticNode) => void) | null;
-    static _latestRead: (<T>(el: Signal<T> | Computed<T>) => T) | null;
-    static _pendingCheck: ((el: OptimisticNode, c: Computed<any> | null, owner: OptimisticNode, firewall: Computed<any> | null) => void) | null;
-    static _recordFresh: ((el: OptimisticNode, value: any) => void) | null;
-    static _applyReask: ((el: Computed<any>, hadReask: boolean) => boolean) | null;
-    static _repollVerdicts: ((el: Computed<any>, snap?: boolean) => void) | null;
-    static _witnessAffects: ((node: OptimisticNode) => void) | null;
-    static _wakeSuppressedProbes: ((transition: Transition) => void) | null;
-    static _optimisticWrite: (<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)) => T) | null;
-    static _resolveOptimistic: ((nodes: OptimisticNode[]) => void) | null;
-    static _transitionBlocked: ((transition: Transition) => boolean) | null;
-    static _cleanupLanes: ((completingTransition: Transition | null) => void) | null;
-    static _runLaneEffects: ((type: number) => void) | null;
-    /** Patch-channel optimistic drain (next/patch.ts): optimistic emissions
-     * apply at lane-effect timing — visible in flight, unlike the regular
-     * effect queues an action stashes. Injected; null when unused. */
-    static _drainPatchOptimistic: (() => void) | null;
-    static _gatedRead: ((el: Signal<any>, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
-    static _laneSuspends: ((owner: OptimisticNode) => boolean) | null;
-    static _laneReadsCommitted: ((el: OptimisticNode, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
-    static _recomputeLane: ((el: Computed<any>, own: boolean) => OptimisticLane | null | false) | null;
-    static _laneAsyncPending: ((el: Computed<any>) => void) | null;
-    /** Authoritative-view reader wakeup: installed by until() and refresh() before
-     * their first read. Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which
-     * only such a reader's carve-out read can set, so `!` invocations are safe once
-     * the gate holds (#3303). */
-    static _notifyAuthoritativeObservers: ((el: Signal<any> | Computed<any>) => void) | null;
-    static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
-    static _trackOptimisticStore: ((store: any) => void) | null;
-    flush(): void;
-    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
-    initTransition(transition?: Transition | null): void;
-}
-export declare function queuePendingNode(node: Signal<any>): void;
-export declare let reaskArmed: boolean;
-/** §12d: bumped by every recompute and every new subscriber edge. A node's
- * staged-rewrite skip is sound only while NOTHING recomputed or linked since
- * its last notify — a mid-batch pull can clean a marked subscriber, and a
- * skipped re-write would leave it stale. */
-export declare let notifyEpoch: number;
-export declare function bumpNotifyEpoch(): void;
-export declare function armReaskClear(): void;
-export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
-export declare let storeCommitHook: (() => void) | null;
-export declare function setStoreCommitHook(fn: () => void): void;
-/** Patch-channel release hook (next/patch.ts): transition-stamped patch
- * emissions are released when THEIR batch commits. Transitions never
- * abort: failed actions still commit (only optimistic overrides revert),
- * and merged-away transitions hand their stash to the survivor
- * (mergeTransitionState) — every stash drains exactly once. Injected like
- * storeCommitHook to stay tree-shakeable. */
-export declare let patchCommitHook: ((batch: Transition) => void) | null;
-export declare function setPatchCommitHook(fn: (batch: Transition) => void): void;
-export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
-/**
- * Count of live `affects()` registrations across the system (including
- * store-scope inherited marks). Gates the read-path mark check in `read()` so
- * graphs that never use the feature pay one integer compare.
- */
-export declare let activeAffectsMarks: number;
-/**
- * Counter mutation seam for the mark engine in affects.ts: an imported `let`
- * binding is read-only, and the read-path gate above must stay a plain module
- * variable so `read()` pays one integer compare, not a function call.
- *
- * @internal
- */
-export declare function shiftAffectsMarks(delta: 1 | -1): void;
-export declare const globalQueue: GlobalQueue;
-/**
- * Synchronously processes the pending reactive queue, or runs `fn` in a synchronous
- * flush scope before draining the queue.
- *
- * Reactive updates are normally batched onto the microtask queue, so multiple
- * writes in a row collapse into a single update pass. Call `flush()` when you
- * need to *observe* the result of those writes synchronously — most commonly
- * in tests, but also at the boundary of imperative integration code. Pass a
- * callback when the writes themselves should bypass microtask scheduling and
- * drain synchronously when the callback returns.
- *
- * @example
- * ```ts
- * const [count, setCount] = createSignal(0);
- * const doubled = createMemo(() => count() * 2);
- *
- * setCount(5);
- * flush();
- * expect(doubled()).toBe(10);
- *
- * flush(() => setCount(6));
- * expect(doubled()).toBe(12);
- *
- * // Nested flushes drain at each level:
- * flush(() => {
- *   setCount(7);
- *   flush(() => setCount(8)); // inner drain — effects fire here
- *   // outer continues with up-to-date state
- * });
- * ```
- */
-export declare function flush(): void;
-export declare function flush<T>(fn: () => T): T;
-/** A fresh, unentered transaction (#3146): the optimistic store's truth
- * flight DECLARES an owned transaction instead of relying on whatever the
- * ambient adoption machinery stamped on its firewall. Activate it with
- * initTransition; it is a plain batch until then. */
-export declare function createTransition(): Transition;
-export declare function currentTransition(transition: Transition): Transition;
-export declare function setActiveTransition(transition: Transition | null): void;
-export declare function runInTransition<T>(transition: Transition, fn: () => T): T;
-/** Run `fn` with `transition` as BOTH the ambient transaction and the
- * registration batch, restoring both after. runInTransition alone is not
- * enough for code that WRITES on behalf of a transaction from inside someone
- * else's window (optimistic replay re-arming a still-open action's edits
- * during a landing commit, #3123): registrations route through the queue's
- * batch pointer, and a bare activeTransition swap leaves them in the ambient
- * batch — a plain batch "completes" at the next flush and reverts optimistic
- * registrations that were supposed to live with the transaction.
- * initTransition is the wrong tool here: it MERGES the currently ambient
- * transaction into the target, entangling whatever the interrupted window
- * belonged to. */
-export declare function runAsTransitionBatch<T>(transition: Transition, fn: () => T): T;

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

@@ -1,204 +0,0 @@
-import type { NOT_PENDING } from "./constants.cjs";
-import type { OptimisticLane } from "./lanes.cjs";
-import type { IQueue, Transition } from "./scheduler.cjs";
-export interface Disposable {
-    (): void;
-}
-export interface Link {
-    _dep: Signal<unknown> | Computed<unknown>;
-    _sub: Computed<unknown>;
-    _nextDep: Link | null;
-    _prevSub: Link | null;
-    _nextSub: Link | null;
-    /**
-     * `_sub._depGen` at the time this link was created or last revalidated
-     * in-order. A link stamped with the subscriber's current pass generation is
-     * inside the validated `[deps.._depsTail]` prefix — an O(1) replacement for
-     * scanning the dep list to answer membership (see `link()`).
-     */
-    _gen: number;
-    _pendingObserver?: boolean;
-}
-export interface NodeOptions<T> {
-    id?: string;
-    name?: string;
-    transparent?: boolean;
-    equals?: ((prev: T, next: T) => boolean) | false;
-    ownedWrite?: boolean;
-    /** Exclude this signal from snapshot capture (internal — not part of public API) */
-    _noSnapshot?: boolean;
-    /** Extra CONFIG_* bits OR'd into the node's config at creation (internal —
-     * not part of public API). Used by resolve()/until() for
-     * CONFIG_DIRECT_COMMIT / CONFIG_AUTHORITATIVE_READ, keeping the per-flag
-     * option arms out of the core creation path. */
-    _extraConfig?: number;
-    unobserved?: () => void;
-    lazy?: boolean;
-    sync?: boolean;
-    /**
-     * Commit #0. When present (checked with `in`, so an explicit `undefined`
-     * counts), the node is born committed with this value instead of
-     * STATUS_UNINITIALIZED: reads serve it everywhere, nothing suspends to
-     * Loading boundaries, transitions are never held, and the window is
-     * verdict-quiet (`isPending` stays false — commit #0 answers the question
-     * by declaration; first-load affordances live in the value itself). After
-     * the first real answer lands, normal refetch/pending semantics apply.
-     */
-    loadingValue?: T;
-}
-/**
- * Cold node extension (stage-3 §12): optional machinery that most nodes
- * never touch lives one hop away so the CORE node literal stays under V8's
- * in-object property boundary (~39 fields measured: past it, every literal
- * allocation spills to an out-of-object backing store and creation cost
- * roughly quadruples — the create0to1 cliff). Allocated lazily by `ext()`
- * on first installer write; ONE shape shared by signals and computeds so
- * `_x` access stays monomorphic. Presence bits on `_config`
- * (CONFIG_OPTIMISTIC / HAS_COMPANIONS / HAS_LANE / HAS_SNAPSHOT) remain the
- * hot-path gates — a bit says "consult _x", never the reverse.
- */
-export interface NodeExtension {
-    _overrideValue: unknown | typeof NOT_PENDING;
-    /**
-     * The transaction that owns the active override (stamped at optimistic
-     * write, cleared at settle). Ownership must live on the node: a lane's
-     * _transition is a scheduling affinity that a shared subscriber can merge
-     * across transactions (#2912) — following it would let one action's settle
-     * revert another action's live override. Node-level sibling of the store
-     * layer's STORE_OPTIMISTIC_OWNERS stamps (#2899). `null` = ambient write.
-     */
-    _overrideOwner: Transition | null | undefined;
-    _optimisticLane: OptimisticLane | undefined;
-    _pendingSignal: Signal<boolean> | undefined;
-    _latestValueComputed: Computed<any> | undefined;
-    _parentSource: Signal<any> | Computed<any> | undefined;
-    /**
-     * Live `affects()` marks on this node (refcount). Non-zero is declared
-     * motion — see affects(); the count is the mark's only graph state.
-     */
-    _affectsCount: number;
-    _inFlight: PromiseLike<any> | AsyncIterable<any> | null;
-    /** Cancellation for the CURRENT iterator flight (#3122): closes the
-     * iterator (`it.return()`), idempotent. Fired at the sites that release
-     * `_inFlight` so a superseded stream stops at supersede time — its owner
-     * cleanup registration may ride the zombie-disposal channel, which a held
-     * transition defers until the SUPERSEDING flight settles. Null for plain
-     * promise flights (no cancellation hook exists). */
-    _flightTeardown: (() => void) | null;
-    _error: unknown;
-    _blocked: boolean | undefined;
-    _pendingSources: Set<Computed<any>> | undefined;
-    _notifyStatus: ((status?: number, error?: any) => void) | undefined;
-    /** Question-scoped re-ask classification of the current pending window
-     * (see the former Computed._x?._reask doc): set by recompute from
-     * REACTIVE_REASK, cleared on landing; meaningless while not pending. */
-    _reask: boolean;
-    _child: FirewallSignal<any> | null;
-    _unobserved: (() => void) | undefined;
-    _snapshotValue: any;
-    /** Zombie staging (staged disposal): a recompute of an owner that HAS
-     * children/disposal parks them here until the flush commits (or a
-     * transition reverts). Childless nodes — the common case — never write
-     * these. */
-    _pendingDisposal: Disposable | Disposable[] | null;
-    _pendingFirstChild: Owner | null;
-    /** #3038: the firewall children that actually carry isPending()/latest()
-     * companions. The post-recompute companion snap iterates THIS set —
-     * O(companions asked for) — never the full `_child` chain (one entry per
-     * materialized leaf). Populated at companion creation; entries live as
-     * long as their companions (which are permanent once created). */
-    _companionChildren: Set<FirewallSignal<any>> | undefined;
-}
-export interface RawSignal<T> {
-    _subs: Link | null;
-    _subsTail: Link | null;
-    /**
-     * DEV-only live subscriber count. Maintained by `link`/`unlinkSubs` for
-     * graph-size diagnostics; undefined in production.
-     */
-    _subCount?: number;
-    _value: T;
-    _name?: string;
-    _equals: false | ((a: T, b: T) => boolean);
-    _config: number;
-    _time: number;
-    /** IN CORE, not the extension (stage-3 §12c): consulted on EVERY write
-     * (setSignal's transition-init check) and on recompute scheduling — the
-     * per-write extension chase measurably taxed propagation chains. */
-    _transition: Transition | null;
-    /** Notify-epoch stamp of the last subscriber walk (§12d). A re-write to an
-     * already-staged node whose stamp still equals the global epoch skips the
-     * whole walk — marking is idempotent, and the epoch bumps on every
-     * recompute and new subscriber edge (either can invalidate the skip). */
-    _notifiedAt: number;
-    _pendingValue: T | typeof NOT_PENDING;
-    /** Cold extension — see NodeExtension. */
-    _x: NodeExtension | null;
-}
-export interface FirewallSignal<T> extends RawSignal<T> {
-    _firewall: Computed<any>;
-    _nextChild: FirewallSignal<unknown> | null;
-}
-export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
-export interface Owner {
-    id?: string;
-    _config: number;
-    _snapshotScope?: boolean;
-    /** Effect-returned cleanup; managed across reruns, invoked at true disposal */
-    _cleanup?: () => void;
-    _disposal: Disposable | Disposable[] | null;
-    _parent: Owner | null;
-    _context: Record<symbol | string, unknown>;
-    _childCount: number;
-    _queue: IQueue;
-    _firstChild: Owner | null;
-    _nextSibling: Owner | null;
-    _prevSibling: Owner | null;
-    /** Cold extension — see NodeExtension (owners use the zombie-pair slots). */
-    _x: NodeExtension | null;
-}
-export interface Computed<T> extends RawSignal<T>, Owner {
-    _deps: Link | null;
-    _depsTail: Link | null;
-    /**
-     * DEV-only live source count. Maintained by `link`/`unlinkSubs` for
-     * graph-size diagnostics; undefined in production.
-     */
-    _depCount?: number;
-    /** Recompute-pass counter; bumped when dep revalidation starts. */
-    _depGen: number;
-    _flags: number;
-    _statusFlags: number;
-    _height: number;
-    _nextHeap: Computed<any> | undefined;
-    _prevHeap: Computed<any>;
-    _fn: (prev?: T) => T;
-    /**
-     * Clock tick at which REACTIVE_MANUAL_WRITE was last applied
-     * (`suppressComputedRecompute`). Lets `refresh()` distinguish a same-tick
-     * manual write (which wins over the refresh, #2692) from a mask carried
-     * across ticks by a transaction (which an explicit refresh lifts, #3026).
-     * Only meaningful while REACTIVE_MANUAL_WRITE is set.
-     */
-    _manualWriteTime?: number;
-    /**
-     * True while a `loadingValue` node's first real answer hasn't landed: the
-     * node was born committed (commit #0 = the loading value) and `handleAsync`
-     * serves that committed value instead of throwing NotReadyError, so first
-     * flights never suspend readers, trip boundaries, or hold transitions.
-     * The window is verdict-quiet: `isPending` stays false, because commit #0
-     * answers the question by declaration (first-load affordances belong to
-     * the value channel). Cleared by the first value landing on any path (sync
-     * return, sync-resolved promise, first iterator yield, async settle); a
-     * real error leaves it set — errors answer reads but don't enter the value
-     * lineage, so a retry serves the loading value again. Once cleared, normal
-     * pending/refetch semantics apply forever. (Stays in CORE: written
-     * unconditionally by recompute and every commit.)
-     */
-    _loading: boolean;
-}
-export interface Root extends Owner {
-    _root: true;
-    _parentComputed: Computed<any> | null;
-    dispose(self?: boolean): void;
-}

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

@@ -1,2 +0,0 @@
-export declare function latest<T>(fn: () => T): T;
-export declare function isPending(fn: () => any): boolean;

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

@@ -1,10 +0,0 @@
-export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.cjs";
-import { type Dev } from "./core/index.cjs";
-export declare const DEV: Dev | undefined;
-export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.cjs";
-export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, refresh, resolve, until, onSettled, onCleanup } from "./signals.cjs";
-export type { Truthy, UntilOptions, Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.cjs";
-export { affects } from "./affects.cjs";
-export { mapArray, repeat, type Maybe } from "./map.cjs";
-export * from "./store/index.cjs";
-export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.cjs";

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

@@ -1,69 +0,0 @@
-import { type Accessor } from "./signals.cjs";
-export type Maybe<T> = T | void | null | undefined | false;
-/**
- * Reactively maps an array, reusing the previously-mapped value for unchanged
- * items.
- *
- * The callback shape follows the keying mode:
- * - default / `keyed: true` receives `(item, index)` where `item` is the raw
- *   row value and `index` is an accessor.
- * - `keyed: false` receives `(item, index)` where `item` is an accessor and
- *   `index` is a stable number.
- * - `keyed: item => key` receives accessors for both arguments.
- *
- * This is the underlying helper that powers `<For>`. App code should use
- * `<For>` directly; reach for `mapArray` when implementing custom list
- * components.
- *
- * - `options.keyed` — `true` (default for primitives) compares by identity;
- *   `false` falls back to index-only mapping; pass a function `(item) => key`
- *   for stable identity by extracted key.
- * - `options.fallback` — accessor returning a value to show when the input is
- *   empty.
- *
- * @example
- * ```ts
- * const view = mapArray(
- *   items,
- *   (item, index) => `${index()}: ${item.label}`,
- *   { fallback: () => "no items" }
- * );
- * ```
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
- */
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Item, index: Accessor<number>) => MappedItem, options?: {
-    keyed?: true;
-    fallback?: Accessor<any>;
-    name?: string;
-}): Accessor<MappedItem[]>;
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: number) => MappedItem, options: {
-    keyed: false;
-    fallback?: Accessor<any>;
-    name?: string;
-}): Accessor<MappedItem[]>;
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options: {
-    keyed: (item: Item) => any;
-    fallback?: Accessor<any>;
-    name?: string;
-}): Accessor<MappedItem[]>;
-/**
- * Reactively renders a callback `count` times, reusing previously-rendered
- * entries when only the count changes. Underlying helper for `<Repeat>`.
- *
- * - `options.from` — start index (default `0`); useful for offset/windowed
- *   rendering.
- * - `options.fallback` — accessor returning a value to show when count is `0`.
- *
- * @example
- * ```ts
- * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
- * ```
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
- */
-export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
-    from?: Accessor<number | undefined>;
-    fallback?: Accessor<any>;
-    name?: string;
-}): Accessor<any[]>;

package/dist/types-cjs/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/dist/types-cjs/store/index.d.cts

@@ -1,18 +0,0 @@
-export type { Store, StoreReturn, ProjectionStoreReturn, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.cjs";
-export type { Merge, Omit } from "./utils.cjs";
-export { isWrappable, $TRACK, $PROXY, $TARGET } from "./store.cjs";
-import type { NoFn, ProjectionOptions, Store, StoreOptions, StoreSetter } from "./store.cjs";
-import type { Refreshable } from "../core/index.cjs";
-export { createProjectionNext as createProjection } from "./next/projection.cjs";
-export { storeIsShallow, storeHasFamily, storeHasOptimisticFamily } from "./next/store.cjs";
-export { createOptimisticStoreNext as createOptimisticStore } from "./next/optimistic.cjs";
-/** Public createStore: plain form `(initialValue, options?)` and derived writable
- * form `(fn, seed, options?)`. */
-export declare function createStore<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
-export declare function createStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
-export declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => T;
-export declare function snapshot<T>(value: T): T;
-export declare function deep<T>(value: T): T;
-export { storePath } from "./storePath.cjs";
-export type { PathSetter, Part, StorePathRange, ArrayFilterFn, CustomPartial } from "./storePath.cjs";
-export { merge, omit } from "./utils.cjs";