@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.8

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

@@ -1,91 +0,0 @@
-import type { Owner } from "../../core/types.js";
-import { type StoreNextTarget } from "./target.js";
-export type PatchFn = (next: any, prev: any, force?: boolean) => void;
-interface PatchEntry {
-    fn: PatchFn;
-    owner: Owner | null;
-}
-/**
- * Emit a record's visibility transition. Callers gate on `hasPatches()` and
- * `t.d` cheaply; this function re-checks and walks ancestors (§4b).
- */
-export declare function emitPatch(t: StoreNextTarget, next: any, prev: any): void;
-/** Emission for sites that already stand at the record with both sides in
- * hand and have already handled ancestors (the adoption walk descends —
- * parents were visited first), so no bubbling walk. */
-export declare function emitPatchLocal(t: StoreNextTarget, next: any, prev: any): void;
-export declare function emitPatchOptimistic(t: StoreNextTarget, next: any, prev: any): void;
-/** Row-ops emission at OPTIMISTIC (lane) timing: user drafts on an
- * optimistic family must show structure IN FLIGHT — bypassing the
- * transition stash exactly like emitPatchOptimistic. Two forms:
- * - `ops` given (write site): `nextRows` is the draft's intended visible
- *   list, ops the identity diff against the pre-write optimistic view.
- * - `ops === null` (revert site): RESYNC — the consumer rebuilds retention
- *   by row identity against the live post-revert view, resolved from the
- *   target at drain time (overrides are gone by then, so `pb ?? v` IS the
- *   committed truth). */
-export declare function emitRowOpsOptimistic(t: StoreNextTarget, nextRows: any[] | null, ops: RowOps | null): void;
-/** Test-only accounting probe: the live registration count must return to
- * baseline across register/unbind/demote cycles. @internal */
-export declare function patchCountForTests(): number;
-export declare function hasPatches(): boolean;
-export declare function registerPatch(record: any, fn: PatchFn): () => void;
-/** Dual-driver bind probe (compiler runtime contract): when `record` is a
- * patchable store record, returns its CURRENT raw backing (the driver's
- * initial force-apply reads it directly — no proxy traffic, no tracking);
- * returns undefined otherwise (driver falls back to the effect path).
- * Not patchable: non-records, non-proxies, accessor-bearing records
- * (patches read raw — getters need tracked evaluation), broken chains. */
-export declare function patchableRaw(record: any): Record<PropertyKey, any> | undefined;
-/** Accessor demotion (design §5): a record that acquires an accessor after
- * registration stops being patchable — reads must go through tracked
- * evaluation. Clears patches and repairs the global count; callers re-drive
- * the pulled bodies (demoteToEffects). */
-export declare function demotePatches(t: StoreNextTarget): PatchEntry[] | null;
-/** The demotion re-drive (re-audit blocker 3): each pulled body becomes the
- * SAME dual-driver effect fallback the web runtime would have chosen had the
- * record carried the accessor at bind — a tracked compute pass (next === prev
- * short-circuits every compare into a pure read THROUGH THE PROXY, so getter
- * dependencies track) plus an untracked force-apply at effect timing.
- *
- * Creation is DEFERRED to the effect phase: the trap that discovers the
- * accessor runs mid-draft, and an effect's initial pass must not read
- * through the proxy inside the write window. The record's own transition
- * for that draft is covered by the new effect's initial force-apply.
- *
- * Known edge (documented): a demoted LIST-ROW body re-drives under its
- * registering owner (the list owner), so per-row severing on removal is
- * lost for demoted rows — the effect lives until the LIST disposes. Rows
- * only demote when user code defines an accessor on a row record at
- * runtime. */
-export declare function demoteToEffects(t: StoreNextTarget): void;
-/** Structural ops for one keyed-array transition. `prefix` rows key-matched
- * in place; for each later index i (absolute), `sources[i - prefix]` is the
- * OLD index its row retained from, or -1 for a new row. `removed` holds the
- * dropped old row values (unbind/teardown handles). Aligned value ticks emit
- * NOTHING — ops exist only when structure changed. */
-export interface RowOps {
-    prefix: number;
-    sources: number[];
-    removed: any[];
-}
-/** `ops === null` is the RESYNC form (optimistic revert): the consumer
- * rebuilds retention by row identity against `next` (the live view). */
-export type RowOpsFn = (next: any[], ops: RowOps | null) => void;
-/** Register a structural-ops consumer on a keyed store array (the list
- * container's channel — what `For` consumes through the seam). */
-export declare function registerRowOps(array: any, fn: RowOpsFn): () => void;
-/** Slot patches (shallow arrays) ride the same apply queue: the walk emits
- * per aligned value-replaced slot; application happens at effect phase under
- * the registration owner's lifetime. */
-export declare function emitSlotPatch(t: StoreNextTarget, index: number, next: any, prev: any): void;
-/** Slot patch for shallow arrays: the reconcile walk emits (index, next,
- * prev) for KEY-ALIGNED value-replaced slots (structure rides row ops), and
- * the emission queues through the patch apply queue — effect-phase timing,
- * transition stamping, disposed-owner drop — like every other channel. */
-export declare function registerSlotPatchNext(arr: any, fn: (index: number, next: any, prev: any) => void): () => void;
-/** Row-ops ride the SAME apply queue/timing as record patches: transition-
- * stamped, applied at effect phase, in emission order (structure before the
- * new rows' own patches can exist; retained rows' value patches commute). */
-export declare function emitRowOps(t: StoreNextTarget, next: any[], ops: RowOps): void;
-export {};

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,23 +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>;
-/** Fire and clear a node's iterator-flight cancellation hook (#3122). */
-export declare function releaseFlightTeardown(el: Computed<any>): void;
-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,63 +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;
-    /**
-     * A new async flight entered the system (`_inFlight` was just assigned
-     * during a recompute of `el`). Always fired inside the owning recompute —
-     * both call paths (core's recompute and the projection self-registration)
-     * run within one — so the engine can read the current frame stack to link
-     * the flight to the change that caused it (waterfall chaining). `flight`
-     * is the registered thenable/iterable itself: the engine keys a first-seen
-     * origin registry on its identity, so shared and preloader-marked promises
-     * carry their true start time instead of the moment the graph saw them.
-     */
-    flightStart(el: Computed<any>, flight: object): 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;