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

package/dist/prod/store/next/target.js

@@ -1,20 +0,0 @@
-/**
- * Ownership (first cut, decision 2026-08-16d): one WeakSet of store-owned
- * backings serving both the production identity-skip guard and the false
- * no-mutation oracle.
- */
-const ownedRaw = new WeakSet;
-
-/** raw → target. The only raw-keyed lookup; boundary mechanism (O8). */ const storeNextLookup = new WeakMap;
-
-function devAssertNeverUserMutation(o) {
-    return;
-}
-
-let optHooks = null;
-
-function setOptHooks(o) {
-    optHooks = o;
-}
-
-export { devAssertNeverUserMutation, optHooks, ownedRaw, setOptHooks, storeNextLookup };

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

@@ -1,6 +0,0 @@
-/**
- * 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/store/next/optimistic.d.ts

@@ -1,20 +0,0 @@
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.js";
-import type { StoreNextFamily, StoreNextTarget } from "./target.js";
-export declare function createOptimisticStoreNext<T extends object = {}>(first: T | ((store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>), second?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
-/** Diff the draft against the current OPTIMISTIC VIEW (committed + active
- * overrides — the same view the draft was seeded from) and emit engine writes
- * for exactly the changed keys. Visible-view diffing keeps no-op writes from
- * entangling lanes (RUL-10 / opt R38). */
-export declare function notifyOptimisticWrites(t: StoreNextTarget, pb: Record<PropertyKey, any>): void;
-/**
- * Landing consumption (RUL-2): fresh authoritative data supersedes every
- * tentative override in the family. Mirrors legacy clearProjectionOverride —
- * drop the override, clear lane/ownership, notify subscribers whose visible
- * value changes (reversion effects go to regular queues via the projection
- * write posture the caller holds).
- */
-export declare function consumeOverridesNext(fam: StoreNextFamily): void;
-/** Optimistic-view composition for snapshot/deep (O1: snapshot is the CURRENT
- * view, lane values included; a fresh copy per call during pending windows —
- * RUL-12). Returns `src` untouched when no override is active on `t`. */
-export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;

package/dist/types/store/next/projection.d.ts

@@ -1,8 +0,0 @@
-import { type Computed, type Refreshable } from "../../core/index.js";
-import { type NoFn, type ProjectionOptions, type Store } from "../store.js";
-export declare function createProjectionNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): Refreshable<Store<T>>;
-/** Derived writable store (legacy parity): a projection whose public setter
- * masks the recompute for the tick (core R31 — the manual write wins over a
- * same-flush dependency change). */
-export declare function createStoreDerivedNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [Refreshable<Store<T>>, (f: (draft: T) => T | void) => void];
-export declare function runProjectionComputedNext<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any) | null, wrapCommit?: (write: () => void) => void, onDraftWrite?: () => void): Computed<void | T>;

package/dist/types/store/next/reconcile.d.ts

@@ -1,3 +0,0 @@
-type KeyFn = (item: any) => any;
-export declare function reconcileNextState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
-export {};

package/dist/types/store/next/store.d.ts

