@solidjs/signals 2.0.0-rc.17 → 2.0.0-rc.19

package/dist/prod/store/target.js

@@ -17,31 +17,27 @@ const $OWNER = Symbol(0);
 /** raw → target for plain (family-less) stores. Family stores use their own
  * map so one raw can wrap once per family (§7b). */ const storeLookup = new WeakMap;
 
-function setLookup(e, o) {
-    (o.fam?.map ?? storeLookup).set(e, o);
+function setLookup(o, e) {
+    (e.fam?.map ?? storeLookup).set(o, e);
 }
 
-function isOwned(e) {
-    return e[$OWNER] !== undefined;
+function isOwned(o) {
+    return o[$OWNER] !== undefined;
 }
 
 /** The target wrapping `raw` in `fam` (or the plain lookup). An owned raw
- * answers from its stamp; a user raw from the map. */ function lookupTarget(e, o) {
-    const t = e[$OWNER];
-    return t !== undefined && t.fam === o ? t : (o?.map ?? storeLookup).get(e);
-}
-
-function devAssertNeverUserMutation(e) {
-    return;
+ * answers from its stamp; a user raw from the map. */ function lookupTarget(o, e) {
+    const n = o[$OWNER];
+    return n !== undefined && n.fam === e ? n : (e?.map ?? storeLookup).get(o);
 }
 
 /** Sticky descendants flag up the parent chain (§6d): adoption descends
- * into a changed child pair only where a target with nodes exists below. */ function markDescendants(e) {
-    let o = e;
-    while (o && !o.d) {
-        o.d = true;
-        o = o.u;
+ * into a changed child pair only where a target with nodes exists below. */ function markDescendants(o) {
+    let e = o;
+    while (e && !e.d) {
+        e.d = true;
+        e = e.u;
     }
 }
 
-export { $OWNER, devAssertNeverUserMutation, isOwned, lookupTarget, markDescendants, setLookup, storeLookup };
+export { $OWNER, isOwned, lookupTarget, markDescendants, setLookup, storeLookup };

package/dist/prod/store/utils.js

@@ -921,6 +921,8 @@ const omitTraps = {
         f++;
         i = o;
         if (typeof o === "function") {
+            // Observe tiers name it and exempt it from UNSTABLE_MEMO_OUTPUT (see
+            // CONFIG_KEY_BAG); prod passes no options.
             n[r] = createMemo(o);
             t[r++] = SOURCE_MEMO;
             continue;

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

@@ -40,6 +40,14 @@
  * yield until(() => todos.some(t => t.id === saved.id));
  * ```
  *
+ * The same holds inside an async helper the action yields
+ * (`yield (async () => { ... })()`): everything after its first `await` runs
+ * outside the transaction. An `await refresh(x)` or `await until(...)` there
+ * waits for this action's commit, which waits on the helper, so it hangs
+ * whenever `x` re-ran during the action (#4263) and works otherwise. Call
+ * `refresh(x)` in the generator once the helper returns; `yield` it only when
+ * the action needs the fresh value.
+ *
  * (For the same reason, don't call `flush()` inside an action body — it
  * cannot reveal the held writes and is refused.)
  *

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

@@ -27,12 +27,22 @@ export declare function settlePendingSource(el: Computed<any>, source?: Computed
 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;
+/**
+ * Internal (not a package export): run `fn` when the current pass's flight
+ * is superseded, at the same instant as the iterator close above, instead of
+ * when the replacing pass commits (owner cleanups wait for that). Chains onto
+ * the node's teardown slot; fires once with it. A no-op unless the ambient
+ * owner is a computed in its own pass. `consumeIterator` fills the slot
+ * before its first pull, so a source opened in an async generator's body
+ * (`for await`) composes after the generator's close.
+ */
+export declare function onSupersede(fn: () => void): void;
 export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void, onError?: (error: unknown, pending: boolean) => 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): void;
+export declare function notifyStatus(el: Computed<any>, status: number, error: any): void;
 /** The dependents' half of `notifyStatus`: `el`'s status reaches each
  * subscriber as a propagated mark (or a re-derive). On its own for a store
  * family's leaves, which are not the derive's dependents — the family
  * propagates the derive's status from each leaf to the leaf's readers
  * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */
-export declare function propagateStatus(el: Computed<any>, status: number, error: any, downstreamBlockStatus?: boolean): void;
+export declare function propagateStatus(el: Computed<any>, status: number, error: any): void;

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

@@ -185,10 +185,30 @@ export declare const CONFIG_WIDE: number;
  * creation by dev builds only (the observe artifact mangles the option name,
  * as it does `_wide`). */
 export declare const CONFIG_SUPERSEDES: number;
+/** Observe tiers only: the memo `merge()` creates for a function source — a
+ * key bag readers consume key by key, built by the framework (a compiled
+ * component spread) with options no user can reach. The attribution engine's
+ * UNSTABLE_MEMO_OUTPUT skips it: a fresh-but-equal bag is the idiom
+ * (`{...(on() ? { a } : {})}`), and the advice (`equals`) cannot be applied
+ * (#4256). Set through `_extraConfig` by observe builds only. */
+export declare const CONFIG_KEY_BAG: number;
+/** The frame (rule 3, D-3): a render effect (set at creation, as
+ * `EFFECT_RENDER << 23` — keep the two in step), and a boundary's tree and
+ * output (boundaries.ts) — structure between the content and the render
+ * effect that shows it, not a user derivation of the content. Outside a
+ * hold's own flush it reads that hold's values as committed and is
+ * re-derived at its landing, and a re-pass of it publishes mainline: it
+ * joins nothing, so two mounts under one boundary made in separate flushes
+ * keep their holds apart (D-4, S-5 rows 1′–3′, #4283). */
+export declare const CONFIG_FRAME: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;
 export declare const STATUS_UNINITIALIZED: number;
+/** An error that answered a node's first read (no value has ever landed):
+ * the error, not UNINITIALIZED, is its status while shown, but a re-ask
+ * makes it uninitialized-pending again — it still has no value (#4244). */
+export declare const STATUS_NO_VALUE: number;
 /** `catchHook`'s answer when the catcher is a boundary re-armed by
  * `on` (truthy, as any catch): what it collects is its own, not the hold's. */
 export declare const CAUGHT_REARMED = 2;
@@ -219,3 +239,8 @@ export declare const $REFRESH: unique symbol;
 export type Refreshable<T> = T & {
     readonly [$REFRESH]: any;
 };
+/** `Set` under a module binding. Bundlers mark a bare `new Set()` pure with
+ * a `/* @__PURE__ *\/` comment that survives minification (16 bytes a site);
+ * a construction through a binding carries none. Same constructor, so the
+ * same objects. */
+export declare const NewSet: SetConstructor;

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

@@ -20,7 +20,20 @@ export declare let context: Owner | null;
 export declare let snapshotCaptureActive: boolean;
 export declare let snapshotSources: Set<any> | null;
 export declare function setSnapshotCapture(active: boolean): void;
-export declare function markSnapshotScope(owner: Owner): void;
+/**
+ * Marks `owner` a snapshot scope: while capture is on, the readers created
+ * under it serve each source's snapshot (the value it had when hydration
+ * began) and replay at `releaseSnapshotScope`.
+ *
+ * With `served` (hydration), `owner` is instead a hydrated computed and
+ * `served` its server answer — what the server rendered every reader of the
+ * node with — landing after the node was created pending (so the creation
+ * arm skipped it). It becomes the node's snapshot when it has none, whether
+ * the node committed the answer or a client write had already taken its
+ * compute over. A claim made later reads the value its markup shows, and
+ * replays the node's own value at its release, as for a written signal.
+ */
+export declare function markSnapshotScope(owner: Owner, served?: unknown): void;
 export declare function releaseSnapshotScope(owner: Owner): void;
 export declare function clearSnapshots(): void;
 export declare function recompute(el: Computed<any>, create?: boolean): void;
@@ -68,13 +81,13 @@ export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val:
  * channel (`_x._notifyStatus`) went with them; effects are the only
  * display consumers.
  */
-export declare let effectStatusNotify: ((this: any, status?: number, error?: any) => void) | null;
+export declare let effectStatusNotify: ((this: any) => void) | null;
 export declare function setEffectStatusNotify(fn: NonNullable<typeof effectStatusNotify>): void;
 /** Resolve a node's status notifier: effect nodes (`_type` — EFFECT_PURE is
  * 0, and only effect literals carry the field) get the shared notifier.
  * Presence doubles as the "display consumer" membership test in the status
  * walks, exactly as the per-node field did when every effect carried one. */
-export declare function statusNotifierOf(el: any): ((this: any, status?: number, error?: any) => void) | undefined;
+export declare function statusNotifierOf(el: any): ((this: any) => void) | null;
 export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
 /** A store slot node (CONFIG_SLOT_NODE): the whole node in ONE literal — the
@@ -128,7 +141,23 @@ export declare let disposalDepth: number;
 export declare function enterDisposal(): void;
 export declare function exitDisposal(): void;
 export declare function resetDisposalDepth(): void;
-export declare function setStrictRead(v: string | false): string | false;
+/**
+ * Dev-only: the DOM event being dispatched when the open strict-read window
+ * opened (`globalThis.event`; null between dispatches and off the main
+ * thread's Window), or `ANY_EVENT` when the window did not record one. A DOM
+ * call made in an effect callback that dispatches events synchronously
+ * (`el.focus()`, `el.click()`, `dialog.showModal()`) runs that event's
+ * handlers inside the window; a handler is a one-shot snapshot whoever
+ * dispatched the event, so a read made while a different event is current is
+ * outside the window (#4235). Only queued effect runs record the event, read
+ * once per queue (the getter is costly under jsdom); `strictReadActive` is
+ * the check.
+ */
+export declare let strictReadEvent: unknown;
+export declare const dispatchingEvent: () => unknown;
+export declare function setStrictRead(v: string | false, event?: unknown): string | false;
+/** Dev-only: is the strict-read window open for a read made now? */
+export declare function strictReadActive(): boolean;
 /**
  * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
  * subscribe the current scope. Returns whatever `fn` returns.

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

@@ -16,7 +16,7 @@ export interface DevHooks {
  * `warn`/`error` as failures unless they opt in to `info`.
  */
 export type DiagnosticSeverity = "info" | "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ASYNC_STORE_SETTER" | "STORE_WRITE_OUTSIDE_SETTER" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "SETTLE_WALK_UNINITIALIZED_SOURCE" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_EFFECT_CALLBACK" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "LOADING_ON_OUTSIDE_HOLD" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "UNTRACKED_READ_AFTER_AWAIT" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "GRAPH_GROWTH" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WASTED_RECOMPUTE" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT" | "SILENT_HOLD" | "LONG_HOLD" | "UNTRACKED_ASYNC_HANDLER" | "ABANDONED_FLIGHTS" | "FALLBACK_FLASH" | "STACKED_HOLDS" | "OPTIMISTIC_REVERTED" | "EFFECT_WRITES_OWN_SOURCE" | "EFFECT_RELAY_TEAR" | "IMMUTABLE_UPDATE_IN_STORE" | "UNSTABLE_LIST_IDENTITY" | "SSR_RENDER_ERROR_CONTAINED" | "SSR_SUBTREE_ABANDONED" | "SSR_STREAM_ABANDONED" | "SSR_CLIENT_CONTENT_MASKED" | "LATE_HEADER_WRITE" | "SERVER_ERROR_SANITIZED" | "SSR_BOUNDARY_WATERFALL" | "SSR_UNDECLARED_LIVE_SOURCE" | "SSR_LIVE_HOLE_LATCHED" | "SERVER_WRITE" | "REVEAL_IN_RENDER_TO_STRING" | "LAZY_ASSET_UNMAPPED" | "PRELOAD_DESCRIPTOR_INVALID" | "HEAD_TAG_INVALID" | "UNRECOGNIZED_INSERT_VALUE" | "UNSCOPED_HOLE_ALLOCATED_IDS" | "LOWERCASE_EVENT_ATTRIBUTE" | "UNCOMMITTED_INPUT_OVERWRITTEN" | "FRAME_MARKER_CORRUPTED" | "DYNAMIC_ASYNC_COMPONENT";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ASYNC_STORE_SETTER" | "STORE_WRITE_OUTSIDE_SETTER" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "ON_FLUSH_IN_OWNED_SCOPE" | "SETTLE_WALK_UNINITIALIZED_SOURCE" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_EFFECT_CALLBACK" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "LOADING_ON_OUTSIDE_HOLD" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "UNTRACKED_READ_AFTER_AWAIT" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "GRAPH_GROWTH" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WASTED_RECOMPUTE" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT" | "SILENT_HOLD" | "LONG_HOLD" | "UNTRACKED_ASYNC_HANDLER" | "ABANDONED_FLIGHTS" | "FALLBACK_FLASH" | "STACKED_HOLDS" | "OPTIMISTIC_REVERTED" | "EFFECT_WRITES_OWN_SOURCE" | "EFFECT_RELAY_TEAR" | "IMMUTABLE_UPDATE_IN_STORE" | "UNSTABLE_LIST_IDENTITY" | "SSR_RENDER_ERROR_CONTAINED" | "SSR_SUBTREE_ABANDONED" | "SSR_STREAM_ABANDONED" | "SSR_CLIENT_CONTENT_MASKED" | "LATE_HEADER_WRITE" | "SERVER_ERROR_SANITIZED" | "SSR_BOUNDARY_WATERFALL" | "SSR_UNDECLARED_LIVE_SOURCE" | "SSR_LIVE_HOLE_LATCHED" | "SERVER_WRITE" | "REVEAL_IN_RENDER_TO_STRING" | "LAZY_ASSET_UNMAPPED" | "PRELOAD_DESCRIPTOR_INVALID" | "HEAD_TAG_INVALID" | "UNRECOGNIZED_INSERT_VALUE" | "UNSCOPED_HOLE_ALLOCATED_IDS" | "LOWERCASE_EVENT_ATTRIBUTE" | "UNCOMMITTED_INPUT_OVERWRITTEN" | "FRAME_MARKER_CORRUPTED" | "DYNAMIC_ASYNC_COMPONENT" | "ASYNC_MEMO_ELEMENT";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error" | "perf" | "graph"
 /** Perceived responsiveness: the runtime behaved correctly but the user saw no feedback. */
  | "responsiveness"

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

@@ -11,7 +11,7 @@ export type { Computed, Disposable, Link, Owner, Root, Signal, NodeOptions } fro
 export { effect, trackedEffect, type Effect, type TrackedEffect } from "./effect.js";
 export { flush, GlobalQueue, enforceLoadingBoundary, resetErrorHalt, type IQueue, type QueueCallback } from "./scheduler.js";
 export type { InteractionRef, NavigationRef } from "./attribution-hooks.js";
-export { ROOT_ERROR_HOOK } from "./scheduler.js";
+export { ROOT_ERROR_HOOK, clock } from "./scheduler.js";
 export { configureClientErrors, type ClientErrorContext, type ClientErrorHook, type ClientErrorsConfig } from "./error-hooks.js";
 export { DEV, OBSERVE, setConsoleFooter, type AttributionSlot, type Dev, type Observe, type ServerObserve, type Records, type RecordTypes, type HostRecordTypes, type RecordType, type RecordEvent, type RecordLive, type RecordListener, type RecordSubscribeOptions, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type DiagnosticListener, type Diagnostics, type DiagnosticSeverity, type DiagnosticSubject } from "./dev.js";
 export * from "./constants.js";

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

@@ -60,5 +60,9 @@ export declare function supersede(n: Signal<any> | Computed<any>, value: unknown
  * has shown, or one the seam has not judged yet (its run waits on the
  * verdict: released if the lane shows, held if it blocks) — and sees the
  * lane's latest. NOT_PENDING falls through: lane work's read of a pending
- * member throws like any. */
+ * member throws like any. A verdict reader entering a lane the seam has
+ * not judged reads ahead of it like a staging read: if the seam holds the
+ * lane, the pass re-derives on the screen (`entered`, #4284) — `latest()`
+ * beside the lane's nodes tears ahead of the hold however the reads are
+ * grouped into effects. */
 export declare function laneRead(c: Computed<any> | null, el: Signal<any> | Computed<any>): unknown;

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

@@ -212,7 +212,14 @@ export declare function setQuestion(q: number): void;
 export declare function nextQuestion(): number;
 export declare const MAINLINE_QUESTION = 2147483647;
 export declare let inEffectCallback: boolean;
-export declare function setEffectCallback(value: boolean): void;
+/** Dev-only: matches no event, so a window or phase holding it applies
+ * whatever event is current (see `strictReadEvent`, core.ts). */
+export declare const ANY_EVENT: {};
+/** Dev-only: the DOM event current when the effect phase was entered. A
+ * handler dispatched synchronously from that phase (`el.focus()`) runs under
+ * a different event and is not in it (#4235). */
+export declare let effectCallbackEvent: unknown;
+export declare function setEffectCallback(value: boolean, event?: unknown): void;
 export type QueueCallback = (type: number) => void;
 export declare function schedule(): void;
 /**
@@ -313,13 +320,15 @@ export declare class GlobalQueue implements IQueue {
  * or without the held read) owes nothing. A run this transaction stashed
  * for it is void (#3322: an effect has one value slot, and the stale pass
  * overwrote the value that run was for) — the re-derivation's run replaces
- * it. */
-export declare function reruns(u: Transaction): void;
+ * it. Truthy when an effect re-derives (`land`). */
+export declare function reruns(u: Transaction): unknown;
 /** The held runs join this flush's effect phase after its own runs (the
  * landing's re-passes, in height order): the frame's effects run as one
  * pass would have queued them — a shell re-derived at the landing before a
  * boundary swap held since the write (#3540's log order). */
 export declare function releaseQueues(u: Transaction): void;
+/** Nodes staged this flush (`_pendingValue` set), committed at its end. */
+export declare const pendingNodes: Signal<any>[];
 /** Passes that read a staging of this flush as the screen — lane work
  * (core.ts `stagedRead`), a verdict reader before the frame's verdict
  * (verdict.ts): if the frame parks they read a held write — re-derived next
@@ -383,3 +392,8 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): void;
 export declare function flush<T>(fn: () => T): T;
+/** Dev-only: the DOM event current when the running effect queue started,
+ * or `ANY_EVENT` outside one. Read once per queue rather than once per
+ * effect (the getter is costly under jsdom); no event starts or ends between
+ * two effects of one synchronous queue (#4235). */
+export declare let queueEvent: unknown;

package/dist/types/from.d.ts

@@ -0,0 +1,47 @@
+/** The observer a `subscribe` call receives. */
+type FromObserver<T> = {
+    next(value: T): void;
+    error(err: unknown): void;
+    complete(): void;
+};
+type Teardown = (() => void) | {
+    unsubscribe(): void;
+} | void;
+/**
+ * Anything `from` accepts: a subscribe function
+ * (`(next, error, complete) => unsubscribe`), an object with
+ * `subscribe(observer)` (RxJS and TC39 Observables, including
+ * `Symbol.observable` / `"@@observable"` interop), or an AsyncIterable.
+ */
+export type FromSource<T> = ((next: (value: T) => void, error: (err: unknown) => void, complete: () => void) => Teardown) | {
+    subscribe(observer: FromObserver<T>): Teardown;
+} | AsyncIterable<T>;
+/**
+ * Converts a callback subscription, an Observable or an AsyncIterable into an
+ * AsyncIterable for a Solid computation. A subscription keeps only the latest
+ * value, and a value the source emits during `subscribe` is served without a
+ * loading frame; an AsyncIterable streams every value through.
+ *
+ * The source closes on supersede — the owning computation re-running — and
+ * on owner disposal. Inside an async generator memo that holds for a
+ * `for await` that starts before the first `await`; one that starts after it
+ * has no owner to bind to, so its source closes only when the loop ends.
+ * Prefer returning `from(...)` from its own memo, with awaited inputs read
+ * from upstream memos and transforms done in a downstream memo.
+ *
+ * Iterate the result with `for await` or return it from a computation: its
+ * `next()` returns an already-buffered value as a bare result, not a promise.
+ *
+ * @example
+ * ```ts
+ * const position = createMemo(() =>
+ *   from<Position>((next, error) => {
+ *     const id = navigator.geolocation.watchPosition(next, error);
+ *     return () => navigator.geolocation.clearWatch(id);
+ *   })
+ * );
+ * const ticks = createMemo(() => from(interval$(rate())));
+ * ```
+ */
+export declare function from<T>(source: FromSource<T>): AsyncIterable<T>;
+export {};

package/dist/types/index.d.ts

@@ -5,6 +5,8 @@ export { $REFRESH, action, ContextNotFoundError, NoOwnerError, NotReadyError, Ti
  * outside dev builds.
  */
 export { setConsoleFooter } from "./core/index.js";
+/** @internal The flush round counter (scheduler.ts): hydration's served pass tells its own round from a later one. */
+export { clock } from "./core/index.js";
 /** @internal The pre-write hook (`setWriteHook` in core/core.ts); the server-components client's deferred hydration. */
 /** @internal Plain-signal identities and the dev read watch (dependency edges; the server-components client). */
 export { setWriteHook, setSignalIdentities, setReadWatch, signalName } from "./core/index.js";
@@ -20,12 +22,13 @@ export declare const OBSERVE: Observe | undefined;
 /** Dev tier (devtools hooks, graph traversal, console reporting): dev builds only. */
 export declare const DEV: Dev | undefined;
 export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, AttributionSlot, ClientErrorContext, ClientErrorHook, ClientErrorsConfig, InteractionRef, NavigationRef, Dev, Observe, ServerObserve, Records, RecordTypes, HostRecordTypes, RecordType, RecordEvent, RecordLive, RecordListener, RecordSubscribeOptions, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, DiagnosticListener, Diagnostics, DiagnosticSeverity, DiagnosticSubject } from "./core/index.js";
-export { createSignal, createOptimistic, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, refresh, resolve, until, onSettled, onCleanup } from "./signals.js";
+export { createSignal, createOptimistic, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, refresh, resolve, until, onSettled, onFlush, onCleanup } from "./signals.js";
 export type { Truthy, UntilOptions, Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
 export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";
 export { affects } from "./affects.js";
 export { createDeferred } from "./deferred.js";
+export { from, type FromSource } from "./from.js";
 export { flatten } from "./flatten.js";
 export { createLoadingBoundary, createErrorBoundary } from "./boundaries.js";
 export { createRevealOrder, type RevealOrder } from "./reveal.js";

package/dist/types/signals.d.ts

@@ -735,4 +735,41 @@ export declare function until<T>(fn: () => T, options?: UntilOptions): Promise<T
  *   on owner disposal
  */
 export declare function onSettled(callback: () => void | (() => void)): void;
+/**
+ * Schedules `callback` to run **once**, right after the pending flush
+ * finishes, in the same microtask checkpoint (before the browser paints).
+ * Unlike `onSettled`, it never waits on async work: if that flush is held by
+ * a pending transition, the callback still runs.
+ *
+ * Its main use is keeping a write out of another update's hold. Writes made
+ * in the same synchronous frame are applied together, so when one of them
+ * starts async work (a route change, a fetch), the others are held with it
+ * until it resolves. A write made in `onFlush` happens after that flush, so
+ * it is its own update: it commits on its own unless something it changes
+ * also derives from the held work (a memo or `createEffect` reading both),
+ * in which case it joins that hold as any later write would.
+ *
+ * Call it from event handlers and effect callbacks (including
+ * `createTrackedEffect` and `onSettled` bodies). In an owned scope such as a
+ * component body or a computation it warns in dev: use `onSettled` there.
+ *
+ * - A write in the callback lands after any write made inline in the same
+ *   frame. Don't write the same signal both inside and outside it; use a
+ *   functional setter if the order matters.
+ * - Several `onFlush` callbacks run in call order and batch into one flush.
+ * - `queueMicrotask` is not a substitute: called before the frame's first
+ *   write, it runs before that flush and its write joins it.
+ *
+ * @example
+ * ```tsx
+ * // A menu closes now even when the consumer's onSelect starts async work.
+ * const select = (id: string) => {
+ *   onFlush(() => setOpen(false));
+ *   props.onSelect?.(id);
+ * };
+ * ```
+ *
+ * @param callback Function to run once after the pending flush
+ */
+export declare function onFlush(callback: () => void): void;
 export {};

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

@@ -34,6 +34,8 @@ export interface StoreFamily {
      * their readers (A9) — the family's enumerable index, in place of a
      * per-leaf chain; a target leaves it with its last node. */
     live: Set<StoreTarget>;
+    /** A source's status reaching the derive by propagation (`familyStatus`). */
+    st?: (status: number) => void;
     shallow?: boolean;
     /** Derive run counter (proj R37): the run whose draft is live. */
     run?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.17",
+  "version": "2.0.0-rc.19",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",