@solidjs/signals 2.0.0-beta.8 → 2.0.0-rc.0

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

@@ -0,0 +1,59 @@
+import type { OptimisticLane } from "./lanes.cjs";
+import type { Computed, Signal } from "./types.cjs";
+/**
+ * Test-mode invariant checks for the async/transition/lane machinery.
+ * Catalog and rationale: packages/solid-signals/INTERNALS-ASYNC-STATE.md.
+ *
+ * These are implementation self-consistency checks, not semantic rules: a
+ * violation means the reactive system contradicted itself.
+ *
+ * They are gated on `__TEST__` (not just `__DEV__`): the per-write Set
+ * tracking and per-flush quiescence sweep are too expensive for shipped dev
+ * builds and for benchmarks (they showed up as a 5-21% hit across the
+ * CodSpeed suite when they ran under `__DEV__`). Call sites stay `__DEV__`
+ * guarded so production tree-shakes the calls; each entry point here
+ * early-returns unless `__TEST__` is set, so dev builds pay only a no-op
+ * call. The test suite (vitest run) defines `__TEST__: true`; benchmark mode
+ * defines `__TEST__: false`.
+ */
+type AnyNode = Signal<any> | Computed<any>;
+/** Wired by core.ts at module init to avoid import cycles. */
+export declare const InvariantHooks: {
+    pendingProbeActive: (() => boolean) | null;
+    /** Fresh oracle for what an isPending companion SHOULD read right now. */
+    computePendingState: ((node: AnyNode) => boolean) | null;
+};
+export declare function devTrackHeldPending(node: AnyNode): void;
+export declare function devTrackCompanionOwner(node: AnyNode): void;
+export declare function devTrackOptimistic(node: AnyNode): void;
+export declare function devTrackAffects(node: AnyNode): void;
+/**
+ * Open/close the sanctioned registration window. Call sites are `__DEV__`
+ * guarded (no prod cost); the code inside the window must not throw.
+ */
+export declare function beginAsyncReporterWrites(): void;
+export declare function endAsyncReporterWrites(): void;
+export declare function createAsyncReporters(): Map<Computed<any>, Set<Computed<any>>>;
+/**
+ * INV-2: a node with an *active* override must be registered for reversion in
+ * the queue's or a transition's `_optimisticNodes`. An unregistered active
+ * override would survive transition completion forever. Runs at the end of
+ * every flush (not just quiescence — the invariant holds mid-transition).
+ * (There is no revert-target requirement: authoritative values commit
+ * silently into `_value` under the override mask — A17 — so reverting is
+ * just dropping the override.)
+ */
+export declare function devCheckActiveOverrides(isRegisteredForRevert: (node: AnyNode) => boolean): void;
+/** INV-1: an isPending() probe must never leak past its own call. */
+export declare function devCheckFlushStart(): void;
+/** INV-5: a merged lane's work moved to its root on merge and must stay empty. */
+export declare function devCheckMergedLaneEmpty(lane: OptimisticLane): void;
+export declare function devCensusCompanions(isQueuedForCommit?: (node: AnyNode) => boolean): void;
+/**
+ * Quiescence checks. Run only when the system is fully drained: nothing
+ * scheduled, no active/stashed transitions, no live lanes. At that point no
+ * transition-scoped state may survive, and the lazily-created companions must
+ * agree with a fresh computation of their owner's state.
+ */
+export declare function devCheckQuiescent(isQueuedForCommit: (node: AnyNode) => boolean): void;
+export {};

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

@@ -37,6 +37,8 @@ export declare function resolveLane(el: {
 export declare function resolveTransition(el: {
     _optimisticLane?: OptimisticLane;
     _transition?: Transition | null;
+    _overrideValue?: any;
+    _overrideOwner?: Transition | null;
 }): Transition | null | undefined;
 /**
  * Check if a node has an active optimistic override.

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

@@ -0,0 +1,6 @@
+/**
+ * Installs the engine's hooks. Idempotent; called by every module that can
+ * create optimistic state (verdict.ts at module top level, createOptimistic
+ * and createOptimisticStore at first call) BEFORE any optimistic node exists.
+ */
+export declare function installOptimisticEngine(): void;

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

@@ -2,21 +2,119 @@ 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 new non-tracked reactive context with manual disposal
+ * 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;
+ * });
  *
- * @param fn a function in which the reactive state is scoped
- * @returns the output of `fn`.
+ * // Later, to tear everything down:
+ * dispose();
+ * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
  */

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

@@ -1,5 +1,5 @@
 import { type Heap } from "./heap.cjs";
-import { activeLanes, assignOrMergeLane, findLane } from "./lanes.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";
@@ -11,8 +11,15 @@ export declare let projectionWriteActive: boolean;
 export declare let _hitUnhandledAsync: boolean;
 export declare function registerTransientStoreNode(node: Signal<any>): void;
 export declare function resetUnhandledAsync(): void;