@@ -1,77 +0,0 @@
-import type { Signal } from "../../core/types.js";
-import { type StoreNextFamily, type StoreNextTarget } from "./target.js";
-export declare function wrapNext<T extends Record<PropertyKey, any>>(value: T, parent?: StoreNextTarget | null, parentKey?: PropertyKey | null, fam?: StoreNextFamily | null): T;
-/** Unwrap our own proxies to their current backing; leave everything else. */
-export declare function unwrapValue(v: any): any;
-export declare function getNode(target: StoreNextTarget, key: PropertyKey, current: any): Signal<any>;
-export declare function getHasNode(target: StoreNextTarget, key: PropertyKey, present: boolean): Signal<boolean>;
-export declare function getKeySetNode(target: StoreNextTarget): Signal<number>;
-/** Deep-witness bump: any value/shape change on a record with a live deep()
- * subscriber notifies it. One null check when unused. */
-export declare function bumpDeep(t: StoreNextTarget): void;
-/** Downgrade a prototype-overlay pending backing to the clone path: builds
- * the real container (committed + overlay writes − deletes) that fold will
- * SWAP in as the committed backing, exactly as if the draft had started on
- * the clone path. Consumers that need a complete container (reconcile's
- * diff walks, drafts escaping into other storage) call this. */
-export declare function materializePB(target: StoreNextTarget): void;
-/**
- * Adoption (2026-08-16c): the incoming object becomes the committed backing
- * IMMEDIATELY — reconcile is eagerly visible to every reader (shipped
- * contract; only its notifications batch), unlike setter writes which stay
- * pending until flush. Ownership resets (incoming is unowned/user data). Any
- * staged draft clone folds into the diff and is discarded — next is the
- * authoritative base (R21/R32).
- */
-export declare function adoptPB(target: StoreNextTarget, incoming: Record<PropertyKey, any>, eager?: boolean): void;
-/** Same logical slot: both values resolve to one (re-pointed) child target —
- * adoption preserved identity, so the slot did not change (R9). */
-export declare function targetsEqual(ov: any, nv: any): boolean;
-/**
- * The fold diff walks SUBSCRIPTION KEYS ONLY (legacy parity: `for key in
- * nodes`): nodes exist exactly where something tracked, so unobserved data
- * costs nothing here regardless of object size. Accessor safety rides the
- * sticky `t.a` flag — a node's key was necessarily read, so the get trap has
- * already seen whether it is an accessor.
- */
-/** One node's fold notification (shared by notifyFold's walk and the fused
- * adoption walk): accessor-aware compare + equality/identity-gated setSignal. */
-export declare function notifyKeyDiff(node: Signal<any>, key: PropertyKey, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>, probe?: boolean): void;
-/** Accessor-flag probe for the fused walk's early-continue (accessor keys
- * can never identity-skip: their VALUE is the descriptor's product). */
-export declare function hasAccessorFlag(node: Signal<any>): boolean;
-/** Fused-walk per-key notification with values already in hand: the caller
- * fetched both sides and handled the identity skip; this applies the
- * accessor branch (cached flag only — reconcile channel) or the plain
- * equality/identity-gated write. */
-export declare function notifyKeyValue(node: Signal<any>, key: PropertyKey, ov: any, nv: any, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
-/** Presence + membership halves of a fold notification (shared tail). */
-export declare function notifyFoldTail(t: StoreNextTarget, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
-export declare function notifyFold(t: StoreNextTarget, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
-/** Authoritative-write wrapper exported for the optimistic module: sets the
- * scheduler's projectionWriteActive through THIS module's binding (proven to
- * share the instance core reads — cross-module live-binding writes from other
- * store modules were observed not to propagate under the test transform). */
-export declare function runAuthoritative<T>(fn: () => T): T;
-/** Active optimistic override on an armed node (armed slot idles at
- * NOT_PENDING; undefined = unarmed plain node). */
-export declare function hasActiveOverride(node: Signal<any>): boolean;
-export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
-/** Low-level setter primitive: opens write mode on a next proxy, runs `fn`,
- * emits write-time notifications at outermost exit, applies returned
- * replacements as adoptions. `guard=false` skips the owned-scope dev guard —
- * projection recomputes legitimately write from inside their computed. */
-export declare function storeSetterNext<T>(proxy: T, fn: (draft: T) => T | void, guard?: boolean): void;
-export declare function createStoreNext<T extends Record<PropertyKey, any>>(init: T, shallow?: boolean): [T, SetStoreNextFunction<T>];
-/** Tracking deep snapshot (`deep()` for next targets): subscribes to the
- * key-set and every property node at every reachable level, then returns the
- * plain view. Shared references and cycles handled via the visited set. */
-export declare function deepNext<T>(value: T): T;
-/**
- * Snapshot with per-object registration resolution (RUL-12 DAG ruling): every
- * reachable wrappable resolves through its target's CURRENT backing, so
- * privatized subtrees are seen through any parent path. Identity-preserving:
- * a subtree with no substitutions below returns its own object (zero copy for
- * settled, never-diverged graphs).
- */
-export declare function snapshotNext<T>(value: T): T;

package/dist/types/store/next/target.d.ts

@@ -1,117 +0,0 @@
-/**
- * Store rewrite — target & ownership (INTERNALS-STORE-STATE.md §1, §5b).
- *
- * The proxy wraps this internal target, never the raw (proxy-target
- * indirection, decision 2026-08-16d). `b` is the single committed home; `pb`
- * is the per-target pending backing (RUL-1's pending home): the CoW clone
- * created at first draft write, mutated natively by the draft, folded into
- * `b` at flush commit. Adoption (setter replacement / reconcile) parks an
- * UNOWNED incoming object in `pb` — fold swaps it in and ownership resets.
- *
- * Creation budget (§5b): one minimal target + one proxy + one storeLookup
- * entry per read-through object; zero layer slots; nodes, has-nodes, and the
- * key-set node are lazy, materialized only by subscription.
- */
-import type { Computed, Signal } from "../../core/types.js";
-/** Projection family (§7b): children wrap into the family's own map (writes
- * land in the projection, never the source family), and every node created
- * under the family carries the projection computed as its firewall. */
-export interface StoreNextFamily {
-    /** Optimistic family: nodes are born armed (`_overrideValue` slot) so every
-     * write rides the core optimistic engine — lanes, per-transaction ownership,
-     * reverts all core-native (§3, RUL-3). */
-    opt?: boolean;
-    /** Root proxy (registered with the scheduler's optimistic-store set for the
-     * transitionBlocked store-half, #2951). */
-    px?: any;
-    /** Targets currently carrying active node overrides (landing-consumption
-     * walk, RUL-2: visible landed truth replaces optimism). */
-    overlaid?: Set<any>;
-    map: WeakMap<object, StoreNextTarget>;
-    /** The projection computed — assigned after creation (accessor pattern). */
-    node: Computed<any> | null;
-    shallow?: boolean;
-}
-export interface StoreNextTarget {
-    /** Committed backing: source object (shared) or owned clone. */
-    v: Record<PropertyKey, any>;
-    /** Pending backing for the current flush (null when settled). */
-    pb: Record<PropertyKey, any> | null;
-    /** cached: committed backing is another store's proxy (§7b chained). */
-    ch: boolean;
-    /** live value-node count (deleted-key sweep fast-out in the fused walk). */
-    nc: number;
-    /** Lazy per-property subscription nodes (real core signals). */
-    n: Record<PropertyKey, Signal<any>> | null;
-    /** Lazy per-key presence nodes (`in` tracks presence, not value — R13). */
-    h: Record<PropertyKey, Signal<boolean>> | null;
-    /** Lazy key-set node: membership/iteration/$TRACK subscriptions (§6). */
-    k: Signal<number> | null;
-    /** Lazy deep-witness node: `deep()` subscribes ONE node per record instead
-     * of one per path; write paths bump it only when it exists. Separate from
-     * `k` so $TRACK/mapArray never rerun on leaf value changes (R9). */
-    dk: Signal<number> | null;
-    /** Parent target (path copying walks this at commit). */
-    u: StoreNextTarget | null;
-    /** Property key of this target in the parent's backing. */
-    pk: PropertyKey | null;
-    /** The proxy for this target (stable outward identity). */
-    px: any;
-    /** Sticky descendants flag (§6d). */
-    d: boolean;
-    /** Sticky accessors-seen flag: an own accessor property was observed on
-     * this target (first-read scan, defineProperty, or clone scan). Gates the
-     * fold diff's descriptor-safe path and the get trap's descriptor path. */
-    a: boolean;
-    /** Accessor scan performed (scan-once on first trap read; adopted data is
-     * not rescanned — legacy-parity behavior). */
-    sc: boolean;
-    /** Backing was swapped by adoption this batch (fold diff-notifies it). */
-    adopted: boolean;
-    /** Pending backing is a prototype-chain OVERLAY of the committed backing
-     * (`Object.create(v)` — own keys are this batch's writes, everything else
-     * reads through). O(written) per flush instead of O(container) clones
-     * (#3044); commit flattens own keys onto an owned committed backing in
-     * place. Only plain-data non-array non-family containers qualify;
-     * `materializePB` downgrades to the clone path when a consumer needs a
-     * real container (reconcile, draft escape). */
-    ovl: boolean;
-    /** Keys deleted in the overlay window (a prototype overlay cannot shadow
-     * a delete); null when none. */
-    del: Set<PropertyKey> | null;
-    /** Keys written through the traps since the last fold commit. Bounds the
-     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
-     * a record with thousands of per-key subscriptions (selection maps) would
-     * otherwise pay a full node scan on every write. null = no trap writes
-     * this batch (bulk paths fall back to the full scan); WK_ALL sentinel =
-     * bound unusable this batch (array length write implies index deletes). */
-    wk: Set<PropertyKey> | null;
-    /** Projection family, null for plain stores (§7b). */
-    fam: StoreNextFamily | null;
-    /** Shallow store root (values served raw). */
-    s: boolean;
-}
-/**
- * Ownership (first cut, decision 2026-08-16d): one WeakSet of store-owned
- * backings serving both the production identity-skip guard and the __TEST__
- * no-mutation oracle.
- */
-export declare const ownedRaw: WeakSet<object>;
-/** raw → target. The only raw-keyed lookup; boundary mechanism (O8). */
-export declare const storeNextLookup: WeakMap<object, StoreNextTarget>;
-/** __TEST__ oracle: every object ingested from a user (never mutate). */
-export declare const ingestedRaw: WeakSet<object> | null;
-export declare function devAssertNeverUserMutation(target: object): void;
-/** Injection table for optimistic-only store machinery (next/optimistic.ts).
- * Every call site is gated on `fam?.opt`, and optimistic families can only
- * be created by createOptimisticStore — whose install populates this — so
- * the non-null assertions at the sites hold by construction. Keeping the
- * implementations out of next/store.ts lets plain-store bundles tree-shake
- * the optimistic channel entirely. */
-export interface OptStoreHooks {
-    notifyOptimisticWrites(t: any, pb: Record<PropertyKey, any>): void;
-    optimisticView(t: any, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
-    applyTentative(t: any, incoming: any, keyFn: ((item: any) => any) | null): void;
-}
-export declare let optHooks: OptStoreHooks | null;
-export declare function setOptHooks(h: OptStoreHooks): void;

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

@@ -1,47 +0,0 @@
-import type { Accessor } from "./signals.cjs";
-import { type Store } from "./store/store.cjs";
-/**
- * Declares that in-flight work will change the targeted data: the named
- * slot(s) — and everything DERIVED from them — read as pending
- * (`isPending` → `true`) from the declaration until the surrounding
- * transaction settles or reverts. A mark lives on its own channel — a
- * refcount on the marked node plus dep-graph reachability in the verdict
- * layer — so the marked values themselves stay readable (a mark is a promise
- * of change, not an absence of value), no reader ever suspends on one, and
- * completion/settlement accounting never sees one. This is the declaration
- * verb of the pending model — additive only. A mark can turn pending ON for
- * data the graph can't see changing yet; nothing can turn pending OFF while
- * a real change is in flight — a quiet `refresh()` re-ask under a mark still
- * reads pending (declaring the reload is what makes it a real question).
- *
- * Targets:
- * - `affects(store)` — a store proxy (any record, root or nested): every
- *   record reachable from it at declaration time reads pending, including
- *   through captured child proxies (e.g. `<For>` rows). Siblings are
- *   untouched; records added after the declaration are not covered.
- * - `affects(record, key)` — exactly the named slot of the record. One key
- *   per call (keys do NOT form a path — target the owning record directly).
- * - `affects(accessor)` — a source accessor (signal or memo): the source
- *   reads pending.
- *
- * Typically called at the top of an `action` alongside optimistic writes —
- * both are up-front declarations about the same mutation. Outside any
- * transaction the mark is released at the end of the current flush.
- *
- * @example
- * ```ts
- * const send = action(function* (text: string) {
- *   setState(s => { s.messages.push({ text, status: "sending" }); });
- *   affects(state.messages.at(-1)!, "status"); // this slot pends until settle
- *   yield api.send(text);
- * });
- *
- * const reload = action(function* () {
- *   affects(thing);      // the whole store pends…
- *   refresh(thing);      // …over this otherwise-quiet re-ask
- *   yield api.done();
- * });
- * ```
- */
-export declare function affects(target: Accessor<unknown> | Store<object>): void;
-export declare function affects<T extends object>(target: Store<T>, key: keyof T): void;

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

@@ -1,175 +0,0 @@
-import { Queue, type Computed, type Effect } from "./core/index.cjs";
-import type { Signal } from "./core/index.cjs";
-import { type Accessor } from "./signals.cjs";
-export interface BoundaryComputed<T> extends Computed<T> {
-    _propagationMask: number;
-}
-type RevealSlot = CollectionQueue | RevealController;
-type BoolAccessor = () => boolean;
-export type RevealOrder = "sequential" | "together" | "natural";
-type OrderAccessor = () => RevealOrder;
-export declare class RevealController {
-    _orderAccessor: OrderAccessor;
-    _collapsedAccessor: BoolAccessor;
-    _slots: RevealSlot[];
-    _parentController?: RevealController;
-    _disabled: Signal<boolean>;
-    _collapsed: Signal<boolean>;
-    _ready: boolean;
-    _minimallyReady: boolean;
-    _evaluating: boolean;
-    constructor(order: OrderAccessor, collapsed: BoolAccessor);
-    _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
-    _isReady(): boolean;
-    /**
-     * "Minimally ready" = this group has something visible to show under its own policy.
-     * Used by an enclosing `together` group to decide when it can release.
-     * - `together`: every direct slot is minimally ready.
-     * - `sequential`: the first owned slot is minimally ready (frontier can advance).
-     * - `natural`: any owned slot is minimally ready.
-     */
-    _isMinimallyReady(): boolean;
-    _register(slot: RevealSlot): void;
-    _unregister(slot: RevealSlot): void;
-    _evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
-}
-export declare class CollectionQueue extends Queue {
-    _collectionType: number;
-    _sources: Set<Computed<any>>;
-    _tree?: BoundaryComputed<any>;
-    _pending: boolean;
-    _disabled: Signal<boolean>;
-    _error?: Signal<unknown>;
-    _collapsed: Signal<boolean>;
-    _revealController?: RevealController;
-    _initialized: boolean;
-    _onFn: (() => any) | undefined;
-    _prevOn: any;
-    constructor(type: number);
-    run(type: number): void;
-    notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
-    _checkSources(): void;
-}
-/**
- * Lower-level primitive that backs the `<Loading>` flow control. Catches
- * pending async reads inside `fn` and renders `fallback` until they settle.
- *
- * App code should use `<Loading fallback={...}>` instead — reach for this only
- * when authoring custom boundary components.
- *
- * @param fn the tracked subtree
- * @param fallback the fallback shown while async reads in `fn` are unresolved
- * @param options `on` — accessor whose value scopes the boundary; when set,
- *   transitions caused by writes to other reactive sources are *not* caught
- *
- * @example
- * ```tsx
- * // Custom boundary component built on top of the primitive.
- * function MyLoading(props: { fallback: JSX.Element; children: JSX.Element }) {
- *   return createLoadingBoundary(
- *     () => props.children,
- *     () => props.fallback
- *   ) as unknown as JSX.Element;
- * }
- * ```
- */
-export declare function createLoadingBoundary<T, U>(fn: () => T, fallback: () => U, options?: {
-    on?: () => any;
-}): Accessor<T | U>;
-/**
- * Lower-level primitive that backs the `<Errored>` flow control. Catches
- * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
- * `error` is an accessor for the latest captured error; `reset()` recomputes
- * the failing sources so the boundary can attempt to recover.
- *
- * App code should use `<Errored fallback={...}>` instead — reach for this only
- * when authoring custom boundary components.
- *
- * @example
- * ```tsx
- * // Custom boundary that wraps the primitive and adds telemetry.
- * function TracedErrored(props: { fallback: (e: () => unknown) => JSX.Element; children: JSX.Element }) {
- *   return createErrorBoundary(
- *     () => props.children,
- *     (err, reset) => {
- *       reportError(err());
- *       return props.fallback(err);
- *     }
- *   ) as unknown as JSX.Element;
- * }
- * ```
- */
-export declare function createErrorBoundary<T, U>(fn: () => T, fallback: (error: Accessor<unknown>, reset: () => void) => U): Accessor<T | U>;
-/**
- * Coordinate the reveal timing of sibling loading boundaries.
- *
- * Accepts reactive accessors:
- * - `order`: `"sequential"` (default) | `"together"` | `"natural"`.
- *   - `"sequential"` — classic frontier reveal: siblings reveal in registration order
- *     as each resolves; later siblings stay hidden until earlier ones complete.
- *   - `"together"` — every direct slot stays on its fallback until the whole group
- *     is "minimally ready" (each direct slot has produced its own first visible
- *     content under its own order), then the whole group releases at once.
- *   - `"natural"` — children reveal independently (as each resolves). At the top
- *     level this is a no-op compared to not using `createRevealOrder`; the mode
- *     exists for nesting, where the group registers as a single composite slot to
- *     any enclosing `createRevealOrder`.
- * - `collapsed`: only meaningful when `order === "sequential"`. When set, tail siblings
- *   past the frontier suppress their own fallback output. Ignored under `"together"`
- *   and `"natural"` — those orders have no frontier.
- *
- * Nested `createRevealOrder` groups compose: the inner controller registers as a
- * single slot in the outer controller and is held on its fallbacks until the outer
- * releases that slot. Once released, the inner controller runs its own order locally
- * over anything still pending. There is no opt-out from an outer hold.
- *
- * "Minimally ready" is what an order considers its first visible content:
- * - `sequential` — frontier-0 is minimally ready (leaf: on resolve; nested: via its
- *   own minimal signal).
- * - `together` — every direct slot is minimally ready.
- * - `natural` — any direct slot has visible content (leaves on resolve; nested
- *   composites via their own minimal signal).
- *
- * @example
- * ```ts
- * // Primitive form of `<Reveal>` — coordinate sibling loading boundaries
- * // programmatically. App code uses the JSX `<Reveal>` component instead.
- * // Both options are accessors so they can react to state changes.
- * createRevealOrder(
- *   () => renderSiblings(),
- *   { order: () => mode(), collapsed: () => true }
- * );
- * ```
- */
-export declare function createRevealOrder<T>(fn: () => T, options?: {
-    order?: OrderAccessor;
-    collapsed?: BoolAccessor;
-}): T;
-/**
- * Resolves a children value to its renderable form: unwraps zero-arg functions
- * (accessors), recursively flattens arrays, and optionally skips
- * non-rendering values (`null`, `undefined`, `true`, `false`, `""`).
- *
- * Used internally by flow components and by the renderer to walk a children
- * tree. App code rarely needs this directly — see `children()` in `solid-js`
- * for the user-facing helper that memoizes the result.
- *
- * @param children value or array of values to flatten
- * @param options
- *   - `skipNonRendered` — drop values that won't render
- *   - `doNotUnwrap` — leave function children as-is (caller will resolve)
- *
- * @example
- * ```ts
- * // Custom renderer walking a children tree manually. Most authors should
- * // use `children()` from solid-js, which memoizes the resolved value.
- * function renderChildren(value: unknown): unknown {
- *   return flatten(value, { skipNonRendered: true });
- * }
- * ```
- */
-export declare function flatten(children: any, options?: {
-    skipNonRendered?: boolean;
-    doNotUnwrap?: boolean;
-}): any;
-export {};

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

@@ -1,64 +0,0 @@
-/**
- * The primitive for mutations: imperative async workflows whose *writes span
- * an async gap* — optimistic write, server round-trip, reconciling write —
- * where intermediate state must not leak and failure must revert cleanly
- * (pair with `createOptimistic` / `createOptimisticStore`).
- *
- * Navigation-shaped updates do not need an action. A plain setter call is
- * enough: reads pull the async, and downstream async computeds hold their
- * previous values per-node until the new ones are ready (`isPending` /
- * `latest` expose the in-flight state). Reach for `action` only when writes
- * happen *after* async work, not merely upstream of it.
- *
- * Framework-level actions (router form actions, server actions) are
- * specializations of this primitive: they are actions in exactly this sense —
- * the same transactional semantics — with form binding, serialization, and
- * submission tracking layered on top. The shared name is deliberate.
- *
- * Wraps a generator function so each invocation runs as a single transaction
- * (a "transition") that batches every signal/store write between yields. The
- * surrounding UI sees one atomic update per yielded step; nothing is committed
- * until the action either completes or the next `yield` resolves.
- *
- * `yield` is the transaction-safe suspension point: the action waits for a
- * yielded promise and re-enters the transaction before running the code after
- * it. A plain `await` does NOT — the runtime has no hook into an async
- * generator's internal await continuations, so writes to fresh signals
- * between an `await` and the next `yield` escape the transaction and commit
- * immediately. `await` is still the ergonomic choice for typed results; just
- * put a bare `yield` before any writes that follow it:
- *
- * ```ts
- * const saved = await api.createTodo(text); // typed result
- * yield; // re-enter the transaction before writing
- * setTodos(t => { ... });
- * ```
- *
- * (For the same reason, don't call `flush()` inside an action body — it
- * drains the transaction mid-step.)
- *
- * Each call returns a `Promise` that resolves with the generator's return
- * value, or rejects if it throws. Pair with `createOptimistic` /
- * `createOptimisticStore` to apply tentative writes that auto-revert if the
- * action fails.
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
- *
- * const addTodo = action(async function* (text: string) {
- *   const tempId = crypto.randomUUID();
- *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
- *   const saved = await api.createTodo(text); // network round-trip, typed
- *   yield; // re-enter the transaction
- *   setTodos(t => {
- *     const i = t.findIndex(x => x.id === tempId);
- *     if (i >= 0) t[i] = saved;
- *   });
- *   return saved;
- * });
- *
- * await addTodo("buy milk");
- * ```
- */
-export declare function action<Args extends any[], Y, R>(genFn: (...args: Args) => Generator<Y, R, any> | AsyncGenerator<Y, R, any>): (...args: Args) => Promise<R>;

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

@@ -1,21 +0,0 @@
-import { NotReadyError } from "./error.cjs";
-import { type OptimisticLane } from "./lanes.cjs";
-import type { Computed, Link } from "./types.cjs";
-export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
-/**
- * A loading-window node hit an unready source (sync throw in recompute, or a
- * NotReadyError-rejected flight): register for the source's settle — the
- * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
- * with NO read-visible pending status, no downstream propagation, no
- * transition, no lane registration. Commit #0 keeps serving.
- */
-export declare function parkLoadingWindow(el: Computed<any>, e: NotReadyError): void;
-export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
-export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
-export declare function releaseSettledDependents(el: Computed<any>): void;
-export declare function settleErroredDependents(el: Computed<any>, error: any): void;
-export declare function settlePendingSource(el: Computed<any>): void;
-export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
-export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
-export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;
-export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;

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

@@ -1,52 +0,0 @@
-import type { Computed, Signal } from "./types.cjs";
-/**
- * Dev-only observability hook points for the reactive core.
- *
- * Core's obligation is to call these with true facts at the moments they
- * happen; ALL attribution semantics (stamps, cause chains, timings, warnings)
- * live in the engine that installs them (attribution.ts — same pattern as the
- * GlobalQueue._* feature slots). `attrHooks` is null unless an engine is
- * installed, so the disabled cost is one null check per site, and prod builds
- * fold every site out behind __DEV__.
- *
- * IMPORTANT for implementers of call sites: a hook call must never sit inside
- * a `try` block — rollup's tryCatchDeoptimization retains functions referenced
- * inside `try` even behind a folded __DEV__ guard, which re-couples the dev
- * engine into prod bundles (#2883 harness). Set a local flag inside the try
- * and call the hook after the catch.
- */
-export interface AttributionHooks {
-    /**
-     * A recompute is starting; `el._deps` still holds the previous run's links.
-     * Always paired with `recomputeEnd` (recompute has no early returns).
-     */
-    recomputeStart(el: Computed<any>, create: boolean): void;
-    /**
-     * The recompute finished. `changed` = committed a changed value (false for
-     * errored runs); `optimistic` = ran under an optimistic lane / lane-dirty
-     * posture; `transition` = a transition was active or owns this node;
-     * `held` = the value went to `_pendingValue` (a transition hold) rather
-     * than committing directly — its reveal happens later on the transition's
-     * own schedule.
-     */
-    recomputeEnd(el: Computed<any>, create: boolean, changed: boolean, optimistic: boolean, transition: boolean, held: boolean): void;
-    /** A non-effect computed committed a changed value during a re-run. */
-    derivedChanged(el: Computed<any>): void;
-    /** A signal write committed (value passed the equality gate). */
-    write(el: Signal<any> | Computed<any>, prev: unknown, value: unknown): void;
-    /** refresh() invalidated this node (self-invalidation, no dep changed). */
-    refreshed(el: Computed<any>): void;
-    /** An async landing is about to apply its value (before any branch). */
-    asyncStart(el: Computed<any>): void;
-    /**
-     * The async landing finished. `direct` = the landing applies the value
-     * itself (lane/override paths); false = it went through setSignal, whose
-     * own `write` hook already saw any committed change. Fired whether or not
-     * the landing committed — call sites cannot carry that fact out of their
-     * try blocks (see the try rule above), so the engine derives committed-ness
-     * from the node's state against its asyncStart snapshot.
-     */
-    asyncEnd(el: Computed<any>, prev: unknown, value: unknown, direct: boolean): void;
-}
-export declare let attrHooks: AttributionHooks | null;
-export declare function setAttributionHooks(hooks: AttributionHooks | null): void;