+/**
+ * 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 shouldReadStashedOptimisticValue(node: Signal<any>): boolean;
 export declare function setProjectionWriteActive(value: boolean): void;
 export declare function setTrackedQueueCallback(value: boolean): void;
 export type QueueCallback = (type: number) => void;
@@ -26,12 +33,22 @@ export interface Transition {
     _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>>;
 }
 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;
@@ -47,6 +64,7 @@ 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;
@@ -58,25 +76,95 @@ export declare class Queue implements IQueue {
 }
 export declare class GlobalQueue extends Queue {
     _running: boolean;
-    _pendingNodes: Signal<any>[];
-    _optimisticNodes: OptimisticNode[];
-    _optimisticStores: Set<any>;
+    _batch: Transition;
     static _update: (el: Computed<unknown>) => void;
     static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
-    static _clearOptimisticStore: ((store: any) => void) | null;
+    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 _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;
+    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) | null;
+    static _laneAsyncPending: ((el: 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 function armReaskClear(): void;
 export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
 export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
-export declare function trackOptimisticStore(store: any): 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;
 /**
- * By default, changes are batched on the microtask queue which is an async process. You can flush
- * the queue synchronously to get the latest updates by calling `flush()`.
+ * 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;
 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;

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

@@ -10,6 +10,14 @@ export interface Link {
     _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;
@@ -21,6 +29,17 @@ export interface NodeOptions<T> {
     _noSnapshot?: boolean;
     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;
 }
 export interface RawSignal<T> {
     _subs: Link | null;
@@ -29,17 +48,35 @@ export interface RawSignal<T> {
     _snapshotValue?: any;
     _name?: string;
     _equals: false | ((a: T, b: T) => boolean);
-    _ownedWrite?: boolean;
-    _noSnapshot?: boolean;
+    _config: number;
     _unobserved?: () => void;
     _time: number;
     _transition: Transition | null;
     _pendingValue: T | typeof NOT_PENDING;
     _overrideValue?: T | 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;
     _optimisticLane?: OptimisticLane;
     _pendingSignal?: Signal<boolean>;
     _latestValueComputed?: Computed<T>;
     _parentSource?: Signal<any> | Computed<any>;
+    /**
+     * Live `affects()` marks on this node (refcount). Non-zero is declared
+     * motion: the node — and, via the verdict layer's dep-graph coverage walk,
+     * everything derived from it — reads pending regardless of graph state,
+     * until every declaring transaction settles/reverts and releases its mark.
+     * This count is the mark's ONLY graph state: the dedicated channel stores
+     * nothing downstream and never touches status flags, errors, or pending
+     * sources.
+     */
+    _affectsCount?: number;
 }
 export interface FirewallSignal<T> extends RawSignal<T> {
     _firewall: Computed<any>;
@@ -48,9 +85,10 @@ export interface FirewallSignal<T> extends RawSignal<T> {
 export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
 export interface Owner {
     id?: string;
-    _transparent?: boolean;
-    _childrenForbidden?: boolean;
+    _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>;
@@ -58,16 +96,17 @@ export interface Owner {
     _queue: IQueue;
     _firstChild: Owner | null;
     _nextSibling: Owner | null;
+    _prevSibling: Owner | null;
     _pendingDisposal: Disposable | Disposable[] | null;
     _pendingFirstChild: Owner | null;
 }
 export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
     _depsTail: Link | null;
+    /** Recompute-pass counter; bumped when dep revalidation starts. */
+    _depGen: number;
     _flags: number;
-    _inSnapshotScope?: boolean;
     _blocked?: boolean;
-    _pendingSource?: Computed<any>;
     _pendingSources?: Set<Computed<any>>;
     _error?: unknown;
     _statusFlags: number;
@@ -78,6 +117,29 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _inFlight: PromiseLike<T> | AsyncIterable<T> | null;
     _child: FirewallSignal<any> | null;
     _notifyStatus?: (status?: number, error?: any) => void;
+    /**
+     * Question-scoped pending classification of the node's CURRENT pending
+     * window: `true` means the in-flight recompute is a re-ask of the same
+     * question (refresh/poll/confirm — no tracked input changed value), so the
+     * shown answer still answers the question and the node reads NOT pending.
+     * Set by `recompute` from `REACTIVE_REASK`, cleared on landing
+     * (`clearStatus`). Meaningless while not STATUS_PENDING.
+     */
+    _reask: boolean;
+    /**
+     * 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.
+     */
+    _loading: boolean;
 }
 export interface Root extends Owner {
     _root: true;

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

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

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

@@ -1,9 +1,10 @@
-export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, isRefreshing, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource } from "./core/index.cjs";
+export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, refresh, 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, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.cjs";
+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, resolve, onSettled, onCleanup } from "./signals.cjs";
-export type { Accessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.cjs";
+export type { 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,19 +1,64 @@
 import { type Accessor } from "./signals.cjs";
 export type Maybe<T> = T | void | null | undefined | false;
 /**
- * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
+ * Reactively maps an array, reusing the previously-mapped value for unchanged
+ * items.
  *
- * similar to `Array.prototype.map`, but gets the value and index as accessors, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
+ * 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: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
-    keyed?: boolean | ((item: Item) => any);
+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 repeats a callback function the count provided - underlying helper for the `<Repeat>` control flow
+ * 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
  */